Cheatsheet
Types de base
| int | 783 0 -192 0b010 0xF3 | ||||
| float | 9.23 0.0 -1.7e-6 | ||||
| bool | True False | ||||
| str |
|
||||
| NoneType | None |
Types conteneurs
| séquences ordonnées, accès par index rapide, valeurs répétables | |||||
|
[] | ||||
|
() | ||||
|
"" | ||||
| conteneurs clés, sans ordre a priori, accès par clé rapide, chaque clé unique | |||||
|
{} |
Identificateurs
pour noms de variables, fonctions, modules, classes…
a…zA…Z_ suivi de a…zA…Z_0…9
- accents possibles mais à éviter
- mots clés du langage interdits
- distinction casse min/MAJ
| 😀 | a | toto | x7 | y_max | BigOne |
| 😞 | 8y | and | for |
Variables et affectations
affectations ⇔ association d'un nom à une valeur
- évaluation de la valeur de l'expression de droite
- affectation dans l'ordre avec les noms de gauche
| x = 1.2 + 8 | affectation simple |
| y , z , r = 9.2 , -7.6 , 0 | affectation multiple |
| a , b = b , a | échange de valeurs |
| x += 3 | incrémentation ⇔ x = x + 3 |
| x -= 2 | décrémentation ⇔ x = x - 2 |
Conversion
en général: type(expression)
| int("15") → 15 | |
| int("3f", "16") → 63 | spécification de la base du nombre entier en 2nd paramètre |
| int(15.56) → 15 | troncature de la partie décimale |
| float("-11.24e8") → -1124000000.0 | |
| round(15.56, 1) → 15.6 | arrondi à 1 décimale (0 décimale → nb entier) |
| bool(x) | False pour x zéro, conteneur vide, None ou False ; True pour autres x |
| str(x) → "..." | chaîne de représentation de x pour l'affichage (cf. Formatage au verso) |
| chr(64) → '@' | code ↔ caractère |
| ord('@') → 64 | |
| list("abc") → ['a', 'b', 'c'] | |
| dict([(3,"trois"),(1,"un")]) → {1:'un',3:'trois'} | |
Logique booléenne
| Comparateurs | < | > | <= | >= | == | != |
| (résultats booléens) | ≤ | ≥ | = | ≠ | ||
| a and b | et logique (les deux en même temps) |
| a or b | ou logique (l'un ou l'autre ou les deux) |
| ⇒ s'assurer que a et b sont booléens. | |
| not a | non logique |
| True / False | constantes Vrai/Faux |
Indexation conteneurs séquences
pour les listes, tuples, chaînes de caractères...
| index négatif | -5 | -4 | -3 | -2 | -1 | ||||||
| index positif | 0 | 1 | 2 | 3 | 4 | ||||||
| lst = | [ | 10 | , | 20 | , | 30 | , | 40 | , | 50 | ] |
nombre d'éléments
len(lst) → 5
⚠ index à partir de 0
(de 0 à 4 ici)
Accès individuel aux éléments par lst[index]
lst[0]→10
lst[-1]→50
⇒ le premier
⇒ le dernier
lst[1]→20
lst[-2]→40
Sur les séquences modifiables (list), la modification se fait par affectation : lst[4] = 25
Blocs d'instruction
⚠ régler l'éditeur pour insérer 4 espaces à la place d'une tabulation d'indentation.
Imports modules/noms
module truc ⇔ fichier truc.py
from monmod import nom1, nom2 as fct →accès direct aux noms (renommage possible avec as)
import monmod →accès via monmod.nom1 …
☝ modules et packages cherchés dans le python path (cf. sys.path)
Instructions conditionnelles
un bloc d'instructions est exécuté uniquement si sa condition est vraie
if condition logique:
bloc d'instructions
seul ou combinable avec des sinon (else) et sinon si (elif). Seul le bloc de la première condition trouvée vraie est exécuté.
if age <= 18 :
etat = "Enfant"
elif age < 65 :
etat = "Retraité"
else :
etat = "Actif"
Maths
| Opérateurs : | + | - | * | / | // | % | ** |
☝ priorités usuelles, utilisation conseillée des parenthèses
1 + 5.3 * 2 → 11.6
abs(-3.2) → 3.2
round(3.57, 1) → 3.6
pow(4, 3) → 64.0
1.1 + 1.1 + 1.1 → 3.3000000000000003
☝ nombres flottants… valeurs approchées !
from math import sin, pi, ...
sin(pi/4) → 0.707…
cos(2*pi/3) → -0.4999…
sqrt(81) → 9.0 √
log(e**2) → 2.0
ceil(12.5) → 13
floor(12.5) → 12
modules math, statistics, random, decimal, fractions, numpy, etc.
Instruction boucle conditionnelle
bloc d'instructions exécuté tant que la condition est vraie
while condition logique:
bloc d'instructions
⚠ Attention aux boucles sans fin !
s = 0 i = 1 |
initialisations avant la boucle condition avec au moins une valeur variable (ici i) |
Algo de :
|
| while i <= 100 : | ||
s = s + i ** 2 i = i + 1 |
☝ faire varier la variable de condition ! | |
| print("somme :", s) | ||
Instruction boucle itérative
bloc d'instructions exécuté pour chaque élément d'un conteneur ou d'un itérateur
for var in sequence:
bloc d'instructions
⚠ Bonne habitude : ne pas modifier la variable de boucle
Parcours des valeurs d'un conteneur
s = "Du texte" cpt = 0 | initialisations avant la boucle |
| for c in s: | c est variable de boucle, affectation gérée par le for |
if c == "e" |
|
|
cpt = cpt + 1 print("trouvé", cpt, "'e'") | Algo de: comptage du nombre de e dans la chaine |
Parcours des index d'un conteneur séquence
◽ changement de l'élément à la position
◽ accès aux éléments autour de la position (avant/après)
|
lst = [-1,18,-4,12,-7,0,17] for idx in range(len(lst)): if lst[idx] < 0 : lst[idx] = 0 |
Algo de : bornage des valeurs négatives |
Parcours simultané index et valeurs de la séquence :
for idx, val in enumerate(lst) :
Affichage
| print( | "v=" , | 3 , | x , | y + 2 | ) |
| ⭡ | ⭡ | ⭡ | ⭡ | ||
| valeurs (tout type) | vatiables | expressions | |||
Options de print:
| ◽ sep = " " | séparateur d'éléments, défaut espace |
| ◽ end = "\n" | fin d'affichage, défaut fin de ligne |
| ◽ file = sys.stdout | print vers fichier, défaut sortie standard |
Saisie
s = input("Directives:" )
☝ input retourne toujours une chaîne, la convertir vers le type désiré (cf. encadré Conversions).
Opérations génériques sur les conteneurs
len(c)→ nb d'éléments | Note: Pour dictionnaires et ensembles, ces opérations travaillent sur les clés. |
min(c) max(c) sum(c) |
val in c → booléen, opérateur in de test de présence (not in d'absence)
enumerate(c)→ itérateur sur (index, valeur)
zip(c1,c2…)→ itérateur sur tuples contenant les éléments de même index des ci
c.clear() supprime le contenu des dictionnaires, ensembles, listes
Spécifique aux conteneurs de séquences ordonnées (listes, tuples, chaînes, bytes…)
reversed(c)→ itérateur inversé
| c * 5 → duplication | c + c2 → concaténation |
sorted(c)→ list copie triée
c.index(val)→ position
c.count(val)→ nb d'occurences
import copy
copy.copy(c)→ copie superficielle du conteneur
copy.deepcopy(c)→ copie en profondeur du conteneur
Définition de fonction
| nom de la fonction (identificateur) | ||
| ⭣ | ||
| def fct(x,y,z): | ⭠ x,y et z sont des paramètres nommés | |
| """documentation""" | ||
| # bloc instructions, calcul de res, etc. | ||
| return res | ⭠ valeur résultat de l'appel, si pas de résultat calculé à retourner : return None | |
☝ les paramètres et toutes les variables de ce bloc n'existent que dans le bloc et pendant l'appel à la fonction (penser “boîte noire”)
Appel de fonction
| r = | fct( | 3, i + 2, 2 * i | ) | |
| ⭡ | ⭡ | |||
| stockage/utilisation de la valeur de retour | une valeur d'argument par paramètre | |||
☝ c'est l'utilisation du nom de la fonction avec les parenthèses qui fait l'appel
Opérations sur les listes
☝ modification de la liste originale
| lst.append(val) | ajout d'un élément à la fin |
| lst.extend(seq) | ajout d'une séquence d'éléments à la fin |
| lst.insert(idx,val) | insertion d'un élément à une position |
| lst.remove(val) | suppression du premier élément de valeur val |
| lst.pop([idx])→valeur | supp. & retourne l'item d'index idx (défaut le dernier) |
| lst.sort() lst.reverse() | tri / inversion de la liste sur place |
Opérations sur les dictionnaires
☝ modification du dictionnaire original
| d[clé] = valeur | reaffectation ou création d'une clé |
| d[clé] → valeur | récupération de la valeur d'une clé |
| d.update(d2) | mise à jour/ajout des couple de d2 à d |
| d.keys() | → vues itérables sur clés / valeurs '/ couples |
| d.values() | |
| d.items() | |
| d.get(clé[,default])→valeur | retourne la valeur de la clé si elle existe, la valeur par defaut sinon. |
| del d[clé] | supprime le couple cle/valeur de d |
Fichiers
stockage de données sur disque, et relecture
| f = open( | "fic.txt" | , | "w" | , | encoding= | "utf8") |
| ⭡ | ⭡ | ⭡ | ⭡ | |||
| variable fichier pour les opérations | nom du fichier sur le disque (+chemin…) | mode d'ouverture ◽ 'r' lecture (read) ◽ 'w' écriture (write) ◽ 'a' ajout (append) ◽ …'+' 'x' 'b' 't' |
encodage des caractères pour les fichiers textes: utf8 ascii latin1 … | |||
| en écriture | en lecture |
|
f.write("coucou") f.writelines(list de lignes) |
☝ lit chaîne vide si fin de fichier f.read([n]) → n caractères suivants si n non spécifié, lit jusqu'à la fin ! f.readlines([n]) → list lignes suivantes f.readline() → ligne suivante |
☝ par défaut mode texte t (lit/écrit str), mode binaire b possible (lit/écrit bytes). Convertir de/vers le type désiré !
f.close() ☝ ne pas oublier de refermer le fichier après son utilisation !
| Très courant : ouverture en bloc gardé (fermeture automatique) et boucle de lecture des lignes d'un fichier texte. |
|