1-01. Bases de Python

• Affecter une valeur à une variable.
• Identifier le type d’une donnée (int, float, str, bool) et savoir le convertir.
• Utiliser print() et input() pour dialoguer avec l’utilisateur.

Affectation

En programmation, une variable, c’est une « étiquette » qu’on attribue à une valeur (ou à un calcul qui est traité juste avant que cette étiquette lui soit attribuée). L’action d’attribuer cette étiquette se fait avec le signe "=".

		x = 3 # la variable x est l’étiquette de la valeur 3
		y = 2+5 # la variable y est l’étiquette de la valeur calculée (7)
		x = "bonjour" # x est l’étiquette de la chaîne de caractères "bonjour"
	

🖐️ C’est très différent du sens du signe "=" en math. En math, écrire « $*x*$ = 3 » a tout autant de sens qu’écrire « 3 = $*x*$ ». En programmation, écrire 3 = x n’a aucun sens et provoquera une erreur.

D’ailleurs, en programmation, on peut se servir du signe égal d’une manière qui n’aurait aucun sens en math… 😅

		x = 3 # la variable x est l’étiquette de la valeur 3
		x = x+1 # Python calcule x+1 (3+1 = 4) puis l’associe à la variable x
	

On dit ici qu’on a incrémenté la variable x. C’est une opération très courante en programmation. On aura largement l’occasion de revenir dessus un peu plus tard.

Les noms de variables interdits

Une variable peut être nommé presque comme vous voulez. Par exemple poids_du_bidule ou prixMachin. Il y a cependant quelques interdictions ⛔ :

• Commencer par un chiffre : 1nom interdit ⟶ nom1 OK
• Contenir un espace : nom utilisateur interdit ⟶ nom_utilisateur OK
• Contenir un caractère spécial autre que l’underscore _ : pas de !, +, ?, @…
• Être un mot-clé réservé de Python : if, else, elif, for, while, def, return, class, True, False, None, and, or, not, in, is, lambda… (la liste complète est longue, mais ce sont tous des mots qui ont déjà un sens précis pour Python).

Il faut également absolument éviter d’écraser le nom d’une fonction native (c’est-à-dire prédéfinie dans Python) comme print, str, etc. Ça ne provoquera pas d’erreur, mais la fonction deviendra inutilisable pour le reste du programme.

Bonnes pratiques pour nommer ses variables

Pour un maximum de clarté et de compatibilité et un minimum de confusion :

• On ne met pas de lettres accentuées dans un nom de variable, ni de "ç".
• On évite de mélanger majuscules et minuscules. Pour commencer, je vous demande de n’utiliser que des minuscules
• Contrairement aux maths et à la physique, on utilise des noms de variable explicites, par exemple user_name plutôt que x. C’est plus long, mais c’est plus clair !

La fonction print()

La fonction native print() permet d’afficher ce qu’on lui donne dans la console.

		print("Bonjour !")   # affiche Bonjour !
		print(3)             # affiche 3
		print(3.5)           # affiche 3.5
	

On peut aussi donner plusieurs valeurs à print(), séparées par des virgules. Elles seront affichées à la suite, séparées automatiquement par un espace.

		poids = 12
		print("l’objet pèse", poids, "kg")   # affiche : l’objet pèse 12 kg
	

Les f-strings

Il existe une manière plus pratique et plus lisible d’afficher une variable au milieu d’un texte : les f-strings (formatted strings). Il suffit de préfixer la chaîne par f et d’écrire le nom de la variable entre accolades { } :

		poids = 12
		print(f"l’objet pèse {poids} kg")   # affiche : l’objet pèse 12 kg
	

C’est cette écriture qu’on utilisera la plupart du temps dans la suite du cours. On peut même glisser un calcul directement entre les accolades (f"le double de x est {x*2}").

Les 4 types de base

On l’a vu juste au-dessus : une variable, c’est une étiquette collée sur une valeur. Mais toutes les valeurs ne se ressemblent pas : 3, 3.0, "3" et True n’ont rien à voir entre elles. C’est ce qu’on appelle le type d’une donnée.

Pour connaître le type d’une valeur, on utilise la fonction type() :

		print(type(3))       # class 'int'
		print(type(3.0))     # class 'float'
		print(type("3"))     # class 'str'
		print(type(True))    # class 'bool'
	

