Bases du langage Python

In [2]:
%matplotlib inline
In [1]:
from jyquickhelper import add_notebook_menu
add_notebook_menu()
Out[1]:
run previous cell, wait for 2 seconds

Ce document résume en quelques lignes les éléments essentiels de la syntaxe du langage python. Quelques lignes suffisent pour découvrir la version installée :

In [ ]:
import sys
print (sys.version)

Avec la version 3.x, le langage a introduit quelques changements importants qui seront précisés. Il est préférable de choisir la version 3.5 plutôt que 2.7. Outre le fait qu'elle contient les dernières évolutions, elle est beaucoup plus cohérente en ce qui concerne les chaînes de caractères.

Syntaxe de base

Quelques précisions sur le langage :

  • Commentaires : Les commentaires dans un programme commencent par le symbole # et vont jusqu’à la fin de la ligne.

  • Généralement une instruction par ligne, sans marqueur à la fin. Si plusieurs instructions par ligne, les séparer par ;

  • Contraintes de nommage : Les noms de variable (fonction, classe...) doivent respecter des règles syntaxiques : ils peuvent contenir des lettres, chiffres, des underscore (_) mais doivent commencer par une lettre

  • L’indentation est primordiale.

  • On commence à compter à 0.

  • L’instruction print permet d’afficher n’importe quelle information. print est une fonction, tout ce qui doit être affiché doit l’être entre parenthèses.

  • L’instruction help affiche l’aide associée à une variable, une fonction, une classe, une méthode, un module. Pour une fonction, une classe, une méthode du programme, cette aide correspond à une chaîne de caractères encadrée par trois ". Ce message d’aide peut s’étaler sur plusieurs lignes.

Valeurs, Variables et Affectations

Les variables

Une variable permet de stocker des données pour les réutiliser plus tard.

a=< valeur >

Le type de détermine le type de la variable a. Si une variable porte déjà le même nom, son contenu est écrasé (perdu aussi).

In [6]:
# Affectation d'une valeur à une variable
a = 1
a
Out[6]:
1

Une affectation crée une liaison entre un nom et une donnée.

Contraintes de nommage

Les noms de variable (de fonction, de classe...) doivent respecter des règles syntaxiques :

- peuvent contenir des lettres, chiffres, des underscore (_) mais doivent commencer par une lettre
- Par convention les noms de variables sont en minuscule, et les noms de classe commencent par une majuscule.
- la casse est importante (ma_variable ≠ Ma_VaRiAbLE)
- certains noms *mots-clés* sont réservés par le langage. Ces mots-clés sont :

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

Note: faites attention au mot-clé lambda, qui pourrait facilement être une variable dans un programme scientifique. Mais étant un mot-clé, il ne peut pas être utilisé comme un nom de variable.

Affectations

Affectation simple

L'opérateur d'affectation en Python est effectuée par =. Python est un langage de typage dynamique, donc vous n'avez pas besoin de spécifier le type d'une variable lors de sa création.

L'affectation d'une valeur à une nouvelle variable crée la variable. De manière générale nom_variable = valeur.

In [8]:
# Affectations simples
a = 2
b = 3
a, b
Out[8]:
(2, 3)
Affectations multiples
In [9]:
# Affectations multiples
(a, b) = (4, 5) ; (a, b)
Out[9]:
(4, 5)
Expressions

Une expression combine des variables et des littéraux par l’intermédiaire d’opérateurs et de fonctions.

Python évalue les expressions : il applique les opérateurs et les fonctions afin de déterminer leur valeur résultat.

In [11]:
(1, 2) + (3, 4)
Out[11]:
(1, 2, 3, 4)
In [13]:
c=5 ; max(a, b) + 5*c
Out[13]:
30

Types de données simples

Chaque donnée en Python est un objet dont :

- le type caractérise la nature de l’objet, ses opérations, cf. `type()`, `dir()`
- l’identité caractérise l’objet (e.g. une adresse mémoire), `id()`
- la valeur est le contenu des données
In [16]:
a="Bonjour"
id(a)
Out[16]:
2154035032784
In [17]:
type(a)
Out[17]:
str
In [21]:
dir(a)
Out[21]:
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmod__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']
In [22]:
help(a.upper)
Help on built-in function upper:

upper(...) method of builtins.str instance
    S.upper() -> str
    
    Return a copy of S converted to uppercase.

Typage dynamique

Une variable possède un type associé, bien qu'il ne soit pas explicitement spécifiée. Le type est dérivé de la valeur qui lui a été attribuée. L’instruction type(a) retourne le type de la variable a.

In [14]:
a = 4
type(a)
Out[14]:
int

Si vous attribuez une nouvelle valeur à une variable, son type peut changer.

In [15]:
a = (3, 8)
type(a)
Out[15]:
tuple
Types fondamentaux
In [1]:
# entier (integers)
a = 1
type(a)
Out[1]:
int
In [2]:
# réel (float)
a = 1.0
type(a)
Out[2]:
float
In [4]:
# Booléen (boolean)
b1 = True
b2 = False
type(b2)
Out[4]:
bool
In [5]:
# Nombres complexes: notez que l'utilisation de `j` permet de spécifier la partie imaginaire 
a = 1.0 - 1.0j
type(a)
Out[5]:
complex
In [7]:
print(a)
print(a.real, a.imag)
(1-1j)
1.0 -1.0
In [ ]:
Vous pouvez également tester si les variables sont de certains types :
In [8]:
type(a) is float
Out[8]:
False
Typage fort
In [27]:
a=12.5
3+a
Out[27]:
15.5
In [24]:
"La valeur de de = "+a
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-24-2cd2b6ed92e9> in <module>()
----> 1 "La valeur de de = "+a

TypeError: Can't convert 'float' object to str implicitly

