Une version simplifiée pour le lycée par L.

Leskow
du Mémento v2.0.7 de Laurent Pointal Mémento Python 3 Version originale sous licence CC4
https://perso.limsi.fr/pointal/python:memento
entier,flottant,booléen,chaîne Types de base int("15") → 15 type(expression) Conversions
int 783 0 -192 0b010 0xF3 str(12) → "13"
zéro binaire hexa
float 9.23 0.0 -1.7e-6 int(15.56) → 15 troncature de la partie décimale
bool True False ×10
-6 list("abc") → ["a","b","c"]
str "Un\nDeux" ☝ immutables
':'.join(["toto","12","pswd"]) → "toto:12:pswd"
retour à la ligne
chr(64)→"@" ord("@")→64 code ↔ caractère

pour noms de variables, Identificateurs Aide ◾ séquences ordonnées, accès par index Types conteneurs
fonctions, modules, classes… help(help) tuple (1,5,9) Valeurs non modifiables (immutables)
a…zA…Z_ suivi de a…zA…Z_0…9 affiche aussi votre list [1,5,9] Valeurs modifiables (mutables) [] liste vide
◽ accents possibles mais à éviter propre documenta- liste en compréhension :
◽ mots clés du langage interdits tion [i ** 2 for i in range(5)] → [0,1,4,9,16]
◽ distinction casse min/MAJ [i for i in range(7) if i % 2 == 0] → [0,2,4,6]
☺ a toto x7 y_max BigOne dir(truc) ◾ conteneurs clés, sans ordre a priori, accès par clé rapide, chaque clé unique
☹ 8y and for dictionnaire dict {"clé":"valeur"} Mutables {} dictionnaire vide

pour les listes, chaînes de caractères, tuples … Indexation conteneurs séquences

= Variables & affectation
☝ affectation ⇔ association d'un nom à une valeur index positif 0 1 2 3 4 Sur les séquences modifiables
1) évaluation de la valeur de l'expression de droite lst=[10, 20, 30, 40, 50] (list) modification par
2) affectation dans l'ordre avec les noms de gauche
affectation lst[4]=25
x = 1.2 + 8 * y Accès individuel aux éléments par lst[index]
y, z, r = 9.2,-7,0 affectations multiples lst[0]→10 Nombre d'éléments lst.append(val) ajout d'un élément à
a, b = b, a échange de valeurs la fin
lst[1]→20 len(lst)→5

range([début,] fin [,pas]) Séquences d'entiers

☝ début défaut 0, fin non compris dans la séquence, pas signé et défaut 1 bloc d'instructions exécuté pour Instruction boucle itérative
range(5)→ 0 1 2 3 4 range(2,12,3)→ 2 5 8 11 chaque élément d'un conteneur ou d'un itérateur
suivant
range(3,8)→ 3 4 5 6 7 range(20,5,-5)→ 20 15 10
☝ range fournit une séquence immutable d'entiers construits au besoin
for var in séquence: …
fini
bloc d'instructions
☝ nombres flottants… valeurs approchées ! Maths Op. sur dictionnaires
Opérateurs : + - * / // % ** Parcours des valeurs d'un conteneur
d[clé]=valeur s = "Du texte" initialisations avant la boucle
Priorités (…) × ÷ ab d[clé]→ valeur cpt = 0
÷ entière reste ÷ vues itérables sur variable de boucle, affectation gérée par l'instruction for
(1+5.3)*2→12.6 abs(-3.2)→3.2 d.keys() les clés for c in s:
from math import sin,pi… d.values() valeurs if c == "e": Algo : comptage
d.items() couples cpt = cpt + 1 du nombre de e
sin(pi/4)→0.707… print("trouvé",cpt,"'e'") dans la chaîne.
cos(2*pi/3)→-0.4999… d.get(clé[,défaut])→ valeur
sqrt(81)→9.0 ☝ bonne habitude : ne pas modifier la variable de boucle

Imports modules/noms
module truc⇔fichier truc.py
bloc d'instructions exécuté Instruction boucle conditionnelle
☝ attention aux boucles sans fin !

from monmod import nom1,nom2 as fct

tant que la condition est vraie →accès direct aux noms, renommage avec as
while condition logique: oui import monmod →accès via monmod.nom1 …
?
☝ modules et packages cherchés dans le python path (cf. sys.path)
bloc d'instructions non

s = 0 initialisations avant la boucle un bloc d'instructions exécuté, Instruction conditionnelle

i = 1 uniquement si sa condition est vraie
condition avec au moins une valeur variable (ici i) oui non oui
while i <= 100: Algo : i=100 if condition logique: ? ?
non
s = s + i**2
s= ∑ i
2 bloc d'instructions
i = i + 1 ☝ faire varier la variable de condition !
print("somme:",s) i=1
Combinable avec des sinon si, sinon si... et
un seul sinon final. Seul le bloc de la if age<=18:
première condition trouvée vraie est etat="Enfant"
Logique booléenne Blocs d'instructions exécuté. elif age>65:
Comparateurs: < > <= >= == != ☝ avec une variable x: etat="Retraité"
(résultats booléens) ≤ ≥ = ≠ instruction parente: if bool(x)==True: ⇔ if x: else:
bloc d'instructions 1… etat="Actif"
a and b et logique les deux en if bool(x)==False: ⇔ if not x:
indentation !

même temps ⁝
a or b ou logique l'un ou l'autre instruction parente: nom de la fonction (identificateur) Définition de fonction
ou les deux bloc d'instructions 2… paramètres nommés
☝ piège : and et or retournent la valeur de ⁝ def fct(x,y,z): fct
a ou de b (selon l'évaluation au plus court).
⇒ s'assurer que a et b sont booléens.
"""documentation"""
instruction suivante après bloc 1 # bloc instructions, calcul de res, etc.
not a non logique return res valeur résultat de l'appel, si rien
True ☝ régler l'éditeur pour insérer 4 espaces à à retourner return None
constantes Vrai/Faux la place d'une tabulation d'indentation. ☝ les paramètres et toutes les
False
variables de ce bloc n'existent que dans le bloc et pendant l'appel à la
fonction (penser “boîte noire”)
print("v=",3,"cm :",x,",",y+4) Affichage
r = fct(3,"hey",a) Appel de fonction
stockage/utilisation une valeur d'argument
éléments à afficher : valeurs littérales, variables, expressions de la valeur de retour par paramètre
Options de print: ☝ c'est l'utilisation du nom fct() fct
◽ sep=" " séparateur d'éléments, défaut espace de la fonction avec les
◽ end="\n" fin d'affichage, défaut fin de ligne parenthèses qui fait l'appel