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

1. 01abAB ?

2. Vive_NSI! ?

3. annee_2024 ?

4. str ?

5. BA0bab ?

6. _ ?

1. Saisir successivement en console les deux lignes de code suivant :

   >>>pv_player = 100
   >>>id(pv_player)

2. Est-ce que chacun d'entre vous a le même identifiant à l'issue de l'exécution de ce code ?

3. 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 ?

4. Déterminer, grâce à la fonction type le type de la variable pv_player.

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

6. Qu'en déduisez-vous ?

7. Saisir le code suivant en console :

   >>>ig_player = True

8. Déterminer l'identifiant et le type de la variable ig_player. Qu'en déduisez-vous ?

1. Tester le code suivant :

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

2. Tester le code suivant :

type(level_player)
					

3. Tester le code suivant :

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

Pourquoi cet affichage ?

1. Tester le code suivant :

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

2. Tester le code suivant :

type(level_player)
					

3. Tester le code suivant :

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

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.

1. É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$.

2. Appeler cette fonction afin de mettre en stack 15352 morceaux de bois.

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.

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

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

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

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

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 ?

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}$.

1. É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.

2. La "fonction" intégrée est-elle une fonction ou une procédure ? Pourquoi ?

3. Vérifier qu'une personne de 80 kg mesurant 1 mètre 80 a un IMC proche de 24.691358024691358.

1. É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.

2. Est-ce une fonction ou une procédure ? Pourquoi ?

3. É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 !".

4. Est-ce une fonction ou une procédure ? Pourquoi ?

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

1. Écrire une fonction nommée get_moyenne qui renvoie la moyenne de trois nombres quelconques passés en arguments.

2. Proposer une précondition portant sur chacun des paramètres d'entrée pour assurer que la possibilité de calculer la somme.

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

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 

1. Préciser le type de chacun des paramètres d'entrée.

2. Est-ce une fonction ou une procédure ?

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