Regardez bien : 3 et "3" se ressemblent à l’écran, mais ce sont deux choses complètement différentes pour Python. Le premier est un nombre sur lequel on peut faire des calculs, le second est juste du texte − une suite de caractères qui ressemble à un chiffre, rien de plus.

		print(3 + 3)      # 6 (une addition)
		print("3" + "3")  # 33 (une concaténation de deux textes, pas un calcul !)
	

Le cas particulier du booléen

Le type bool est sans doute le plus étrange des quatre au premier abord. Il ne peut prendre que deux valeurs : True (vrai) ou False (faux). Rien d’autre.

		reponse = True
		est_termine = False
	

À quoi ça sert ? À stocker une information qui n’a que deux états possibles : vrai ou faux, oui ou non… On s’en servira un peu plus loin, dans le paragraphe sur les conditions.

Convertir un type en un autre

On peut parfois transformer une valeur d’un type vers un autre grâce à des fonctions de conversion : int(), float(), str() et bool().

		x = "3"
		y = int(x)     # y vaut 3 (un nombre entier), pas "3"
		z = float(x)   # z vaut 3.0

		a = 7
		b = str(a)     # b vaut "7" (une chaîne de caractères)
	

On peut aussi convertir n’importe quelle valeur en booléen, avec bool(). Contrairement aux autres conversions, celle-ci ne provoque (presque) jamais d’erreur : Python applique une règle très simple.

		print(bool(0))          # False
		print(bool(3))          # True
		print(bool(-5))         # True (même négatif !)
		print(bool(""))         # False (chaîne vide)
		print(bool("bonjour"))  # True
		print(bool("0"))        # True !!
	

La règle : tout ce qui représente « rien » ou « vide » devient False − le nombre 0, la chaîne vide "" − et absolument tout le reste devient True. Même "0", qui n’est qu’une chaîne de caractères non vide (donc True), même si ça peut sembler contre-intuitif au premier abord !

La fonction input()

La fonction input() permet enfin de dialoguer avec l’utilisateur : elle affiche un message, attend que la personne tape quelque chose au clavier, puis renvoie ce qu’elle a tapé.

		prenom = input("Quel est ton prénom ? ")
		print(f"Bonjour {prenom} !")
	

		age = input("Quel âge as-tu ? ")  # l’utilisateur tape : 15
		print(type(age))                  # class 'str' − et non 'int' !
		print(age + 1)                    # 💥 TypeError !
	

Pour utiliser cette saisie comme un vrai nombre, il faut donc penser à la convertir, avec int() ou float() selon le cas :

		age = int(input("Quel âge as-tu ? "))   # on convertit tout de suite
		print(age + 1)                          # ça fonctionne : 16
	

Et souvenez-vous du bool() vu juste avant : c’est justement très utile pour vérifier qu’une saisie n’est pas vide avant de continuer.

		nom = input("Quel est ton nom ? ")
		print(bool(nom))   # False si on a juste appuyé sur Entrée sans rien taper
	

			pv = 100
			pseudo = "Nova"
			niveau = "12"

			print(pv + 20)
			print(pseudo + niveau)
			print(pv + niveau)
		

				print(pv + int(niveau))   # 112
			

				pseudo = input("Quel est ton pseudo ? ")
				niveau = int(input("Quel est ton niveau ? "))
				print(f"{pseudo} est niveau {niveau}. Encore un effort pour atteindre le niveau {niveau + 1} !")
			

				pseudo = input("Quel est ton pseudo ? ")
				print(bool(pseudo))
			

• Écrire une structure if / elif / else.
• Utiliser les opérateurs de comparaison et les combiner avec and, or, not.

La structure if

Un programme qui fait toujours exactement la même chose, quelle que soit la situation, c’est vite limité. On veut souvent qu’il réagisse différemment selon les circonstances. C’est le rôle du mot-clé if : il permet d’exécuter un bloc de code seulement si une condition est vraie.

		age = int(input("Quel âge as-tu ? "))

		if age >= 18:
			print("Tu es majeur.")
	

Ici, la ligne print("Tu es majeur.") ne s’exécute que si la condition age >= 18 est vraie − c’est-à-dire si elle vaut True. Sinon, Python saute directement cette ligne et continue son chemin.

Sinon : else et elif

Que faire si la condition est fausse ? Le mot-clé else (« sinon ») permet de définir un bloc de code alternatif :

		age = int(input("Quel âge as-tu ? "))

		if age >= 18:
			print("Tu es majeur.")
		else:
			print("Tu es mineur.")
	

