Quelques notes à propos des spécificités du langage Python.

En Python tout est objet, le type d'une variable est déterminé dynamiquement, pas de déclaration avant l'utilisation. La fonction type() renvoi le type de l'objet passé en paramètre:

>>> # initialisation d'une variable de type entier:
... 
>>> a = 3
>>> type (a)
<type 'int'>
>>> # une variable flottante
... 
>>> f = 2.1
>>> type (f)
<type 'float'>
>>> # une variable chaine de caractères
... 
>>> c = 'c'
>>> type(c)
<type 'str'>
>>> c = 'ma chaine'
>>> type(c)
<type 'str'>

Remarques:

1. La fonction type() retourne le type de la variable passée en paramètre.
2. Python ne distingue pas caractère et chaîne de caractères, le type est 'str' (string).

Une liste est un ensemble ordonné d'objets pouvant être de différents types. Les éléments de l'ensemble sont accessible via leur index.

>>> ma_liste = ['toto', 2, 2.1, 'z']

Le contenu d'une liste peut être modifié, on peut ajouter/retirer des éléments à l'aide des méthodes pop() et insert(). On peut également réaffecter un élément de la liste via l'index:

>>> ma_liste[0] = 'tata'
>>> ma_liste.pop(2)
2.1
>>> ma_liste.insert(3, 2.5)
>>> print (ma_liste)
['tata', 2, 'z', 2.5]

Le tuple est un ensemble ordonné et figé d'objets pouvant être de types différents. On ne peut pas ajouter/supprimer/modifier les éléments d'un tuple. Le principal avantage d'un tuple est le temps d’accès à l'information bien plus court que la liste.

# La syntaxe de déclaration d'un tuple utilise les parenthèse:
>>> tuple = (1, 'toto', 2.2, True);
 
# La syntaxe abrégée de déclaration d'un tuple
>>> t2 = 1, 'tata', 'tutu'
>>> print t2
(1, 'tata', 'tutu')
 
# Si le tuple a un seul élément, bien terminer la déclaration par la virgule lors de l'utilisation de la notation abrégée
>>> t3 = 'test',
>>> print t3
('test',)
 
>>> tuple[1] = 'tata' # Réaffecter un élément d'un tuple provoque une erreur.
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Le slicing permet de sélectionner un sous ensemble d'une variable de type liste en spécifiant:

1. le premier élément
2. le dernier élément+1
3. le pas

Remarque 1: Si les arguments ne sont pas spécifiés, ils ont des valeurs par défaut (min, max et pas de 1).

Remarque 2: si le pas est négatif on parcourt la variable en sens inverse, pratique pour inverser une chaîne.

>>> texte="un joli texte"
>>> sous_chaine=texte[3:7]
>>> print(sous_chaine)
joli
 
>>> sous_chaine=texte[:7]
>>> print(sous_chaine)
un joli
 
>>> sous_chaine=texte[::-1]
>>> print(sous_chaine)
etxet iloj nu

Un dictionnaire est un ensemble dynamique non ordonné (on parle aussi de tableau associatif). On accède aux élément via la clé. Une clé peut être une chaîne de caractères ou un nombre.

# déclaration d'un dictionnaire
>>> d = {'prenom': 'yoann', 'nom': 'BEZILLE', 'age' : 32, 42: 'test'}

Remarque: Pour copier un dictionnaire utiliser la méthode copy()

class monType(object)
"""Toute classe par defaut herite du type de base object"""
    __init__(self,...):
    """Le constructeur de la classe monType"""
    def methode_1(self,...):
    def methide_2(self,...):

Remarques:

1. Attention le premier argument des méthodes est toujours self.
2. Toute classe de base hérite d'object.

mon_objet = maClasse(valeur1, valeur2, valeur3)

Pour instancier un objet de la classe maClasse, j'utilise ne nom de la classe et entre parenthèses je place les valeurs à transmettre au constructeur.

Exemple Se placer dans le dossier ~/dev/python contenant le fichier compte.py et lancer l’interpréteur python

>>> import compte
>>> mon_compte = compte.compte("2221");
>>> mon_compte.depot(2000000000);
>>> mon_compte.affiche()
le solde du compte '2221'est 2000000000.00
>>>

Pour utiliser une fonction présente dans un fichier, utiliser la directive import avec le nom de fichier sans le suffixe .py

Remarque: dans un module, les variables globales sont accessibles. Ils est possible de modifier la valeur de la variable du module, cela peut être problématique: pour éviter cela on utilisera les objets.

Il est possible de tester si le script est appelé directement ou via un import avec le code suivant:

if __name__ == __main__:

Les objets python savent qui ils sont, c'est l'introspection. La fonction dir() permet de lister les attributs/méthodes de tout objet.

>>> dir (ma_liste)
['__add__', '__class__', '__contains__', '__delattr__',..., 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

Python intègre nativement la documentation au code (attribut doc d'une instance). Lors de la définition d'une classe ou d'une méthode, ajouter un texte entre triple guillemets sous la définition pour qu'elle soit prise en compte.

Remarque: La position du commentaire est importante. Seuls les commentaires entre triples guillemets sous la déclaration seront exportés. Attention a bien indenter le commentaire.

La commande pydoc se charge d'extraire et de formater la doc incluse dans le code. Pour consulter la documentation d'un module nommé test.py

Remarque: Pour les scripts python3 utiliser pydoc3

$ pydoc test.py

• https://docs.python.org/dev/howto/index.html
• http://wiki.deimos.fr/index.php?title=Introduction_au_Python