Mémento Python 3 (partie 1)

entier, flottant, booléen, chaîne, octets Types de base◾ séquences ordonnées, accès par index rapide, valeurs répétables Types conteneurs
int 783 0 -192 0b010 0o642 0xF3 list [1,5,9] ["x",11,8.9] ["mot"] []
nul binaire octal hexa tuple (1,5,9) 11,"y",7.4 ("mot",) ()
float 9.23 0.0 -1.7e-6
-6 Valeurs non modifiables (immutables) ☝ expression juste avec des virgules →tuple
bool True False ×10
Chaîne multiligne :
str bytes (séquences ordonnées de caractères / d'octets) ""
str "Un\nDeux" b""
◾ conteneurs clés, sans ordre a priori, accès par clé rapide, chaque clé unique
retour à la ligne échappé """X\tY\tZ
'L\'âme' 1\t2\t3""" dictionnaire dict {"clé":"valeur"} dict(a=3,b=4,k="v") {}
' échappé tabulation échappée (couples clé/valeur) {1:"un",3:"trois",2:"deux",3.14:"π"}
bytes b"toto\xfe\775" ensemble set {"clé1","clé2"} {1,9,3,0} set()
hexadécimal octal ☝ immutables ☝ clés=valeurs hachables (types base, immutables…) frozenset ensemble immutable vides

pour noms de variables, Identificateurs type(expression) Conversions

int("15") → 15
fonctions, modules, classes…
int("3f",16) → 63 spécification de la base du nombre entier en 2nd paramètre
a…zA…Z_ suivi de a…zA…Z_0…9
◽ accents possibles mais à éviter int(15.56) → 15 troncature de la partie décimale
◽ mots clés du langage interdits float("-11.24e8") → -1124000000.0
◽ distinction casse min/MAJ round(15.56,1)→ 15.6 arrondi à 1 décimale (0 décimale → nb entier)
☺ a toto x7 y_max BigOne bool(x) False pour x nul, x conteneur vide, x None ou False ; True pour autres x
☹ 8y and for str(x)→ "…" chaîne de représentation de x pour l'affichage (cf. Formatage, en partie 2)
chr(64)→'@' ord('@')→64 code ↔ caractère
= Affectation de variables repr(x)→ "…" chaîne de représentation littérale de x
☝ association d'un nom à une valeur bytes([72,9,64]) → b'H\t@'
1) évaluation de la valeur de l'expression de droite list("abc") → ['a','b','c']
2) affectation dans l'ordre avec les noms de gauche dict([(3,"trois"),(1,"un")]) → {1:'un',3:'trois'}
x=1.2+8+sin(y) set(["un","deux"]) → {'un','deux'}
a=b=c=0 affectation à la même valeur str de jointure et séquence de str → str assemblée
y,z,r=9,-7.6,0 affectations multiples ':'.join(['toto','12','pswd']) → 'toto:12:pswd'
a,b=b,a échange de valeurs str découpée sur les blancs → list de str
a,*b=seq dépaquetage de séquence en "des mots espacés".split() → ['des','mots','espacés']
*a,b=seq élément et liste str découpée sur str séparateur → list de str
x+=3 incrémentation ⇔ x=x+3 et
*= "1,4,8,2".split(",") → ['1','4','8','2']
x-=2 décrémentation ⇔ x=x-2 /= séquence d'un type → list d'un autre type (par liste en compréhension)
x=None valeur constante « non défini » %=
del x suppression du nom x
[int(x) for x in ('1','29','-3')] → [1,29,-3]
…