Et s’il y a plus de deux cas possibles ? On utilise elif (contraction de « else if »), autant de fois que nécessaire, avant le else final (qui reste facultatif) :

		note = int(input("Quelle note as-tu obtenue ? "))

		if note >= 16:
			print("Excellent !")
		elif note >= 10:
			print("C’est validé.")
		elif note >= 8:
			print("Peut mieux faire…")
		else:
			print("Il va falloir travailler davantage !")
	

Python teste les conditions dans l’ordre, et s’arrête à la première qui est vraie : dès qu’un bloc s’exécute, tous les suivants sont ignorés, même si leur condition aurait aussi été vraie.

Les opérateurs de comparaison

On a déjà croisé == dans le paragraphe sur l’affectation. Il existe toute une famille d’opérateurs de comparaison, qui renvoient toujours un booléen (True ou False) :

Souvenez-vous du paragraphe sur le booléen : une condition, ce n’est jamais qu’une question posée à Python. age >= 18, c’est littéralement la question « est-ce que age est supérieur ou égal à 18 ? », et Python y répond par True ou False.

Combiner plusieurs conditions

Parfois, une seule condition ne suffit pas : on veut vérifier plusieurs critères à la fois. On dispose pour ça de trois opérateurs booléens : and (« et »), or (« ou ») et not (« non »).

		age = int(input("Quel âge as-tu ? "))
		a_un_billet = input("As-tu un billet ? (oui/non) ") == "oui"

		if age >= 18 and a_un_billet:
			print("Tu peux entrer.")
	

and exige que les deux conditions soient vraies pour que le tout soit vrai. or se contente qu’au moins une des deux conditions le soit. Et not inverse simplement une condition (vrai devient faux, et inversement).

		jour = input("Quel jour sommes-nous ? ")

		if jour == "samedi" or jour == "dimanche":
			print("C’est le week-end !")

		if not (jour == "samedi" or jour == "dimanche"):
			print("On est un jour de semaine.")
	

				porte = int(input("Quelle porte choisissez-vous (1, 2 ou 3) ? "))

				if porte == 1:
					print("Bravo, vous avez trouvé le trésor !")
				elif porte == 2:
					print("Un dragon vous dévore. Fin de la partie.")
				elif porte == 3:
					a_la_cle = input("Avez-vous la clé ? (oui/non) ") == "oui"
					mot_de_passe = input("Quel est le mot de passe ? ")
					if a_la_cle and mot_de_passe == "abracadabra":
						print("La porte s’ouvre sur un passage secret !")
					else:
						print("La porte reste fermée.")
				else:
					print("Ce numéro de porte n’existe pas.")
			

• Utiliser une boucle for avec range() pour répéter un traitement un nombre connu de fois.
• Parcourir les caractères d’une chaîne ou les éléments d’une séquence simple.

La boucle for et range()

Copier-coller vingt fois la même ligne de print() parce qu’on veut répéter vingt fois la même chose : quelle horreur 😫. Une boucle bornée permet de répéter un bloc de code un nombre connu à l’avance de fois, avec le mot-clé for.

		for i in range(5):
			print("Bonjour !")
	

Ce code affiche 5 fois "Bonjour !". La fonction range(5) fournit à la boucle une suite de 5 nombres, et à chaque tour de boucle, la variable i prend la valeur suivante de cette suite (on l’appelle un compteur). On ne se sert pas forcément de i dans le bloc de code, comme ici, mais on peut très bien l’utiliser :

		for i in range(5):
			print(f"Tour n°{i}")
	

range() a d’autres subtilités qu’on découvrira plus tard. Pour l’instant, on retient simplement que range(n) permet de répéter un bloc de code n fois.

Parcourir une chaîne de caractères

Une chaîne de caractères, c’est une suite de lettres. On peut donc, elle aussi, la parcourir avec une boucle for, caractère par caractère :

		for lettre in "bonjour":
			print(lettre)
	

Ici, la variable lettre prend successivement la valeur de chaque caractère de la chaîne "bonjour" : "b", puis "o", puis "n", etc. Contrairement à range(), on ne connaît pas de nombre à l’avance : c’est Python qui s’arrête tout seul une fois la chaîne entièrement parcourue.

Compteurs et accumulateurs

Un des grands intérêts d’une boucle, c’est de construire progressivement un résultat, au fil des répétitions. Pour ça, on utilise une variable qu’on initialise avant la boucle, et qu’on met à jour à l’intérieur de la boucle.

Si cette variable sert à compter des occurrences, on parle de compteur :

		mot = "anticonstitutionnellement"
		nb_voyelles = 0   # le compteur démarre à 0

		for lettre in mot:
			if lettre in "aeiouy":
				nb_voyelles = nb_voyelles + 1   # on incrémente le compteur

		print(nb_voyelles)
	

