Mémo Python

Types

documentation

Immuables (immutables) = non modifiable

• Nombres (number) : int , float
123, -231, 45.6, 7.89e-3
0b1000111001, 0xAF34
• Chaînes de caractères (string) : str
"abc", 'xyz', """
• Booléens (boolean) : bool
True, False
• n-uplets (tuple) : tuple
(1, 2, 3), ('a', 'b', 'c')
• Absence de valeur : None

Muables (mutables) = modifiables

• Listes : list
• Dictionnaires : dict

Listes et dictionnaires sont des conteneurs (ils peuvent contenir n’importe quel autre type de donnée) et des itérateurs (il est possible de parcourir leurs contenu par itération).

 

Variables et Constantes

Identificateur (nom) associé à une valeur (de type quelconque ou objet). Une variable peur changer de valeur au cours de l’exécution.

Noms

Commencent par une lettre ou le caractère _

 

Affectation (=)

Opération qui consiste à affecter une valeur à une variable (préexistante ou pas)

nom = valeur

Exemple :

>>> a = 2
>>> a
2

 

Opérations

Arithmétiques (int ou float)

+	Addition	12.5+6.1 → 18.6
-	Soustraction	12.5-6.1 → 6.4
*	Multiplication	3*7 → 42
/	Division	11/5 → 2.2
//	Division entière (euclidienne)	11//5 → 2
%	Modulo (reste de la division euclidienne)	11%5 → 1
**	Puissance	2**3 → 8

 

Booléennes (bool)

and	ET	True and True → True
or	OU	True or False→ True
not	NON	not True → False

 

Binaires (bit à bit) (int)

|	OR : ou binaire	0b0110 | 0b1100 → 0b1110
^	XOR : ou exclusif binaire	0b0110 ^ 0b1100 → 0b1010
&	AND : et binaire	0b0110 & 0b1100 → 0b0100
<<	décalage vers la gauche	0b0110 << 2 → 0b11000
>>	décalage vers la droite	0b0110 >> 2 → 0b0001
~	NOT : inversion	~0b0110 → 0b1001

 

Chaînes de caractères (str)

+	Concaténation	"bon"+"jour" → "bonjour"
*	Répétition	"bon"*2 → "bonbon"

 

 

Structures de contrôle

Fonctions

def nom(paramètres):
   instructions

 

 

Structures conditionnelles

Conditions

Expression dont l’évaluation est un booléen.

 

Comparaison

<	strictement inférieur	4 < 5 → True
<=	inférieur ou égal	4 <= 5 → True
>	strictement supérieur	4 > 5 → False
>=	supérieur ou égal	4 >= 5 → False
==	égal	4 == 5 → False
!=	différent	4 < 5 → True
is	identité d’objet	obj is None
is not	contraire de l’identité d’objet	obj is not None

 

Appartenance

in	fait partie de	4 in [1, 3, 5] → False
not in	ne fait pas partie de	4 not in (1, 3, 5) → True

 

Conteneurs

Tuples (tuple) (ou n-uplet)

Conteneur immuable dont les éléments sont accessibles par leurs indices (index), de type int.

• Tuple vide : t = ()
• Tuple non vide : r = (1, 2, 'a', 'b') ou t = 1, 2, 'a', 'b'
• Accès à un élément : voir les listes
• Modification d’un élément : impossible !

 

Listes (list)

Conteneur muable dont les éléments sont accessibles par leur indice (index), de type int.

• Liste vide : l = []
• Liste non vide : q = [1, 2, 'a', 'b']
• Longueur : len(q) → 4
• Accès à un élément :
  • q[0] → 1
  • q[1] → 2
  • q[3] → 'b'
  • q[len(q)-1] → 'b'
  • q[-1] → 'b'
• Modification d’un élément : q[1] = 5

 

Méthodes

append	ajouter à la fin	q.append(True)	q == [1, 2, 'a', 'b', True]
pop	retirer et retourner un élément par défaut, le dernier	q.pop() → True q.pop(1) → 2	q == [1, 2, 'a', 'b'] q == [1, 'a', 'b']

 

Dictionnaires (dict)

Conteneur muable dont les éléments sont accessibles par leur clé (key) (de type int, float, str ou tuple de ces types).

• Dictionnaire vide : d = {}
• Dictionnaire non vide : z = {'a' : 1, 'b' : 2, 6 : "Bonjour !"}
• Ajout d’un élément : z['3'] = 'x'
• Accès à un élément : z['b'] → '2'
• Modification d’un élément : z['6'] = "Salut !"

Après ces opérations : z == {'a': 1, 'b': 2, 6: 'Bonjour !', '3': 'x', '6': 'Salut !'}

Méthodes

keys	Renvoyer la liste des clés	z.keys() → ['a', 'b', 6, '3', '6']
values	Renvoyer la liste des valeurs (éléments)	z.values() → [1, 2, 'Bonjour !', 'x', 'Salut !']
items	Renvoyer la liste des tuples (clé, valeur)	z.items() → [('a', 1), ('b', 2), (6, 'Bonjour !'), ('3', 'x'), ('6', 'Salut !')]

 

Boucles

Boucles bornées for ... in ...

Itérateur de nombres : fonction range

range(début, fin , pas)

début,  fin et pas de type int

• début (facultatif) : premier élément de l’itérateur (inclus)
• fin (obligatoire) : premier élément de l’itérateur (exclus)
• pas (facultatif) : écart entre chaque élément

range(5) → [0, 1, 2, 3, 4]

range(1, 5) → [1, 2, 3, 4]

range(1, 5, 2) → [1, 3]

range(0, 5, 2) → [0, 2, 4]

range(5, 0, -1) → [5, 4, 3, 2, 1]

 

 

for valeur in itérateur:
    instructions

 

 

Boucles non bornées while ...

while condition:
   instructions