Affectation

Pendant l’exécution d’un programme, les données que ce dernier manipule sont stockées en mémoire centrale. En nommant ces données, on peut les manipuler beaucoup plus facilement. Les variables nous permettent donc de manipuler ces données sans avoir à se préoccuper de l’adresse explicite qu’elles occuperont effectivement en mémoire. Pour cela, il suffit de leur choisir un nom ou identificateur.
L’interpréteur est un programme qui traduit les lignes de code en langage Python en un langage directement compréhensible par l'ordinateur : le langage machine. L'interpréteur s’occupe d’attribuer une adresse à chaque variable et de superviser tous les éventuels futurs changements d’adresse.

Une variable peut-être assimilée à une boîte aux lettres portant un nom.

Par exemple, on veut stocker le nombre 5 dans une variable notée x. Nous avons noté en pseudo-code ceci :

Ceci signifie : « à l’adresse mémoire référencée par x - autrement dit, dans la boîte aux lettres dénommée x -, se trouve la valeur 5 ». Nous utilisons plus fréquemment l’abus de langage « la variable x vaut 5 ».

En langage Python, l'affectation sera notée à l'aide du symbole égal : =. On note ainsi l'affectation de 5 à x : x = 5

L'instruction (en mode console) de cette affectation s'écrit donc :

>>>x = 5

Attention ! cette instruction n'a pas la même signification qu'en mathématiques. Il s'agit d'une affectation et non pas un symbole d'égalité. Ainsi, l'instruction

>>>x = x+1

Sous Python, on peut affecter une valeur à plusieurs variables simultanément :

>>>a=b=2
>>>a
2
>>>b
2
>>>

Affichage et saisie

Affichage

La fonction print permet d'afficher dans la console les éléments mis entre parenthèses.

>>>print("Salut tout le monde !")
Salut tout le monde !	
					

La fonction print peut prendre plusieurs arguments séparés par une virgule ,.

>>>a=25
>>>print("Cette année, Noël sera le",a,"décembre 2020 !")
Cette année, Noël sera le 25 décembre 2020 !	
									

Vous avez dû remarquer avec l'exemple prédécent qu'à l'exécution, un espace ' ' ou " " est automatiquement ajouté entre chaque argument de la fonction print.
Ce comportement peut être modifié par l'ajout d'un argument identifié par le nom sep, de type chaîne de caractères (str en Python), de la façon suivante :

>>>val=3.14159
>>>print("Mots",'et','valeur',val,"à afficher.",sep="_")
Mots_et_valeur_3.14159_à afficher.
			

Le chaîne de caractères \n sert à passer à la ligne lors de l'affichage. Ainsi, dans l'utilisation suivante, les arguments affichés sont placés les uns en dessous des autres :

>>>val=3.14159
>>>print("Mots",'et','valeur',val,"à afficher.",sep="\n")
Mots
et
valeur
3.14159
à afficher.
								

Saisie

La fonction input permet d'obtenir une saisie depuis le clavier.

Attention ! La fonction input renvoie toujours une chaîne de caractères (son type est bien str) même si un nombre (entier ou réel) a été saisi. Pour pouvoir utiliser le renvoi dans un calcul, il est parfois nécessaire de changer son typage à l'aide des fonctions int ou float qui permettent de transformer respectivement une chaîne de caractères correspondant à un nombre en nombre entier ou nombre réel (un flottant pour être précis).

>>>input("Quelle année sommes-nous !")
Salut tout le monde !	

Les fonctions

Notion

En informatiques, les fonctions servent à mieux structurer votre code. Par exemple, elles permettent d'éviter de répéter plusieurs fois des portions de codes identiques. Ainsi, une fonction peut être vu comme un «petit» programme :

• à qui on donne des paramètres en entrée,
• puis qui effectue alors un traitement sur ces paramètres,
• qui renvoie enfin un résultat en sortie.

En Python

En Python, une fonction peut s'écrire en suivant toujours le même formalisme :