Si elle sert plutôt à cumuler une valeur (une somme, par exemple), on parle d’accumulateur :

		somme = 0   # l’accumulateur démarre à 0

		for i in range(101):
			somme = somme + i

		print(somme)   # la somme de 0 + 1 + 2 + ... + 100
	

Dans les deux cas, le principe est le même : une variable qui existe avant la boucle, et qui évolue à chaque tour. C’est un des schémas les plus courants de toute la programmation, autant s’y habituer tout de suite 😉.

Interrompre une boucle avec break

Parfois, il sert à rien de poursuivre une boucle jusqu’au bout si on a déjà trouvé ce qu’on cherchait. Le mot-clé break permet d’interrompre immédiatement la boucle et de passer à la suite du programme.

		mot = "pythons"

		for lettre in mot:
			if lettre == "h":
				print("Lettre 'h' trouvée ! On arrête tout.")
				break
			print(f"Lettre analysée : {lettre}")
	

Ici, dès que la lettre "h" est détectée, le break s'exécute : Python sort instantanément de la boucle sans examiner les lettres suivantes (o, n, s).

				nombre = int(input("Quel nombre ? "))

				for i in range(10):
					print(f"{nombre} x {i + 1} = {nombre * (i + 1)}")
			

				for i in range(5):
					print("*" * (i + 1))
			

• Utiliser une boucle while pour répéter un traitement tant qu’une condition est vraie.
• Identifier la différence d’usage entre boucle bornée (for) et boucle non bornée (while).
• Éviter les boucles infinies en modifiant la condition d'arrêt.

La boucle while (« Tant que »)

Avec la boucle for, on devait savoir à l’avance combien de fois répéter les instructions. Mais que faire si le nombre de répétitions dépend d'un événement imprévisible (une saisie de l'utilisateur, un lancer de dés, une jauge de vie) ?

On utilise alors une boucle non bornée avec le mot-clé while (« tant que »). Tant que la condition reste vraie (True), Python répète le bloc d'instructions.

		faim = 5

		while faim > 0:
			print(f"Miam ! Il reste {faim} bouchées.")
			faim = faim - 1   # on diminue la faim

		print("Rassasié !")
	

for ou while : comment choisir ?

Pour savoir quelle boucle utiliser, posez-vous une seule question : « Est-ce que je sais à l'avance combien de fois je répète ? »

• OUI ⟶ for : pour répéter $*N*$ fois (avec range()) ou parcourir chaque caractère d'un texte.
• NON ⟶ while : quand la fin dépend d’une condition qui peut arriver au bout de 1, 10 ou 1000 essais.

La validation de saisie utilisateur

Un cas d'usage très courant du while est de forcer l'utilisateur à donner une réponse valide avant de continuer :

		reponse = input("Voulez-vous rejouer ? (oui/non) ")

		while reponse != "oui" and reponse != "non":
			print("Saisie invalide ! Veuillez répondre par 'oui' ou 'non'.")
			reponse = input("Voulez-vous rejouer ? (oui/non) ")

		print("Merci pour votre réponse !")
	

Le piège de la boucle infinie

Que se passe-t-il si la condition de la boucle while ne devient jamais fausse ? La boucle tourne indéfiniment et le programme plante (ou gèle).

		# ⚠️ NE PAS EXÉCUTER (ou préparez-vous à un Ctrl+C)
		compteur = 1
		while compteur > 0:
			print("Je tourne à l'infini !!!")
			compteur = compteur + 1   # compteur augmente, donc reste toujours > 0 !
	

				code_secret = "1234"
				code_saisi = input("Entrez votre code PIN : ")

				while code_saisi != code_secret:
					print("Code erroné, réessayez !")
					code_saisi = input("Entrez votre code PIN : ")

				print("Code correct, accès autorisé !")
			

				mystere = 42
				proposition = int(input("Devinez le nombre mystère : "))

				while proposition != mystere:
					if proposition > mystere:
						print("C'est moins !")
					else:
						print("C'est plus !")
					proposition = int(input("Proposez un autre nombre : "))

				print("Bravo ! Vous avez trouvé !")
			

• Définir une fonction simple avec def et l’appeler.
• Passer des paramètres à une fonction.
• Comprendre la différence capitale entre print() et return.
• Comprendre la notion de variable locale (portée des variables).

Qu’est-ce qu’une fonction ? (ou l’art de la flemme intelligente)