pour les listes, tuples, chaînes de caractères, bytes… Indexation des conteneurs séquences
index négatif -5 -4 -2 -3 -1 Nombre d'éléments Accès individuel aux éléments par lst[index]
index positif 0 1 3 2 4 len(lst)→5 lst[0]→10 ⇒ le premier lst[1]→20
lst=[10, 20, 30, 40, 50] lst[-1]→50 ⇒ le dernier lst[-2]→40
tranche positive 0 1 2 3 4 5 ☝ index à partir de 0
Sur les séquences modifiables (list),
tranche négative -5 -4 -3 -2 -1 (de 0 à 4 ici)
suppression avec del lst[3] et modification
Accès à des sous-séquences par lst[tranche début:tranche fin:pas] par affectation lst[4]=25
lst[:-1]→[10,20,30,40] lst[::-1]→[50,40,30,20,10] lst[1:3]→[20,30] lst[:3]→[10,20,30]
lst[1:-1]→[20,30,40] lst[::-2]→[50,30,10] lst[-3:-1]→[30,40] lst[3:]→[40,50]
lst[::2]→[10,30,50] lst[:]→[10,20,30,40,50] copie superficielle de la séquence
Indication de tranche manquante → à partir du début / jusqu'à la fin.
Sur les séquences modifiables (list), suppression avec del lst[3:5] et modification par affectation lst[1:4]=[15,25]

Logique booléenne Blocs d'instructions module truc ⇔ fichier truc.py Modules & Imports
Comparateurs : < > <= >= == != from monmod import nom1,nom2 as fct
(résultats booléens) ≤ ≥ = ≠ instruction parente: → accès direct a nom1, renommage nom2 en fct avec as
a and b et logique les deux en bloc d'instructions 1… import monmod → accès via monmod.nom1 …
même temps
indentation !

⁝ ☝ modules et packages cherchés dans le python path (cf. sys.path)

a or b ou logique l'un ou l'autre instruction parente:
ou les deux un bloc d'instructions exécuté, Instruction conditionnelle
☝ piège : and et or retournent la valeur bloc d'instructions 2…
⁝ uniquement si sa condition est vraie
de a ou de b (selon l'évaluation au plus
court). if condition logique: oui ? non oui ?
⇒ s'assurer que a et b sont booléens. instruction suivante après bloc 1 bloc d'instructions non
not a non logique Combinable avec des sinon si, sinon si...
True ☝ régler l'éditeur pour insérer 4 espaces à et un seul sinon final. Seul le bloc de la
constantes Vrai/Faux if age<=18:
False la place d'une tabulation d'indentation. première condition trouvée vraie est
etat="Enfant"
exécuté. elif age>65:
☝ nombres flottants… valeurs approchées ! angles en radians Maths ☝ avec une variable x : etat="Retraité"
if bool(x)==True: ⇔ if x: else:
Opérateurs : + - * / // % ** from math import sin,pi…
if bool(x)==False: ⇔ if not x: etat="Actif"
Priorités (…) × ÷ ab sin(pi/4)→0.707…
÷ entière reste ÷ cos(2*pi/3)→-0.4999… Signalisation sur détection : Exceptions sur erreurs
@ → × matricielle (python3.5+numpy) sqrt(81)→9.0 √ raise ExcClass(…) traitement
(1+5.3)*2→12.6 log(e**2)→2.0 Traitement : traitement erreur
abs(-3.2)→3.2 ceil(12.5)→13 try: raise X() traitement raise
bloc traitement normal normal erreur
round(3.57,1)→3.6 floor(12.5)→12
pow(4,3)→64.0 modules math, statistics, random, except ExcClass as e: ☝ bloc finally pour traitements
☝ priorités usuelles decimal, fractions, numpy, etc. bloc traitement erreur finaux dans tous les cas.
 Mémento Python 3 (partie 2)
Instruction boucle conditionnelle bloc d'instructions exécuté pour Instruction boucle itérative
☝ attention aux boucles sans fin !
bloc d'instructions exécuté
tant que la condition est vraie chaque élément d'un conteneur ou d'un itérateur
while condition logique: oui ? Contrôle de boucle for var in séquence: suivant …
bloc d'instructions non break sortie immédiate bloc d'instructions fini
continue itération suivante

☝ bonne habitude : ne pas modifier la variable de boucle

