Langage Python

Collections
 Liste

Les listes (ou list) en python sont une variable dans laquelle on peut mettre
plusieurs variables (les éléments peuvent être quelconques).
• Créer une liste vide: maListe = []; maListe = list()
• Initialiser une liste: maListe = [1,2,3]
• Retourner la taille de une liste: len(maListe)
• Retourner l’élément par l'indice (commence à 0): maListe[2]
• Retourner le dernier élément : maListe[-1]
• Retourner une sous liste: maListe[0:2]
• Insertion des éléments d’une liste: maListe[1:1] = ['x','y']
• Supprimer un élément (par un indice): del maListe[2]
• Inverser la liste : maListe.reverse(); maListe[::-1]
 Liste

Concaténer 2 listes : maListe1 + maListe2

Copie de liste :
• maListe2 = maListe1 : maListe2 et maListe1 référencent la même liste.
• maListe2 = maListe1[:] : maListe2 est une copie de la liste maListe1.
• maListe2 = list(maListe1) : maListe2 est une copie de la liste maListe1.
 Liste

Fonctions sur les listes :

• maListe.append(x) : ajoute un élément x.
• maListe.extend(maListe2) : ajoute la liste maListe2 à la fin.
• maListe.insert(i, x) : insert l'élément i à la position x, et décale le reste (comme l[i:i] = x).
• maListe.remove(x) : enlève le premier élément identique à x (erreur si non trouvé).
• maListe.pop() : enlève le dernier élément et le renvoie.
• maListe.pop(0) : enlève le premier élément et le renvoie.
• maListe.pop(i) : enlève l'élément à la position i et le renvoie.
• maListe.index(x) : renvoie l'index du 1er élément identique à x (erreur si non trouvé).
• maListe.count(x) : compte combien de fois l'élément x est dans la liste.
• maListe.sort() : trie en place les éléments de la liste.
 Tuple

Les tuples c'est comme une liste, sauf que les éléments ne peuvent pas être
changés (immuables), il est impossible de les remplacer ou de les supprimer.
Définition d'un tuple :
• t = ('a', 'b', 2)
• tuple à 0 élément : t = ()
• tuple à 1 élément : t = ('a',) ou t = 'a', avec la virgule dans les 2 cas !
• tuple à 2 éléments : t = ('a', 'b') ou t = 'a', 'b'

Les Tuples fournissent seulement deux méthodes:

• t.count (x), qui renvoie le nombre de fois objet x se produit dans tuple t,
• t.index (x), qui renvoie la position de la première occurrence de x
 Tuple

les tuples peuvent être utilisés avec les opérateurs :

• + (concaténation),
• * (réplication)
• [] (tranche),
• in et not in pour critère de l'appartenance.
Le += et *= opérateurs d'affectation augmentée peuvent être utilisés.
Tuples peuvent être comparées en utilisant les opérateurs de comparaison
standard (<, <=, ==,! =,> =,>), Avec les comparaisons étant appliquées article
par article (et récursivement pour les éléments imbriqués comme tuples
intérieur tuples).
 Séquences

• En python, une séquence est : une string (chaîne), une list (liste) ou un tuple.

• in, not in : opérateurs de condition pour savoir si une valeur est présente dans une séquence.

• is, is not : pour savoir si 2 objets mutables (liste) sont réellement les mêmes.

• Conversion des séquences :

• list('abc') : convertit une chaîne en liste, ici ['a', 'b', 'c'].
• tuple('abc') : convertit une chaîne en tuple, ici ('a', 'b', 'c').
• list(('a', 'b', 'c')) : convertit un tuple en liste, ici ['a', 'b', 'c'].
• tuple(['a', 'b', 'c']) : convertit une liste en tuple, ici ('a', 'b', 'c').

• affectation : du moment que les séquences ont le même nombre d'éléments, on peut faire :
• (x, y, z) = (1, 2, 3)
• [x, y, z] = [1, 2, 3]
• mais aussi (x, y, z) = [1, 2, 3] et [x, y, z] = (1, 2, 3)
• et même : (x, y, z) = 'abc' ou [x, y, z] = 'abc'
 Dictionnaire