Le typage fort signifie que les conversions implicites de types sont formellement interdites.

Les seules conversions implicites de types sont entre types numériques : int → float → complex.

Pour toutes les autres conversions, il faut utiliser explicitement des fonctions de conversion.

In [25]:
"La valeur de de = "+str(a)
Out[25]:
'La valeur de de = 12.5'

Opérateurs et opérateurs de comparaisons

La plupart des opérateurs et des opérateurs de comparaisons en Python fonctionnent comme on peut s'y attendre:

- Opérateurs arithmétiques +, -, *, /, // (division entière), '**' puissance
In [28]:
1 + 2, 1 - 2, 1 * 2, 1 / 2
Out[28]:
(3, -1, 2, 0.5)
In [29]:
1.0 + 2.0, 1.0 - 2.0, 1.0 * 2.0, 1.0 / 2.0
Out[29]:
(3.0, -1.0, 2.0, 0.5)
In [30]:
# Division entière des nombres réels
3.0 // 2.0
Out[30]:
1.0

Remarque : L'opérateur / effectue toujours une division en virgule flottante dans Python 3.x. Cela n'est pas vrai dans Python 2.x, où le résultat de / est toujours un entier si les opérandes sont des entiers. Pour être plus précis, 1/2 = 0.5 (float) dans Python 3.x et 1/2 = 0 (int) dans Python 2.x (mais 1.0 / 2 = 0.5 dans Python 2.x).

- Les opérateurs booléens sont : and, not, or.
In [31]:
True and False, not True, True or False
Out[31]:
(False, False, True)
- Les opérateurs de comparaison : >, <, >= (supérieur ou égal), <= (inférieur ou égal), == égalité, is identiques.
In [32]:
2 > 1, 3<=6
Out[32]:
(True, True)
In [33]:
# égalité
[1,2] == [1,2]
Out[33]:
True
In [34]:
# Objets identiques?
l1 = l2 = [1,2]

l1 is l2
Out[34]:
True

Types composés : Chaînes de caractères, Listes et dictionnaires

Les chaînes de caractères (String : str)

Les chaînes sont le type de variable utilisé pour stocker des messages texte.

Trois syntaxes :

- simples quotes : 'Bonjour, dit-elle'
- doubles quotes : "Qu'y a-t-il ?"
- triple quotes (simples ou doubles) : '''chaînes multilignes'''

Caractère d’échappement : 'aujourd\'hui' Passage à la ligne : Ligne 1\nLigne 2

In [36]:
s = "Bonjour"
type(s)
Out[36]:
str

Comme n’importe quelle séquence, les chaînes de caractères supportent :

- le test d’appartenance, la concaténation, la répétition,
- la taille, le plus petit/plus grand élément,..
In [37]:
s='Bienvenue '+ 'à l\'ENSAI'   # concaténation
len(s)    # Longueur de la chaîne: le nombre de caractères
Out[37]:
19
In [39]:
'u' in s     # test d’appartenance à la chaîne
Out[39]:
True
In [40]:
s.index('ENSAI')
Out[40]:
14

En tant que séquence,

- on peut accéder aux éléments de la chaîne par index en utilisant [index].
    *Note :* Les index sont utilisés de 0 à (n-1)
In [44]:
s[0]
Out[44]:
'B'
- Il est possible d’indéxer en partant de la fin avec des indices négatifs :
In [43]:
s[-1]
Out[43]:
'I'
 - On peut extraire une partie d'une chaîne en utilisant la syntaxe [start: stop], qui extrait les caractères entre index start et stop -1 (le caractère à l'index stop n'est pas inclus):
