Cours Python pour les administrateurs systèmes et réseaux

Python pour les administrateurs systèmes et réseaux

Jean-Marc Pouchoulon

Rectorat de Montpellier

Pour le groupe Laser Languedoc Roussillon

Python

? Python est un langage objet de très haut     niveau , dynamiquement typé.( Tout objet est manipulable à l'exécution ). ? Python est guidé par quelques grands     principes qui s'appliquent partout.

? Python est multi-plateforme et produit du byte-code.

? Python est donné avec un ensemble conséquent de modules prêts à l'emploi.

? Python s'interface bien avec du C.

Zen de Python

? Au départ Python est fait pour le prototypage rapide:On développe, on identifie les goulots d'étranglements, on développe en C ensuite les fonctions les plus lentes et on les mappe en objet Python

? Dans les faits il y a déjà beaucoup de travail de fait et les modules sont déjà optimisés.

? Python dispose d'une console interactive très pratique

? import this (pour voir le zen de Python)

       Ma Comparaison avec d'autres languages

? Plus simple que Perl mais moins de choix en termes de modules. Python n'est pas fait pour le one liner.

? Vis à vis de Java il est beaucoup moins verbeux. Par contre son modèle objet est moins académique (design patterns #).

    Il est aussi plus lent.

? Ruby est le grand concurrent.

? Php est à mon sens moins lisible.

? Plusieurs implémentations de python existent: cpython,jython,ironpython,boo,python for .net..

Python dans le monde « réel »

? Zope est la "killer" application de python.

? Python-ldap permet d'accéder et de gérer un annuaire LDAP.

? Twisted se pose comme une référence originale dans le domaine des réseaux.

? Python est un langage de prédilection pour XML.

? Python XPCOM permet de manipuler la suite Mozilla.

? Pythonwin32 permet de manipuler les objets com tels qu'excel word ...

? Python est inclus dans openoffice...

? RedHat développe ses assistants en python.

? L'institut Pasteur forme ses chercheurs à Python.

? Bit torrent..

? Google

Objectifs

? L'objet de cette formation est de vous donner les éléments pour utiliser python dans un contexte d'administration systèmes et réseaux (par pour faire du développement d'applications graphiques) et de créer un groupe     d'utilisateurs python pour échanger.

Editeurs: spe

Editeurs:Eclipse: Pydev

Préparation

? Chargement sur de python et du module win 32 et/ou image vmware.

? Premier pas avec pythonwin et/ou ipython

? Faite print "hello world"

? Rappeler la commande

? Completion, affichage des attributs

? Regarder la documentation

Bases du language

? L'interpréteur python est accessible en tapant python. 

? On peut aussi créer un fichier ( extension

.py ) avec shebang #!/usr/bin/python

? Sous windows de nombreuses consoles existent. Nous utiliserons pythonwin pour cette introduction. (il existe aussi pydev pour eclipse,jedit,spe...)

? ATTENTION : Python est sensible à la casse.

? Le code doit être indenté. (très clair , formateur et donc pas de parenthèses)

            La gueule de Python ?

Code

Python

? Indentation : 4 car pas de TAB ? 1 Instruction par ligne. ? Pas plus de 80 car / Ligne ? Conventions :

? Variables = minuscules

? Classe = MixedCase

? Méthodes = mixedCase

? Constante =  CONSTANTE

? voir PEP 8(Python Enhanced Proposal )

Obtenir de l'aide

? Comment avoir de l'aide:

     help(objet) ex help(list)      dir(list) pour avoir les méthodes de l'objet      (introspection toujours possible en Python)

? L'attribut __doc__  contient un string de documentation en ligne.

? Il peut être formater via un simple print.

>>> print .__doc__ exit([status])...

Typage dynamique lors de l'affectation

>> a = 5

>> b = 6   # integer

>> a = 'zozo' # string

>> a = "le petit 'bouchon'"

>> a

"le petit 'bouchon'"

Trois """ permettent d'inhiber l'interprétation des caractères spéciaux.

>>> """ ceci ne bouge pas ``\^^ $1"""

' ceci ne bouge pas ``\\^^ $1'

Les variables

On peut affecter plusieurs variables en seule passe:

>>> a,b,c = 1,2, 'toto' a,b,c = 1,2,'toto'

Les entiers

>>> a = 5

>>> type(a)

  <type 'int'>

>>> import sys #  import d'un

   #  module on verra

          # ensuite ce que c'est

>>> sys.maxint # taille maximale d'un

      # entier

2147483647

    Longs integers

Floating point numbers

>>> 200L

200L

    La seule limite de ce type est la mémoire de la machine.

>>> 200.37

200.37

>>> 300e-2

3.0

Les imaginaires

>>> a=(4+6j)

>>> a.real

4.0

>>> a.imag

6.0

>>> 

>>> a = 4 + 5j

>>> b = 6 + 4j

>>> a +  b

(10+9j)

Fonctions sur les types numériques

? Les fonctions classiques abs(X), round(X),int,long(X), sont disponibles pour ces types.

? Les assignements de ce type +=, -= sont supportés.

    >>> a = 3

>>> a += 1

>>> a

4

>>> 

Le module operators

    >>> a= 5

>>> b= 6

>>> from operator import *

>>> div(a,b)

>>> mul(a,b)

30

>>> floordiv(a,b)

>>> add(a,b)

11

Les Booléens

      >>> a = 5

>>> b = 6

>>> a > 5

False

>>> a < b

True

>>> a = False

>>> b = True

>>> a or b

True

>>> a and b

False

>>> not ( 0 > 2 )

True

>>> a,b,c = True,False,True

>>> b=0

>>> a & b

 0

AND et OR

Attention: ‘and’ et ‘or’ ne retournent pas True ou False.

•      X and Y and Z

–              Si tous sont vrais, retourne la valeur de  Z. –  Sinon , retourne la première valeur fausse de la                sous-expression. • XorYorZ

–              Si tout est faux, retourne la valeur de Z.

–              Sinon , retourne la première valeur vrai de la sous-expression.

• Astuce: Comment implémenter  (test ? expr1 : expr2) en Python:

resultat = testandexpr1orexpr2 - Si test is True, resultat = expr1.

–Si test est False, resultat = expr2.

Attention: expr1 ne doit pas être Faux

Les Strings

On peut saisir de longue chaînes en python sur plusieurs lignes grâce à \.

  >>> """ ceci est un long texte \

... bla bla `\

... fin """

' ceci est un long texte bla bla `fin '

Python concatène automatiquement les strings séparés par un espace.

>>> 'a' "toto" "5" 'atoto5'

Opérations sur les strings

Ajout:

>>> 'complet' + `5`

'complet5'

>>> 'complet' + str(5)

'complet5'

Multiplier les strings:

>>> a = "coucou

>>> a * 3

'coucoucoucoucoucou'

Opérations sur les strings

    >>> a = "Le mot le plus long" >>> len(a) # donne la longueur du string.

19

>>> a = "coucou"

>>> a.upper()

'COUCOU'

>>> b = "que d'or que d'or"

>>> b.find("or")

6

>>> b.find("or",7) # On limite la

                    # recherche sur b[7:] voir le slicing.

15

Format de données

Comme en C on retrouve une syntaxe proche de

printf

    >>> "Il est %d heures , %s" % (11,'jean-marc') 'Il est 11 heures , jean-marc'

Ou encore à l'aide d'un tuple ( voir plus  loin) :

    >>> f = (11,'jean-marc')

>>> "Il est %d heures , %s" % f

'Il est 11 heures , jean-marc'

Slicing

a                 z              e r              t          y

            0          1          2          3         4       5       index caractère

-5          -4          -3          -2         -1       0        index car inverse    

 | |            |             |          |            |        |

0             1         2             3                4 5       6    index slice

-6         -5 -4           -3       -2          -1       0index slice inverse 

     >>> z[1:]                                                 >>> z[::-2]

                 'zerty' 'yrz'

                   >>> z[:4] >>> z[::-1]

                  'azer ' 'ytreza'

      >>> z[-2]

't'

>>> z[-1]

'y'

>>> z[:-1]

'azert'

 Objets, identité, Types mutables et valeurs

? 'Objects are Python's abstraction for data. All data in a Python program is represented by objects or by relations between objects . Every object has an identity, a type and a value'

? Un type mutable va supporter la modification de sa valeur.

? Un type non mutable ne pourra qu'être recréé si on veut le changer.(ex string )

? Pour voir l'identité d'un objet = id(objet)

? Pour voir le type de l'objet = type(objet) ? Notions qui vont s'éclairer par la suite.

Exo 1

? Créer un string chaine 'azerty'

? Retrouvez son id (via la commande id(objet))

? Que se passe t il si on modifie le premier caractère (via un slicing) ?

? Comment le modifier ?

Les types complexes: Listes

    Les listes sont mutables. Il s'agit d'une collection d'objets, indexée comme les strings donc "slicibles". Les tuple sont proches des listes mais sont non mutables.

    >>> L =

[1,3,'a','test',['abc',345]]

>>> L

[1, 3, 'a', 'test', ['abc', 345]]

>>> L[1]

3

Listes

   Peut contenir d'autres listes

  >>>  L =[1,3,'a','test',['abc',345]]

  Slicibles

  >>> L[1:3]

[3, 'a']

>>> L[4]

['abc', 345]

  Isolation d'un sous éléments

>>> L[4][1]

345

  Inversion

>>> L[:-1]

[1, 3, 'a', 'test']

>>> 

Listes dynamiques

    On peut générer des listes à partir d'expressions valides en python:

    >>> [ x for x in range(1,10)]

[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> [ x * x for x in range(1,10)]

[1, 4, 9, 16, 25, 36, 49, 64, 81]

>>> [ x * y for x in range(1,10) for y

in range(1,4)]

[1, 2, 3, 2, 4, 6, 3, 6, 9, 4, 8, 12, 5,

10, 15, 6, 12, 18, 7, 14, 21, 8, 16, 24,

9, 18, 27]

Les types complexes: Tuples

? Idem que les listes mais non mutables ? Intérêt objets optimisés pour la lecture.

? Même opération que sur les listes.

   >>> x = () # tuple vide

>>> x = 3,4,'toto' # pas besoin de parenthèses pour créer un tuple

>>> x

(3, 4, 'toto')

>>> x = (3,4,'toto') # mais ca marche aussi

>>> tuple('toto')

('t', 'o', 't', 'o')

>>> x[1:] # Le slicing fonctionne aussi

      (4, 'toto')

>>> x[1:]

>>> x[1] = 'p' #type non mutable au contraire deslistes.

Traceback (most recent call last):

  ....

Types complexes: dictionnaires

? Type mutable équivalent au hash de Perl

? Ensemble de clef:valeur

>>> D1 = { 'Clement': 'grand',

  'Arnaud':'moyen' ,

  'Mathilde':'petite'}

Pour être une clef d'un dict un objet doit être hashable vérifiable via la fonction hash

>>> hash('toto')

1380683436

Instructions de contrôle de flow

Forvariablesinsequence:     instructions....

Exo 2

? Créer un dictionnaire via dict()

? Ajouter des valeurs à l'aide D[clef]=valeur

(prendre par exemple les os (windows , linux, mac , vms , aix , solaris )comme clefs et vos appréciations perso comme valeur.

? Retrouver une valeur avec D.get(clef)

? Lister les clefs/valeurs à l'aide de la fonction items() via une boucle for.

? Lister les clefs via keys() et les valeurs via values()

Exo 3

? Créer une liste des jours de la semaine

? Copier là lCopie = [:]

? Enlever samedi et dimanche via la function pop

? Les rajouter via append

? Extraire les éléments jeudi,vendredi de la liste.( slicing )

? Afficher la liste  inversée via un slicing[::-1]

? Faire un tri de la liste via sort

? Lister un éléments sur 2 de la liste avec un tri décroissant

? Quel est la différence entre l.reverse()     et l[::-1] ?

? Faire un cast de la liste en string avec un séparateur « ; »

Pour cela utiliser la syntaxe  ";".join(liste)

Les Références

Comme en JAVA on crée une référence sur un objet, un changement sur l'objet est visible sur l'ensemble des références.

On peut créer des références circulaires.

>>> a = [1,2,3,4,5]

>>> b = a

>>> b

[1, 2, 3, 4, 5]

>>> a[1]=6

Attention

>>> a= list('azerty')

>>> a

['a', 'z', 'e', 'r', 't', 'y']

>>> b=a

>>> b

['a', 'z', 'e', 'r', 't', 'y']

>>> del a

>>> b

['a', 'z', 'e', 'r', 't', 'y']

>>>

Références

    >>> a

[1, 6, 3, 4, 5]

>>> b

                   [1, 6, 3, 4, 5]       

    >>> id(a) # La fonction id donne l'identifiant d'un objet

14556336

>>> id(b) # On vérifie qu'ils sont identiques.

14556336

>>>

?

Copie d'objets

? Listes:

    >>> a

[1, 6, 3, 4,

5]

>>> c = a[:]

>>> c

[1, 6, 3, 4,

5]

>>> a[1]=2

>>> a

[1, 2, 3, 4,

5]

>>> c

[1, 6, 3, 4,

5]

? Dicos:

    >>> D1 =

{'Mathilde':

'petite', 'Clement':

'grand', 'Arnaud':

'moyen'}

>>> D2 = ()

>>> D2 {'Mathilde':

'petite', 'Clement':

'grand', 'Arnaud':

'moyen'}

>>>

Exo 4:shallow et deep copy

? Créez une copie  L2 de L1

>>> L1 = [['un','deux','trois'],1,2,3]

      Vérifiez via la commande "is" que L1 est égal à L2

       Enlevez 'un' de L1.

Qu'y a t il dans L2 ?

Utilisez le module deepcopy et refaites les mêmes tests.

Que veux donc dire shallow et deepcopy ?

Les fonctions en python.

Les arguments peuvent être n'importe quels objets. Ces objets sont passés par référence Une fonction même sans return retourne None...

( équivalent de null)

Exemple de fonction

def prouvemod(a,b):

    a = 1     b = 2

c = 5 d = 6 prouvemod(c,d)

print "c = %d, d = %d" %(c,d)

>>> c = 5, d = 6

Fonction: arguments

Une  fonction peut  recevoir des arguments nommés :

def fonction(a=5,b='toto'):

connect (host='

Ouverture et bind de la connexion

Requête search synchrone

En mode synchrone le programme attend le résultat de la requête

Ldap v3 rfc2251

L’enveloppe (PDU) contient le type de requête et un message ID

? LDAPMessage ::= SEQUENCE { messageID MessageID, protocolOp CHOICE

{ bindRequest BindRequest, bindResponse BindResponse, unbindRequest UnbindRequest,

searchRequest SearchRequest

….

Ldap v3 rfc2251

Result est le résultat de la requête

LDAPResult ::= SEQUENCE { resultCode ENUMERATED { success (0), operationsError (1), protocolError (2), timeLimitExceeded (3), sizeLimitExceeded (4), compareFalse (5), compareTrue (6), authMethodNotSupported (7), strongAuthRequired (8),

referral (10),  …..

Requête search asynchrone

Requête modify (mode add)

Utilisation d’une modlist