Bases_Python_1Bases_Python_1Bases_Python_1.pdf

20/09/2024 09:42 Variables et affectations - ZoneNSI
file:///home/fabien/Documents/GitHub/ZoneNSI.md/site/NSI/Premiere/C01/Bases_Python_1/tmpf1xbhou6.html 1/20
Objets, variables et affectation
Ce cours est accompagné de notebooks Capytale disponibles aux personnes disposant d'un compte (par
Toutatice dans l'académie de Rennes).
1. Types de base
1.1. Objets et types de base
Le principe d'un programme est de manipuler des données avec des instructions afin de produire de nouvelles
données.
En Python, des données sont appelées des objets, et tout ce qui est manipulable est un objet. On manipule des
objets en écrivant des expressions :

Par exemple, dans le code suivant :
Tester les objets
Test1
Tapez l'expression suivante dans le terminal ci-dessous, puis appuyez sur la touche Enter :
Test2
Test3
Test4
Une astuce
Dans un terminal, la seule ligne active est celle du prompt, c'est-à-dire la dernière marquée par les chevrons
>>> . On ne peut pas ré-exécuter une ligne déjà tapée. Cependant, il est possible de récupérer une telle ligne,
grâce à l'historique de commande obtenu en utilisant les flèches de direction Up et Down
⏎
5 / 3
⏎
"abra"+"cadabra"
⏎
5<9
⏎
4.5 + "3.2"
↑ ↓
>>>
7+5
4.2+4.6
1
2
3

