Python - Les fondamentaux
Chapitre 5 - Bases du langage Python - Syntaxe et structures

Exploiter la documentation

Il existe une Documentation de Python. Ce n'est pas de la faiblesse de lire la doc mais du professionnalisme.

Commenter votre code en Python

Il est important d'ajouter des commentaires afin de se rappeler plus tard pourquoi on a fait quelque chose dans le code ou si on travaille à plusieurs sur le code. Le commentaire peut aussi se faire pour mettre une fonction en pause afin de debugger.

Il existe 2 manières de commenter :

• La touche #
• 3x la touche ' ouvrant et fermant le commentaire à savoir '''. Cela permet de mettre un commentaire plus conséquent.

Dans l'exemple ci-dessous, seul "Hello World" sera affiché dans la console.
Voilà le contenu du fichier V02_Commenter_code.py après la vidéo :

# Ceci est une ligne de commentaire

'''
Il est aussi possible d'utiliser 3x la simple cote pour créer des bloques de commentaires.
Ligne commentaire 2
Ligne commentaire 3
'''

print("Hello World")

Exploiter les variables en Python

Définition

En informatique, les variables sont des éléments qui associent un nom (l'identifiant) à une valeur.

Les variables en Python

Dans beaucoup de langage de programmation, il est nécessaire de définir le type de variable (string, boolean, etc.).
En Python, ce n'est pas forcément nécessaire. C'est ce qui s'appelle du typage dynamique.

1	'''
2	Les variables de bases en python
3	'''
4	
5	age = 47
6	print(age)
7	print("age")

Dans le code ci dessus, la commande print de la ligne 6 va appeler la valeur sauvée dans la variable de la ligne 5 alors que celle de la ligne 7 va afficher age car age est écrit entre double cote '' ce qui change l'information (chaîne de caractères au lieu de variable).

Changer le type de variable

Pour changer le type de variable, il faut utiliser la fonction type(variable) ou variable = le nom de de la variable dont il faut changer le type.
La fonction print(type(variable)) va permettre de sortir le type de la variable. Voici quelques exemples :

Exemple integer :

age = 47
print(age)
print(type(age))

Sortie console :
47
<class 'int'>

Exemple string :
prenom = "Jean-Philippe"
print(prenom)
print(type(prenom))

Sortie console :
Jean-Philippe
<class 'str'>

Exemple float :

taille = "1.79"
print(taille)
print(type(taille))

Sortie console :
1.79
<class 'float'>

Exemple bool :

masculin = True
print(masculin)
print(type(masculin))

Sortie console :
True
<class 'bool'>

Suivre les règles et la convention de nommage

Les règles à suivre

• Les variables ne peuvent pas commencer par un chiffre.
• Les variables ne peuvent pas contenir d'espace.
• Les variables ne peuvent contenir que des caractères alphanumériques (A-Z, 0-9) et l'underscore (_).
• Les variables ne peuvent pas être des mots réservées, tell que print, true, etc..

Les conventions

Délimitation des mots des variables par un underscore et tout doit être en minuscule.

Une variable s'écrit en minuscule alors qu'une constante s'écrit en majuscule.
La constante ne se modifie pas.

La convention PEP8 : Python Enhancement Proposals

Traduction :
Proposition d'amélioration de Python

Constat de Guido Van Rossum :

Code is read much more often than it is written
Le code est plus souvent lu qu'écrit.

PEP8 fournit des directives et les meilleurs pratiques sur la façon d'écrire du code Python.
PEP8 a été écrit en 2001, par Guido Van Rossum, Barry Warsaw et Alyssa Coghlan.
L'objectif du PEP8 est d'améliorer la lisibilité du code et la cohérence.

Determiner les blocs qui constituent votre code

A quoi sert l'indentation

L'indentation va permettre de délimiter les bloc de code à exécuter par l'interpréteur.
Dans beaucoup de langage, les { et } sont utilisées pour faire l'indentation. Dans Python, c'est la tabulation qui est utilisée.
L'indentation doit être d'au moin un espace. De convention en python, ce sont 4 espaces qui correspondent à une fois la touche TAB.
Ci-dessous, un exemple d'indentation

li = [0, 434, 43, 6436, 5]
m = 0

for i in range(0, len(li)):
	if li[m] < li[i]:
		m = i

print(m)

En exécutant ce code :

prenom = "bob"
	print("bonjour")
print(prenom)

Sortie console :
File "c:\Users\yannj\OneDrive\VS_Code\Python\01_Les_fondamentaux\C05_Bases_du_langage_Python
				\V05_Determiner_blocs_constituant_code.py", line 6
		print("bonjour")
IndentationError: unexpected indent

Exploiter la saisie utilisateur

La fonction input

Pour commencer, il faut basculer du plugin Code Runner sur Run Python File.

Exemple 1

prenom = input("Quel est votre prenom ? ")
print("bonjour")
print(prenom)

Sortie console : 
Quel est votre prenom ? Yann
bonjour
Yann

Exemple 2

age = input("Quel est votre age ? ")
print(type(age))

Sortie console :
Quel est votre age ? 37
<class 'str'>

Utiliser les opérateurs arithmétiques

Les opérateurs arithmétiques fonctionnent également en Python. Il suffit de connaître le symbole à utiliser.

Voilà différentes possibilités d'utiliser les calculs :

nb1 = 10
nb2 = 5

print(nb1+nb2)
print(nb1+45)

result = nb1+nb2
print(result)

L'incrémentation

Pour faire une incrémentation il existe plusieurs possibilités :

nb1 = 10
nb1 = nb1 + 1
print(nb1)

nb2 = 10
nb2 += 1
print(nb2)

Dans les 2 cas ci-dessus, le résultat sera 11.

La décrémentation

Pour faire une incrémentation il existe plusieurs possibilités :

nb1 = 10
nb1 = nb1 - 1
print(nb1)

nb2 = 10
nb2 -= 1
print(nb2)

Dans les 2 cas ci-dessus, le résultat sera 9.

L'incrémentation et la décrémentation fonctionneront de la même manière avec la multiplication et la division. C'est simplement un raccourci pour le calcul.

Transtyper des variables

Petit rappel sur les types de variables (vu dans le Chapitre Bases du langage Python, vidéo Exploiter les variables en Python cf. le tableau "Les différents types de variables").

Si on travaille avec un input pour que l'utilisateur saisisse un nombre, on ne pourra pas l'additionner directement à un autre nombre. Cela vient du fait que la fonction input va automatiquement renvoyer une chaîne de caractères (str).
Exemple :

nb = input("un nombre ? ")
print(nb+10)

Sortie console : 
un nombre ? 10
Traceback (most recent call last):
  File "c:\Users\yannj\OneDrive\VS_Code\Python\01_Les_fondamentaux
				\C05_Bases_du_langage_Python\V08_Transtyper_des_variables.py",line 12, in <module>
    print(nb+10)
          ~~^~~
TypeError: can only concatenate str (not "int") to str

Ce message "TypeError: can only concatenate str (not "int") to str" démontre que la saisie utilisateur va automatiquement renvoyer une chaîne de caractères.

En ajoutant la fonction int, cela permet de transtyper / caster, la variable em afin de pouvoir l'utiliser pour les calcules. Dans l'exemple ci-dessous, la variable nb a été transtypée provisoirement :

nb = input("un nombre ? ")
print(int(nb)+10)

Sortie console : 
un nombre ? 10
20

Le message d'erreur précédent a disparu.

Si on utilise maintenant float (nombre à virgule) à la place du int (nombre entier), nous obtenons ceci :

nb = input("un nombre ? ")
print(float(nb)+10)

Sortie console : 
un nombre ? 10
20.0

Le chiffre 20 c'est bien transformé en 20.0.

Pour transtyper une variable de manière définitive, il faut redéfinir la variable une seconde fois.
Exemple :

nb = input("un nombre ? ")
# Transtyper la variable nb de str en int
nb = int(nb) 
print(nb+10)
print(type(nb))

Sortie console :
un nombre ? 10
20
<class 'int'>

Pour travailler avec les boolean, il faut savoir que True = 1 et False = 0.
Exemple :

homme = 1
homme = bool(homme)
print(homme)

Sortie console :
True

Pour transtyper un nombre en chaîne de caractères, le fonctionnement est similaire. Il suffit d'utiliser la fonction str.
Exemple :

nb1 = 123
nb1 = str(nb1)
print(nb1)
print(type(nb1))

Sortie console :
123
<class 'str'>

Concaténer des chaînes de caractères

La concaténation permet un enchaînement de deux chaînes de caractères mises bout à bous.
Exemple :

str1 = "Hello"
str2 = "World"

print(str1, str2)

Sortie console :
Hello World

Ici, la , permet d'ajouter automatiquement un espace entre les chaînes de caractères.
Exemple 2 :

prenom = "Jean-Philippe"
age = 47

print("Je me nomme", prenom, "et j'ai", age, "ans.")

Sortie console :
Je me nomme Jean-Philippe et j'ai 47 ans.

Une autre solution de concaténer est le symbole "+". Contrairement au symbole de la virgule, le symbole "+" ne va pas ajouter d'espace. De plus, il peut générer des erreurs à cause du type de variable.

prenom = "Jean-Philippe"
print("Je me nomme"+prenom)

Sortie console :
Je me nommeJean-Philippe

Voilà à quoi peut ressembler une concaténation avec le symbole "+ en respectant les espaces et le type de variable :

prenom = "Jean-Philippe"
age = 47

print("Je me nomme  "+ prenom + "  et j'ai  " + str(age) + "  ans.")

Sortie console :
Je me nomme Jean-Philippe j'ai 47 ans.

Les espaces avant la fermeture des guillemets et après leur ouvertures ne sont pas bien visible ci-dessus, mais ils sont présent. Afin de facilité la vision, j'ai ajouté dans le HTML des espaces supplémentaires, espaces supplémentaires qui ne sont pas requis dans le Python. Un seul suffis.

Exploiter les structures conditionnelles

Les trois structures conditionnelles les plus courantes sont les suivantes :

• if qui veut dire si
• else qui veut dire sinon
• elif qui veut dire sinon si

Pour vérifier si une couleur est rouge, il faut utiliser le double égal (==).
Une fois qu'on a défini le test, il faut ajouter le ":" à la fin.
Par défaut, VS Code va ajouter une indentation sur la ligne suivante.

couleur = "rouge"

if couleur == "rouge":
	print("La couleur est rouge")
print("Fin du programme ...")

Sortie console :
La couleur est rouge
Fin du programme ...

Ajouter la commande else va permettre d'afficher un message, d'executer une action si le test n'est pas concluant.

couleur = "jaune"

if couleur == "rouge":
	print("La couleur est rouge.")
else:
	print("La couleur n'est pas rouge.")

Sortie console :
La couleur n'est pas rouge.

Ajouter la commande elif va permettre d'enchaîner différent test avant d'arriver au cas généraliste du else.

couleur = "vert"

if couleur == "rouge":
	print("La couleur est rouge.")
elif couleur == "jaune":
	print("La couleur est jaune.")
else:
	print("La couleur n'est pas rouge ou jaune.")

	Sortie console :
La couleur n'est pas rouge ou jaune.

Le nombre de elif n'est pas limité. Le problème est que s'il y a beaucoup de test a faire, cela va devenir long et redondant.

La commande match va permettre d'enchaîner les case ce qui signifie les cas.
Chaque nouveau cas aura son bloc de code distinct et pourra exécuter des fonctions différentes.

couleur = "vert"

match couleur:
	case "rouge":
		print("la couleur est rouge")
	case "vert":
		print("la couleur est vert")

La commande case other: correspond au else pour tester tous les autres cas de figure non listé.
La commande case other: doit toujours être placé à la fin du bloc.

couleur = "jaune"

match couleur:
	case "rouge":
		print("la couleur est rouge")
	case "vert":
		print("la couleur est verte.")
	case other:
		print("la couleur n'est pas rouge ni verte.")

Utiliser les opérateurs de comparaison

Il existe plusieurs opérateurs de comparaison :

Exemple pour Différent de :

nb1 = 10
nb2 = 20

if nb1 != nb2:
	print(nb1, "est different de", nb2)

Sortie console :
10 est different de 20

Exemple pour Strictement inférieur à :

nb1 = 10
nb2 = 20

if nb1 < nb2:
	print(nb1, "est plus petit que", nb2)

	Sortie console :
10 est plus petit que 20

Utiliser les opérateurs logiques

if homme==True: peut également s'écrire if homme:
La fonction if va te toute façon renvoyer vrai ou faux
Donc si on ajoute aucune égalité, cela sous-entend que c'est vrai (True).

homme = True
if homme:
	print("Bonjour Monsieur")
else:
	print("Bonjour Madame")

Sortie console :
Bonjour Monsieur

Opérateur "not"

Il est possible de définir une variable et plus loin lui demander son opposé à l'aide de l'opérateur logique not:

homme = True
homme = not homme

if homme:
	print("Bonjour Monsieur")
else:
	print("Bonjour Madame")

Sortie console :
Bonjour Madame

Opérateur "and"

Exemple de base :

username = "bob"
password = 123

if username == "bob":
	if password == 123:
		print("Bienvenue Bob")

L'opérateur logique and permet de concaténer les 2 conditions. Il est nécessaire que toutes les conditions soient remplies pour que cela fonctionne.

username = "bob"
password = 123

if username == "bob" and password == 123:
	print("Bienvenue Bob")

Sortie console :
Bienvenue Bob

L'opérateur "or"

La différence entre l'opérateur or et l'opérateur and, c'est que l'opérateur or a besoin qu'au moins 1 condition fonctionne pour que le résultat s'affiche.

username = "bob"
password = 123

if username == "bob" or password == 123:
	print("Bienvenue Bob")
else:
	print("erreur")

Exploiter la boucle conditionnelle "for"

En programmation, une boucle est conditionnelle. Quand on passe dans une boucle, on définit le nombre de passage.
Le nombre de passage s'appelle itération. En python, l'itérateur s'appelle range. La variable de convention utilisée est souvent i. La boucle for est souvent utilisée pour parcourir un tableau.

for i in range(5):
print("Hello World")

Dans ce cas, le message "Hello World" sera affiché 5 fois.
En ajoutant la variable i dans la fonction print, on obtient également le nombre de passage dans la sortie console.

for i in range(5):
	print(i,"Hello World")

Sortie console :
0 Hello World
1 Hello World
2 Hello World
3 Hello World
4 Hello World

Les attributs du mot clé range

En mettant 2 nombres séparés par une virgule dans les parenthèses du range, cela va faire l'itération du premier nombre inclus jusqu'au 2ème nombre exclu.

for i in range(2,6):
	print(i,"Hello World")

Sortie console :
2 Hello World
3 Hello World
4 Hello World
5 Hello World

En mettant un 3ème chiffre en argument dans le range, il est possible de définir un pas.

for i in range(10,20,2):
print(i,"Hello World")

Sortie console :
10 Hello World
12 Hello World
14 Hello World
16 Hello World
18 Hello World

La commande else dans la boucle for

Il est possible d'ajouter un else à la fin d'une boucle mais c'est moyennement aimé dans le monde du développement.

for i in range(10,20,2):
	print(i,"Hello World")
else:
	print("fin de boucle")

Sortie console :
10 Hello World
12 Hello World
14 Hello World
16 Hello World
18 Hello World
fin de boucle

La boucle dans la boucle

Il est possible d'imbriquer une boucle dans une boucle.

for i in range(5):
	for j in range(2):
		print("i",i,"j",j)

Sortie console :
i 0 j 0
i 0 j 1
i 1 j 0
i 1 j 1
i 2 j 0
i 2 j 1
i 3 j 0
i 3 j 1
i 4 j 0
i 4 j 1

Exploiter la boucle conditionnelle "while"

Le mot clé while permet de faire une boucle tant que. Cela signifie, tant que la condition n'est pas ou tant qu'elle est remplie, on reste dans la boucle. C'est une boucle infinie.

while i<10:
	print(i,"Hello World")

Sortie console :
"0 Hello World" à l'infini

Pour arrêter une boucle infinie, il faut presser CTRL + C.

Pour éviter la boucle infinie, dans ce cas, il ne faut pas oublier d'incrémenter la valeur de i.

while i<10:
	print(i,"Hello World")
	i+=1

Sortie console :
0 Hello World
1 Hello World
2 Hello World
3 Hello World
4 Hello World
5 Hello World
6 Hello World
7 Hello World
8 Hello World
9 Hello World

Voilà un exemple avec interaction de l'utilisateur :

while True:
com = input("com>")
if com == "hello":
	print("Salut à toi !!!")

Sortie console :
com>hello
Salut à toi !!!
com>l
com>hello
Salut à toi !!!
com>

Comme on peut le constater ci-dessus, on est dans une boucle infinie car la console demande toujours une nouvelle saisie utilisateur. La saisie de "hello" a bien renvoyé "Salut à toi !!!" alors que "l" n'a rien sortie car le cas n'était pas défini.

Pour sortir de la boucle, on peut insérer un test qui change la valeur de condition de la boucle while.

stop = False

# tant que stop n'est pas égal à True
while not stop:
	com = input("com>")
	
	# Test saisie "hello"
	if com == "hello":
		print("Salut à toi !!!")

	# Permet de sortir de la boucle
	elif com == "stop":
		stop = True
	
	# Tous les autres cas de figures
	else:
		print("commande non valide")
	
		Sortie console :
com>hello
Salut à toi !!!
com>olleh
commande non valide
com>stop
PS C:\Users\yannj\OneDrive\VS_Code>

Modifier le flux d'une boucle

Il existe plusieurs moyens d'interrompre une boucle.

• break = casser
• continue = continuer

Dans le code ci-dessous, sans la commande break, le code s'arrêterai à 9 car il commence à 0.

for i in range(10):
	if i==5:
		break
	print(i)

Sortie console :
0
1
2
3
4

Remplacer break par continue aura pour conséquence de recommencer la boucle avec l'itération suivante tout en ignorant la fin de la boucle si la condition est remplie. On peut constater ci-dessous que le 5 est manquant dans la sortie console à cause du continue.

for i in range(10):
	if i==5:
		continue
	print(i)

print("fin du programme")

Sortie console :
0
1
2
3
4
6
7
8
9
fin du programme

Exploiter la structure de données "Liste"

L'avantage du python pour la structure de données "Liste" est que le contenu est que le contenu peut être mixte (nombre, texte, etc.) car le langage python a un typage dynamique.

Pour créer une liste, il faut définir une variable. Contrairement aux variables classique, la liste ce crée en mettant les valeurs entre crochet [ et ] et les valeurs sont séparées par des virgules.
Exemple :

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

La commande len (length)

Ce n'est pas propre à la liste, la commande len(variable) permet de définir le nombre d'élément dans la liste.

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

print(len(ma_liste))

Sortie console :
6

Récupérer un élément de la liste

Pour récupérer un élément de la liste il faut mettre le numéro d'indexe entre crochet :

#		    	0		1	     2	   	3	4	  5
ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

print(ma_liste[1])

Sortie console :
rouge

Sortir tous les éléments de la liste

Pour sortir tous les éléments d'une liste, il faut utiliser une boucle for.

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]
			