s = 0 initialisations avant la boucle ☝ bloc else en sortie Parcours des valeurs d'un conteneur
i = 1 normale de boucle. s = "Du texte" initialisations avant la boucle
condition avec au moins une valeur cpt = 0
while i <= 100: variable (ici i) Algo : i=100 variable de boucle, affectation gérée par l'instruction for
2 for c in s:
s = s + i**2
i = i + 1 ☝ faire varier la variable de condition ! s= i ∑ if c == "e":
cpt = cpt + 1
Algo : comptage
du nombre de e
print("somme:",s) i=1
print("trouvé",cpt,"'e'") dans la chaîne.
print("v=",3,"cm :",x,",",y+4) Affichage boucle sur dict/set ⇔ boucle sur séquence des clés ; utilisation des
tranches pour parcourir un sous-ensemble d'une séquence
éléments à afficher : valeurs littérales, variables, expressions Parcours des index d'un conteneur séquence
Options de print: ◽ changement de l'élément à la position
◽ accès aux éléments autour de la position (avant/après)
◽ sep=" " séparateur d'éléments, défaut espace
lst = [11,18,9,12,23,4,17]
◽ end="\n" fin d'affichage, défaut fin de ligne perdu = [] Algo : bornage des
◽ file=sys.stdout print vers fichier, défaut sortie standard for idx in range(len(lst)): valeurs supérieures à 15,
Saisie val = lst[idx] mémorisation des
s = input("Directives:") if val > 15: valeurs perdues.
☝ input retourne toujours une chaîne, la convertir vers le type désiré perdu.append(val)
lst[idx] = 15
(cf. encadré Conversions, en partie 1). print("modif:",lst,"-modif:",perdu)
len(c)→ nb d'éléments Opérations génériques sur conteneurs Parcours simultané index et valeurs de la séquence :
min(c) max(c) sum(c) Note : pour dictionnaires et ensembles, for idx,val in enumerate(lst):
sorted(c)→ list copie triée ces opérations travaillent sur les clés.
val in c → booléen, opérateur in de test de présence (not in d'absence) range([début,] fin [,pas]) Séquences d'entiers
enumerate(c)→ itérateur sur (index, valeur) ☝ début défaut 0, fin non compris, pas signé et défaut 1
zip(c1,c2…)→ itérateur sur tuples contenant les éléments de même index des ci range(5)→ 0 1 2 3 4 range(2,12,3)→ 2 5 8 11
all(c)→ True si tout élément de c évalué vrai, sinon False range(3,8)→ 3 4 5 6 7 range(20,5,-5)→ 20 15 10
any(c)→ True si au moins un élément de c évalué vrai, sinon False range(len(séq))→ séquence des index des valeurs dans séq
Spécifique aux conteneurs de séquences ordonnées (listes, tuples, chaînes, bytes…) ☝ range fournit une séquence immutable d'entiers construits au besoin
reversed(c)→ itérateur inversé c*5→ duplication c+c2→ concaténation
c.index(val)→ position c.count(val)→ nb d'occurences nom de la fonction (identificateur) Définition de fonction
import copy
paramètres nommés
copy.copy(c)→ copie superficielle (1er niveau) du conteneur def fct(x,y,z): fct
copy.deepcopy(c)→ copie en profondeur (récursive) du conteneur """documentation"""
☝ modification de la liste originale Opérations sur listes # bloc instructions, calcul de res, etc.
lst.append(val) ajout d'un élément à la fin return res valeur résultat de l'appel, si pas de résultat
lst.extend(seq) ajout d'une séquence d'éléments à la fin calculé à retourner : return None
☝ les paramètres et toutes les
lst.insert(idx,val) insertion d'un élément à une position variables de ce bloc n'existent que dans le bloc et pendant l'appel à la
lst.remove(val) suppression du premier élément de valeur val fonction (penser “boîte noire”)
lst.pop([idx])→valeur supp. & retourne l'item à l'index (sinon le dernier) Avancé : def fct(x,y,z,*args,a=3,b=5,**kwargs):
lst.sort() lst.reverse() tri / inversion de la liste sur place *args ↣ nb variables d'arguments positionnels (tuple), a=3 ↣ valeurs
par défaut, **kwargs ↣ nb variable d'arguments nommés (dict).
Opérations sur dictionnaires Opérations sur ensembles
d[clé]=valeur d.clear() Opérateurs : r = fct(3,i+2,2*i) Appel de fonction
d[clé]→ valeur del d[clé] | → union (caractère barre verticale) stockage/utilisation une valeur d'argument
de la valeur de retour par paramètre
d.update(d2) mise à jour/ajout & → intersection
fct() fct
des couples - ^ → différence/diff. symétrique ☝ c'est l'utilisation du nom de Avancé:
d.keys() la fonction avec les paren- *séquence
d.values() →vues itérables sur les < <= > >=→ relations d'inclusion **dict
d.items() clés / valeurs / couples Existent aussi sous forme de méthodes. thèses qui fait l'appel
d.pop(clé[,défaut])→ valeur s.update(s2) s.copy() s.startswith(prefix[,début[,fin]]) Opérations sur chaînes
d.popitem()→ (clé,valeur) s.add(clé) s.remove(clé) s.endswith(suffix[,début[,fin]]) s.strip([caractères])
d.get(clé[,défaut])→ valeur s.discard(clé) s.clear() s.count(sub[,début[,fin]]) s.partition(sep)→ (avant,sep,après)
d.setdefault(clé[,défaut])→valeur s.pop()
s.index(sub[,début[,fin]]) s.find(sub[,début[,fin]])
stockage de données sur disque, et relecture Fichiers s.is…() tests sur les catégories de caractères (ex. s.isalpha())
f = open("fic.txt","w",encoding="utf8") s.upper() s.lower() s.title() s.swapcase()
s.casefold() s.capitalize() s.center([larg,rempl])
variable nom du fichier mode d'ouverture encodage des s.ljust([larg,rempl]) s.rjust([larg,rempl]) s.zfill([larg])
fichier pour sur le disque ◽ 'r' lecture (read) caractères pour les s.encode(codage) s.split([sep]) s.join(séq)
les opérations (+ chemin…) ◽ 'w' écriture (write) fichiers textes :
◽ 'a' ajout (append) utf8 ascii directives de formatage valeurs à formater Formatage
Cf. modules os,os.path,pathlib ◽ …'+' 'x' 'b' 't' latin1 …
"modele{} {} {}".format(x,y,r) str
en écriture ☝ lit chaîne vide si fin de fichier en lecture
f.write("coucou") f.read([n]) → caractères suivants "{sélection:formatage!conversion}"
f.writelines(list lignes) si n non spécifié, lit jusqu'à la fin ! ◽ Sélection : "{:+2.3f}".format(45.72793)
f.readlines([n]) → list lignes suiv. 2 →'+45.728'
Exemples

f.readline() → ligne suivante nom "{1:>10s}".format(8,"toto")

☝ par défaut mode texte t (lit/écrit str), mode binaire b possible 0.nom →' toto'
(lit/écrit bytes). Convertir de/vers le type désiré ! 4[clé] "{x!r}".format(x="L'ame")
0[2] →'"L\'ame"'
f.close() ☝ ne pas oublier de refermer le fichier après son utilisation ! ◽ Formatage :
f.flush() écriture du cache f.truncate([taille]) retaillage car-rempl. alignement signe larg.mini.précision~larg.max type
☝ lecture/écriture progressent séquentiellement dans le fichier, modifiable avec :
<>^= + - espace 0 au début pour remplissage avec des 0
f.tell()→position f.seek(position[,origine]) entiers : b binaire, c caractère, d décimal (défaut), o octal, x ou X hexa…
Très courant : ouverture en bloc gardé (ferme- with open(…) as f: flottant : e ou E exponentielle, f ou F point fixe, g ou G approprié (défaut), 
ture automatique) et boucle de lecture des for ligne in f : chaîne : s … % pourcentage
lignes d'un fichier texte : # traitement de ligne ◽ Conversion : s (texte lisible) ou r (représentation littérale)