Affectation et grammaire des fonctions

Voici la fiche servant de trace écrite liée à ce chapitre qui est à compléter au cours de l'avancée.

Python : un langage interprété

Python est un langage de programmation développé à partir de 1989 par Guido van Rossum. photo de Van Rossum

Ce langage de programmation est :

entièrement gratuit,
portable : c'est-à-dire est exécutable sur tout système d'exploitation,
modulaire : de nombreuses librairies dédiées à des tâches précises ont été développées autour d'un noyau concis,
populaire : vous pouvez trouver de nombreux forums pour vous aider en cas de difficultés,
de "haut niveau" : vous pouvez programmer sans tenir compte des spécificités de votre système d'exploitation et des structures de données complexes (qui seront vues et utilisées sur les deux ans) sont disponibles,
interprété.

Langage interprété ?

Dans un langage interprété : le code que vous écrivez est interprété en gros ligne à ligne, par un logiciel qu'on appelle interpréteur. Celui-ci va utiliser le code source et les données d'entrée pour calculer les données de sortie.

D'autres langages (comme le C, ...) sont compilés : le code que vous écrivez est d'abord compilé par un logiciel qu'on appelle compilateur en une succession de 0 et de 1. Le système d'exploitation utilise ce code compilé ainsi que les données pour calculer les données de sorties.

schéma de l'exécution d'un programme en langage compilé — source : http://data.france-ioi.org

L'intérêt principal d'un langage interprété est la portabilité de votre programme : il marche quelle que soit la configuration de votre ordinateur.

Le principal défaut est que l'exécution d'un programme interprété est souvent plus lente que le même programme écrit dans un langage compilé.

Pour plus d'information sur le langage Python, nous vous conseillons le site suivant : https://www.lebigdata.fr/python-langage-definition

Variables et affectation

Variable

Dans un programme informatique, on va avoir en permanence besoin de stocker provisoirement des valeurs. Il peut s’agir de données issues du disque dur, fournies par l’utilisateur (frappées au clavier), ou autres. Il peut aussi s’agir de résultats obtenus par le programme, intermédiaires ou définitifs.
Ces données peuvent être de plusieurs types (on en reparlera) : elles peuvent être des nombres, du texte, etc. Toujours est-il que dès que l’on a besoin de stocker une information au cours d’un programme, on utilise une variable.

Pour employer une image, une variable est une boîte, que le programme (l’ordinateur) va repérer par une étiquette. Pour avoir accès au contenu de la boîte, il suffit de la désigner par son étiquette.
Ainsi, ci-dessous la variable $x$ est l'étiquette d'une boîte contenant l'entier 5.

illustration naïve du concept de variable

En réalité, dans la mémoire vive de l’ordinateur, il n’y a bien sûr pas une vraie boîte, et pas davantage de vraie étiquette collée dessus.
Dans l’ordinateur, physiquement, il y a un emplacement de mémoire, repéré par une adresse binaire.
Si on programmait dans un langage directement compréhensible par la machine, on devrait désigner nos données par exemple avec le nombre binaire 0010 (souvent écrit en hexadécimal 0002), ce nombre désignant un emplacement particulier de la mémoire interne considérée de l'ordinateur.

Ci-dessous la variable nommée $x$ fait référence à l'emplacement de mémoire dont l'adresse en hexadécimale est 0002. Cet emplacement mémoire stocke le nombre 5. illustration plus réaliste du concept de variable

En général, une variable est composée :

d'une nom (ou identificateur),
d'une adresse en mémoire où est enregistrée une valeur (ou un ensemble de valeurs),
d'un type qui définit les propriétés de la variables.

Dans le langage assembleur qui sera étudié lors du chapitre sur l'architecture de Von Neumann, il faudra préciser en programmation l'adresse mémoire.

Les langage informatique plus évolué Python se charge, entre autres rôles, d’épargner au programmeur la gestion fastidieuse des emplacements mémoire, de leurs adresses et même de la suppression automatique des données une fois les variables inutilisées, ainsi que la gestion des types.

Plus précisément, L’interpréteur de Python 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.

Le type d'une variable définit l'ensemble des valeurs que peut prendre cette variable ainsi que les opérations et les fonctions utilisables.

Le type int est utilisé pour représenter des nombres entiers (positifs ou négatifs).
On peut, par exemple, utiliser entre deux variables a et b de ce type :

l'addition : a+b,
la soustraction : a-b,
la multiplication : a*b,
l'exponentiation ( $a^b$ ) : a**b,
la division (si b est non nul): a/b,
Si la division euclidienne de a par b (celle que vous avez apprise en fin de primaire) s'écrit comme $a=bq+r$ , $q$ étant le quotient et $r$ le reste, alors on peut directement obtenir ces deux nombres avec :
- la division entière qui donne le quotient $q$ : a//b,
- L'opération modulo qui donne le reste $r$ : a%b.

Il existe de nombreux types de variables utilisés, en voici quelques uns parmi tous ceux que vous découvrirez cette année :

types	Nom du type en Python	Remarques
booléen	`bool`	vrai ou faux
caractère	`str`	symbole typographique
chaîne de caractères	`str`	ensemble de caractères entre " " ou ' '
entier	`int`	entiers relatifs
flottant	`float`	"Utilisé pour les réels"

Affectation

Pendant l’exécution d’un programme, les données que celui-ci manipule sont stockées en mémoire centrale.
En nommant ces données, on peut les utiliser 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.

En python, pour définir une variable, il suffit de lui choisir un nom ou identificateur.

Les identificateurs sont des suites de lettres, de chiffres et de tirets bas (alt gr + 8), le premier caractère ne pouvant être un chiffre.
Attention à ne pas choisir comme identificateur des mots-clés ou de types comme for, int, ...

Parmi les chaînes de caractères suivantes, lesquelles peuvent servir de nom de variable en Python ?

01abAB ?
Vive_NSI! ?
annee_2024 ?
str ?
BA0bab ?
_ ?

L'affection d'une donnée à une variable, c'est l'action de mettre en mémoire une donnée dans une variable.

Par exemple, l'action stocker 100 dans la variable pv_player correspond à l'affection des 100 points de vie dans la variable pv_player

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