for element in ma_liste:
	print(element)

Sortie console :
jaune
rouge
blanc
22
1.5
True

Sortir le numéro d'index avec sa valeur

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

index = 0
for element in ma_liste:
	print(index,element)
	index+=1

	Sortie console :
0 jaune
1 rouge
2 blanc
3 22
4 1.5
5 True

Ajouter un élément à la fin de la liste - append

Pour ajouter un élément à la fin d'une liste, il faut utiliser le nom de la liste, un . suivi de la fonction append.

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

ma_liste.append("vert")

index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
0 jaune
1 rouge
2 blanc
3 22
4 1.5
5 True
6 vert

Ajouter un élément selon un numéro d'index

A la place de append il faut utiliser insert.

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

ma_liste.insert(0,"vert")

index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
0 vert
1 jaune
2 rouge
3 blanc
4 22
5 1.5
6 True

On peut constater que cette fois, le mot vert est en tête de liste avec l'index 0 au lieu de 6 comme dans le cas précédent.
Il est également possible d'insérer des éléments n'importe où dans la liste en utilisant l'index. Les éléments qui suivent se décaleront.

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

ma_liste.insert(2,"vert")

index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
0 jaune
1 rouge
2 vert
3 blanc
4 22
5 1.5
6 True

Supprimer un élément d'une liste

