05 Cours Syntaxe et types

Variables et assignation⚓︎

Pour accéder à une donnée, on lui donne un nom que l’on appelle variable. Cette opération s’appelle affectation et se fait avec l’opérateur =.

🐍 Script Python

x = "donnée"

signifie qu’on affecte la donnee à la x.

Attention à respecter la casse car le langage Python y est sensible (utilisation des majuscules ou minuscules)

🐍 Script Python

age = 25
print(Age)

retourne un message erreur !

Nota bene :⚓︎

Le style recommandé pour nommer les variables (et les fonctions) en Python est le snake_case.
Il s'agit de n'utiliser que des minuscules (pas d'accent), et de séparer les mots avec des tirets du bas. On peut également utiliser les chiffres, mais pas au début.

🐍 Script Python

age_recommande = 12
mon_age = 10
mon_age_2025 = 11

Le mécanisme d’assignation en détail⚓︎

Lorsqu’on fait l’assignation x = donnee, Python :

crée et mémorise le nom de variable x ;
crée un objet dont le type dépend de la nature de la donnée et y stocke la valeur particulière donnee ;
établit une référence entre le nom de la variable x et l’emplacement mémoire de donnee. Cette référence est mémorisée dans l’espace de noms.

Exemple avec l’entier 7 :

pour Python, 7 est l’objet de type entier (int) dont la donnée est 7 ;
lorsqu’on appelle la donnée 7 dans un programme, Python créé l’objet correspondant et lui affecte un identifiant unique dans l’espace de nom courant ;
cet identifiant est renvoyé par la fonction intrinsèque id() :

🐍 Script Python

print(id(7))

📋 Texte

1906591472

🐍 Script Python

print(id(7))
x = 7
print(id(x))
y = x
print(id(y))  # y référence le même objet que x

📋 Texte

1906591472
1906591472
1906591472

On note que, si on réaffecte une autre donnée à x, on id() change.

🐍 Script Python

x = 7
print(id(x))
x += 1
print(id(x))
x += 1
print(id(x))

📋 Texte

1906591472
1906591488
1906591504

Remarque : notez également la différence d'adresse entre les nombres entiers 7, 8, 9...

🐍 Script Python

L = [7, 8]
L2 = L
print(id(L))
print(id(L2))
print(id(L[0]))

📋 Texte

69801384
69801384
1906591472

🐍 Script Python

L = [7, 8]
L3 = L[:]
print(id(L3))
print(id(L3[0]))

📋 Texte

69801384
64640584
1906591472

Le type⚓︎

En Python, les variables n’ont pas de type propre : c’est la donnée qui est typée, pas la variable qui la référence. Une variable peut donc faire référence à une donnée d’un autre type après une nouvelle assignation. La fonction type() retourne le type effectif de la donnée passée en paramètre.

🐍 Script Python

# Des nombres
age = 23
print(type(age))

📋 Texte

<class 'int'>

🐍 Script Python

# Les variables peuvent aussi changer de type : chaîne de caractères
age = 'vingt quatre ans'
print(type(age))

📋 Texte

<class 'str'>

🐍 Script Python

# Sans limites...
age = 24.5
print(type(age))

📋 Texte

<class 'float'>

🐍 Script Python

# Attention aux pièges...
age = '25'
print(type(age))

📋 Texte

<class 'str'>

Une variable peut être initialisée avec des valeurs constantes, comme vu précédement, mais aussi à partir d’autres variables ou des valeurs de retour de fonctions, etc.

🐍 Script Python

a = 1
b = a
c = a * 2
d = max(a, 2, 3, c)  #la fonction max() renvoie le max des valeurs données
print(a, b, c, d)

📋 Texte

1 1 2 3

Les différents types⚓︎

None⚓︎

Il existe dans python un type de données particulier : None.
None représente un objet sans valeur. On s’en sert comme valeur de retour en cas d’erreur ou pour représenter un cas particulier.
None est équivalent à NULL en Java et en C.

🐍 Script Python

a = None
print(a)
print(type(a))

📋 Texte

None
<class 'NoneType'>

Booléens⚓︎

Les booléens ne peuvent avoir que deux valeurs :

🐍 Script Python

True, False

On peut utiliser la fonction bool() pour construire un booléen.

Dans un contexte booléen, toutes ces valeurs sont équivalentes à False :

None
le zéro des types numériques, par exemple : 0, 0.0, 0j.
les séquences vides, par exemple : '', (), [].
les dictionnaires vides, par exemple, {}.

Tout le reste est équivalent à True :

une valeur numérique différente de zéro
une séquence non vide
un dictionnaire non vide

Exemples de constructions de valeurs booléennes à partir d’autres types⚓︎

Exemple	Valeur booléenne
bool(None)	False
bool()	False
bool(0)	False
bool(1)	True
bool(0.0)	False
bool(0.5)	True
bool("")	False
bool("abc")	True
bool([])	False
bool([1, 0])	True
bool({})	False
bool({'ane': True, 'chat': True})	True

Exemple d’utilisation d’une conversion booléenne⚓︎

🐍 Script Python

L1 = []
if L1:
    print(L1[0])
L2 = ['a', 'b', 'c']
if L2:
    print(L2[0])

Nombres entiers⚓︎

La taille est illimitée.

🐍 Script Python

entier = 4
print(entier)
print(type(entier))

# Ce nombre nécéssite 131 bits
entier = 1415926535897932384626433832795028841971
print(entier)
print(type(entier))

📋 Texte

4
<class 'int'>
1415926535897932384626433832795028841971
<class 'int'>

On peut utiliser la fonction interne int() pour créer des nombres entiers.
int() peut créer des entiers à partir de leur représentation sous forme de chaîne de caractères.

🐍 Script Python

entier = int(12)
print(entier)
print(type(entier))
entier = int('13')
print(entier)
print(type(entier))

📋 Texte

12
<class 'int'>
13
<class 'int'>

On peut aussi spécifier la base :

🐍 Script Python

entier = int('0xFF', 16)
print(entier)
print(type(entier))

📋 Texte

255
<class 'int'>

Nombres flottants⚓︎

Pour créer des nombres réels (en virgule flottante), on peut utiliser la fonction interne float().

La précision est limitée à la 16ème décimale.

🐍 Script Python

pi_approx = 3.1415926535897932
print(pi_approx)
print(type(pi_approx))
print(f"{pi_approx:.16f}")

📋 Texte

3.141592653589793
<class 'float'>
3.1415926535897931

Attention. Python autorise un affichage plus long que la précision des flottants mais tous les chiffres après le 16e chiffre significatif sont faux :

🐍 Script Python

# On demande 20 chiffres après la virgule, alors que 16 seulement sont exacts
print(f"{pi_approx:.20f}")

📋 Texte

3.14159265358979311600

On peut convertir des entiers en flottants avec float() (la valeur ne change pas, c'est juste un changement de type).
On peut aussi convertir des flottants en entiers avec ìnt() (dans ce cas, la valeur est changée : on prend la troncature à l'entier près).

🐍 Script Python

nombre_flottant = 3.6
print(nombre_flottant)
print(type(nombre_flottant))
nombre_entier = int(nombre_flottant)
print(nombre_entier)
print(type(nombre_entier))
nouveau_flottant = float(nombre_entier)
print(nouveau_flottant)
print(type(nouveau_flottant))

📋 Texte

3.6
<class 'float'>
3
<class 'int'>
3.0
<class 'float'>

Opérateurs logiques⚓︎

📋 Texte

and, or, not

retournent une valeur booléenne.

🐍 Script Python

print(True or False)
print(True and False)
print(not True)
print(not False)
print(not [])
print(not (1, 2, 3))

📋 Texte

True
False
False
True
True
False

Valeurs :
AND :
True and True vaut True
True and False vaut False
False and True vaut False
False and False vaut False

OR :
True or True vaut True
True or False vaut True
False or True vaut True
False or False vaut False

Attention, ce sont des opérateurs « court-circuit » :

🐍 Script Python

a = True
b = False and a  # b vaut False sans que a soit évalué
c = True or a    # c vaut True, sans que a soit évalué

A quoi ça sert ?

🐍 Script Python

L = []
if L[0]:
   print("OK")

renvoie un message erreur

🐍 Script Python

if L and L[0]:
   print("OK")

permet de ne pas évaluer L[0] si la liste est vide.

Comparaison⚓︎

🐍 Script Python

==, is, !=, is not, >, >=, <, <=

L’évaluation de ces opérateurs retourne une valeur booléenne.

🐍 Script Python

print(2 == 2)
print(2 != 2)
print(2 == 2.0)
print(type(2) is int)
print(isinstance(2, int))

📋 Texte

True
False
True
True
True

On peut utiliser ces opérateurs avec des variables et des appels à des fonctions.

🐍 Script Python

x = 3
print(1 > x)
y = [0, 1, 42, 0]
print(x <= max(y))
print(x <= min(y))

📋 Texte

False
True
False

On peut chaîner ces opérateurs, mais ils fonctionnent en mode « court-circuit » et l’opérande centrale n’est évaluée qu’une seule fois.

🐍 Script Python

y = [0, 1, 42, 0]
print(2 < max(y) <= 9) # équivalent à 2 < max(y) and max(y) <= 9 mais max(y) n'est évanlué qu'1 fois

📋 Texte

True

Attention : comparer des types non numériques peut avoir des résultats surprenants.

🐍 Script Python

# Chaînes de caractères
print("aaa" < "abc")
print("aaa" < "aaaa")
print("22" > "3.0")

📋 Texte

True
True
False

🐍 Script Python

# Listes
print([1, 2, 3, 4] > [42, 42])
print([666] > [42, 42])

📋 Texte

False
True

Attention : ne pas comparer des types incompatibles.

🐍 Script Python

# Les instructions ci-dessous renvoient des erreurs.
print('chaîne:\t', "a" < 2)
# TypeError: '<' not supported between instances of 'str' and 'int'
print('liste:\t', ["zogzog"] > 42)
# TypeError: '>' not supported between instances of 'list' and 'int'
print('vide:\t', [] > 1)
# TypeError: '>' not supported between instances of 'list' and 'int'
print('tuple:\t', [23, 24] >= (23, 24))
# TypeError: '>=' not supported between instances of 'list' and 'tuple'
print('dict:\t', [23, 24] >= {23: True, 24: "c'est pas faux"})
# TypeError: '>=' not supported between instances of 'list' and 'dict'

Attention, l’égalité de valeur n’implique pas forcément que l’identité des objets comparés est la même.

🐍 Script Python

a = []  # a est une liste vide
b = []  # b est une AUTRE liste vide

print(a == b) # test de valeur
print(a is b) # test d'identité
print('id(a) =', id(a))
print('id(b) =', id(b))

📋 Texte

True
False
id(a) = 139766940832768
id(b) = 139766941863680

Mais, comme vu précédemment, des variables différentes peuvent référencer le même objet.

🐍 Script Python

a = []  # a est une liste vide
b = []  # b est une AUTRE liste vide
c = a
print(a == c) # test de valeur
print(a is c) # test d'identité

📋 Texte

True
True