illustration plus réaliste du concept de variable

Affecter l'entier 100 dans une variable nommée pv_player est noté en pseudo-code :

pv_player ← 100

En langage Python, l'opérateur d'affectation est le symbole égal : = ; on place à sa gauche toujours le nom de la variable.
On note ainsi l'affectation de 100 à pv_player : pv_player = 100

Attention ! En écrivant ceci, on n'exprime pas une égalité mais l'interpréteur exécute les actions suivantes :

il définit un identificateur pv_player comme une nouvelle variable,
il réserve et attache un espace mémoire pour cette variable,
il associe à cette variable un entier dont la valeur est 100, pv_player est dès lors une variable de type entier.

Ainsi, en python, on peut lire pv_player = 100 comme : "pv_player est lié à un objet de type int dont la valeur est 100 et qui se trouve à un certain endroit dans la mémoire centrale".

Même si Python est un langage non typé, on peut tout de même préciser le type directement ainsi : pv_player:int = 100.

L'instruction d'affectation

>>>x = x+1

est très fréquente en informatique ; elle demande à l'ordinateur d'aller chercher la valeur stockée dans la variable x, puis d'augmenter cette valeur de 1 et enfin d'affecter cette nouvelle valeur dans la même variable x.
En revanche, l'expression est fausse d'un point de vue mathématique.

En python, on peut récupérer pour chaque variable son identifiant (le numéro qui identifie une case mémoire) et son type :

L'identifiant d'une variable en utilisant la fonction id.
Le type d'une variable en utilisant la fonction type.

Saisir successivement en console les deux lignes de code suivant :
```
>>>pv_player = 100
>>>id(pv_player)
```
Est-ce que chacun d'entre vous a le même identifiant à l'issue de l'exécution de ce code ?
Saisir successivement en console les deux lignes de code suivant :
```
>>>pv_player2 = pv_player
>>>id(pv_player2)
```
Que remarquez-vous sur l'identifiant de pv_player2 ?
Déterminer, grâce à la fonction type le type de la variable pv_player.
Saisir en console le code suivant :
```
>>>pv_player = "end"
```
Saisir en console successivement les cinq lignes de code suivant afin de connaître le contenu et l'identifiant de pv_player2 puis ceux de pv_player ainsi que son type :
```
>>>pv_player2
>>>id(pv_player2)
>>>pv_player
>>>id(pv_player)
>>>type(pv_player)
```
Qu'en déduisez-vous ?
Saisir le code suivant en console :
```
>>>ig_player = True
```
Déterminer l'identifiant et le type de la variable ig_player. Qu'en déduisez-vous ?

Après chaque affectation en Python, toute variable est attachée à un emplacement mémoire, emplacement dans lequel est stockée la valeur, valeur qui définit le type de la variable.
En affectant une variable à une seconde variable, les deux variables pointent vers la même case mémoire.
On peut réaffecter une variable en Python : elle pointe alors vers une autre case mémoire, case qui contient le nouveau contenu de la variable.

Une variable est l'association entre un nom, une position en mémoire et le contenu d'un certain type.

Python gère lui-même les positions mémoire et les types des variables.

L'affectation se fait en Python à l'aide du symbole =, la variable d'affectation étant écrite à gauche de ce symbole.

En Python, on copie en fait des adresses mémoire, pas des valeurs.

En Python, on peut réaffecter une valeur d'un autre type à une variable.

Sous Python, on peut affecter une valeur à plusieurs variables simultanément :
```
>>>a = b = 2
>>>a
2
>>>b
2
>>>
```
Sous Python, on peut affecter plusieurs valeurs à plusieurs variables simultanément :
```
>>>a, b = 3, 0.07
>>>a
3
>>>b
0.07
>>>
```
Dans certains langages, comme le C ou Java, il est possible de réaffecter une valeur à une variable, mais cette nouvelle valeur doit être de même type que celle initiale,
Dans certains langages, comme le Rust (développé initialement pour Firefox), il est impossible de réaffecter une valeur à une variable.

Affichage et saisie

Affichage

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

Tester l'instruction suivante :

print("Salut tout le monde !")

La fonction print peut prendre plusieurs arguments séparés par une virgule ,
Cela permet ainsi d'afficher un mélange de texte et de contenu de variables.

Tester le script suivant :

a = 25
print("Cette année, Noël sera le", a, "décembre ! Incroyable! Amazing ! Dingue! Breaking News !")

Concaténation

Vous avez dû remarquer avec l'exemple précédent qu'à l'exécution, un espace ' ' ou " " est automatiquement ajouté entre chaque argument de la fonction print.
On peut améliorer l'affichage en utilisant l'opérateur de concaténation +.

Tester les instructions suivantes :

name_player = "Rage"
pv_player = 100
print("Tu te nommes " + name_player + " et tu as :", pv_player, "points de vie.")

Transformer les espaces

Vous avez dû remarquer avec l'exemple précédent 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).

Tester les instructions suivantes :

name_player = "Rage"
pv_player = 100
print("Tu te nommes ", name_player, " et tu as :", pv_player, "points de vie.", sep="_")

Aller à la ligne dans un print

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 :

Tester l'instruction suivante :

print("c'est ma première ligne \ncelle la la deuxième \net la troisième.")

Réaliser l'affichage suivant en n'utilisant qu'un seul \n :


Rage a assez
de vices
pour faire
du bricolage.

la fonction print("chaînes de caractères",'à','afficher',sep=' ') sert à afficher un ensemble de chaînes de caractères avec comme séparateur par défaut un espace.

\n, pour newline, sert à passer à la ligne (lors de l'affichage, ...)

Saisie

input

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

Tester le code suivant :

level_player = input("Quel est ton niveau ?")

Tester le code suivant :

type(level_player)

Tester le code suivant :

print("tu as gagné un niveau, tu es maintenant de niveau : ", level_player+1, ".")

Pourquoi cet affichage ?

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).

Tester le code suivant :

level_player=int(input("Quel est ton niveau ?"))

Tester le code suivant :

type(level_player)

Tester le code suivant :

print("tu as gagné un niveau, tu es maintenant de niveau : ", level_player+1,".")