Il faut utiliser la commande remove pour retirer un élément. Il est nécessaire d'utiliser la valeur de l'élément à supprimer de la liste.

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

ma_liste.remove("blanc")

index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
0 jaune
1 rouge
2 22
3 1.5
4 True

Supprimer un élément par son index

La commande pop permet de supprimer un élément par son index.

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

ma_liste.pop(2)

index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
0 jaune
1 rouge
2 22
3 1.5
4 True

Afficher l'index selon une valeur

La commande index permet d'afficher l'index d'une valeur.

ma_liste = ["jaune", "rouge", "blanc", 22, 1.5, True]

print(ma_liste.index("rouge"))

print("------------------")
index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
1
------------------
0 jaune
1 rouge
2 blanc
3 22
4 1.5
5 True

Nombre de fois qu'un élément se trouve dans la liste

La commande count permet de compter le nombre de fois qu'un élément se trouve dans une liste données.

ma_liste = ["jaune", "rouge", "jaune", 22, 1.5, True]

print(ma_liste.count("jaune"))

print("------------------")
index = 0
for element in ma_liste:
	print(index,element)
	index+=1

	Sortie console :
2
------------------
0 jaune
1 rouge
2 jaune
3 22
4 1.5
5 True

Trier une liste par ordre croissant

La commande sort permet de trier les éléments d'une liste par ordre croissant.