1. Commencer par le mot clé def,
2. Poursuivre sur la même ligne par l'entête constituée des 3 éléments successifs suivants :
   1. le nom de la fonction
   2. entre parenthèses, de 0 à N paramètres avec pour chacun un nom
3. Terminer obligatoirement la première ligne par deux points :
4. En desous, écrire le blocs des instructions. Attention il faut indenter (=décaler) ce bloc.
5. Finir en dernière ligne par le mot clé return suivi de ce que renvoie la fonction (ou None si la fonction ne retourne rien). Attention, cette ligne est indentée également et marque la fin de la fonction.

Voici visuellement la structure d'une fonction en Python :

def nomFonction(liste des arguments):
	blocs des instructions
	return résultat

def carree(a: float) -> float:
	return a**2 		# renvoie l'image de a par la fonction carree 
			

Vocabulaire :

• Lorsqu'on définit la fonction carree(), a est appelé paramètre de la fonction.

• Lorsqu'on appelle la fonction avec une valeur explicite pour a, comme dans carree(3), on dira plutôt que 3 est un argument de la fonction. Ainsi, en appelant la fonction carree() d'argument 3, on obtient 9.

Bonnes pratiques de programmation

Préciser le typage de chacun des paramètres

Le langage Python est plus aisé pour démarrer la programmation pour la concision des codes écrits et pour la gestion automatique du typage par l'interpréteur. Cependant, le but est que vous puissiez à terme être capable de faire basculer vos compétences acquises en NSI sur Python vers d'autres langages de programmation.

Comme la plupart des langages de programmation nécessitent la spécification du typage des variables, à terme, on vous demandera d'écrire en Python, une fonction en précisant le type de chaque antrée et sortie en suivant le même formalisme ci-dessous :

def nomFonction(liste des arguments: type) -> typeRetour:
		blocs des instructions
		return résultat
	

La convention PEP8 donne l'habitude de nommer les fonctions (comme les variables) avec des lettres minuscules et des tirets bas (celui du "8") _. Pour clarifier la fonction, il est conseillé d'utiliser un verbe dans son nom (obtenir, donner, get, set, ...).

Documenter ses fonctions

Il est important de documenter vos fonctions, c'est-à-dire de décrire en quelques phrases le rôle de la fonction, de donner des informations sur la fonction, le lien entre les entrées et la sortie.

Pour cela, juste en dessous de la première ligne définissant la fonction, il suffit de mettre ses informations entre """ et """ ; c'est ce que l'on appelle en franglais le docstring de la fonction). En reprenant l'exemple précédent (sans le typage), on peut écrire :

def carree(a):
	""" 
	Fonction permettant de renvoyer le carré du nombre a qui est en paramètre
	"""
	return a**2 		# renvoie l'image de a par la fonction carree
					

L'intérêt de l'auto-documentation d'une fonction par un texte est double :

• Pour vous : le faire vous oblige à réfléchir au contenu de votre fonction avant de la programmer ; c'est un gain d'efficacité,
• Pour les utilisateurs de votre code (ou pour vous longtemps après avoir programmé la fonction) : Quand on saisit dans la console, après l'exécution de la fonction, l'instruction help(nom de la fonction), Python affiche le docstring de la fonction ce qui nous permet d'avoir des informations sur la fonction en cas d'oubli.

  >>> help(carree)
  Help on function carree in module __main__:
  				
  carree(a: float) -> float
  	Fonction permettant de renvoyer le carré du nombre a qui est en paramètre		
  >>>

La portée des variables

Il faut faire la différence entre les variables utilisé dans le programme (variables globales) et les variables utilisées dans une fonction (variables locales).

Vous allez comprendre cela à l'aide des exemples de l'exercice suivant :

x=-101
def carre(x):
	x=x**2
	return x

x=-101
def carre_2():
	x=x**2
	return x

x=-101
def carre_3():
	global x
	x=x**2
	return x
	

Normalement vous avez dû détecter un problème : il y a une fonction qui ne peut pas être interprétée !

Il faut privilégier les variables locales. La première écriture, celle de carre est la définition à privilégier.

Vous pouvez utiliser des variables globales, comme mais dans carre3, des cas qu'il faudra bien définir en amont.