input("texte") permet de saisir une information, sous forme de chaîne de caractères (=texte), pour un programme.

Il faudra éventuellement convertir ce texte dans le type voulu avec les fonctions int() ou float().

Les fonctions

Notion

Fonctions en informatique

En informatique, 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.

Une fonction qui modifie des variables mais sans renvoyer de résultat est appelée une procédure. Le langage Python ne fait pas de différence dans la syntaxe entre fonction et procédure.

vision naïve d'une fonction en informatique

Une fonction qui renvoie un booléen est aussi appelé un prédicat.

En Python

Fonctions en Python

En Python, une fonction est définie (= être créée) en suivant toujours le même formalisme :

Commencer par le mot clé def,
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 :
En dessous, écrire le blocs des instructions. Attention il faut indenter (=décaler) ce bloc !
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 nom_fonction(liste des arguments):
	blocs des instructions
	return resultat

Voici la fonction move_pv :

def move_pv(pv_player, attaque) :
    pv_player = pv_player - attaque
    return pv_player 		# renvoie le nouveau nombre de pv du joueur

Commentaires : le symbole # apparaîtra à maintes reprises. Il marque le début d’un commentaire que la fin de la ligne termine. Autrement dit, un commentaire est une information aidant à la compréhension du programme mais n’en faisant pas partie.
La notion de fonction en informatique relève du même concept qu'une fonction mathématique, c'est-à-dire qu'on définit une fonction puis on l'applique à différentes valeurs.
Vous remarquerez le symbole : très important en Python qui marque le début d'un bloc en dessous.

C'est l'indentation qui délimite le bloc d'instructions.
La fonction se termine avec le mot-clef return. Ce qui suit le return est l'image des entrées par la fonction. Dès que la fonction rencontre un return, elle renvoie ce qui suit le return et stoppe son exécution.

Appel de fonction

Une fonction est utilisée comme une instruction quelconque. Un appel de fonction est constitué du nom de la fonction suivi entre parenthèses des valeurs des paramètres d'entrée. Cet appel peut être fait :

Soit par un appel dans la console :
```
>>>move_pv(100, 27)
73
			
```

Soit dans le corps d'un programme :

def att_player(force_player, force_arme) :
	return force_player + force_arme 		

pv_mob = pv_mob - att_player(15, 6)			
print(pv_mob)

Lorsqu'on définit la fonction set_pv(), pv_player et attaque sont appelés paramètres de la fonction.
Lorsqu'on appelle la fonction avec des valeurs explicites pour pv_player et pour attaque , comme dans set_pv(100, 26), on dira plutôt que 100 et 26 sont des arguments de la fonction.

Rage récolte du bois. Il en ramasse une grande quantité. Dans son inventaire, il ne peux faire des piles (stack en anglais) uniquement de 500 morceaux de bois. On aimerait disposer d'une fonction qui renvoie le nombre de piles complètes et le niveau de remplissage du dernier stack.

Écrire une fonction stacking(dropped) qui a une quantité d'objets ramassés dropped renvoie le nombre de piles à 500 éléments et le nombre de morceaux de la dernière pile incomplète.
Par exemple stacking(1232) renvoie 2, 232 pour 2 stacks à 500 morceaux de bois et un stack de 232 morceaux de bois.
Il peut vous être utile d'utiliser les deux opérateurs // et % définis ainsi :
- a // b renvoie le quotient de la division euclidienne de a par b.
  
  13 // 5 renvoie 2 car $13 = 5 \times 2 + 3$ .
- a % b renvoie le reste de la division euclidienne de a par b.
  
  13 % 5 renvoie 3 car $13 = 5 \times 2 + 3$ .
Appeler cette fonction afin de mettre en stack 15352 morceaux de bois.

Exercice de renforcement

Voici un exercice à faire en autonomie pour tester votre maîtrise des bases sur les fonctions.
Cet exercice est issu du site collaboratif de la forge.
La dernière question de l'exercice est intéressante puisque vous aurez à utiliser les fonctions construites dans les premières questions, mais faites attention à la conversion Wh / kWh !

Cliquer sur ce lien pour accéder à l'exercice.

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 entrée et sortie en suivant le même formalisme que ci-dessous :

def nom_fonction(liste des arguments: type) -> typeRetour:
	blocs des instructions
	return resultat

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

def set_pv(pv_player: float, attaque: int) -> float:
    pv_player = pv_player - attaque
    return pv_player

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 set_pv(pv_player: float, attaque: int) -> float:
    """
    Renvoie le nombre de point de vie du joueur auquel on retire la valeur contenu dans la variable attaque.
    """
    pv_player = pv_player - attaque
    return pv_player

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)

help

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(set_pv)
Help on function set_pv in module __main__:
				
set_pv(pv_player: float, attaque: int) -> float
	Renvoie le nombre de point de vie du joueur auquel on retire la valeur contenu dans la variable attaque.		
>>>

Voici ci-dessous une fonction qui renvoie le niveau d'armure du joueur en disposant comme argument le niveau d'armure base_armor et le niveau d'usure de l'armure armor_damage exprimé en pourcentage.

def set_armor(base_armor, armor_damage):
    armor = base_armor * (1 - armor_damage/100)
    return armor

Améliorer le code précédent en préciser le typage de chaque paramètre et en documentant cette fonction.

Exercice de renforcement

Utilisation de modules

Nous avons déjà vues les fonctions print et input. Ce sont deux fonctions prédéfinies dans le langage Python, On appelle ce type de fonction des fonctions natives au langage Python , elles sont directement utilisables.

D'autres fonctions ont été développées et testées par différents programmeurs mais ne sont pas directement utilisables. Ces fonctions sont regroupées dans des modules, appelés aussi bibliothèques. En terminale, vous apprendrez même à en créer par vous même !

le module math contient de nombreuses fonctions mathématiques usuelles comme la racine carrée (sqrt), ...
le module random contient de nombreuses fonctions modélisant le hasard comme l'obtention d'un nombre entier aléatoire compris entre deux nombres entiers a et b (randint(a, b)), ...
le module matplotlib.pyplot permet de réaliser des graphiques, des tracés de courbes, ...