ma_liste = ["zebra", "rouge", "alain", 22, 1.5, True]

ma_liste.sort()

print("------------------")
index = 0
for element in ma_liste:
	print(index,element)
	index+=1

	Sortie console :
Traceback (most recent call last):
  File "c:\Users\yannj\OneDrive\VS_Code\Python\01_Les_fondamentaux
			\C05_Bases_du_langage_Python
			\V16_Exploiter_la_structure_de_donnees_liste.py", 
			line 17, in <module>
    ma_liste.sort()
TypeError: '<' not supported between instances of 'int' and 'str'

Cette erreur est logique car il n'est pas possible de trier des mots et des chiffre en même temps.
En supprimant tout sauf les string, on obtient ceci :

ma_liste = ["zebra", "rouge", "alain"]

ma_liste.sort()

print("------------------")
index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
0 alain
1 rouge
2 zebra

Inverser l'ordre d'une liste

La commande reverse permet d'inverser l'ordre d'une liste. Pour obtenir un ordre décroissant, il est nécessaire de faire un tri auparavant avec la commande sort.

ma_liste = ["zebra", "zoe","rouge", "alain"]

ma_liste.sort()
ma_liste.reverse()

print("------------------")
index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
0 zoe
1 zebra
2 rouge
3 alain

Copier une liste