Imaginez que vous deviez répéter 10 fois dans votre programme la même série de calculs pour calculer les dégâts d’un personnage. Recopier le même code partout, c’est long, pénible, et si vous voulez changer une règle, il faut tout modifier 10 fois !

Une fonction, c’est comme une recette enregistrée dans la mémoire de Python. On lui donne un nom, on écrit son code une bonne fois pour toutes, et ensuite, pour l’exécuter, il suffit d’appeler son nom !

Définir et appeler une fonction

Pour créer une fonction, on utilise le mot-clé def (pour « définir ») suivi du nom qu’on choisit et de parenthèses ().

		# 1. On DÉFINIT la fonction (on écrit la recette)
		def dire_bonjour():
			print("Bonjour !")
			print("Bienvenue dans le jeu !")

		# 2. On APPELLE la fonction (on exécute la recette)
		dire_bonjour()
	

Passer des paramètres (les ingrédients)

Une fonction devient beaucoup plus puissante si on lui donne des « ingrédients » pour travailler. C’est ce qu’on place entre les parenthèses : les paramètres.

		def saluer(prenom):
			print(f"Salut {prenom}, prêt pour la suite ?")

		saluer("Nova")   # affiche : Salut Nova, prêt pour la suite ?
		saluer("Sacha")  # affiche : Salut Sacha, prêt pour la suite ?
	

On peut lui passer plusieurs paramètres en les séparant par des virgules :

		def afficher_meteo(ville, temperature):
			print(f"À {ville}, il fait actuellement {temperature}°C.")

		afficher_meteo("Paris", 18)
		afficher_meteo("Marseille", 25)
	

print() vs return

C’est l’erreur classique du débutant : confondre print() et return.

• print() : affiche un texte dans la console pour l’humain devant l’écran. Mais Python « oublie » aussitôt la valeur !
• return : demande à la fonction de renvoyer un résultat à Python, pour qu’on puisse le réutiliser dans un calcul ou le stocker dans une variable.

		def doubler(nombre):
			return nombre * 2

		# On récupère le résultat renvoyé par la fonction
		resultat = doubler(5)
		print(resultat + 10)  # Affiche 20 ! (5 * 2 = 10, puis + 10 = 20)
	

La portée des variables

Une variable créée à l’intérieur d’une fonction est une variable locale. Elle n’existe que pendant l’exécution de cette fonction. Une fois la fonction terminée, cette variable est automatiquement effacée !

		def secret():
			code = 9999   # variable locale
			print("Dans la fonction, le code vaut :", code)

		secret()
		print(code)   # ERREUR ! NameError: name 'code' is not defined
	

Considérez qu’une fonction est une boîte noire étanche : ce qu’elle fabrique à l’intérieur ne peut en sortir que si elle utilise un return.

				def degats_critiques(attaque):
					return attaque * 1.5

				# Test :
				degats = degats_critiques(40)
				print(degats)  # Affiche 60.0
			

				def en_secondes(heures, minutes):
					return heures * 3600 + minutes * 60

				# Test :
				print(en_secondes(2, 15))  # Affiche 9000
			

				def est_majeur(age):
					if age >= 18:
						return True
					else:
						return False

				# Astuce "flemme intelligente" ultra courte :
				# def est_majeur(age):
				#     return age >= 18
			

• Importer un module externe avec import.
• Utiliser des fonctions d’un module (exemple : random.randint()).

Qu’est-ce qu’un module ?

De base, Python possède un nombre limité de fonctionnalités (print(), input(), int(), etc.). Mais il existe des milliers d'outils supplémentaires pré-construits qu'on peut charger selon nos besoins : ce sont des modules (ou bibliothèques).

Imaginez que Python de base est un smartphone nu, et qu'importer un module revient à installer une nouvelle application !

Le module random (le hasard)

Pour ajouter du hasard dans nos programmes, on utilise le module random. Pour l’utiliser, il faut obligatoirement écrire cette ligne tout en haut de notre fichier :

		import random
	

Une fois le module importé, on a accès à toutes ses fonctions. La plus utile pour nous est random.randint(a, b) qui génère un nombre entier au hasard entre a et b (inclus) :

		import random

		# Simuler le jet d'un dé à 6 faces :
		de = random.randint(1, 6)
		print(f"Vous avez fait un {de} !")

		# Simuler un tirage entre 10 et 20 dégâts :
		degats = random.randint(10, 20)
		print(f"L’attaque inflige {degats} points de dégâts.")