Pour pouvoir utiliser ces fonctions, il faut d'abord importer ces modules. Pour cela, il y a plusieurs méthodes :

Soit importer tout le module en ajoutant en début de programme :

from nom_module import *

On peut alors utiliser n'importe qu'elle fonction du module sans prendre en utilisant seulement son nom.

from math import *     # import de toutes les fonctions du module math
a = (1 + sqrt(5))/2
print("valeur approchée du nombre d'or :", a)

Pour éviter des confusions entre deux fonctions portant éventuellement le même nom dans deux modules différents, il peut être utile d'importer un module en lui fixant un nom d'utilisation en ajoutant en début de programme :

import nom_module as nom_raccourci

import matplotlib.pyplot as plt    # import de toutes les fonctions du module matplotlib.pyplot mentionné plt dans toute la suite du programme 
plt.grid()		# utilisation de la fonction grid (qui permet d'obtenir un quadrillage), fonction issue du module plt (=matplotlib.pyplot) 
plt.show()		# utilisation de la fonction show (qui permet de réaliser le tracé du code précédent), fonction issue du module plt (=matplotlib.pyplot)

Il peut suffire d'importer seulement une fonction d'un module en ajoutant en début de programme :

from nom_module import nom_fonction

from random import randint    # import de la seule fonction randint du module random 
resultat_de = randint(1, 6)

L'importation avec from import * est fortement déconseillée par la PEP8 (conventions d'écriture de codes en Python)

La portée des variables

Il faut faire la différence entre les variables utilisées 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 :

Réaliser des appels des trois fonctions suivantes pour comprendre la différence entre leurs codes :

pv_player = 100
def set_pv_1(pv_player, attack):
	pv_player = pv_player - attack
	return pv_player
print(set_pv_1(50, 25))

pv_player = 100
def set_pv_2(attack): 
    pv_player = pv_player - attack
    return pv_player
print(set_pv_2(25))

pv_player = 100
def set_pv_3(attack):
	global pv_player
	pv_player = pv_player - attack
	return pv_player
print(set_pv_3(25))

Exercice de renforcement

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 set_pv_1 est la définition à privilégier.

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

Le danger des variables globales est qu'elles peuvent être modifiées à différents endroits d'un programme ce qui rend plus difficile la prévision du comportement du programme, dès que celui-ci devient assez conséquent.

Le seul moment où on pourra utiliser les variables globales , c'est à la construction de jeu ( ou autre appli ) en programmation itérative (celle de première).

Voici une fonction set_score qui prend comme paramètre d'entrée les points à rajouter et renvoie le nouveau score obtenu.

def set_score(points: int) -> int:
    """
    fonction qui renvoie le score du nombre de points donnés comme entrée
    paramètres :
        points : nombre de points à rajouter à la variable globale score (nombre entier)
    retour : 
        score : nombre de points du score (nombre entier)
    """	
	global score
	score = score + points
	return score

Combien de variables apparaissent dans la fonction set_score ? De quel type ?

Exécuter le script suivant :

score = 100
def set_score(points: int) -> int:
	"""
	fonction qui renvoie le score du nombre de points donnés comme entrée
	paramètres :
		points : nombre de points à rajouter à la variable globale score (nombre entier)
		retour : 
		score : nombre de points du score (nombre entier)
	"""	
	global score
	score = score + points
	return score

for parties in range(1, 4):				# 3 répétitions de l'affichage suivant
	print("J'ai gagné 10 points ! set_score(10) affiche :", set_score(10))

Est-ce que les appels set_score(10) renvoie toujours la même valeur ?

Comme il est préférable d'éviter les variables globales, proposer une modification de la fonction set_score afin de supprimer la ligne global score.

Rajouter un paramètre à la fonction peut-être très utile pour supprimer une variable globale.
Tester le script complet précédent avec la fonction set_score modifiée.

La structure générale d'une fonction :

def nom_fonction(liste des arguments: type) -> typeRetour: blocs des instructions return resultat

L'indentation permet de définir ce qui fait partie de la fonction de ce qui en est exclu.

Une fois une fonction définie, pensez à l'appeler pour l'utiliser.

Toujours terminer une fonction par un return qui doit être pour le mieux unique.

Essayer de préciser les types des paramètres et du retour dans l'en-tête d'une fonction.

Essayer de documenter ses fonctions : texte explicatif entre triples guillemets ou apostrophes.

Essayer d'éviter l'utilisation 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.

Une précondition est une propriété (sur le type, sur les valeurs possibles, ...) vérifiée au début de l'exécution d'une fonction.

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

"Précondition 1" : 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 le mot-clef 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

Quelques explications :

a == b renvoie True si l'égalité "a=b" est vraie (même type et même contenu) et False sinon,
int est le type "entier". Il existe les types float pour les flottants, str pour les chaînes de caractères, ...
Le mot-clé assert est suivi :
1. d'une condition (une expression booléenne qui vaut True ou False),
2. éventuellement suivie d'une virgule , et d'une phrase en langue naturelle, sous forme d'une chaîne de caractères.

assert

Le mot-clé assert teste sa condition. Deux cas possibles :