La commande copy permet de copier une liste.

ma_liste = ["zebra", "zoe","rouge", "alain"]

ma_liste_2 = ma_liste.copy()

print("------------------")
index = 0
for element in ma_liste:
	print(index,element)
	index+=1

print("------------------")
index = 0
for element in ma_liste_2:
	print(index,element)
	index+=1

Sortie console :
------------------
0 zebra
1 zoe
2 rouge
3 alain
------------------
0 zebra
1 zoe
2 rouge
3 alain

Etendre une liste

La commande extend permet d'étendre une liste, d'ajouter une liste à la fin d'une liste existante.

ma_liste = ["zebra", "zoe","rouge", "alain"]

ma_liste_2 = [0,1,2,32,44]

ma_liste.extend(ma_liste_2)

print("------------------")
index = 0
for element in ma_liste:
	print(index,element)
	index+=1

	Sortie console :
0 zebra
1 zoe
2 rouge
3 alain
4 0
5 1
6 2
7 32
8 44

Effacer le contenu d'une liste

La commande clear permet d'effacer le contenu d'une liste.

ma_liste = ["zebra", "zoe","rouge", "alain"]

ma_liste.clear()

print("------------------")
index = 0
for element in ma_liste:
	print(index,element)
	index+=1

Sortie console :
------------------

Exploiter la structure de données "Dictionnaire

Un dictionnaire permet d'associer une valeur/une définition à un mot/une clé unique. La clé doit toujours être unique alors que la valeur peut être utilisée par plusieurs clés. Le type des clés et/ou valeur n'a pas besoin d'être identique.