Lorsqu'on exécute ce code, des objets différents sont créés, présents dans ce qu'on appelle l'espace des objets.
Cependant l'exécution du script ne renvoie aucune donnée (aucun objet). En effet, un mécanisme existant dans
presque tous les langages de programmation, appelé garbage collector (soit collecteur d'ordure), nettoie
automatiquement tout objet non utilisé. La mémoire de l'ordinateur étant limitée physiquement, il est nécessaire
de nettoyer très régulièrement (plusieurs centaines de fois par seconde), afin de garantir le bon fonctionnement
de la machine. Le garbage collector a donc supprimé tous les objets, y compris les objets 12 , 8.8 , 5436 et 7
obtenus par les évaluations des quatre expressions données.
Regardons plus précisément les objets, en demandant à Python grâce à l'instruction built-in type() la nature
des objets créés.
453*12
12-5
3
4
5

Dans la console ci-dessous, testez une par une les expressions suivantes :
Les types basiques de Python sont donc les suivants :
le type int : qui permet de manipuler des nombres entiers relatifs, de à (mais la plage
pouvant être étendue, en pratique on ne s'intéresse pas en python aux limites des entiers) ;
le type float : qui permet de manipuler des nombres décimaux à bits (s'écrivant avec 32 chiffres
binaires) entre et (avec quelques subtilités, que nous verrons dans le chapitre
correspondant au codage des nombres flottants);
le type str : qui permet de manipuler des chaines de caractères ;
le type bool : qui permet de manipuler des valeurs booléennes, c'est à dire vraies ou fausses, utilisées
par défaut dans les instructions nécessitant une condition ( if ou while par exemple).
Chacun de ces types possède des opérations qui lui sont propres. Elles sont nombreuses, et largement
documentées dans la doc Python 3 officielle, en suivant le lien ci contre : Doc Python 3 en français.
Les types d'objets
Test 1
Test 2
Test 3
Test 4
type("Abracadabra")
type(True)
type(5)
type(4.5)
>>>
Une erreur ?
Types de bases et objets spécifiques
−2.10
9
+2.10
9
32
−10
302
+10
302

Il existe aussi des constantes spécifiques, c'est-à-dire des objets spéciaux comme, par exemple None , qui
est un objet de type NoneType , signifiant une absence de valeur.
1.2. Nommage des objets et affectations
Bien entendu, de manière quasi obligatoire, il est nécessaire de conserver des objets et d'éviter que ceux-ci
disparaissent avec le garbage collector.
Pour cela, on va associer à chaque objet un nom dans l'espace de nom, grâce à l'opération d'affectation = ,
comme par exemple un_inconnu = "Toto" . Ici le nom de variable un_inconnu est associé à l'objet de type
chaine de caractère "Toto" .
Une fois un objet associé à un nom, il n'est plus ramassé automatiquement par le garbage collector, et peut être
rappelé plus tard dans le code en utilisant son nom.
Objets spéciaux

Exécutez le code suivant (avec la flèche), puis testez dans la console à droite le type des objets suivants, en
utilisant leur nom.
Testez ensuite chacune des expressions ci-dessous. Pour chacune d'entre elles, expliquez ce qui se passe.
Exemple
mon_entier = 5
le_vrai_hero = "Dark"
est_actif = True
mon_flottant = 3.2
c_est_lui = "Vador"
1
2
3
4
5
6
7
mon_entier**2
le_vrai_hero+c_est_lui
mon_flottant if est_actif else mon_entier
mon_flottant if not(est_actif) else mon_entier
type(mon_flottant*mon_entier)
mon_entier == mon_flottant
le_vrai_hero*10
1
2
3
4
5
6

Le nom donné à l'objet peut être n'importe lequel, en respectant les règles impératives suivantes :
Un nom de variable est une séquence de lettres, de chiffres, qui ne doit pas commencer par un chiffre.
La casse est significative (les caractères majuscules et minuscules sont distingués). Donc Joseph ,
joseph , et JOSEPH sont des variables différentes.
Les « mots réservés » du langage sont déjà pris (ex : type() , float , str ...). Il s'agit des instructions
de bases et des fonctions natives ( voir ici ). Si vous nommez une variable comme un de ces mots, vous
ne pourrez plus utiliser la fonctionnalité du mot réservé.
Comprendre l'affectation
Énoncé
On considère le code suivant :
Compléter le tableau d'état des variables suivants en exécutant le programme à la main, puis vérifier dans la
console :
Solution
a = 5
b = 4.2
c = a+b
a*c
a = a*3
b = 42
a b c
Accueil (/) / Vidéos (/videos/) / Affectations de variables en Python et état mémoire
Français (FR)
Connexion (/accounts/login/?next=/video/23382-affectations-de-variables-en-python-et-etat-memoire/)
Règles de nommage des variables

Il existe quelques règles de "bien nommage" des variables, définies dans ce qu'on appelle la PEP8, c'est-à-
dire une description des bonnes pratiques d'écriture en Python. La PEP8 donne les conventions principales,
qui permettent de lire plus facilement le code fourni par un·e autre codeur·euse. Les principales
recommandations sont :
Ne jamais utiliser les caractères "l" (L minuscule), "O" (o majuscule), ou "I" (i majuscule) seuls comme
nom de variables. Dans certaines polices, ces caractères sont impossibles à distinguer des numériques
un et zéro. Lorsque vous êtes tenté·e d’utiliser "l", utilisez "L" à la place.
Il est recommandé d'écrire les noms de variables en minuscule. Si le nom de variable doit contenir
plusieurs mots, on conseille d'écrire en snake_case, c'est-à-dire en séparant les mots par le caractère _ .
Exemple : marge_brut .
Il convient aussi d'éviter autant que possible l'énumération de variables ( toto1 , toto2 , toto3 , ...), cela
rend le programme parfaitement incompréhensible et sujet à des erreurs.
De manière générale, il convient de suivre aussi strictement que possible les règles édictées par la
Python Software Foundation à travers les normes PEP.
1.3. Exercices d'affectation
Les exercices sont disponibles sur le notebook Capytale 22ab-3807776.
2. Opérations sur les objets
2.1. Types numériques et opérations
Pour les types numériques, int et float (et pour le type complex , mais qui n'est pas vu en maths avant la
terminale), on trouve toutes les opérations classiques.
Addition entière
Addition flottante
Addition mixte
Pour les cracks
Conventions de nommage et PEP8
>>> 5 + 2 #Addition entière
7
>>> 5.6 + 3.4 # Addition flottante ( Quel est le type du résultat ?)
9.0
>>> 5 + 3.4 # Addition entre un entier et un flottant ( Quel est le type du résultat ?)
8.4

Testez dans la console ci-dessous l'instruction suivante 0.1 + 0.2 . Qu'obtient-on ?
Soustractions
Multiplication
Division flottante
Attention ! Au résultat ci-dessous, le type obtenu est float , même si le dividende et le diviseur sont entiers et
que le résultat « tombe juste »...
Division Euclidienne
Ici par contre le résultat est bien de type int (à tester aussi...)
Reste de la Division Euclidienne
C'est un point important en informatique, nous avons souvent besoin du reste, aussi appelé modulo. Par
exemple pour savoir si un nombre entier est pair, on utilise :
Attention avec les flottants
>>>
>>> 3.2-4 #Soustraction ( A tester de la même manière)
-0.79999999999
>>> 4*8.5 #Multiplication ( idem)
34.0
>>> 1/3 #Division
0.3333333333333333
>>> 4/2
2.0
>>> 72//5 #Quotient de la division euclidienne
14
>>> 72%5 #reste de la division euclidienne ( ou modulo).
2

Puissances
Tourtes les opérations faites avec les objets ci-dessus peuvent être effectuées directement sur les noms si
ils existent :
Vous pouvez tester ces éléments dans le terminal ci-dessous :
2.2. Exercices sur les types numériques
Les exercices sont disponibles sur le notebook Capytale 1138-3808462.
2.3. Types str (chaines de caractères) et opérations
Déclarations
Une chaine de caractère doit être déclarée :
soit entre une paire de guillemets simples (simple quote) : 'Toto' ;
soit entre une paire de guillemets doubles (double quote) : "Toto" .
L'utilisation de l'un ou de l'autre n'a pas d'importance, mais on peut rapidement se tromper selon le contenu de la
chaine :
>>> 23%2 == 0
False
>>> 10**7 #Puissance
10000000
Opérations avec les noms des objets
>>> a = 5
>>> b = 2
>>> a + b
7
>>> a%b
1
>>>

Tester les affectations suivantes dans le terminal ci-dessous, et expliquez les éventuels problèmes :
Normalement, une chaine de caractère, quelle que soit sa longueur, n'est considérée être que sur une seule et
unique ligne. Il est cependant possible d'avoir des chaines de caractères multi-lignes, à condition de les déclarer
entre trois paires de guillemets identiques :
Tester les chaines de caractères
1
2
3
4
5
6
texte = "Hello World !"
texte = 'Hello World !'
texte = "Salut l'ami !"
texte = 'Salut l'ami !'
texte = 'Alors là je dis : "Non !"'
texte = "Alors là je dis : "Non !""
>>>
>>> zen = """
Préfère :
la beauté à la laideur,
l'explicite à l'implicite,
le simple au complexe
et le complexe au compliqué,
le déroulé à l'imbriqué,
l'aéré au compact.
Prends en compte la lisibilité.
Les cas particuliers ne le sont jamais assez pour violer les règles.
Mais, à la pureté, privilégie l'aspect pratique.

Indice d'un caractère
Chaque caractère d'une chaine est repéré par son indice, c'est-à-dire par un numéro donnant sa position.
Attention toutefois, en informatique, les indices commencent à 0 (dans quasiment tous les langages) !
Ainsi :
Dans la chaine précédente, "P" à pour indice 0, "y" a pour indice 1 et "n" a pour indice 5 .
Accès à un caractère par son indice
Vous utiliserez beaucoup les crochets en Python, pour les obtenir sur un clavier AZERTY :
[ s'obtient par AltGr + [ ;
] s'obtient par AltGr + ] ;
On utilise l'indice entre crochets, juste après la chaine de caractère.
Si la chaine est associée à un nom :
Attention, si on cherche un indice qui n'existe pas, on a l'erreur suivante :
Ne passe pas les erreurs sous silence,
... ou bâillonne-les explicitement.
Face à l'ambiguïté, à deviner ne te laisse pas aller.
Sache qu'il ne devrait [y] avoir qu'une et une seule façon de procéder,
même si, de prime abord, elle n'est pas évidente, à moins d'être Néerlandais.
Mieux vaut maintenant que jamais.
Cependant jamais est souvent mieux qu'immédiatement.
Si l'implémentation s'explique difficilement, c'est une mauvaise idée.
Si l'implémentation s'explique aisément, c'est peut-être une bonne idée.
Les espaces de nommage ! Sacrée bonne idée ! Faisons plus de trucs comme ça.
"""
Les crochets
>>> "Python"[3]
'h'
>>> texte = "DarkVador"
>>> texte[4]
'V'
>>> "Abcdefg"[10]
Traceback (most recent call last):
File "<input>", line 1, in <module>
IndexError: string index out of range

Cependant, il est aussi possible de parcourir une chaine à l'envers :
Longueur d'une chaine
La longueur de la chaine "Python" , c'est-à-dire le nombre de caractères qui la composent, est par contre bien
de 6, et on peut y accéder grâce à la fonction built-in len() .
La longueur d'une chaine vide est 0 :
Concaténation
La concaténation est l'opération consistant à accoler deux chaines de caractères :
On peut aussi concaténer une chaine avec elle-même à plusieurs reprises :
2.4. Méthodes des chaines de caractères
Le type str possède lui aussi ses propres fonctionnalités (ou méthodes) qui permettent de transformer ou
modifier une chaine de caractère. Parmi celles-ci, en voici quelques-unes utiles :
Substitution d'une sous-chaine par une autre
On utilise ici la méthode replace sur la chaine de caractère "abracadabra" , et on va récupérer la nouvelle
chaine 'aBRUHHHcadaBRUHHH'
>>> "Python"[-1]
'n'
>>> "Python"[-3]
'h'
>>> len("Python")
6
>>> len("")
0
>>> "Toto"+"Tata"
'TotoTata'
>>> "Toto"*5
'TotoTotoTotoTotoToto'
>>> "abracadabra".replace("bra","BRUHHH")
"'aBRUHHHcadaBRUHHH'"

Exécutez les lignes suivantes une par une dans le terminal ci-dessous :
Le contenu de la variable texte n'a pas été remplacé. En effet, un nouvel objet de type str
( "UbrUcUdUbrU" ) a bien été créé, mais il a été immédiatement ramassé par le garbage collector, et a donc
disparu. Il n'y a aucune modification de l'objet original qui est conservé (la modification n'est pas en
place).Si on veux conserver :
la chaine originale et la chaine modifiée, il faut donner un nouveau nom et affecter de la manière
suivante :
uniquement la chaine modifiée, il suffit de réaffecter la modification au nom texte :
Changement de casse
Il existe les méthodes .lower() , .upper() et .capitalize() qui mettent respectivement la chaine originale en
minuscule, en majuscule, et la première lettre en majuscule puis le reste en minuscule.
Modifications en place ou non ?
>>> texte = 'abracadabra'
>>> texte.replace('a', 'U')
>>> texte
texte = 'abracadabra'
nouveau_texte = texte.replace('a', 'U')
texte = 'abracadabra'
texte = texte.replace('a', 'U')
>>> "Toto".lower() #mise en minuscule, appel encore une fois à une méthode de classe.
'toto'
>>> "Toto".upper() #mise en majuscule, idem
'TOTO'
1
2
3
1
2
3

Suppression des espaces inutiles avant et après une chaine
Supprime les espaces inutiles devant et après une chaine de caractères
Séparation d'une chaine selon un motif donné
Sépare une chaine de caractère en, fonction d'une chaine passée en argument, et renvoie une liste (que nous
étudierons plus tard)
2.5. Les objets de type séquence
Il existe dans Python de nombreux autres types d'objets, et plus particulièrement les types list et tuple , que
nous étudierons en détail plus tard dans l'année. Ces objets permettent de regrouper en une seule séquence
ordonnée différents objets, et peuvent être alors utilisés simplement avec les possibilités suivantes (non
exhaustives) :
Construction d'une liste ou d'un tuple
Une liste se crée à l'aide des crochets [ et ] , avec deux possibilités :
soit une liste vide :
soit une liste contenant déjà des objets :
Une liste en python est un objet qu'on peut modifier. On peut y ajouter un élément, en retirer un, en modifier un
en particulier, etc.
Un tuple ne peut se crée à l'aide des parenthèses ( et ) , mais il doit déjà être rempli, car il ne peut pas être
modifié(ni ajout, ni suppression, ni modification d'éléments) :
Accès à un élément
>>> "une phrase SANS QUEUE ni tÊte.".capitalize()
#Met en majuscule le premier caractère de la chaine, et en minuscule les autres, idem
'Une phrase sans queue ni tête.'
>>> " Des Blancs ".strip()
'Des Blancs'
>>> "Une phrase est faite avec des mots".split("est")
['Une phrase ', ' faite avec des mots']
>>> "12:34:45:78".split(":")
['12', '34', '45', '78']
>>> ma_liste = []
>>> ma_liste = [5, 4.2, True, "Toto"]
>>> mon_tuple = (12, 45, -13, "Bob")

Dans une liste ou un tuple, on peut accéder à un objet grâce à son indice, tout comme pour les chaines de
caractères :
Ajouter un élément à une liste à la dernière position
Supprimer le dernier élément
Modifier un élément d'indice donné :
2.6. Exercices sur les chaines de caractères et les séquences
Les exercices sont disponibles sur le notebook Capytale 23b2-3809144.
3. Interactions avec l'utilisateur, transtypage des données, notions de
formatage des chaines de caractères
3.1. Afficher à l'écran
Jusqu'à présent, les seules choses que nous avons obtenues dans le terminal étaient des affichages simples des
objets attachés à un nom connu. Il est possible de personnaliser, de différer, et de multiplier les affichages grâce
à la fonction built_in `print()'.
Par exemple, essayez le code suivant :
>>> ma_liste[3]
'Toto'
>>> mon_tuple[2]
-13
>>> ma_liste.append(7)
>>> ma_liste
[5, 4.2, True, "Toto", 7]
>>> ma_liste.pop()
"Toto" # l'élément est renvoyé dans l'espace des objets courants
>>> ma_liste
[5, 4.2, True]
>>> ma_liste[1] = "Abracadabra"
>>> ma_liste
[5, "Abracadabra", True, "Toto"]
###

La fonction print prend entre parenthèse un objet et l'écrit sous la forme d'une chaine de caractères dans la
console. Cela signifie que la fonction print ne créé pas de nouvel objet !
Il est possible d'afficher plusieurs objets, en les séparant par une virgule. Testez par exemple le code suivant :
###

On voit qu'il est possible de mêler affichage de variables (par définition pouvant changer) et de textes fixes,
en utilisant les virgules.
Mais cette pratique est parfois source de nombreuses erreurs de syntaxe (oubli de virgules, ou bien virgules
placées entre guillemets, etc.).
Il est possible, et même recommandé, d'utiliser le formatage des chaines de caractères de Python !
Exécutez alors le code ci-dessous :
Une chaine de caractères est formatée automatiquement par Python à condition que :
la chaine soit préfixée par f ;
les variables à remplacer soient situées entre accolades.
On a ici une chaine de caractère créée en remplaçant le nom de la variable situé entre accolades par l'objet
auquel elle est reliée.La documentation python vous donnera toutes les subtilités nécessaires.
AInsi, La sortie écrite par le programme dans la console est devenu bien plus compréhensible.
Vous utiliserez beaucoup les accolades en Python, pour les obtenir sur un clavier AZERTY :
{ s'obtient par AltGr + ' ;
} s'obtient par AltGr + = ;
3.2. Demander à l'utilisateur de saisir quelque chose au clavier
Pour demander une saisie clavier à un utilisateur, on utilise la fonction built-in input() , prenant éventuellement
en argument une chaine de caractères. Cette fonction input interrompt le programme et attend une saisie
Formatage des chaines de caractères
f"La variable a contient {a}."
Les accolades
###

clavier de l'utilisateu·trice, et retourne cette saisie sous la forme d'une chaine de caractère dès que la touche
Enter est pressée.
Il faut cependant être attentif·ve à ce qui est réalisé par la fonction input() . En effet, le retour effectué par
cette fonction est renvoyé sous la forme de chaine de caractères, ce qui peut poser un problème comme, par
exemple, dans la situation ci-dessous :
Pour lever cette ambigüité, nous sommes parfois obligés d'effectuer un transtypage des données, c'est-à-dire
une modification du type de la valeur de retour, avec l'aide des fonctions built-in suivantes :
str()
int()
float()
bool()
...
Par exemple :
⏎
###
###
###

On a forcé ici dans la première ligne Python à transformer (s'il le peut) le contenu de la variable nb comme étant
un nombre entier.
Ceci ne lève cependant pas tous les problèmes, puisque si l'utilisateur·trice saisit une chaine de caractères ne
pouvant être transtypée en nombre entier, le programme renverra une erreur.
Écrire dans l'éditeur ci dessous un code python qui :
demande deux nombres entiers à l'utilisateur·trice et les stocke dans des variables a et b ;
donne le produit des deux nombres saisis, ainsi que le type du résultat, sous la forme d'une chaine de
caractères du type "3x4 = 12 résultat de type <class'int'>" (si l'utilisateur·trice à saisi 4 pour a
et 3 pour b )
Exercice
###

Bases_Python_1Bases_Python_1Bases_Python_1.pdf

Contenu connexe

Similaire à Bases_Python_1Bases_Python_1Bases_Python_1.pdf (20)

Plus de Oussama Haj Salem (9)

Bases_Python_1Bases_Python_1Bases_Python_1.pdf