si la condition est satisfaite, elle ne fait rien (l'interpréteur passe à la ligne suivante),
sinon elle arrête immédiatement l'exécution du programme en affichant la phrase qui lui est éventuellement associée. Ainsi, l'interpréteur arrête l'exécution de la fonction plutôt que de faire planter le programme et affiche un message clair pour corriger l'erreur !

Vous pouvez retrouver ici une petite vidéo qui synthétise les appels de modules, les docstring et les assert

Voici un fonction nommée diviser réalisation la division du premier argument par le second.

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

Quelle précondition, écrite en langage Python, doit-on rajouter afin d'assurer le bon fonctionnement de la fonction ?

Pour tester une différence, on utilise en langage Python l'opérateur !=.
Par exemples, l'expression 2*3 != 3 prend la valeur False car $2\times 3\neq 3$ , tandis que l'expression 2*3 != 6 prend la valeur True car $2\times 2 = 6$ .

Exercice de renforcement

Postcondition

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

Une postcondition est une propriété (sur le type, sur les valeurs possibles, ...) vérifiée à la fin de l'exécution d'une fonction.

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 :

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

On utilise encore le mot-clé 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

Exercice de renforcement

Ces mécanisme d'assertion est une aide au développeur qui permet de repérer des erreurs dans le code.
En supprimant toutes les assertions, le programme doit à la fin toujours fonctionner.
Normalement, Lors de la finalisation du programme les différentes assertions doivent être ôtées.
Le mot-clé assert est utilisé pour créer un jeu de tests pour vérifier qu'une fonction renvoie un résultat correct dans des cas prédéfinis.
Cette utilisation est par exemple vu dans l'autotest suivant.

Voici un exercice à faire en autonomie pour tester votre maîtrise des bases sur les fonctions.
Cet exercice est issu du site collaboratif de la forge.

Cliquer sur ce lien pour accéder à l'exercice.

Une précondition est une propriété vérifiée au début de l'exécution d'une fonction.

Une postcondition est une propriété vérifiée à la fin de l'exécution d'une fonction.

Dans le langage Python, une pré/postcondition commence par le mot-clé assert.

Le mot-clef assert est suivi :

d'une condition, qui vaut True ou False,

éventuellement suivie d'une virgule , et d'une phrase en langue naturelle, sous forme d'une chaîne de caractères.

Le mot-clé assert teste la condition. Deux cas possibles :

si la condition est satisfaite, l'interpréteur passe à la ligne suivante,

sinon elle arrête immédiatement l'exécution du programme en affichant la phrase qui lui est éventuellement associée. Ainsi, l'interpréteur arrête l'exécution de la fonction plutôt que de faire planter le programme et affiche un message clair pour corriger l'erreur !

Suivre l'état des variables pas à pas : trace d'exécution et Python Tutor

Il existe différentes manières de réaliser une trace de programme et/ou d'algorithme. Une trace :

permet de suivre pas à pas l'algorithme ;
permet de détecter des erreurs ;
permet de contrôler que l'algorithme fait bien ce que l'on avant prévu ;
permet de comprendre ce que fait un algorithme.

Dans la mesure du possible, on peut organiser une trace d'exécution d'un algorithme en constituant un tableau avec toutes les variables de l'algorithme. Il faut numéroter toutes les lignes de votre algorithme. En colonne, il faut indiquer le nom des variables et en ligne les numéros de ligne.

On considère l'algorithme suivant :

1 pv_player = 40
2 attack = 10
3 pv_player = pv_player - attack
4 attack = 2 * attack
5 pv_player = pv_player - attack

Regarder la vidéo, elle vous montre comment faire une trace d'exécution.

Une solution numérique (plus simple qu'une trace d'execution) est proposée sur le Pythontutor.

Tester cette procédure avec Pythontutor :

def letter_by_letter(ch):
    for elt in ch : 
        print(elt)

letter_by_letter("Une société écologique, c'est une société qui trouve le point d'équilibre entre la société matérialiste absolue dans laquelle nous sommes et une société qui voudrait tomber dans une spiritualité béate qui ne serait pas plus intéressante.")

Des exercices

Fonction

L'Indice de Masse Corporelle (IMC)est un nombre réel utilisé en médecine. Sa formule est pour une $masse$ en kilos et une $taille$ en mètres : $IMC = \frac{masse}{taille^2}$ .

Écrire en langage Python dans Jupyter un programme qui :
- Demande la masse de l'utilisateur en kg (nombre réel).
- Demande la taille de l'utilisateur en cm (nombre entier).
- contient une "fonction" de paramètres masse et taille.
- "fonction" qui affiche l'IMC de l'utilisateur.
La "fonction" intégrée est-elle une fonction ou une procédure ? Pourquoi ?
Vérifier qu'une personne de 80 kg mesurant 1 mètre 80 a un IMC proche de 24.691358024691358.

Exercice de renforcement

Fonction

Écrire une fonction saisir_nom qui ne prend pas de paramètre mais renvoie le nom saisi par l'utilisateur comme chaîne de caractères.
Est-ce une fonction ou une procédure ? Pourquoi ?
Écrire une fonction nommée dire_bonjour ayant comme paramètre un mot qui affiche bonjour suivi du mot.
Exemple : dire_bonjour("Paul") affiche "Bonjour Paul !".
Est-ce une fonction ou une procédure ? Pourquoi ?
Proposer un programme qui :
- intègre d'abord les deux fonctions précédentes,
- qui utilise ces deux fonctions dans le corps principal du programme
Ce programme :
- Demande à l'utilisateur son nom.
- Affiche Bonjour suivi du nom de la personne.

Exercice de renforcement

Précondition

Écrire une fonction nommée get_moyenne qui renvoie la moyenne de trois nombres quelconques passés en arguments.
Proposer une précondition portant sur chacun des paramètres d'entrée pour assurer que la possibilité de calculer la somme.

Exercice de renforcement

Fonction

Écrire une fonction appelée echanger qui échange les valeurs de deux paramètres a et b.
Par exemple, echanger("mot", 12) renvoie (12, "mot").

La possibilité de stocker un entier dans une variable stockant initialement une chaîne de caractères est possible en Python car c'est un langage non typé : l'interpréteur gère automatiquement le typage. Attention ! Dans beaucoup d'autres langages de programmation, cela n'est pas possible.

Précondition

Documenter la fonction suivante en ajoutant un docstring.

def examen(x, y, z, t):
	m = (2*x + 2*y + z + t)/6
	if m >= 10:
		print("Le candidat est reçu")
	else :
		print("le candidat est refusé")
	return None

Proposer des préconditions écrites sur les variables x, y, z et t en utilisant le mot-clé assert qui assurent le bon usage de cette fonction examen.

Exercice de renforcement

Fonction

Voici une fonction cherche_lettre qui affiche si le caractère lettre est présent ou non dans le nom saisi nom, tout deux entrés comme paramètre de la fonction :

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

Préciser le type de chacun des paramètres d'entrée.
Est-ce une fonction ou une procédure ?
Proposer des préconditions écrites sur les variables nom et lettre en utilisant le mot-clef assert qui assurent le bon usage de cette fonction cherche_lettre.

La longueur d'une chaîne de caractères (c'est-à-dire le nombre de caractères) nommée chaine en Python s'obtient avec la commande len(chaine).

