Quelques notes à propos des spécificités du langage Python basées sur mes écueils.

ipython est interpréteur proposant des couleurs et de l'autocomplétion. Il offre un mode interactif plus user friendly.

$ sudo apt-get install ipython

Par défaut l’interpréteur python2.7 attend des scripts utilisant le jeu de caractères ASCII. Si l'on utilise un autre jeu de caractère il faut le spécifier. Pour cela insérer au plus tôt (avant que la première conversion ait lieu) dans le fichier la ligne suivante:

# coding: utf8 

L'encodage utilisé pour écrire le fichier de script est à paramétrer dans l'éditeur ou l'EDI. Il faut toujours savoir quel encodage on utilise pour écrire son code et privilégier utf-8 (mise en œuvre de l'encodage universel unicode).

Généralement pour un fichier script l’entête comprend également le chemin de l’interpréteur à appeler:

#!/usr/bin/python
# coding: utf8

Cet entête permet d'appeler le script depuis le bash (si les droits de lecture et d’exécution sont correctement positionnés) directement:

./monscript.py

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]

Notes plus détaillées à propos des listes en Python.

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 dans une séquence (liste, tuple, string, etc) en spécifiant:

1. l'index du premier élément
2. l'index du 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"""
    def __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
>>>

En python tout est objet, quelques méthodes d'utilité générale:

• dir() pour lister objets et méthodes
• help() pour afficher l'aide intégrée au code
• type() pour connaître le type d'un objet
• id() retourne l'adresse mémoire d'un objet
• eval() pour évaluer une chaîne de caractères

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 ci-dessous:

# Déclaration variables et directives importables
# par d'autres scripts
 
if __name__ == "__main__":
  # Le Bloc ci dessous n'est exécuté que
  # lorsque le script est appelé directement
  # mais pas lorsqu'il est importé

Ce branchement conditionnel est souvent utilisé pour des tests unitaires.

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.

Pour obtenir de l'aide, depuis l'interpreteur utiliser la commande help(), cela fonctionne meme sur les types de base:

help(str)

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

Python fournit un le module pdb.

import pdb

si vous utilisez l’interpréteur ipython, ipdp

pip install ipdb

Pour les tests le mot clé assert permet de lever une exception AssertionError lorsque l'expression évaluée n'est pas vraie.

• https://docs.python.org/dev/howto/index.html
• http://wiki.deimos.fr/index.php?title=Introduction_au_Python
• http://sametmax.com/debugger-en-python-les-bases-de-pdb/