dico = {"nom":"Parein" , "prenom":"jean" , "age":47}
dico1 = {0:120 , 1:45 , "a":45}

Sortie console :
Rien ne sort et il n'y a pas d'erreur non plus.

Il est possible de mettre le contenu du dictionnaire sur plusieurs ligne pour le rendre plus lisible.

dico = {"nom":"Parein", 
	     "prenom":"Jean", 
	     "age":47}

Voilà un exemple :

dico = {"nom":"Parein", "prenom":"jean", "age":47}

print(dico)

Sortie console : 
{'nom': 'Parein', 'prenom': 'jean', 'age': 47}

Cette sortie n'est pas bien lisible.

Changer la valeur d'une clé ou ajouter une nouvelle clé

Pour modifier la valeur d'une clé, il suffit de rappeler la clé. Pour ajouter une nouvelle clé, il faut définir une nouvelle clé.

dico = {"nom":"Parein", "prenom":"jean", "age":47}

dico["prenom"] = "luc"
dico["taille"] = 1.8

print(dico)

Sortie console :
{'nom': 'Parein', 'prenom': 'luc', 'age': 47, 'taille': 1.8}

Supprimer une pare dans le dictionnaire

Tout comme pour la liste, utiliser la commande pop va permettre de supprimer une clé avec sa valeur du dictionnaire.

dico = {"nom":"Parein", "prenom":"jean", "age":47}

dico.pop("prenom")

print(dico)

Sortie console :
{'nom': 'Parein', 'age': 47}

Effacer le contenu d'un dictionnaire

dico = {"nom":"Parein", "prenom":"jean", "age":47}

dico.clear()

print(dico)
Sortie console :
{}

Copier le contenu d'un dictionnaire

dico = {"nom":"Parein", "prenom":"jean", "age":47}

autre_dico = dico.copy()

print(dico)
print(autre_dico)

Sortie console :
{'nom': 'Parein', 'prenom': 'jean', 'age': 47}
{'nom': 'Parein', '>prenom': 'jean', 'age': 47}

Sortir les valeurs de manière exploitable

Pour sortir de manière plus lisible les valeurs du dictionnaire, il faut utiliser une boucle.

dico = {"nom":"Parein", "prenom":"jean", "age":47}
for val in dico.values():
	print(val)

Sortie console :
Parein
jean
47

Pour récupérer les clés, il faut remplacer values par keys.

dico = {"nom":"Parein", "prenom":"jean", "age":47}
for key in dico.keys():
	print(key)

Sortie console :
nom
prenom
age

Lister le contenu du dictionnaire de manière lisible

dico = {"nom":"Parein", "prenom":"jean", "age":47}
for key,val in dico.items():
	print(key, " : ", val)

Sortie console :
nom  :  Parein
prenom  :  jean
age  :  47

Test de présence d'une clé

Pour le test ci-dessous, une f-string est utilisée.

dico = {"nom":"Parein", "prenom":"jean", "age":47}
cle_1 = "age"
cle_2 = "taille"

if cle_1 in dico:
	print(f"La clé {cle_1} est présente.")
else:
	print(f"La clé {cle_1} n'est pas présente.")

if cle_2 in dico:
	print(f"La clé {cle_2} est présente.")
else:
	print(f"La clé {cle_2} n'est pas présente.")

Sortie console :
La clé age est présente.
La clé taille n'est pas présente.

Exploiter la structure de données "Tableau"

Dans Python, les tableaux n'existent pas. Les concepteurs du Python ont fait en sorte que les listes fonctionnent comme des tableaux.

Dans MS Excel, il y a la possibilité de faire des tableaux multidimensionnels.

Pour obtenir le même résultat en Python, il est nécessaire de faire une liste dans une liste.

tab = [
	["Stallone", "Sylvester", "Rocky"], # index = 0
	["Schwarzeneger", "Arnold", "Predator"], # index = 1
	["Gibson", "Mel", "Braveheart"] # index = 2
]

print(tab[1])

Sortie console :
['Schwarzeneger', 'Arnold', 'Predator']

Si on souhaite sortir uniquement une donnée d'une ligne du tableau (liste dans la liste), il faut ouvrir une seconde fois les "[ ]". Dans l'exemple ci-dessous, l'index 0 va chercher la première ligne du tableau et l'index 2 va chercher le film dans la première ligne.

tab = [
	["Stallone", "Sylvester", "Rocky"], # index = 0
	["Schwarzeneger", "Arnold", "Predator"], # index = 1
	["Gibson", "Mel", "Braveheart"] # index = 2
]

print(tab[0][2])

Sortie console :
Rocky

Il est également possible de parcourir le tableau avec une boucle.

tab = [
	["Stallone", "Sylvester", "Rocky"], # index = 0
	["Schwarzeneger", "Arnold", "Predator"], # index = 1
	["Gibson", "Mel", "Braveheart"] # index = 2
]

for v in tab:
	print(v)

Sortie console :
['Stallone', 'Sylvester', 'Rocky']
['Schwarzeneger', 'Arnold', 'Predator']
['Gibson', 'Mel', 'Braveheart']