Exercice de renforcement

Travail complémentaire

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

Écrire une fonction div_euclidienne qui prend en paramètre deux nombres entiers a et b, qui effectue la division euclidienne de a par b et qui renvoie le couple (q, r), respectivement le quotient et le reste de cette division euclidienne.

Un tel couple est appelé tuple.
Proposer des préconditions sur les paramètres a et b afin d'assurer le bon usage de la fonction div_euclidienne.
Proposer des postconditions sur les deux valeurs renvoyées (q et r) afin d'assurer le bon usage de la fonction div_euclidienne.

Voici un algorithme écrit en pseudo-code :

1 PG ← 0
2 IPG ← 0
3 n ← longueur de la liste
4 for i← 0 to n-1
5	if liste[i] > PG then
6		PG ← liste[i]
7		IPG ← i

On admet que la variable PG contient à la fin de l'algorithme la valeur maximale de la liste liste et la variable IPG à la position de ce maximum dans la liste.

Écrire une fonction get_max_position qui prend en paramètre une liste et qui renvoie le couple (le tuple) (PG, IG), respectivement la plus grande valeur de la liste et la position de cette valeur maximale dans la liste.

Indications :
- Une liste en python se note entre crochet [ ] chaque élément étant séparée d'une virgule.
- la longueur d'une liste nommée liste en Python s'obtient avec la commande len(liste)
- Chaque élément d'une liste est positionné à l'aide d'un index compris entre 0 et len(liste) - 1.
- L'élément d'une liste nommée liste positionné à l'index i est obtenu avec : liste[i].
Proposer des postconditions sur la valeur renvoyée IG afin d'assurer le bon usage de la fonction get_max_position.

Écrire une fonction get_max qui prend en paramètre une liste et renvoie le max des éléments de celle-ci.

Une liste en python se note entre crochet [ ] chaque élément étant séparée d'une virgule ,.
la longueur d'une liste nommée liste en Python s'obtient avec la commande len(liste).

Exercices de renforcement

L'ensemble des exercices de renforcement sont corrigés et expliqués dans le document Jupyter accessible avec ce lien.

On veut pouvoir convertir une durée en heures en une spécifiant le nombre de jours et le nombre d'heures correspondant. Pour cela, il suffit de créer une fonction.

Définir une fonction convertir_jour qui prend comme paramètre un entier duree_heure en renvoie un tuple (=couple ici) formé des deux valeurs nb_jours et nb_heures.
Appeler cette fonction afin de convertir en nombres de jours 260 heures.

Cliquer pour afficher la solution

Voici ci-dessous une fonction qui donne le prix TTC connaissant le prix Hors Taxe pour une TVA à t% :

def TTC(HT, t):
	TTC = HT * (1 + t/100)
	return TTC

Améliorer le code précédent en préciser le typage de chaque paramètre et en documentant cette fonction.

Cliquer pour afficher la solution

def TTC(HT: float, t: int) -> float:
    """
    fonction qui renvoie le prix TTC connaissant le prix Hors Taxe (HT) et la taux de TVA (t)
    HT est un nombre réel
    t est un entier compris entre 0 et 100
    """
    TTC = HT * (1 + t/100)
    return TTC

Parmi les scripts suivants, le(s)quel(s) peuvent correspondre à l'utilisation de la fonction inverse pour calculer l'image de 4 :

# script 1 :
x = 4
def fct1(x):
	x = 1/x
	return x

# script 2 :
x = 4
def fct2():
	x = 1/x
	return x

# script 3 :
def fct3(x):
	return 1/x

# script 4 :
x = 4
def fct4():
	global x
	x = 1/x
	return x

Cliquer pour afficher la solution

Un moyen d'estimer la profondeur d'un puits est de lâcher une pierre au dessus du puits et de compter le nombre de secondes avant d'entendre le bruit du "plouf" de son entrée dans l'eau. On note $t$ la durée d'attente du "plouf" (en seconde) et $p$ le profondeur du puits (en mètre).

On admet que les paramètres $t$ et $p$ sont liés par la relation physique suivante : $t=\sqrt{\frac{p}{4.9}}+\frac{p}{330}$ .

Première partie : une fois la notion précondition vue

Proposer une fonction temps qui prend en paramètre la profondeur $p$ du puits et renvoie le temps $t$ d'attente du "plouf".

Penser à importer la fonction sqrt du module math.
Vérifier que l'on obtient l'affichage suivant pour l'exécution du script suivant :
```
>>>temps(30)
2.5652673874360583
```
Rajouter à votre programme deux préconditions sur $p$ .
Seconde partie : une fois la notion postcondition vue

Rajouter à votre programme une postcondition sur le valeur renvoyée.
Rajouter une documentation à la fonction temps.

Cliquer pour afficher la solution

L'énergie cinétique d'un objet de masse $m$ (en kg) qui se déplace à la vitesse $v$ (en $m.s^{-1}$ ) est donnée par la formule : $E_c=\frac{1}{2}\times m \times v^2$ .

Écrire une fonction nommée get_energie_cinetique ayant comme paramètres la masse m et la vitesse v qui renvoie l'énergie cinétique.
Est-ce une fonction ou une procédure ? Pourquoi ?
Quelle est l'énergie (en Joule) d'un objet de 3 kg se déplaçant à 1.56 $m.s^{-1}$ ?

Cliquer pour afficher la solution

Écrire une fonction saisir_num_tel qui ne prend pas de paramètre mais renvoie le numéro de téléphone saisi par l'utilisateur comme chaîne de caractères.
Est-ce une fonction ou une procédure ? Pourquoi ?
Écrire une fonction nommée prevenir_message ayant comme paramètre un numéro de téléphone qui affiche "Vous allez recevoir un message de confimation au .........." où apparaît le numéro de téléphone saisi.
Exemple : prevenir_message("0665432100") affiche "Vous allez recevoir un message de confimation au 0665432100.".

Est-ce une fonction ou une procédure ? Pourquoi ?
Intégrer ces deux fonctions pour faire apparaître un programme qui :
- Demande à l'utilisateur son numéro de téléphone.
- Affiche un message selon lequel un message de confirmation va être envoyé au numéro de la personne.