En résumé, pour l'instant, pas de variables globales.

Précondition et postconditions en Python

Précondition

Voici le code en Python d'une fonction nommée get_unite qui prend comme paramètre un nombre entier et qui renvoie son chiffre des unités.

def get_unite(n: int) -> int:
	"""
	renvoie le chiffre des unités d'un entier n
	"""
	while n>=10 : 		# répétition tant que n est supérieur ou égal à 10
		n = n-10
	return n

Une documentation a été donnée afin d'expliciter le bon usage de la fonction. Mais on ne pas être certain qu'un utilisateur de la fonction respectera les contraintes implicites ou explicites de la documentation et du typage. Voici quelques exemples d'appel de la fonction :

>>> get_unite(4567)
7
>>> get_unite(45.67)
5.670000000000002
>>> get_unite(-6)
-6

On voit que l'appel conduit à une réponse à chaque fois, mais que celle-ci ne correspond pas toujours à ce qui est attendu. Pour rendre "robuste" la fonction précédente, on doit vérifier au début de celle-ci certaines contraintes de bon usage que l'on appelle précondition.

Dans l'exemple précédent, ces préconditions sont :

• "Précondition 2" : n est de type entier (par exemple, le programme buggera si une chaîne de caractères est saisie come argument),
• "Précondition 2" : n est positif (sinon le résultat renvoyé est la valeur négative saisie).

Pour cela, le langage Python possède l'instruction assert qui permet un mécanisme d'assertion.
Les deux préconditions précédentes s'ajoutent à la fonction précédente ainsi :

def get_unite(n: int) -> int:
	"""
	renvoie le chiffre des unités d'un entier n
	"""
	assert type(n)==int, "vous devez entrer un nombre entier."  		# "Précondition 1"
	assert n>=0, "le nombre étudié doit être positif ou nul."			# "Précondition 2"
	while n>=10 : 		# répétition tant que n est supérieur ou égal à 10
		n = n-10
	return n

def diviser(a: float,b: float) ->float:
	"""
	renvoie le résultat décimal de la division de a par b.
	"""
	return a/b

Postcondition

Souvent les fonctions sont appelées au cours de programme ; le type et la qualité du résultat renvoyé est important pour ne pas conduire à un plantage. Des contraintes sur la variable renvoyée sont souvent nécessaires : on les appellent les postconditions.

Reprenons l'exemple précédent :

def get_unite(n: int) -> int:
"""
renvoie le chiffre des unités d'un entier n
"""
while n>=10 : 		# répétition tant que n est supérieur ou égal à 10
	n = n-10
return n

Voici le résultat de quelques appels effectués :

>>> get_unite(4567)
7
>>> get_unite(45.67)
5.670000000000002
>>> get_unite(-6)
-6

Comme le résultat renvoyé doit être un nombre entier compris entre 0 et 9, on va rajouter les postconditions suivantes :

1. "postcondition 1" : n est un entier naturel.
2. "postcondition 2" : n est positif.
3. "postcondition 3" : n est strictement inférieur à 10

On utilise encore l'instruction assert, juste avant le return pour écrire ces postconditions comme montré ci-dessous :

def get_unite(n: int) -> int:
	"""
	renvoie le chiffre des unités d'un entier n
	"""
	while n>=10 : 		# répétition tant que n est supérieur ou égal à 10
		n = n-10
	assert type(n)==int, "Le nombre renvoyé devrait être un entier."  		# "Postcondition 1"
	assert n>=0, "le nombre renvoyé doit être positif ou nul."				# "Postcondition 2"
	assert n<10, "le nombre renvoyé doit être inférieur à 10."			# "Postcondition 3"
	return n
	

Travail à effectuer

def cherche_lettre(nom,lettre):
	if lettre in nom:
		print(lettre," est dans le nom ",nom)
	else:
		print(lettre,"n' est pas dans le nom ",nom)
	return None 

Travail complémentaire

Les exercices qui suivent nécessitent d'utiliser les instructions if, for ou while ainsi que des listes.

Savoir faire et Savoir