Si l'on souhaite sortir qu'une colone d'un tableau à l'aide d'une boucle, il faut ajouter l'index.

tab = [
	["Stallone", "Sylvester", "Rocky"], # index = 0
	["Schwarzeneger", "Arnold", "Predator"], # index = 1
	["Gibson", "Mel", "Braveheart"] # index = 2
]

for v in tab:
	print(v[0])

Sortie console :
Stallone
Schwarzeneger
Gibson

Pour sortir le nom et le prénom des acteurs de la liste, il faut concaténer les index au moment du print.

tab = [
	["Stallone", "Sylvester", "Rocky"], # index = 0
	["Schwarzeneger", "Arnold", "Predator"], # index = 1
	["Gibson", "Mel", "Braveheart"] # index = 2
]

for v in tab:
	print(v[0], " : ", v[1])

Sortie console :
Stallone  :  Sylvester
Schwarzeneger  :  Arnold
Gibson  :  Mel

Le nombre de sous-liste n'est pas limitée.

tab = [
	["Stallone", "Sylvester", [
		"Rocky", "cobra"
		]
	], # index = 0
	["Schwarzeneger", "Arnold", "Predator"], # index = 1
	["Gibson", "Mel", "Braveheart"] # index = 2
]
print(tab[0][2][0])

Sortie console :
Rocky

La preuve que le tableau n'existe pas dans Python est la sortie du type via la console.

tab = [
	["Stallone", "Sylvester", [
		"Rocky", "cobra"
		]
	], # index = 0
	["Schwarzeneger", "Arnold", "Predator"], # index = 1
	["Gibson", "Mel", "Braveheart"] # index = 2
]
print(tab[0][2][0])

print(type(tab))

Sortie console :
Rocky
<class 'list'>

Utiliser les séquences (Tuples)

Utiliser un tuple va permettre de "bétonner" le code pour éviter un changement par erreur par la suite. Par exemple, un numéro de sécurité sociale, la constante pi, etc.

Si on essaie de sortir le type d'un tuple, il faut faire attention à la manière de le définir.
Voilà une manière erronée.

mon_tuple = (1)
print(type(mon_tuple))

Sortie console :
<class 'int'>

Pour déclarer un tuple, il faut ajouter une virgule après la valeur.

mon_tuple = (1,)
print(type(mon_tuple))

Sortie console :
<class 'tuple'>

Les parenthèses ne sont pas obligatoires mais conseillées.

Pour accéder aux valeurs du tuple, on utilise les crochets "[ ]" comme précédemment pour les listes et les dictionnaires.

mon_tuple = (2,4,6,8,10)
print(mon_tuple[0])

Si on essaie de changer une valeur d'un tuple, la console va sortir une erreur :
L'objet « tuple » ne prend pas en charge l'affectation d'éléments.

mon_tuple = (2,4,6,8,10)
mon_tuple[0] = "45"
print(type(mon_tuple))

Sortie console :
File "c:\Users\yannj\OneDrive\VS_Code\Python\01_Les_fondamentaux
		\C05_Bases_du_langage_Python
		\V20_Utiliser_les_sequence_Tuples.py", line 7, in <module>
	mon_tuple[0] = "45"
~~~~~~~~~^^^
TypeError: 'tuple' object does not support item assignment

Comme pour les autres entités, il est possible de sortir toutes les valeurs à l'aide d'une boucle for.

mon_tuple = (2,4,6,8,10)

for v in mon_tuple:
	print(v)

Sortie console :
2
4
6
8
10

On peut se servir de tuples pour définir plusieurs variables en même temps.

mon_tuple = ("jean","philippe")

for v in mon_tuple:
	print(v)

nb1 , nb2 , nb3 = 1 , 2 , 3

print(nb1)
print(nb2)
print(nb3)

Sortie console :
jean
philippe
1
2
3

En sortant le type d'une variable défini via un tuple, on peut constater que ce n'est pas un tuple qui sort, mais bien un integer dans ce cas.

nb1 , nb2 , nb3 = 1 , 2 , 3
print(type(nb1))

Sortie console :
<class 'int'>

Vu qu'il n'y a qu'une valeur définie par variable, il est possible de la redéfinir par la suite. Cela ne génère pas de tuple.

nb1 , nb2 , nb3 = 1 , 2 , 3
nb1 = 456
print(nb1)

Sortie console :
456

Utiliser les opérateurs d'appartenance

L'opérateur in vérifie en Python si une valeur spécifiée est un élément constitutif d'une séquence comme une chaîne de caractères, un tableau, une liste ou même un tuple. Au contraire de l'opérateur not in qui lui vérifie si l'élément est absent.
Le résultat va renvoyer une valeur boolean.

ma_liste = ["jaune", "rouge", "vert", "noir"]
print("vert" in ma_liste)
print("vert" not in ma_liste)
print("rose" not in ma_liste)

Sortie console :
True
False
True

Cela permet d'afficher des informations plus précises.

ma_liste = ["jaune", "rouge", "vert", "noir"]