Cliquer pour afficher la solution

Écrire une fonction nommée get_moyenne5 qui renvoie la moyenne de cinq nombres quelconques passés en arguments.
Proposer une précondition portant sur chacun des paramètres d'entrée pour assurer que la possibilité de calculer la somme.

Cliquer pour afficher la solution

Voici une écriture possible en langage Python d'une fonction qui prend en paramètre un entier naturel n et qui renvoyant la somme de tous les nombres entiers compris entre 0 et n :

def tous_additionner(n):
	s = 0
	for i in range(1, n+1):
		s = s + i
	return s

Documenter la fonction précédente en ajoutant un docstring et préciser le typage des paramètres.
Proposer des préconditions écrites sur la variable n en utilisant le mot-clef assert qui assurent le bon usage de cette fonction exo6.
Proposer un postcondition écrite sur la variable renvoyée.

Cliquer pour afficher la solution

Voici une écriture possible en langage Python de l'algorithme d'une fonction qui prend en paramètres deux chaînes de caractères phrase et lettre et qui renvoie la chaîne de caractères phrase où tous les caractères lettre ont été ôtés :

def supprimer(phrase, lettre):
	fin = ""
	for elt in phrase:
		if elt != lettre:
			fin = fin + elt
	return fin

Documenter la fonction précédente en ajoutant un docstring et préciser le typage de chaque paramètre.
Proposer des préconditions écrites sur les variables phrase et lettre en utilisant le mot-clef assert qui assurent le bon usage de cette fonction exo15.

L'expression len(chaine) prend comme valeur le nombre de caractères de la chaîne de cractères nommée chaine.
Proposer un postcondition écrite sur la variable renvoyée.

Cliquer pour afficher la solution


def supprimer(phrase: str, lettre: str) -> str:
    """
    phrase est une chaîne de caractères
    lettre est un unique caractère
    fonction qui renvoie la phrase initiale où tous les caractères lettre ont été ôtés.
    """
    fin = ""
    for elt in phrase:
        if elt != lettre:
            fin = fin + elt
    return fin

def supprimer(phrase: str, lettre: str) -> str:
    """
    phrase est une chaîne de caractères
    lettre est un unique caractère
    fonction qui renvoie la phrase initiale où tous les caractères lettre ont été ôtés.
    """
    # ajout de deux préconditions portant sur le type et la longueur des arguments saisis
    assert type(phrase) == str, "le premier argument doit être une chaîne de caractères"
    asssert type(lettre) == str and len(lettre), "le second argument doit être une chaîne de caractères réduite à un seul caractère"
    fin = ""
    for elt in phrase:
        if elt != lettre:
            fin = fin + elt
    return fin

def supprimer(phrase: str, lettre: str) -> str:
    """
    phrase est une chaîne de caractères
    lettre est un unique caractère
    fonction qui renvoie la phrase initiale où tous les caractères lettre ont été ôtés.
    """
    assert type(phrase) == str, "le premier argument doit être une chaîne de caractères"
    asssert type(lettre) == str and len(lettre), "le second argument doit être une chaîne de caractères réduite à un seul caractère"
    fin = ""
    for elt in phrase:
        if elt != lettre:
            fin = fin + elt
    # ajout d'une postcondition portant sur le type de la valeur renvoyée
    assert type(fin) == str, "la valeur renvoyée doit être une chaîne de caractères"
    return fin

QCM

Questions issues de la Banque Nationale de Sujets

Propriétaire des ressources ci-dessous : ministère de l'Éducation nationale et de la jeunesse, licence CC BY SA NC