Un dictionnaire en python est une sorte de liste mais au lieu d'utiliser des
index, on utilise des clés alphanumériques.
• d = {} : initialisation à vide, on peut aussi faire d = dict().
• d = {'toto': 1, 'titi': 2} : initialisation.
• Définir un dictionnaire avec une liste de paires : d = dict([('a', 1), ('b', 2)])
• d['toto'] = 5 : affectation d'une valeur.
• les clefs d'un dictionnaire peuvent être des tuples (de constantes) ! (mais pas des listes)
• del d['toto'] : destruction d'une clef.
• d.keys() : renvoie les clefs sous forme d'une nouvelle liste.
• 'toto' in d ('toto' not in d ) : test de l'existence (non existence ) d'une clef.
• len(d) : renvoie le nombre d'items dans le dictionnaire.
 Dictionnaire
Fonctions sur les dictionnaires:
• d.clear() : efface tout.
• d.copy() : shallow copie
• d.get(key) (ou d.get(key, defaultVal) ): renvoie la valeur si clef présente, sinon None (ou defaultVal)
• d.items() : renvoie une copie du dictionnaire sous forme de liste de paires (key, value).
• d.pop(key) (ou d.pop(key, val) ) : enlève la clef et renvoie la valeur si clef n'existe pas KeyError ( ou
val sans lever une exception).
• d.popitem() : renvoie une paire (key, value) au hasard et la retire du dictionnaire.
• d.values() : renvoie une copie de la liste des valeurs.
• d.setdefault(key, defaultVal) : si la clef existe, renvoie sa valeur, si la clef n'existe pas, insère la clef
avec la valeur defaultVal et renvoie sa valeur.
• d.iterkeys().next(): pour avoir une seule clef du dictionnaire
 Ensemble
Un Ensemble (ou set) en python est une collection non ordonnée de zéro au plusieurs références d'objets
qui se réfèrent à des objets hachables. Les ensembles sont mutables, facilement ajouter ou supprimer des
éléments, mais comme ils sont désordonnés, ils n'ont aucune notion de position (indice d’élément)
• s = set() : initialisation d'un set avec aucun élément.
• s = set(['a', 'b', 'c']) ou s={'a', 'b', 'c'} ou s = set('abc') : définition d'un set.
• s = frozenset(['a', 'b', 'c']) : définition d'un set non modifiable.
• test si un élément appartient au set : 'a' in s (ou: 'a' not in s).
• ajout d'un élément : s.add('d').
• retrait d'un élément : s.discard('d') ou s.remove('d') (remove donne une exception KeyError si non
présent).
• enlever un élément au hasard et le renvoyer : s.pop()
• récupérer un élément au hasard sans l'enlever : iter(s).next()
• effacer tous les éléments au hasard et le renvoyer : s.clear()
• nombre d'éléments du set : len(s)
 Ensemble
Fonctions sur les dictionnaires:
• s.isdisjoint(s2) , s.issubset(s2), s.issuperset(s2)
• s <s2 : inclusion stricte (pareil avec s <= s2, s >= s2, s > s2).
• s.union(s2) : l’union, n'affecte pas les sets de départ (on peut aussi faire s | s2).
• s.intersection(s2) l’intersection(on peut aussi faire s & s2).
• set.union(s1, s2, s3) , set.intersection(s1, s2, s3) : renvoie l’union (intersection) de plusieurs sets (on peut
aussi faire s1 | s2 | s3, s1 & s2 & s3 ).
• s.difference(s2) (on peut aussi faire s - s2).
• s.symmetric_difference(s2) (on peut aussi faire s ^ s2).
• s.copy() : renvoie une shallow copy..
• s.update(s2) : rajoute les éléments à s et modifie s (on peut aussi faire s |= s2).
• s.intersection_update(s2) : l'intersection et modifie s (on peut aussi faire s &= s2).
• s.difference_update(s2) : la différence et modifie s (on peut aussi faire s -= s2).
• s.symmetric_difference_update(s2) : la différence symétrique et modifie s (on peut aussi faire s ^= s2).
Les instructions de contrôle
 Les instructions de contrôle

On appelle une instruction de contrôle toute instruction qui permet