if "jaune" in ma_liste:
	print("le jaune est dans la liste")

Sortie console :
le jaune est dans la liste

Les opérateurs d'appartenances permettent d'éviter des erreurs. Voilà l'erreur qui s'affiche si on tente de retirer un élément d'une liste sans avoir testé si l'élément se trouve ou non dans la liste.

ma_liste = ["jaune", "rouge", "vert", "noir"]

ma_liste.remove("rose")

Sortie console :
File "c:\Users\yannj\OneDrive\VS_Code\Python\01_Les_fondamentaux
		\C05_Bases_du_langage_Python
		\V21_Utiliser_les_operateurs_d_appartenance.py", line 11, in <module>
	ma_liste.remove("rose")
ValueError: list.remove(x): x not in list

Pour éviter l'erreur, il faut faire un test. De cette manière, on évite l'erreur.

ma_liste = ["jaune", "rouge", "vert", "noir"]

if "rose" in ma_liste:
	ma_liste.remove("rose")
else:
	print("rose n'est pas dans la liste")

Sortie console :
rose n'est pas dans la liste

Ces opérateurs peuvent s'utiliser avec toutes les structures (dico, liste, chaîne de caractères).

Gérer les exceptions

Par gérer les exceptions, il faut comprendre gérer les erreurs. On va également parler de lever une erreur. Pour cela, il y a 2 mots clés :

• try qui permet de tester un bloc de code.
• except qui permet d'exécuter un bloc de code en cas d'erreur.

nb1 = input("Nombre 1 ? ")
nb2 = input("Nombre 2 ? ")

print(nb1/nb2)

Sortie console :
Traceback (most recent call last):
  File "c:\Users\yannj\OneDrive\VS_Code\Python\01_Les_fondamentaux
			\C05_Bases_du_langage_Python
			\V22_Gerer_les_exceptions.py", line 12, in <module>
    print(nb1/nb2)
          ~~~^~~~
TypeError: unsupported operand type(s) for /: 'str' and 'str'

Les mots clés try et except vont de pair. Si l'on met l'un, on est obligé de mettre l'autre.

nb1 = input("Nombre 1 ? ")
nb2 = input("Nombre 2 ? ")

try:
	print(int(nb1)/int(nb2))
except:
	pass

print("Fin du programme")
		
Sortie console :
Nombre 1 ? 10
Nombre 2 ? zzz
Fin du programme

Nous pouvons constater que Fin du programme a été imprimé sans le résultat de la division. Cela vient de l'exception qui test si le bout de code est possible ou non. La partie except va permettre de déclencher une fonction spécifique en cas d'erreur.

Les exceptions peuvent être ajoutées les unes après les autres.

nb1 = input("Nombre 1 ? ")
nb2 = input("Nombre 2 ? ")

try:
	print(int(nb1)/int(nb2))
except ValueError:
	print("Vous devez saisir un nombre.")
except ZeroDivisionError:
	print("nb2 ne doit pas être égal à 0.")
except:
	print("Une erreur c'est produite.")

print("Fin du programme")

Avec ce code, un premier test est fait que la saisie utilisateur doit bien être un nombre.
Le second test va regarder que nb2 ne doit pas être égal à 0.
Le 3ème test est pour toutes autres exceptions auxquelles on aurait pas pensées.

Il est aussi possible de récupérer l'erreur dans une variable.

nb1 = input("Nombre 1 ? ")
nb2 = input("Nombre 2 ? ")

try:
	print(int(nb1)/int(nb2))
except Exception as err:
	print("Erreur de type : ", err)

print("Fin du programme")
		
Sortie console :
Nombre 1 ? 10
Nombre 2 ? 0
Erreur de type :  division by zero
Fin du programme

Il est également possible d'utiliser le else pour informer l'utiliser que cela a fonctionné. Le else s'exécute uniquement si aucune exception n'a été levée dans le bloc try.

nb1 = input("Nombre 1 ? ")
nb2 = input("Nombre 2 ? ")

try:
	print(int(nb1)/int(nb2))
except Exception as err:
	print("Erreur de type : ", err)
else:
	print("L'opération s'est déroulée correctement.")

print("Fin du programme")

Sortie console :
Nombre 1 ? 10
Nombre 2 ? 5
2.0
L'opération s'est déroulée correctement.
Fin du programme

La commande finally va s'exécuter dans tous les cas à la fin du test. qu'il y a une exception ou non.

nb1 = input("Nombre 1 ? ")
nb2 = input("Nombre 2 ? ")

try:
	print(int(nb1)/int(nb2))
except Exception as err:
	print("Erreur de type : ", err)
else:
	print("L'opération s'est déroulée correctement.")
finally:
	print("bloc finally")

print("Fin du programme")

Sortie console 1 :
Nombre 1 ? 10
Nombre 2 ? 2
5.0
L'opération s'est déroulée correctement.
bloc finally
Fin du programme

Sortie console 2 :
Nombre 1 ? 10
Nombre 2 ? a

Erreur de type :  invalid literal for int() with base 10: 'a'
bloc finally
Fin du programme