Voici une sélection de questions issues de la banque nationale de sujets, répondez à ces questions (attention, cette sélection n'est pas exhaustive).

On définit deux fonctions :

def f(x):
    y = 2*x + 1
    return y

def calcul(x):
    y = x - 1
    return f(y)

Quelle est la valeur renvoyée par l'appel calcul(5) ?

Réponses :

A- 4

B- 9

C- 11

D- 19

On exécute le code suivant

a = 2
b = 3
c = a ** b
d = c % b

Quelle est la valeur de d à la fin de l'exécution ?

Réponses :

A- 1

B- 2

C- 3

D- 4

On définit L = [2, 3, 5, 7, -4].
En demandant la valeur de L[5], qu'obtient-on ?

Réponses :

A- -4

B- 2

C- 3

D- une erreur

On définit L = [4, 25, 10, 9, 7, 13].
Quelle est la valeur de L[2] ?

Réponses :

A- 4

B- 25

C- 10

D- 9

En Python, quelle est la méthode pour charger la fonction sqrt du module math ?

Réponses :

A- using math.sqrt

B- #include math.sqrt

C- from math include sqrt

D- from math import sqrt

On exécute le script suivant :

def calcul(a, b):
    a = a + 2
    b = b + 5
    c = a + b
    return c

a, b = 3, 5
calcul(a, b)

À la fin de cette exécution :

Réponses :

A- a vaut 3, b vaut 5 et c vaut 15

B- a vaut 3, b vaut 5 et c n'est pas défini

C- a vaut 5, b vaut 10 et c vaut 15

D- a vaut 5, b vaut 10 et c n'est pas défini

On exécute le script suivant :

def essai():
    a = 2
    b = 3
    c = 4
    return a
    return b
    return c

t = essai()

Quelle est la valeur de t après l'exécution de ce code ?

Réponses :

A- 2

B- 3

C- 4

D- (2, 3, 4)

La fonction suivante calcule la racine carrée du double d’un nombre flottant :

from math import sqrt
def racine_du_double(x):
    return sqrt(2*x)

Quelle est la précondition sur l'argument de cette fonction ?

Réponses :

A- x < 0

B- x >= 0

C- 2 * x > 0

D- sqrt(x) >= 0

On définit la fonction :

def f(a, b):
    assert b!=0,'le deuxième argument est nul'
    result = a/b
    return result

Qu'obtient-on en exécutant la commande r = f(4, 0) ?

Réponses :

A- Une erreur "ZeroDivisionError: division by zero" et l'arrêt de l'exécution

B- Une erreur "NameError: name 'b' is not defined" et l'arrêt de l'exécution

C- Une erreur "AssertionError: le deuxième argument est nul" et la variable r prend la valeur 0

D- Une erreur "AssertionError: le deuxième argument est nul" et l'arrêt de l'exécution

Autres QCM

Les QCM suivants sont issus de https://genumsi.inria.fr.

(Auteur Nicolas Revéret)

On souhaite écrire un programme calculant le triple d'un nombre décimal et affichant le résultat. On a saisi le code suivant :

nombre = input("Saisir un nombre")
triple = nombre * 3
print(triple)

Un utilisateur saisit le nombre 5 lorsque l'ordinateur lui demande. Quel va être le résultat affiché ?

Réponses :

A- nombrenombrenombre

B- 555

C- 15

D- 15.0

(Auteur Nicolas Revéret)

On a saisi le code suivant :

nombre = int (input("Saisir un nombre") )
double = nombre * 2
print(double)

Quel message affiche l’ordinateur lorsque l'utilisateur saisit 8.5 ?

Réponses :

A- 16

B- 16.0

C- 17

D- L'ordinateur affiche une erreur

(Auteur Nicolas Revéret)

On a saisi le code suivant :

a = 8
b = 5
a = a + b
b = a - b
a = a - b

Quelles sont les valeurs de a et b à la fin du programme ?

Réponses :

A- a = 8 et b = 5

B- a = 8 et b = 13

C- a = 5 et b = 8

D- a = 13 et b = 5

(Auteur Christophe BEASSE)

Que contiennent les variables a et b si on execute ce script ?

def func(a):
    a += 2.0
    return a 
a = 5.0 
b = func(a)

Quelles sont les valeurs de a et b à la fin du programme ?

Réponses :

A- 5.0 et 5.0

B- 5.0 et 7.0

C- 7.0 et 5.0

D- 7.0 et 7.0

(Auteur Pierre Marquestaut)

On considère le code suivant :

def fonction(nombre):
    global a
    a = 4
    return a+nombre

a = 5
b = fonction(3)
print(a)

Qu'est-ce qui s'affiche après le code précédent ?

Réponses :

A- 3

B- 4

C- 5

D- 7

(Auteur Philippe PICART)

La fonction ci-dessous calcule la température en °F (Fahrenheit) à partir d’une température en °C (Celsius). On a saisi le code suivant :
On a saisi le code suivant :

def convertir(temp_c):	
	temp_f = temp_c *1.8+32
	return temp_f

a = .....................................
print("la température en °F est de ", a)

Quelle instruction doit-on choisir pour appeler la fonction avec une température de 20 °C ?

Réponses :

A- a = convertir(20°C)

B- a = convertir("20")

C- a = int(input("saisir la temp en °C"))

D- a = convertir(20)

(Auteur Eric Buonocore)

type(abs(-42)) nous renseigne sur le type de la valeur retour de abs(-42) :

>>> type(abs(-42))

Quel est le type de la valeur retour de print("coucou") ?

>>> type(print("coucou"))
coucou

Réponses :

A- <class 'int'>

B- <class 'str'>

C- <class 'NoneType'>

D- <class 'coucou'>

(Auteur Jean-Louis Thirot)

On a exécuté le code suivant :

cote = input("quel est la longueur du coté du carré ?")
aire = cote**2
print(aire)

On obtient le message d'erreur suivant :

Traceback (most recent call last): 
File "", line 2, in 
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'

Que signifie ce message d'erreur ?

Réponses :

A- On a utilisé une variable qui n'est pas définie

B- On a mal indenté le code

C- On a fait une erreur de syntaxe

D- On effectue une opération impossible entre deux valeurs de types différents

Savoir faire et Savoir

Savoir la définition d'une variable
Savoir la définition d'un type
Savoir la définition d'une affectation
Savoir qu'une variable peut contenir des données de différents types
Savoir définir la notion de fonction
Savoir ce qu'est une chaîne de caractères
Savoir la différence entre paramètre et argument
Savoir la différence entre variable locale et globale
Savoir la portée d'une variable à l'intérieur d'une fonction
Savoir ce qu'est une précondition et une post condition
Savoir ce qu'est une trace d'exécution

Savoir nommer une variable en Python
Savoir écrire une affection en Python
Savoir afficher à l'aide de la fonction print
Savoir faire saisir depuis le clavier à l'aide de la fonction input
Saisir changer de type avec la fonction int
Savoir écrire une fonction en Python
Savoir appeler une fonction
Savoir typer les paramètres d'une fonction
Savoir écrire la documentation d'une fonction
Savoir déclarer une variable globale en Python
Savoir écrire une précondition à l'aide du mot-clé assert
Savoir écrire une postcondition à l'aide du mot-clé assert

Remédiation

En cas de difficultés persistantes sur certaines notions de ce chapitre, vous pouvez essayer de retravailler ces notions sur le site futurecoder de la forge.
Les pages liées aux "Variables" et aux "Fonctions" sont celles le plus en lien avec le chapitre.
Pour la partie "Fonctions de tests", la fonction assert_equal spécifique au site futurecoder est une manière de tester des assertions sans le mot-clé assert.
La partie "return termine l'appel de la fonction" est difficile car nécessite de maîtriser les boucles for. De plus, ne vous attardez pas sur l'utilisation du mot-clé break.

Espace vidéos

Utilisation de la console EDUPYTHON :

Présentation de JUPYTER :

Les fonctions (en mode console EDUPYTHON) :

Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International

▲

Python : un langage interprété

Langage interprété ?

Variables et affectation

Variable

Affectation

Affichage et saisie

Affichage

Saisie

Les fonctions

Notion

En Python

Bonnes pratiques de programmation

Utilisation de modules

La portée des variables

Précondition et postconditions en Python

Précondition

Postcondition

Suivre l'état des variables pas à pas : trace d'exécution et Python Tutor

Des exercices

Fonction

Fonction

Précondition

Fonction

Précondition

Fonction

Travail complémentaire

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

Exercices de renforcement

QCM

Questions issues de la Banque Nationale de Sujets

Autres QCM

Savoir faire et Savoir

Remédiation

Espace vidéos

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