In [45]:
s[0:12]
Out[45]:
'Bienvenue à '
- Si nous omettons l'index start ou stop  (ou les deux) de [start: stop], la valeur par défaut est le début et la fin de la chaîne, respectivement :
In [46]:
s[:4]
Out[46]:
'Bien'
In [47]:
s[14:]
Out[47]:
'ENSAI'
In [48]:
s[:]
Out[48]:
"Bienvenue à l'ENSAI"
- Nous pouvons également définir *le pas (step)* en utilisant la syntaxe [start: end: step] (la valeur par défaut pour step est 1, comme nous l'avons vu ci-dessus) :
In [50]:
s[::3]
Out[50]:
'Bnn lNI'

Cette technique est appelée Slicing. Pour en savoir plus sur la syntaxe, cliquez ici: 'http://docs.python.org/release/2.7.3/library/functions.html?highlight=slice#slice'

Python possède un ensemble très riche de fonctions pour le traitement de texte. Voir par exemple 'http://docs.python.org/2/library/string.html' pour plus d'informations.

Parmi les fonctions les plus souvent utilisées sur les chaînes on cite :

Méthode Rôle
strip, lstrip, rstrip Élimine les espaces
split Découpe (en une liste)
join Recolle une liste de chaînes
find Recherche une sous-chaîne
replace Remplace une sous-chaîne
upper, lower Change la casse

Les listes

Les listes sont très semblables aux chaînes, sauf que chaque élément peut être de n'importe quel type. La syntaxe pour créer des listes en Python est [...]:

- Collection ordonnée (de gauche à droite) d’éléments (combinaison de basic data types, conteneur hétérogène)
- De taille quelconque, peut grandir, rétrécir, être modifiée, être encapsulée (liste de listes de listes)
In [52]:
l = [1,2,3,4]

print(type(l))
print(l)
<class 'list'>
[1, 2, 3, 4]

Les éléments d'une liste peuvent ne pas être du même type :

In [59]:
l = [1, 'a', 1.0, 1-1j]

print(l)
[1, 'a', 1.0, (1-1j)]

Les listes Python peuvent être inhomogènes et arbitrairement imbriquées:

In [60]:
l1 = [1, [2, [3, [4, [5]]]]]

l1
Out[60]:
[1, [2, [3, [4, [5]]]]]

Les mêmes techniques de slicing utilisées précédement sur les chaînes de caractères peuvent également être utilisées pour manipuler les listes.

In [55]:
L=[ '14 ' ,'14231363 ' ,'14232541 ', 'MC1R ']
L[3]
Out[55]:
'MC1R '
In [56]:
L[0:2]
Out[56]:
['14 ', '14231363 ']
In [58]:
print(L[::3])
['14 ', 'MC1R ']

On peut modifier les listes en attribuant de nouvelles valeurs aux éléments de la liste. Dans le jargon technique, on dit que les listes sont mutables.

In [62]:
L [3]= ' ENSOARG00000002239 ' # une liste est modifiable
L
Out[62]:
['14 ', '14231363 ', '14232541 ', ' ENSOARG00000002239 ']
In [63]:
L [1]= int(L[1]) ; L[2]= int(L[2]) # conversion string -> integer
L # les elements sont de types differents
Out[63]:
['14 ', 14231363, 14232541, ' ENSOARG00000002239 ']

Il existe un certain nombre de fonctions pratiques pour générer des listes de différents types. Exemple :

In [65]:
# Sous Python 3.x, on peut générer une liste en utilisant l'instruction suivante : List (range (start, stop, step)

list(range(1, 20, 6))   
Out[65]:
[1, 7, 13, 19]
In [67]:
# Convertir une chaîne en une liste  :
s2=list(s)
s2
Out[67]:
['B',
 'i',
 'e',
 'n',
 'v',
 'e',
 'n',
 'u',
 'e',
 ' ',
 'à',
 ' ',
 'l',
 "'",
 'E',
 'N',
 'S',
 'A',
 'I']
Fonctions opérations sur les listes

Ajouter, insérer, modifier et supprimer des éléments des listes

In [94]:
List =[3 , 2, 4, 1]
List.append(15)   # ajoute un élément à la fin de la liste  avec append
print(List)
[3, 2, 4, 1, 15]
In [95]:
List.extend ([7 , 8, 9])  # étendre la liste  avec extend
print(List)
[3, 2, 4, 1, 15, 7, 8, 9]

Insérer un élément à un index spécifique à l'aide de insert

In [96]:
List.insert(0, 111)
print(List)
[111, 3, 2, 4, 1, 15, 7, 8, 9]

Supprimer le premier élément avec une valeur spécifique à l'aide de remove

In [97]:
List.remove(15)
print(List)
[111, 3, 2, 4, 1, 7, 8, 9]

Supprimer un élément à un emplacement spécifique à l'aide de del

In [80]:
del List [3] # supprimer l'élément se trouvant à l'index 3 de la liste
print(List)
[1, 2, 3, 7, 8, 9, 15]
In [79]:
List.sort () # Tri de liste
List
[1, 2, 3, 4, 7, 8, 9, 15]
In [85]:
List.count (3)   # renvoie le nombre d'occurence de 3 dans la liste
Out[85]:
1

Voir help(list) pour plus de détails, ou lire la documentation en ligne.

Les Tuples

Les tuples sont comme des listes, sauf qu'ils ne peuvent pas être modifiés une fois créés, c'est-à-dire qu'ils sont immuables. En Python, les tuples sont créés en utilisant la syntaxe (..., ..., ...), ou ..., ...:

In [100]:
Mon_Tuple =('Carmen ', 'Georges Bizet ', 1875)
print (type ( Mon_Tuple ))
<class 'tuple'>
In [101]:
point = 24, 17

print(point, type(point))
(24, 17) <class 'tuple'>

On peut décompresser un tuple en l'affectant à une liste de variables séparées par des virgules :

In [102]:
x, y = point

print("x =", x)
print("y =", y)
x = 24
y = 17

On peut accéder aux élément d'un tuples en précisant les index

In [ ]:
Mon_Tuple [1]

Si on essaye d'assigner une nouvelle valeur à un élément dans un tuple, nous obtenons une erreur:

In [103]:
Mon_Tuple [1]=10
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-103-63b1f9527b13> in <module>()
----> 1 Mon_Tuple [1]=10

TypeError: 'tuple' object does not support item assignment

Les dictionnaires

Les dictionnaires sont également des listes, sauf que chaque élément est une paire clé-valeur.

- La syntaxe des dictionnaires est {key1: value1, ...}:
- chaque clé est unique
- mutables
In [118]:
mois ={ 'Jan ':31 , 'Fev ':28 , 'Mar ':31}
print(type(mois))
print(mois)
<class 'dict'>
{'Mar ': 31, 'Fev ': 28, 'Jan ': 31}
In [107]:
mois.keys()
Out[107]:
dict_keys(['Mar ', 'Fev ', 'Jan '])
In [108]:
mois.values()
Out[108]:
dict_values([31, 28, 31])
In [109]:
mois.items()
Out[109]:
dict_items([('Mar ', 31), ('Fev ', 28), ('Jan ', 31)])

Suppression d'une clé :

In [119]:
del mois['Mar ']  # supprimer une clé 
print(mois)
{'Fev ': 28, 'Jan ': 31}

Test de présence d'une clé

In [120]:
"Fev " in mois # Test de présence d’une clé
Out[120]:
True

STRUCTURES DE CONTRÔLE (Conditions, branchements et boucles)

Test : if - elif - else

La syntaxe Python pour l'exécution conditionnelle du code utilise les mots-clés if, elif (else if), else :

In [128]:
Instruction1 = False
Instruction2 = False

if Instruction1:
    print("Instruction1 est vrai")
    
elif Instruction2:
    print("Instruction2 est vrai")
    
else:
    print("Instruction1 et Instruction2 sont toutes les deux False")
Instruction1 et Instruction2 sont toutes les deux False

Remarque : être très attentif sur la gestion des indentations car la fin d’indentation signifie la fin d’un bloc de commandes

L'étendue d'un bloc de code est définie par le niveau d'indentation (habituellement une tabulation ou quatre espaces blancs). Cela signifie qu'il faut faire attention à indenter votre code correctement, sinon vous obtiendrez des erreurs de syntaxe.

In [129]:
Instruction1 = Instruction2 = True

if Instruction1:
    if Instruction2:
        print("l'Instruction1 et l'Instruction2 sont toutes les deux True")
la Instruction1 et Instruction2 sont toutes les deux True
In [130]:
# Mauvaise indentation!
if Instruction1:
    if Instruction2:
    print("l'Instruction1 et l'Instruction2 sont toutes les deux True")  # Cette ligne n'est pas correctement indentée
  File "<ipython-input-130-af1112d4f58e>", line 4
    print("l'Instruction1 et l'Instruction2 sont toutes les deux True")  # Cette ligne n'est pas correctement indentée
        ^
IndentationError: expected an indented block
In [131]:
Instruction1 = False 

if Instruction1:
    print("Afficher si Instruction1 est True")
    
    print("Encore à l'intérieur du bloc if")
In [133]:
if Instruction1:
    print("Afficher si Instruction1 est True")
    
print("Maintenant à l'extérieur du bloc if")
Maintenant à l'extérieur du bloc if
In [ ]:
##### Syntaxe compacte d'une assignation conditionnelle

Exemple :

In [198]:
x,y = 10, 6
if x < y:
    minimum = x
else:
    minimum = y

minimum
Out[198]:
6

Python offre une syntaxe abrégée (inspirée du C) pour faire ceci :

In [199]:
minimum = x if x < y else y
minimum
Out[199]:
6

Boucles

En Python, les boucles peuvent être programmées de différentes façons. Il y a deux types de boucles, la boucle for parcourt un ensemble, la boucle while continue tant qu’une condition est vraie.

La plus courante est la boucle for, qui est utilisée avec des objets itérables, comme des listes. La syntaxe de base est :

Boucle for :
In [135]:
for x in [1,2,3]:
    print(x)
1
2
3
In [136]:
for i in range (4) :    # Par défaut range commence à 0
    print(i, end =" ")
0 1 2 3 

Note :

- range (4) génère une liste de 0 à n-1 donc, ne comprend pas 4!
        Syntaxe générale de range : range(start, stop, step)
- la propriété end = " " dans la fonction `print` permet de rester sur la même ligne lors de l'affichage

Pour itérer sur les paires clé-valeur d'un dictionnaire:

In [138]:
for cle, valeur in mois.items():
    print(cle + " = " + str(valeur))
Fev  = 28
Jan  = 31

Parfois, il est utile d'avoir accès aux indices des valeurs lors de l'itération sur une liste. Nous pouvons utiliser la fonction enumerate pour cela :

In [139]:
for idx, x in enumerate(range(-3,3)):
    print(idx, x)
0 -3
1 -2
2 -1
3 0
4 1
5 2
Listes en Compréhension : Création de listes à l'aide des boucles for

La liste en compréhension permet d’éviter une écriture en boucle explicite et rend l’exécution plus rapide

In [140]:
L = [x ** 2 for x in range (0 ,5)]
print (L)
[0, 1, 4, 9, 16]

est la version courte de :

In [142]:
L =list()
for x in range (0, 5):
    L.append (x ** 2)
print (L)
[0, 1, 4, 9, 16]
Boucle while :

Parfois, on ne sait pas à l'avance combien de fois on veut exécuter un bloc d'instructions. Dans ce cas, il vaut mieux utiliser une boucle while dont la syntaxe est:

In [ ]:
while CONDITION:
    INSTRUCTION 1
    INSTRUCTION 2
    ...
    INSTRUCTION n

Le bloc d'instruction est exécuté (au complet) tant que la condition est satisfaite. La condition est testée avant l'exécution du bloc, mais pas pendant. C'est donc toutes les instructions du bloc qui sont exécutées si la condition est vraie. Par exemple, on peut afficher les puissances de 5 inférieures à un million avec une boucle while :

In [200]:
a = 1
while a < 1000000:
    print(a)
    a = a * 5
1
5
25
125
625
3125
15625
78125
390625
In [143]:
ct =2
while ct <= 8:
    print(ct , end =" ")
    ct = ct + 2
2 4 6 8 
Interruptions de boucles avec break et continue
  • La commande break permet d'interrompre une boucle for ou while en cours:
In [201]:
for i in range(10):
    if i == 5:
        break
    print(i)
0
1
2
3
4

On remarque que les valeurs plus grandes que 4 n'ont pas été affichées par la fonction print.

  • La commande continue permet de continuer le parcours d'une boucle à la valeur suivante :
In [202]:
for i in range(10):
    if i == 5:
        continue
    print(i)
0
1
2
3
4
6
7
8
9

On remarque que la valeur 5 n'a pas été affichées par la fonction print.

Fonctions

Une fonction en Python est définie à l'aide du mot-clé def, suivi d'un nom de fonction, d'un ensemble d'arguments en entrée (ou pas) entre parenthèses () et de deux points :. Le code suivant, avec un niveau d'indentation représente le corps de la fonction.

In [146]:
def droite (x):
    print(2*x+1)
In [145]:
droite (2)
5

Optionnel, mais fortement recommandé, vous pouvez définir un "docstring", qui est une description des fonctions. Le docstring doit figurer directement après la définition de la fonction, avant le code correspondant au corps de la fonction.

In [148]:
def droite (x):
    """ Ecrit le res. 2x+1 """
    print(2*x+1)        
In [149]:
help(droite)
Help on function droite in module __main__:

droite(x)
    Ecrit le res. 2x+1

In [150]:
droite.__doc__
Out[150]:
' Ecrit le res. 2x+1 '

Les fonctions qui renvoient une valeur utilisent le mot-clé return

In [ ]:
def droite (x):
    """ Renvoie le res . 2x+1 """
    return 2*x+1
In [151]:
droite(4)
9

On peut retourner plusieurs valeurs en utilisant des virgules (un tuple est renvoyé)

In [154]:
def puissance(x):
    """
    Retourne certaines puissance de x
    """
    return x ** 2, x ** 3, x ** 4
In [155]:
puissance(2)
Out[155]:
(4, 8, 16)
In [157]:
x2, x3, x4 = puissance(2)

print(x4)
16

Les arguments par défaut et les arguments mots clés

On peut donner des valeurs par défaut aux arguments que la fonction prend en entrée :

In [159]:
def mafonction(x, p=2, debug=False):
    if debug:
        print("Evaluer mafonction pour x = " + str(x) + " en utilisant un exposant p = " + str(p))
    return x**p

Si nous ne fournissons pas une valeur de l'argument debug lors de l'appel de la fonction myfunc, elle prend par défaut la valeur fournie dans la définition de fonction :

In [160]:
mafonction(4)
Out[160]:
16
In [162]:
mafonction(4, debug=True)
Evaluer mafonction pour x = 4 en utilisant un exposant p = 2
Out[162]:
16

Si vous énumérez explicitement le nom des arguments dans les appels de fonction, ils n'ont pas besoin d'être dans le même ordre que dans la définition de la fonction. C'est ce qu'on appelle les arguments mot-clé, et est souvent très utile dans les fonctions qui nécessitent beaucoup d'arguments facultatifs.

In [164]:
mafonction(p=2, debug=True, x=14)
Evaluer mafonction pour x = 14 en utilisant un exposant p = 2
Out[164]:
196

Fonctions de manipulation de séquences

Fonction : filter

Applique la fonction passée en premier argument sur chacun des éléments de la séquence passée en second argument et retourne une nouvelle liste qui contient tous les éléments de la séquence pour lesquels la fonction a retourné une valeur vrai.

In [172]:
def funct1 (val ):
    return val > 0
list(filter( funct1 , [1, -2, 3, -4, 5]))
Out[172]:
[1, 3, 5]
Fonction : map

applique la fonction passée en premier argument sur chacun des éléments de la ou des séquences passées en paramètre

In [174]:
def somme (x,y):
    return x+y
L4= map(somme ,[1 , 2, 3], [4, 5, 6])
list(L4)
Out[174]:
[5, 7, 9]

Remarque : map peut être beaucoup plus rapide qu’une boucle for

Fonction : zip

permet de parcourir plusieurs séquences en parallèle

In [180]:
for (x, y) in zip ([1 , 2, 3] ,[4 , 5, 6]) :
    print(x, '+', y, '=', x + y)
1 + 4 = 5
2 + 5 = 7
3 + 6 = 9

La fonction zip est très utile pour créer un dictionnaire. En effet, cela permet de raccourcir le code pour créer un dictionnaire à partir de clés et de valeurs séparés. Ca paraît bien plus long de créer les listes des clés et des valeurs. Et pourtant le code suivant peut être considérablement raccourci :

In [20]:
hist = {'a': 1, 'b': 2, 'er': 1, 'gh': 2}
cles = []
vals = []
for k, v in hist.items():
    cles.append(k)
    vals.append(v)
cles, vals
Out[20]:
(['gh', 'b', 'a', 'er'], [2, 2, 1, 1])

Cela devient :

In [21]:
hist = {'a': 1, 'b': 2, 'er': 1, 'gh': 2}
cles, vals = zip(*hist.items())
cles, vals
Out[21]:
(('gh', 'b', 'a', 'er'), (2, 2, 1, 1))

Petite différence, cles, vals sont sous forme de tuple mais cela reste très élégant.

Fonction : reduce

Réduit une séquence par l’application récursive d’une fonction sur chacun de ses éléments.

- La fonction passée comme premier paramètre doit prendre deux arguments
- La fonction reduce prend un troisième paramètre optionnel qui est la valeur initiale du calcul
- Importer la fonction reduce à partir du module functools : from functools import reduce
In [178]:
from functools import reduce
reduce(somme , [1, 2, 3, 4, 5])
Out[178]:
15

Fonctions sans nom (mot-clé lambda)

Sous Python, vous pouvez également créer des fonctions sans nom, en utilisant le mot-clé lambda :

In [ ]:
f1 = lambda x: x**2
    
# est équivalent à 

def f2(x):
    return x**2
In [166]:
f1(2), f2(2)
Out[166]:
(4, 4)

Les lambda expressions permettent une syntaxe plus légère pour déclarer une fonction simple

Cette technique est utile par exemple lorsque nous voulons passer une fonction simple comme argument à une autre fonction, comme ceci :

In [169]:
# map est une fonction intégrée de python
map(lambda x: x**2, range(-3,4))
Out[169]:
<map at 0x1f586a50f98>
In [170]:
# Dans python 3 nous pouvons utiliser `list (...)` pour convertir l'itérateur en une liste explicite
list(map(lambda x: x**2, range(-3,4)))
Out[170]:
[9, 4, 1, 0, 1, 4, 9]

Classes

Les classes sont les éléments centraux de la programmation orientée objet. Une classe est une structure qui sert à représenter un objet et les opérations qui peuvent être effectuées sur l'objet.

En Python, une classe peut contenir des attributs (variables) et des méthodes (fonctions).

Une classe est définie de manière analogue aux fonctions, mais en utilisant le mot-clé class. La définition d'une classe contient généralement un certain nombre de méthodes de classe (des fonctions dans la classe).

  • Le premier argument d'un méthode doit être self: argument obligatoire. Cet objet self est une auto-référence.

  • Certains noms de méthode de classe ont un sens particulier, par exemple:

    • __init__: nom de la méthode invoquée à de la création de l'objet.
    • __str__: méthode invoquée lorsqu'une représentation de la classe sous forme de chaîne de caractères est demandée, par exemple quand la classe est passée à la fonction print
    • Voir http://docs.python.org/2/reference/datamodel.html#special-method-names pour les autres noms de méthode
In [181]:
class Point:
    """
    Classe simple pour représenter un point dans un système de coordonnées cartésiennes.
    """
    
    def __init__(self, x, y):
        """
        Créer un nouveau point à x, y.
        """
        self.x = x
        self.y = y
        
    def translate(self, dx, dy):
        """
        Calcul de la déviation de direction du point par dx et dy
        """
        self.x += dx
        self.y += dy
        
    def __str__(self):
        return("Point de coordonnées [%f, %f]" % (self.x, self.y))

Pour créer une nouvelle instance d'une classe:

In [184]:
p1 = Point (0, 0) # ceci va appeler la méthode __init__ dans la classe Point

print (p1) # ceci va appeler la méthode __str__
Point de coordonnées [0.000000, 0.000000]

Pour faire appel à une méthode de classe dans l'instance de classe p :

In [185]:
p2 = Point(1, 1)

p1.translate(0.25, 1.5)

print(p1)
print(p2)
Point de coordonnées [0.250000, 1.500000]
Point de coordonnées [1.000000, 1.000000]

Exceptions

  • Dans Python les erreurs sont gérées à travers des "Exceptions"
  • Une erreur provoque une Exception qui interrompt l'exécution normale du programme
  • L'exécution peut éventuellement reprendre à l'intérieur d'un bloc de code try - except
  • Une utilisation typique: arrêter l'exécution d'une fonction en cas d'erreur:

def my_function(arguments) :

if not verify(arguments): raise Expection("Invalid arguments")

et on continue

On utilise try et expect pour maîtriser les erreurs : try:

# normal code goes here

except:

# code for error handling goes here
# this code is not executed unless the code
# above generated an error

Par exemple :

In [8]:
try:
    print("test_var")
    # genere une erreur: la variable test n'est pas définie
    print(test_var)
except:
    print("Caught an expection")
test_var
Caught an expection

Pour obtenir de l'information sur l'erreur : accéder à l'instance de la classe Exception concernée:

except Exception as e :

In [10]:
try:
    print("test")
    # generate an error: the variable test is not defined
    print(test)
except Exception as e:
    print("Caught an expection:", e)
test
Caught an expection: name 'test' is not defined

Fichiers

L’écriture et la lecture dans un fichier s’effectuent toujours de la même manière. On ouvre le fichier en mode écriture ou lecture, on écrit ou on lit, puis on ferme le fichier, le laissant disponible pour une utilisation ultérieure. Ce paragraphe ne présente pas l’écriture ou la lecture dans un format binaire car celle-ci est peu utilisée dans ce langage.

Dans cette partie, on prend l'exemple d'un fichier SerieTV.txt ayant le contenu suivant :

walking dead

Black Mirror

Narcos

Game of Thrones

* Lecture dans un fichier texte

La lecture dans un fichier texte s’effectue selon le même schéma :

In [ ]:
f = open(' nom_du_fichier.txt ','r')
lignes =f.readlines ()
f.close ()
  • Ouverture du fichier : open(nom,mode)
    • nom : chaîne de caractère, nom du fichier
    • mode : chaîne de caractères, accès au fichier (’r’ : read, ’w’ : write, ’a’ : append)
  • Lecture ligne par ligne ; La ligne est affectée à une variable texte
  • Principales méthodes :
    • read() Lit tout le fichier (jusqu’à EOF) et renvoie un str
    • read(n) Lit n caractères du fichier à partir de la position courante
    • readline() Lit une ligne du fichier jusqu’à nn et renvoie la chaîne
    • readlines() Lit toutes les lignes du fichier, renvoie un objet list
  • Fermeture du fichier

Méthodes seek() et tell()

Les méthodes seek() et tell() permettent respectivement de se déplacer au n ième caractère (plus exactement au n ième octet) d’un fichier et d’afficher où en est la lecture du fichier, c’est-à-dire quel caractère (ou octet) est en train d’être lu.

In [ ]:
f1 = open('SerieTV.txt', 'r')
f1.readline()
'walking dead\n'
f1.tell()
14
f1.seek(0)
f1.tell()
0
f1.readline()
'walking dead\n'
f1.readline()
'Black Mirror \n'
f1.close()

On remarque qu'à l’ouverture d’un fichier, le tout premier caractère est indexé par 0 (tout comme le premier élément d’une liste). La méthode seek() permet facilement de remonter au début du fichier lorsque l’on est arrivé à la fin ou lorsqu’on en a lu une partie.

Itérations directement sur le fichier

Il existe également un moyen à la fois simple et élégant de parcourir un fichier.

In [ ]:
f1 = open('SerieTV.txt', 'r')
for ligne in f1:
    print(ligne)
    
walking dead

Black Mirror 

Narcos

Game of Thrones

f1.close()

La boucle for va demander à Python d’aller lire le fichier ligne par ligne.

*Ecriture dans un fichier texte

La syntaxe d'écriture dans un fichier est la suivante :

In [ ]:
f = open ("nom-fichier", "w") # ouverture en mode écriture "w" ou écriture ajout "a"
f.write ( s ) # écriture de la chaîne de caractères s
f.write ( s2 ) # écriture de la chaîne de caractères s2
...
f.close () # fermeture

Certains codes sont très utiles lors de l’écriture de fichiers texte comme : \n : passage à la ligne

\t : insertion d’une tabulation, indique un passage à la colonne suivante dans le logiciel Excel

In [ ]:
#### Lecture et ecriture d'un fichier CSV
In [ ]:
import csv
def read_csv_file ( filename ):
    """ Lire un fichier CSV et ecrire chaque ligne sous
    forme de liste """
    f = open( filename)
    for row in csv.reader (f):
        print( row )
        f. close()
In [ ]:
import csv
def read_csv_file1 ( filename ):
    """ Lire un fichier CSV et ajouter les elements a la liste . """
    f = open( filename )
    data = []
    for row in csv.reader (f):
        data.append ( row )
        print(data)
        f.close()
In [ ]:
def write_csv(filename):
    import csv
    L = [['Date', 'Nom', 'Notes'],
         ['2016/1/18', 'Martin Luther King Day', 'Federal Holiday'],
         ['2016/2/2','Groundhog Day', 'Observance'],
         ['2016/2/8','Chinese New Year', 'Observance'],
         ['2016/2/14','Valentine\'s Day', 'Obervance'],
         ['2016/5/8','Mother\'s Day', 'Observance'],
         ['2016/8/19','Statehood Day', 'Hawaii Holiday'],
         ['2016/10/28','Nevada Day', 'Nevada Holiday']]
    f = open(filename, 'w', newline='')
    for item in L:
        csv.writer(f).writerow(item)
    f.close()

*Méthode optimisée d’ouverture et de fermeture de fichier

Depuis la version 2.5, Python introduit le mot-clé with qui permet d’ouvrir et fermer un fichier de manière commode. Si pour une raison ou une autre l’ouverture conduit à une erreur (problème de droits, etc), l’utilisation de with garantit la bonne fermeture du fichier (ce qui n’est pas le cas avec l’utilisation de la méthode open() invoquée telle quelle). Voici un exemple :

In [ ]:
with open('SerieTV.txt', 'r') as f1:
    for ligne in f1:
    print(ligne)

walking dead

Black Mirror 

Narcos

Game of Thrones

Vous remarquez que with introduit un bloc d’indentation. C’est à l’intérieur de ce bloc que nous effectuons toutes les opérations sur le fichier. Une fois sorti, Python fermera automatiquement le fichier. Vous n’avez donc plus besoin d’invoquer la fonction close().

Modules

  • Un module contient un ensemble de fonctions et commandes
  • Python dispose d’une bibliothèque de base quand il est initialisé. Et selon nos besoins ces bibliothèques vont être chargées.
  • Pour utiliser un module, il faut l’importer.
    • Nous avons deux types de modules : ceux disponibles sur Internet (programmés par d’autres) et ceux que l’on programme soi-même.
  • Pour les modules disponibles, les bibliothèques souvent utiles pour faire un programme python scientifique, nous avons : import os import sys import numpy as np import math
    import random import csv import scipy import matplotlib . pylab as plt

Syntaxe d'importation

Syntaxe 1 : importer le module sous son nom

In [3]:
import math
# on peut utiliser math.sin, math.sqrt...

Syntaxe 2 : importer le module sous un nom différent

 - permet d’abréger le nom des modules
In [ ]:
import math as m

# on utilise m.sin, m.sqrt...

Syntaxe 3 : importer seulement certaines définitions

In [ ]:
from math import sqrt
# on peut utiliser uniquement sqrt (les autres fonctions math.sin..., ne sont pas reconnu)
  • On peut utiliser help pour obtenir de l'aide sur les modules importés.
In [4]:
help(math)
Help on built-in module math:

NAME
    math

DESCRIPTION
    This module is always available.  It provides access to the
    mathematical functions defined by the C standard.

FUNCTIONS
    acos(...)
        acos(x)
        
        Return the arc cosine (measured in radians) of x.
    
    acosh(...)
        acosh(x)
        
        Return the inverse hyperbolic cosine of x.
    
    asin(...)
        asin(x)
        
        Return the arc sine (measured in radians) of x.
    
    asinh(...)
        asinh(x)
        
        Return the inverse hyperbolic sine of x.
    
    atan(...)
        atan(x)
        
        Return the arc tangent (measured in radians) of x.
    
    atan2(...)
        atan2(y, x)
        
        Return the arc tangent (measured in radians) of y/x.
        Unlike atan(y/x), the signs of both x and y are considered.
    
    atanh(...)
        atanh(x)
        
        Return the inverse hyperbolic tangent of x.
    
    ceil(...)
        ceil(x)
        
        Return the ceiling of x as an Integral.
        This is the smallest integer >= x.
    
    copysign(...)
        copysign(x, y)
        
        Return a float with the magnitude (absolute value) of x but the sign 
        of y. On platforms that support signed zeros, copysign(1.0, -0.0) 
        returns -1.0.
    
    cos(...)
        cos(x)
        
        Return the cosine of x (measured in radians).
    
    cosh(...)
        cosh(x)
        
        Return the hyperbolic cosine of x.
    
    degrees(...)
        degrees(x)
        
        Convert angle x from radians to degrees.
    
    erf(...)
        erf(x)
        
        Error function at x.
    
    erfc(...)
        erfc(x)
        
        Complementary error function at x.
    
    exp(...)
        exp(x)
        
        Return e raised to the power of x.
    
    expm1(...)
        expm1(x)
        
        Return exp(x)-1.
        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
    
    fabs(...)
        fabs(x)
        
        Return the absolute value of the float x.
    
    factorial(...)
        factorial(x) -> Integral
        
        Find x!. Raise a ValueError if x is negative or non-integral.
    
    floor(...)
        floor(x)
        
        Return the floor of x as an Integral.
        This is the largest integer <= x.
    
    fmod(...)
        fmod(x, y)
        
        Return fmod(x, y), according to platform C.  x % y may differ.
    
    frexp(...)
        frexp(x)
        
        Return the mantissa and exponent of x, as pair (m, e).
        m is a float and e is an int, such that x = m * 2.**e.
        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
    
    fsum(...)
        fsum(iterable)
        
        Return an accurate floating point sum of values in the iterable.
        Assumes IEEE-754 floating point arithmetic.
    
    gamma(...)
        gamma(x)
        
        Gamma function at x.
    
    gcd(...)
        gcd(x, y) -> int
        greatest common divisor of x and y
    
    hypot(...)
        hypot(x, y)
        
        Return the Euclidean distance, sqrt(x*x + y*y).
    
    isclose(...)
        isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) -> bool
        
        Determine whether two floating point numbers are close in value.
        
           rel_tol
               maximum difference for being considered "close", relative to the
               magnitude of the input values
            abs_tol
               maximum difference for being considered "close", regardless of the
               magnitude of the input values
        
        Return True if a is close in value to b, and False otherwise.
        
        For the values to be considered close, the difference between them
        must be smaller than at least one of the tolerances.
        
        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That
        is, NaN is not close to anything, even itself.  inf and -inf are
        only close to themselves.
    
    isfinite(...)
        isfinite(x) -> bool
        
        Return True if x is neither an infinity nor a NaN, and False otherwise.
    
    isinf(...)
        isinf(x) -> bool
        
        Return True if x is a positive or negative infinity, and False otherwise.
    
    isnan(...)
        isnan(x) -> bool
        
        Return True if x is a NaN (not a number), and False otherwise.
    
    ldexp(...)
        ldexp(x, i)
        
        Return x * (2**i).
    
    lgamma(...)
        lgamma(x)
        
        Natural logarithm of absolute value of Gamma function at x.
    
    log(...)
        log(x[, base])
        
        Return the logarithm of x to the given base.
        If the base not specified, returns the natural logarithm (base e) of x.
    
    log10(...)
        log10(x)
        
        Return the base 10 logarithm of x.
    
    log1p(...)
        log1p(x)
        
        Return the natural logarithm of 1+x (base e).
        The result is computed in a way which is accurate for x near zero.
    
    log2(...)
        log2(x)
        
        Return the base 2 logarithm of x.
    
    modf(...)
        modf(x)
        
        Return the fractional and integer parts of x.  Both results carry the sign
        of x and are floats.
    
    pow(...)
        pow(x, y)
        
        Return x**y (x to the power of y).
    
    radians(...)
        radians(x)
        
        Convert angle x from degrees to radians.
    
    sin(...)
        sin(x)
        
        Return the sine of x (measured in radians).
    
    sinh(...)
        sinh(x)
        
        Return the hyperbolic sine of x.
    
    sqrt(...)
        sqrt(x)
        
        Return the square root of x.
    
    tan(...)
        tan(x)
        
        Return the tangent of x (measured in radians).
    
    tanh(...)
        tanh(x)
        
        Return the hyperbolic tangent of x.
    
    trunc(...)
        trunc(x:Real) -> Integral
        
        Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.

