Résumé du langage Python 3

Il y a peu, j’ai commencé un peu le Python. C’est un langage qui me rebutait assez jusqu’ici, essentiellement à cause de sa manie d’utiliser les tabulations pour formater les blocs de code. Et puis un jour, j’ai réalisé que c’est exactement ce que je fait quand j’écris du pseudo code pour mettre au point un algo. Alors, je me suis dit : “Pourquoi ne pas y rejeter un coup d’oeil ?”. Et finalement, j’ai découvert un langage sympa, très bien structuré avec une bibliothèque de fonctionnalités très conséquente !

Ce petit mémo, c’est juste pour garder en tête (et à portée de main) les principes du langage. J’ai décidé de ne couvrir que Python 3, c’est la version actuelle du langage.

Ce mémo couvre la syntaxe de base du langage.

Pour commencer, quelques remarques générales :

• Python n’a qu’un seul type de fichier source, comme Java ou C# (et contrairement à C/C++).
• Les identificateurs sont sensibles à la casse

Commentaires

Les commentaires commencent par le symbole # et s’étendent jusqu’à la fin de la ligne.

# Je suis un commentaire.

Un commentaire multiligne peut être fait en utilisant la syntaxe des chaînes multilignes.

""" Je suis un commentaire
qui s'étend
sur plusieurs lignes."""

Déclaration de fonction

def nom_fonction ( parametre = valeur_defaut ) :
    `' Description de la fonction, cette partie s'appelle une docstring
    la docstring peut s'étendre sur plusieurs ligne est se termine par `'

    ensuite, tout ce qui est tabulé est le corps de la fonction
    quand on arrête de tabuler, la fonction est finie !

Appel de fonction

Lors d’un appel de fonction, on peut passer les paramètres dans n’importe quel ordre si on les nomme. Si les paramètres ne sont pas nommés, ils sont considérés comme passés dans l’ordre de la déclaration. On peut commencer à passer les paramètres dans l’ordre de la déclaration et commencer à les nommer à un moment mais pas l’inverse.

def ma_fonction( param1, param2, param3 ):
    print('param1 = {0}, param2 = {1}, param3 = {2}'.format(param1,param2,param3)

ma_fonction(1,2,3)
ma_fonction(1,param3=2,param2=3)

produira l’affichage :

param1 = 1, param2 = 2, param3 = 3
param1 = 1, param2 = 3, param3 = 2

Déclaration de variable

Une variable est déclarée par son affectation. Python type automatiquement en fonction de la valeur affectée.

ma_chaine = "Je suis une chaîne"
mon_autre_chaine = 'moi aussi'
un_entier = 5

Importer un module

Les modules constituent la boite à outils du développeur Python. On importe un module dans un script avec :

import nom_module

Les modules sont cherchés dans la variable sys.path (il faut bien sûr importer le module sys pour y accéder !).

Tout est objet

En Python, tout est objet. Et à ce titre, tout peut avoir des méthodes et des attributs. Par exemple, les fonctions sont elles-même des objets et elles ont un attribut doc qui retourne leur docstring.

Les exceptions

La gestion des erreurs en Python se fait au moyen d’exceptions. Les exceptions sont levées avec la syntaxe :

raise TypeException()

par exemple :

raise ValueError('nombre trop grand')

et elles sont capturées par :

try
    ...
except TypeException:
    ...

Un exemple typique d’utilisation d’exception, c’est le traitement de l’import d’un module :

try
    import un_module
except ImportError:
    un_module = None

if un_module:
    ...
else
    ...

Les modules

Chaque script est un module en lui-même. A l’intérieur d’un script, la variable spéciale __name__ vaut le nom du module s’il a été importé et la valeur __main__ si on est dans le module principal.

Les types de données

Les principaux types de données sont :

• Booléens : True ou False
• Nombres : Entiers (ex : 1), Flottants (ex : 1.0), Fractions (ex : 1/3)
• Chaînes : Toujours UNICODE
• Octets et tableaux d’octets
• Listes : suites ordonnées d’éléments
• Tuples : suites ordonnées immuables d’éléments
• Ensembles (sets) : groupes non ordonnés d’éléments
• Dictionnaires : groupes non ordonnés de couples clé, valeur
• et bien sûr toutes les classes (puisque tout est objet)

Pour connaître le type d’une variable, on dispose de l’opérateur type. Par exemple type(True) renvoie <class 'bool'>.

La conversion entier vers flottant se fait avec l’opérateur float() et l’inverse avec int() (attention, int() tronque le flottant, il n’y a pas d’arrondi !)

Les opérateurs classiques sont supportés (+, -, *, /) ainsi que : // : la division entière, ** : l’exposant et % : le modulo

Les listes sont déclarées avec des crochets. On accède à leurs éléments avec l’indice (base 0) entre crochets. On peut accéder aux élément à l’envers avec un indice négatif. [-1] est donc toujours le dernier élément d’une liste non vide. On peut découper une liste avec l’opérateur crochet et le deux-points :

ma_liste = [ 1, 2, 3, 4, 5, 6 ]
ma_liste[0]     # -> 1
ma_liste[1]     # -> 2
ma_liste[-1]    # -> 6
ma_liste[0:2]   # -> [ 1, 2, 3 ]
ma_liste[:3]    # -> [ 1, 2, 3, 4 ]
ma_liste[5:]    # -> [ 6 ]
ma_liste[:]     # -> [ 1, 2, 3,  4, 5, 6 ]

L’algorithmique de base

La règle de base est : une ligne de code = une instruction. Il est toutefois possible de mettre plusieurs instructions à la suite en les séparant par un ;. Une instruction peut être découpée en plusieurs ligne avec un \ (ou implicitement en faisant un retour à la ligne après la virgule d’un paramètre dans un appel de fonction.

Les commentaires sont les lignes qui commencent par une dièse #.

Mots clés

Il n’y a que 33 mots-clés en Python :

• and
• as
• assert
• break
• class
• continue
• def
• del
• elif
• else
• except
• finally
• for
• from
• global
• if
• import
• in
• is
• lambda
• nonlocal
• not
• or
• pass
• raise
• return
• try
• while
• with
• yield

De plus, None, True et False sont également des mots-clés (qui représentent l’élément vide et les deux valeurs booléennes possibles).

Opérateurs

Les opérateurs en Python sont :

• +
• -
• *
• **
• /
• //
• %
• ~
• &
• |
• ^
• >
• <
• >=
• <=
• !=
• ==
• >>
• <<

Les opérateurs unaires s’appliquent à l’objet qui les porte. Les opérateurs binaires s’appliquent à l’objet de gauche en reçoivent l’objet de droite en paramètre.

>>> 'a' * 2
'aa'

>>> 2 * 'a'
NotImplemented