de contrôler la succession des actions d'un programme.

Donc leur rôle est essentiel pour faire des tests dans un programme.
 Instructions de contrôle : if

if condition: if condition: if condition:

bloc d’instructions bloc d’instructions bloc d’instructions
else: elif condition:
bloc d’instructions bloc d’instructions
elif condition:
bloc d’instructions
elif condition:
bloc d’instructions
else:
• Si la condition est vraie alors le code est exécuté. bloc d’instructions
• Sinon, c’est le code de else qui est exécuté.
• Il peut y avoir plusieurs clauses elif, mais une seule clause else

Remarque : le code à exécuter peut être des instructions simples a=b ; ou un bloc
d’instructions a=b ; c=d ; ....
Instructions de contrôle : if

a,b = 4, 5
if a > b:
print("%f est supérieur à %f" % (a,b) )
elif a == b:
print("%f est égal à %f" % (a,b) )
else:
print("%f est inférieur à %f" % (a,b) )
Instructions de contrôle : if

La syntaxe suivante peut être parfois commode :

variable = expression1 if condition else expression2

* Si la condition est vraie, alors la valeur de expression1 est fournie comme résultat
* Si la condition est fausse, alors la valeur de expression2 est fournie comme résultat

max= a if a>b else b

Les boucles
 Les boucles

En programmation, la boucle est une structure de contrôle permettant d'exécuter

un ensemble d'instructions de façon répétée sur la base d'une condition booléenne.

La boucle peut être considérée comme une répétition de l'instruction de contrôle if.
Les boucles : while
La forme générale d’une boucle while :
while condition:
bloc d’instructions
else:
bloc d’instructions
l'instruction else est exécutée lorsque la condition devient false.
Les boucles : while

count = 0
while count < 5:
print(count, " est inférieur à 5")
count = count + 1
else:
print(count, " n'est pas inférieur à 5“)
Les boucles : for
La forme générale d’une boucle for:
for element in iterateur :
bloc d’instructions
else:
bloc d’instructions

element parcourt l’iterateur qui peut être une liste, un tuple,un fichier, ou tout autre
objet itérable. Un itérable est un objet Python sur lequel est définit un itérateur.
Pour chaque element de cet itérateur, le bloc d’instructions de la boucle est exécuté
l'instruction else est exécutée lorsque la boucle est épuisée.
Les boucles : for
maList=[1,7,5,0,9]

for x in maList:
print(x)

for x in 'abcdef':
print(x)

for i in range(len(maList)):
print(i, x[i])

range([a],b,[c]): permet de créer une liste. Elle accepte 1,2 ou 3 paramètres.

a contient le numéro de départ de la liste, b contient le dernier nombre de la
liste et finalement c l'incrément entre chaque nombre généré.
Les boucles : break et continue

break : sort directement de la boucle.

continue : retourne directement à l'itération suivante en sautant ce qui
est est après.
pas possible en python de sortir directement de 2 boucles imbriquées avec
un break
pass : ordre vide qui ne fait rien, mais qui est nécessaire si boucle ou
condition dont le contenu est vide, car il faut au moins une instruction

while True:
pass
Les boucles : break et continue

for n in range(0, 10):

if (n % 2) == 0:
continue
carre = n**2
if carre > 25:
break
Les fonctions
 Les fonctions

Une fonction est une suite d'instructions que l'on peut appeler avec un nom.

Définition d'une fonction :

def myFunc(args):
bloc d’instructions
Valeur de retour d'une fonction :
• une fonction peut renvoyer une valeur avec return.
• une fonction peut renvoyer un tuple qui est récupéré dans plusieurs
variables à condition que le nombre de variables égale le nombre de
valeurs du tuple
 Les fonctions

• Les paramètres sont passés par valeur (mais c'est la référence qui est passée par valeur
quand c'est une variable de type liste ou dictionnaire ou tuple).

• Lorsque vous indiquez des paramètres à une fonction, ces dernièrs doivent
impérativement être renseignés sans quoi une erreur apparaitra.

• On peut définir une fonction avec des valeurs par défaut : def myFunc(a, b=5)

• On peut appeler une fonction avec des arguments précisés par nom : myFunc(a=8)