DATA
    e = 2.718281828459045
    inf = inf
    nan = nan
    pi = 3.141592653589793

FILE
    (built-in)


ou, si on veut connaître en seul coup d’oeil toutes les méthodes ou variables associées à un module (ou objet), on peut utiliser la commande dir

In [4]:
print(dir(math))
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

Modules courants

Il existe une série de modules que vous serez probablement amenés à utiliser si vous programmez en Python. En voici une liste non exhaustive. Pour la liste complète, reportez-vous àla page des modules sur le site de Python :

*math : fonctions et constantes mathématiques de base (sin, cos, exp, pi...).

*sys : passage d'arguments, gestion de l'entrée/sortie standard...

*os : dialogue avec le système d'exploitation (e.g. permet de sortir de Python, lancer une commande en {\it shell}, puis de revenir à Python).

*random : génération de nombres aléatoires.

*time : permet d'accéder à l'heure de l'ordinateur et aux fonctions gérant le temps.

*calendar : fonctions de calendrier.

*profile : permet d'évaluer le temps d'exécution de chaque fonction dans un programme ({\it profiling} en anglais).

*urllib2 : permet de récupérer des données sur internet depuis python.

*Tkinter : interface python avec Tk (permet de créer des objets graphiques; nécessite d'installer Tk.

*re : gestion des expressions régulières.

Je vous conseille vivement d'aller surfer sur les pages de ces modules pour découvrir toutes leurs potentialités.

Création de vos propres modules

  • Vous pouvez également définir vos propres modules.

Considérez l'exemple suivant: le fichier mymodule.py contient des exemples simples d'implémentation d'une variable, d'une fonction et d'une classe :

In [193]:
%%file monmodule.py
"""
Exemple de module python. Contient une variable appelée ma_variable,
Une fonction appelée ma_fonction, et une classe appelée MaClasse.
"""

ma_variable = 0

def ma_fonction():
    """
    Exemple de fonction
    """
    return ma_variable*2
    
class MaClasse:
    """
    Exemple de classe.
    """

    def __init__(self):
        self.variable = ma_variable
        
    def set_variable(self, n_val):
        """
        Définir self.variable à n_val
        """
        self.variable = n_val
        
    def get_variable(self):
        return self.variable
Overwriting monmodule.py

On peut importer le module monmodule dans notre programme Python en utilisant import :

In [194]:
import monmodule
In [195]:
monmodule.ma_variable
Out[195]:
0

La bibliothèque standard et ses modules

Une bibliothèque standard Python (Python Standard Library) est une collection de modules qui donne accès à des fonctionnalités de bases : appels au système d'exploitation, gestion des fichiers, gestion des chaînes de caractères, interface réseau, etc.

Références

Quelques liens