Objectif :
Réalisation d’un programme pour gérer une calculette.
Mission :
- Utilise les boutons A ou B pour réveiller a calculette,
- Choix des nombres de 0 à 9 avec le bouton A ou B,
- Choix des opérateurs +,-,*,/,= avec le bouton A ou B,
- Calcul par le choix de l’opérateur =, afficher les opérations puis le résultat
- Un appui long permet l’arrêt la mise en veille
Etapes :
- Affichage d’un caractère
- Affichage des nombres et des opérateurs
- Attendre la saisie de la touche A ou B
- Affichage d’une liste de caractères et le choix
- Affichage d’un chiffre avec virgule avec la notion d’un ascenseur
- Calcul des différentes opérations
- Choix d’un nombre puis d’un opérateur
- Mémorisation des différentes opérations
- Calcul
Table des matières
- Découverte des instructions à utiliser.
- Le dictionnaire en python.
- Les fonctions en Python.
- Etape 1 Affichage d’un caractère.
- Etape 2 Affichage des nombres.
- Etape 3 Attendre la saisie de la touche A ou B.
- Etape 4 Détection de la saisie du bouton A ou B.
- Etape 5 Afficher une liste de caractères et choix d’un caractère.
- Etape 6 Afficher un chiffre à virgule.
- Etape 7 Calcul des différentes opérations arithmétiques de base.
- Etape 8 Calculette choix de deux nombres et d’un opérateur.
- Etape 9 Calculette mémorisation des opérations.
- Etape 10 Affichage du résultat de l’opération.
- Etape 11 Sonoriser ta calculette.
Découverte des instructions à utiliser
#Affichage d’une LED
from pystubit.board import display
display.set_pixel(0, 0, 9)
display.set_pixel(colonne de 0 à 4, ligne de 0 à 4,intensité de la LED de 0 à 9)
INTENSITE_LED=9
display.set_pixel(0, 0, INTENSITE _LED)Une liste de données :
En Python, une liste est un type de données qui permet de stocker une collection ordonnée d’éléments, tels que des nombres, des chaînes de caractères ou d’autres objets. Les listes sont définies en utilisant des crochets [].
ceci_est_une_liste = [0,1,2,3,4]
#pour accéder à un élément de la liste
premier_element = ceci_est_une_liste[0]
#pour lire toute la liste
for ligne in ceci_est_un_liste:
display.set_pixel(0, ligne, 9)Une liste de liste :
une_liste_de_leds = [0,4,2,9,5]
ligne=0
for intensite in une_liste_de_leds:
display.set_pixel(0, ligne, intensite)
ligne+=1Le dictionnaire en python
Un dictionnaire en Python est un type de données qui permet de stocker des éléments sous forme de paires clé-valeur. Contrairement à la liste, les éléments dans un dictionnaire ne sont pas stockés dans un ordre particulier, mais plutôt associés à une clé unique qui permet d’y accéder facilement.
Les dictionnaires sont définis en utilisant des accolades {} et des paires clé-valeur séparées par des virgules. Par exemple, voici comment vous pouvez créer un dictionnaire pour stocker des informations :
from microbit import display
allume = {"OUI" :9,"NON" :0}
for colonne in range(5):
for ligne in range(5):
display.set_pixel(colonne, ligne, allume["OUI"])Les fonctions en Python
Déclaration de la fonction :
Commence par déclarer la fonction en utilisant le mot-clé def, suivi du nom de la fonction et des parenthèses qui contiennent éventuellement des paramètres d’entrée. Par exemple :
def ma_fonction(parametre1, parametre2):
# Addition de deux nombres
# En paramètre deux nombres
# Retourne la somme de deux nombres (optionnel)
resultat = parametre1 + parametre2
return resultat
nombre1=5
nombre2=2
print(nombre1,"+",nombre2,"=",ma_fonction(nombre1,nombre2))Etape 1 Affichage d’un caractère
#Bibliothèques à importer
from microbit import display
t_zero = [
[0, 9, 9, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 9, 9, 0],
]
# Affichage d’un caractère en utilisant le tableau de LEDs
def affichage(caractere):
num_ligne = 0
# Affichage des lignes
for ligne in caractere:
num_colonne = 0
# Affichage des colonnes
for led in ligne:
display.set_pixel(num_colonne, num_ligne, led)
num_colonne += 1
num_ligne += 1
affichage(t_zero)Flasher pour tester puis bouton reset pour lancer
from microbit import display
#Tableaux pour afficher les nombres de 0 à 9
t_zero = [
[0, 9, 9, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 9, 9, 0],
]
t_un = [
[0, 0, 9, 0, 0],
[0, 9, 9, 0, 0],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
[0, 9, 9, 9, 0],
]
t_deux = [
[0, 9, 9, 0, 0],
[9, 0, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 9, 0, 0, 0],
[9, 9, 9, 9, 0],
]
t_trois = [
[0, 9, 9, 0, 0],
[0, 0, 0, 9, 0],
[0, 9, 9, 9, 0],
[0, 0, 0, 9, 0],
[0, 9, 9, 0, 0],
]
t_quatre = [
[0, 0, 9, 0, 0],
[0, 9, 0, 0, 0],
[9, 9, 9, 9, 0],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
]
t_cinq = [
[0, 9, 9, 9, 0],
[0, 9, 0, 0, 0],
[0, 9, 9, 9, 0],
[0, 0, 0, 9, 0],
[0, 9, 9, 0, 0],
]
t_six = [
[0, 0, 9, 0, 0],
[0, 9, 0, 0, 0],
[9, 9, 9, 0, 0],
[9, 0, 0, 9, 0],
[0, 9, 9, 0, 0],
]
t_sept = [
[0, 9, 9, 9, 0],
[0, 0, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
]
t_huit = [
[0, 0, 9, 0, 0],
[0, 9, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 9, 0, 9, 0],
[0, 0, 9, 0, 0],
]
t_neuf = [
[0, 9, 9, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 9, 9, 0],
[0, 0, 0, 9, 0],
[0, 9, 9, 0, 0],
]
# Tableaux pour afficher les opérateurs =,+,-,/,*
t_egal = [
[0, 0, 0, 0, 0],
[9, 9, 9, 9, 9],
[0, 0, 0, 0, 0],
[9, 9, 9, 9, 9],
[0, 0, 0, 0, 0],
]
t_plus = [
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
[9, 9, 9, 9, 9],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
]
t_moins = [
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[9, 9, 9, 9, 9],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
]
t_div = [
[0, 0, 0, 0, 9],
[0, 0, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 9, 0, 0, 0],
[9, 0, 0, 0, 0],
]
t_multiple = [
[9, 0, 0, 0, 9],
[0, 9, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 9, 0, 9, 0],
[9, 0, 0, 0, 9],
]
# Tableaux pour afficher un séparateur
t_point = [
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 9, 9, 9, 0],
[0, 9, 9, 9, 0],
[0, 9, 9, 9, 0],
]
# Affichage d’un caractère
def affichage(caractere):
num_ligne = 0
for ligne in caractere:
num_colonne = 0
for led in ligne:
display.set_pixel(num_colonne, num_ligne, led)
num_colonne += 1
num_ligne += 1
# Test pour afficher un caractère
affichage(t_huit)Flasher pour tester puis bouton reset pour lancer
Peux-tu répondre à ce QCM sur la boucle FOR et les tableaux :
Quelle est la sortie du code suivant ?
tableau = [2, 4, 6, 8, 10]
for i in tableau:
print(i)- A) 0 1 2 3 4
- B) 2 4 6 8 10
- C) 1 2 3 4 5
- D) 0 2 4 6 8
Quelle est la sortie du code suivant ?
tableau = [3, 6, 9, 12, 15]
for i in range(len(tableau)):
print(tableau[i])- A) 0 1 2 3 4
- B) 3 6 9 12 15
- C) 1 2 3 4 5
- D) 0 3 6 9 12
Comment parcourir un tableau en utilisant une boucle for et l’index du tableau ?
A)
tableau = [5, 10, 15, 20]
for i in tableau:
print(tableau[i])B)
tableau = [5, 10, 15, 20]
for i in range(len(tableau)):
print(tableau[i])C)
tableau = [5, 10, 15, 20]
for i in range(tableau):
print(tableau[i])D)
tableau = [5, 10, 15, 20]
for i in tableau:
print(i)Quel est le résultat de ce code ?
tableau = [1, 2, 3, 4, 5]
total = 0
for i in tableau:
total += i
print(total)Comment ajouter tous les éléments d’un tableau en utilisant une boucle for ?
A)
tableau = [1, 2, 3, 4, 5]
total = 0
for i in tableau:
total += tableau[i]
print(total)B)
tableau = [1, 2, 3, 4, 5]
total = 0
for i in range(len(tableau)):
total += tableau[i]
print(total)C)
tableau = [1, 2, 3, 4, 5]
total = 0
for i in tableau:
total += i
print(total)D)
tableau = [1, 2, 3, 4, 5]
total = 0
for i in range(tableau):
total += i
print(total)Etape 2 Affichage des nombres
#Tableau de tous les nombres# Tableau de la liste des chiffres de 0 à 9
chiffres = {
0: t_zero,
1: t_un,
2: t_deux,
3: t_trois,
4: t_quatre,
5: t_cinq,
6: t_six,
7: t_sept,
8: t_huit,
9: t_neuf,
}
# Tableau de tous les opérateurs
operateurs = {"=": t_egal, "+": t_plus, "-": t_moins, "*": t_multiple, "/": t_div}
#Test pour afficher un nombre
affichage(chiffres[3])Flasher pour tester puis bouton reset pour lancer
Peux-tu répondre à ce QCM sur l’utilisation des dictionnaires Python :
Quelle est la sortie du code suivant ?
dictionnaire = {"a": 1, "b": 2, "c": 3}
print(dictionnaire["a"])- A) « a »
- B) 1
- C) « b »
- D) 2
Comment parcourir un dictionnaire en utilisant une boucle for ?
A)
dictionnaire = {"a": 1, "b": 2, "c": 3}
for cle in dictionnaire:
print(cle, dictionnaire[cle])B)
dictionnaire = {"a": 1, "b": 2, "c": 3}
for cle, valeur in dictionnaire.items():
print(cle, valeur)C)
dictionnaire = {"a": 1, "b": 2, "c": 3}
for cle in dictionnaire.keys():
print(cle, dictionnaire[cle])D) Toutes les réponses précédentes sont correctes
Etape 3 Attendre la saisie de la touche A ou B
Attente de l’appui du bouton A ou bouton B
# Bibliothèques à importer
from microbit import display, button_a, button_b
import time
#Test pour attendre l’appui du bouton A ou B ou time out
def attendre_boutonA_ou_boutonB(delai_attente = 0):
start = time.ticks_ms()
# Attente appui sur le bouton A ou bouton B ou au bout d'un time out
while (not (button_a.is_pressed()) and
not (button_b.is_pressed()) and
((delai_attente == 0) or ((time.ticks_ms()-start) < delai_attente *1000))):
pass
while button_a.is_pressed() or button_b.is_pressed():
pass
affichage(chiffres[3])
attendre_boutonA_ou_boutonB(0)
affichage(chiffres[4])
attendre_boutonA_ou_boutonB(2)
affichage(chiffres[5])
attendre_boutonA_ou_boutonB(delai_attente = 2)
display.clear()Flasher pour tester puis bouton reset pour lancer
Peux-tu répondre à ce QCM sur l’appel des fonctions Python :
Quelle est la sortie du code suivant ?
def fonction(a, b):
return a + b
print(fonction(1, 2))- A) 1
- B) 2
- C) 3
- D) Erreur
Comment définir une fonction avec un paramètre par défaut ? A)
def fonction(a = 1):
return aB)
def fonction(a):
a = 1
return aC)
def fonction():
a = 1
return aD) Toutes les réponses précédentes sont correctes
Comment appeler une fonction avec un argument nommé ?
A)
def fonction(a, b):
return a + b
print(fonction(a = 1, b = 2))B)
def fonction(a, b):
return a + b
print(fonction(1, b = 2))C)
def fonction(a, b):
return a + b
print(fonction(a = 1, 2))D) Toutes les réponses précédentes sont correctes
Comment définir une fonction avec un nombre variable d’arguments ?
A)
def fonction(*args):
return argsB)
def fonction(args):
return argsC)
def fonction(**args):
return argsD) Toutes les réponses précédentes sont correctes
Etape 4 Détection de la saisie du bouton A ou B
Détection du bouton appuyé ou sur un délai d’attente
def attendre_boutonA_ou_boutonB(delai_attente = 0):
button = "o"
start = time.ticks_ms()
# Attente appui sur le bouton A ou bouton B ou au bout d'un time out
while (not (button_a.is_pressed()) and
not (button_b.is_pressed()) and
((delai_attente == 0) or ((time.ticks_ms()-start) < delai_attente *1000))):
pass
if button_a.is_pressed():
button = "a"
if button_b.is_pressed():
button = "b"
while button_a.is_pressed() or button_b.is_pressed():
pass
return button
while True:
# Test pour afficher un caractère
affichage(chiffres[3])
print(attendre_boutonA_ou_boutonB(2))
display.clear()Flasher pour tester puis bouton reset pour lancer
Vérifier que vous avez en retour de la fonction dans la fenêtre REPL :
- a après l’appui du bouton A
- b après l’appui du bouton B
- après une attente de plus de 2 secondes
Détection d’un appui long sur la touche A ou B
def attendre_boutonA_ou_boutonB(delai_attente = 0, delai_appui_long = 1500):
button = "o"
start = time.ticks_ms()
start_button = 0
# Attente appui sur le bouton A ou bouton B ou au bout d'un time out
while (not (button_a.is_pressed()) and
not (button_b.is_pressed()) and
((delai_attente == 0) or ((time.ticks_ms()-start) < delai_attente *1000))):
pass
if button_a.is_pressed():
button = "a"
start_button = time.ticks_ms()
if button_b.is_pressed():
button = "b"
start_button = time.ticks_ms()
while button_a.is_pressed() or button_b.is_pressed():
pass
if (start_button > 0) and ((time.ticks_ms()-start_button) > delai_appui_long):
button = button + "l"
return button
while True:
# Test pour afficher un caractère
affichage(chiffres[3])
print(attendre_boutonA_ou_boutonB(2))
display.clear()Flasher pour tester puis bouton reset pour lancer
Vérifier que vous avez en retour de la fonction dans la fenêtre REPL :
- a après l’appui du bouton A
- b après l’appui du bouton B
- après une attente de plus de 2secondes
- al après l’appui long sur le bouton A
- bl après l’appui long sur le bouton B
Test de tous les nombres
nbr=0
while True:
# Test pour afficher un caractère
affichage(chiffres[nbr])
print(attendre_boutonA_ou_boutonB(2))
nbr += 1
if nbr >= len(chiffres):
nbr = 0Flasher pour tester puis bouton reset pour lancer
En appuyant sur les boutons A ou B tu dois faire défiler les nombres de 0 à 9
Test de tous les opérateurs
nbr=0
# Mettre le dictionnaire des opérateurs en liste
operateurs_list = list(operateurs.items())
while True:
# Test pour afficher un caractère
# Utiliser la clé du dictionnaire pour afficher l'opérateur
affichage(operateurs[operateurs_list[nbr][0]])
print(attendre_boutonA_ou_boutonB(2))
nbr += 1
if nbr >= len(operateurs):
nbr = 0Flasher pour tester puis bouton reset pour lancer
En appuyant sur les boutons A ou B tu dois faire défiler les opérateurs de 0 à 9
L’utilisation de fonctions dans un code Python permet d’améliorer la visibilité et la maintenance du code. Voici quelques raisons pour lesquelles cela est vrai :
- Structuration du code : Les fonctions permettent de diviser le code en blocs logiques et fonctionnels, ce qui facilite la compréhension du code par les autres développeurs ou par soi-même plus tard. En regroupant les instructions qui effectuent une tâche spécifique dans une fonction, on peut rendre le code plus facile à lire et à comprendre.
- Réutilisation du code : Les fonctions peuvent être réutilisées dans différentes parties du code, ce qui évite de dupliquer des instructions similaires à plusieurs endroits. Cela permet également de simplifier le code et de réduire les erreurs de copier-coller.
- Facilité de maintenance : Les fonctions permettent de modifier le code plus facilement. Si une partie du code doit être modifiée, il suffit de modifier la fonction correspondante plutôt que de modifier plusieurs lignes de code dans différentes parties du programme. Cela permet de gagner du temps et de réduire les risques d’introduire de nouvelles erreurs.
- Amélioration de la visibilité : Les fonctions peuvent être nommées de manière à décrire leur fonctionnalité, ce qui facilite la compréhension du code. En utilisant des noms de fonctions significatifs, on peut rendre le code plus facile à comprendre pour les autres développeurs ou pour soi-même plus tard.
- Réduction des erreurs : Les fonctions permettent de réduire les erreurs en limitant la portée des variables et en évitant les conflits de noms. En utilisant des variables locales à l’intérieur d’une fonction, on peut éviter les conflits de noms avec des variables globales ou des variables d’autres fonctions.
En résumé, l’utilisation de fonctions permet de structurer le code, de faciliter la réutilisation et la maintenance du code, d’améliorer la visibilité et de réduire les erreurs. Il est donc recommandé d’utiliser des fonctions dans un code Python pour améliorer sa qualité et sa lisibilité.
Etape 5 Afficher une liste de caractères et choix d’un caractère
"""
Choix des chiffres ou des opérateurs
les boutons A et B pour faire défiler les caractères
Appui long sur A ou B pour valider le caractère
"""
def choix_caractere(caracteres, item=0, delai_attente=0, delai_appui_long=1500):
button = ""
caractereres_keys = list(caracteres.keys())
try:
item = caractereres_keys.index(item)
except ValueError:
item=0
while True:
if caractereres_keys[item] in caracteres:
# Affichage du caratère
affichage(caracteres[caractereres_keys[item]])
# Attente bouton A ou B
button = attendre_boutonA_ou_boutonB(delai_attente, delai_appui_long)
# Défilement des caratères
if button == "a":
item -= 1
if button == "b":
item += 1
# Appui long sur A ou B
if button == "al" or button == "bl":
return caractereres_keys[item]
# Délai d'attente dépassé
if button == "o":
return None
if item >= len(caractereres_keys):
item = 0
if item < 0:
item = len(caractereres_keys) - 1
#Tester le défilement des chiffres
while True:
print(choix_caractere(chiffres, 0, 5, 1000))
#Tester le défilement des opérateurs
while True:
print(choix_caractere(operateurs, 0, 5, 1000))Flasher pour tester puis bouton reset pour lancer
QCM sur les différentes possibilités pour arrêter une boucle infinie while True: utilisée dans une fonction en Python :
Comment arrêter une boucle infinie en utilisant les instructions ?
- A) En utilisant l’instruction continue
- B) En utilisant l’instruction return
- C) En utilisant l’instruction pass
- D) En utilisant l’instruction break
Comment arrêter une boucle infinie en utilisant une variable de contrôle ?
- A) En utilisant l’instruction continue
- B) En utilisant l’instruction break
- C) En utilisant une variable de contrôle
- D) En utilisant l’instruction pass
Quelle instruction permet de sauter une itération dans une boucle ?
- A) L’instruction break
- B) L’instruction return
- C) L’instruction pass
- D) L’instruction continue
# Affichage d'un ascenceur pour les nombres de plusieurs chiffres
def barre_ascenceur(maxi, ascenceur):
if maxi > 5:
maxi = 5
if ascenceur >= maxi:
ascenceur = maxi - 1
# Effacement 5éme colonne
for ligne in range(5):
display.set_pixel(4, ligne, 0)
# Affichage de l'ascenceur
display.set_pixel(4, ascenceur, 5)
#Affichage d’un nombre avec une virgule
# Affichage d’un nombre avec une virgule
def affichage_nombre(nombre, delai_attente=0, delai_appui_long=1500):
# Convertir le nombre en une chaine de caractère
nombreString = str(nombre)
grandeur = len(nombreString)
ascenceur = 0
button = ""
# Affichage du nombre jusqu'à appui long ou hors délai d'attente
while (not (button == "al") and
not (button == "bl") and
not (button == "o")):
# Affichage d'un caractère du nombre et de l'ascenceur
if nombreString[ascenceur] == ".":
affichage(t_point)
elif nombreString[ascenceur] == "-":
affichage(t_moins)
else:
affichage(chiffres[int(nombreString[ascenceur])])
barre_ascenceur(grandeur, ascenceur)
# Attente récation de l'utilisateur
button = attendre_boutonA_ou_boutonB(delai_attente, delai_appui_long)
if button == "a":
ascenceur -= 1
if button == "b":
ascenceur += 1
if ascenceur >= grandeur:
ascenceur = 0
if ascenceur < 0 :
ascenceur = grandeur-1
return button
# Tester un nombre avec deux chiffres, défilement de l’ascenseur avec les bouton A ou B
# Validation par un appui long
while True:
affichage_nombre(-123456.4,0)
affichage_nombre(-987)
affichage_nombre(-55.1234)Etape 6 Afficher un chiffre à virgule
Flasher pour tester puis bouton reset pour lancer
Afficher un nombre avec plusieurs chiffres, avec éventuellement un signe moins, une virgule :
- Faire défiler le nombre avec les touches A et B
- Valider le nombre par un appui long sur A ou B
- Vérifier la présence du signe moins – et la présence de la virgule .
Etape 7 Calcul des différentes opérations arithmétiques de base
# Calcul avec deux nombres
def calcul(nombre1, operateur="=", nombre2=0):
resultat = 0
if operateur == "=":
resultat = nombre1
if operateur == "+":
resultat = nombre1 + nombre2
if operateur == "-":
resultat = nombre1 - nombre2
if operateur == "*":
resultat = nombre1 * nombre2
if operateur == "/":
if nombre2 > 0:
resultat = nombre1 / nombre2
return resultat
while True:
# Initialiser
resultat = calcul(2)
affichage_nombre(resultat)
# Additionner
resultat = calcul(resultat, "+", 4)
affichage_nombre(resultat)
# Soustraire
resultat = calcul(resultat, "-", 4)
affichage_nombre(resultat)
# Multiplier
resultat = calcul(resultat, "*", 2)
affichage_nombre(resultat)
# Diviser
resultat = calcul(resultat, "/", 2)
affichage_nombre(resultat)
# Division par zéro impossible
resultat = calcul(resultat, "/", 0)
affichage_nombre(resultat)Flasher pour tester puis bouton reset pour lancer
Vérifier que le calcul est correct après chaque opération :
- Faire défiler le résultat par les touches A et B
- Valider le résultat par un appui long sur A ou B
Etape 8 Calculette choix de deux nombres et d’un opérateur
operateur = "+"
while True:
nombre1 = choix_caractere(chiffres)
operateur = choix_caractere(operateurs, operateur)
nombre2 = choix_caractere(chiffres)
resultat = calcul(nombre1, operateur, nombre2)
affichage_nombre(resultat)Flasher pour tester puis bouton reset pour lancer
Les opérateurs +, -, * et / sont respectivement appelés :
- L’opérateur d’addition (+)
- L’opérateur de soustraction (-)
- L’opérateur de multiplication (*)
- L’opérateur de division (/)
Ces opérateurs sont utilisés pour effectuer des opérations arithmétiques de base sur des nombres en Python. Par exemple :
# Addition
5 + 3 # Résultat : 8
# Soustraction
5 - 3 # Résultat : 2
# Multiplication
5 * 3 # Résultat : 15
# Division
5 / 3 # Résultat : 1.6666666666666667Il est important de noter que l’opérateur de division (/) renvoie un résultat sous forme de nombre à virgule flottante, même si les nombres utilisés sont des entiers. Pour obtenir un résultat sous forme d’entier, il est possible d’utiliser l’opérateur de division entière (//) :
# Division entière
5 // 3 # Résultat : 1L’opérateur de division entière renvoie le quotient entier de la division, en arrondissant vers le bas. Le reste de la division peut être obtenu en utilisant l’opérateur de modulo (%) :
# Modulo
5 % 3 # Résultat : 2L’opérateur de modulo renvoie le reste de la division entière.
Etape 9 Calculette mémorisation des opérations
En Python, une liste est une structure de données qui permet de stocker une collection ordonnée d’éléments. Les éléments d’une liste peuvent être de n’importe quel type (entiers, chaînes de caractères, listes, etc.).
Pour ajouter des éléments à une liste en Python, on peut utiliser la méthode append(). La méthode append() ajoute un élément à la fin de la liste. Voici un exemple :
# Création d'une liste vide
ma_liste = []
# Ajout d'éléments à la liste
ma_liste.append(1)
ma_liste.append(2)
ma_liste.append(3)
# Affichage de la liste
print(ma_liste) # Résultat : [1, 2, 3]Dans cet exemple, on crée une liste vide ma_liste. On ajoute ensuite les éléments 1, 2 et 3 à la liste en utilisant la méthode append(). Enfin, on affiche la liste à l’aide de la fonction print(). Le résultat affiché est [1, 2, 3].
Il est également possible d’ajouter plusieurs éléments à une liste en utilisant la méthode extend(). La méthode extend() prend une liste en argument et ajoute tous les éléments de cette liste à la fin de la liste existante. Voici un exemple :
# Création d'une liste
ma_liste = [1, 2, 3]
# Ajout de plusieurs éléments à la liste
ma_liste.extend([4, 5, 6])
# Affichage de la liste
print(ma_liste) # Résultat : [1, 2, 3, 4, 5, 6]Dans cet exemple, on crée une liste ma_liste contenant les éléments 1, 2 et 3. On ajoute ensuite les éléments 4, 5 et 6 à la liste en utilisant la méthode extend(). Enfin, on affiche la liste à l’aide de la fonction print(). Le résultat affiché est [1, 2, 3, 4, 5, 6].
def saisie_operation():
operation = []
item = 0
retour = 0
operateur = "+"
while ((retour is not None) and
(retour != "=")):
item += 1
resultat = None
# Saisie de l'opération nombre opérateur nombre ... jusqu'au égal =
if item % 2 == 0:
retour = choix_caractere(operateurs, operateur,
delai_attente=60,
delai_appui_long=700)
if retour :
operateur = retour
else:
retour = choix_caractere(chiffres,
delai_attente=60,
delai_appui_long=700)
if retour :
operation.append(retour)
if retour :
return operation
else:
return None
while True:
# Saisie de l’opération
print(saisie_operation())Flasher pour tester puis bouton reset pour lancer et visualise le résultat dans REPL
- Fait le choix des nombres par les touches A et B puis valide le nombre par un appui long par les touches A ou B
- Puis fait le choix de l’opérateur de ton opération par les touches A et B puis valide par un appui long par les touches A ou B
- Valide ton calcul par le choix de l’opérateur « = » par un appui long sur A ou B
- Vérifie ton calcul dans la console REPL
Etape 10 Affichage du résultat de l’opération
def affichage_calcul(operation):
resultat = 0
if operation :
item = 0
for operande in operation:
item += 1
if item % 2 == 0:
operateur = operande
affichage(operateurs[operateur])
attendre_boutonA_ou_boutonB(1)
else:
affichage(chiffres[operande])
attendre_boutonA_ou_boutonB(1)
# Calcul de l'opération
if item == 1 :
resultat = calcul(operande)
else:
resultat = calcul(resultat, operateur, operande)
return resultat
button = ""
while True:
# Saisie de l'opération
operation = saisie_operation()
# Affichage de l'opération et calcul de l'opération
if operation :
# Affichage et calcul de l'opération
resultat = affichage_calcul(operation)
# Affichage du résultat
button = affichage_nombre(resultat,
delai_attente=60,
delai_appui_long=700)
if operation is None or button == "o" :
# Mise en veille
display.clear()
attendre_boutonA_ou_boutonB()Flasher pour tester puis bouton reset pour lancer
QCM sur les différentes possibilités d’ajouter des éléments dans une liste en Python :
Comment ajouter un élément à la fin d’une liste en Python ?
- A) En utilisant la méthode add()
- B) En utilisant la méthode insert()
- C) En utilisant la méthode append()
- D) En utilisant la méthode extend()
Comment ajouter plusieurs éléments à la fin d’une liste en Python ?
- A) En utilisant la méthode add()
- B) En utilisant la méthode insert()
- C) En utilisant la méthode append()
- D) En utilisant la méthode extend()
Comment ajouter un élément à une position spécifique dans une liste en Python ?
- A) En utilisant la méthode add()
- B) En utilisant la méthode insert()
- C) En utilisant la méthode append()
- D) En utilisant la méthode extend()
Comment ajouter une liste à une autre liste en Python ?
- A) En utilisant la méthode add()
- B) En utilisant la méthode insert()
- C) En utilisant la méthode append()
- D) En utilisant la méthode extend()
Comment ajouter un élément au début d’une liste en Python ?
- A) En utilisant la méthode add() avec l’index 0.
- B) En utilisant la méthode insert() avec l’index 0.
- C) En utilisant la méthode append() avec l’index 0.
- D) En utilisant la méthode extend()avec l’index 0.
Exemple pour comprendre :
liste1= [1,2,3,4]
liste2= [10,11,12,13]
liste1.append(6)
liste1.extend([7,8,9])
liste1.insert(4,5)
liste1.extend(liste2)
liste1.insert(0,0)
print(liste1)Etape 11 Sonoriser ta calculette
La sonorisation des logiciels est un domaine de recherche qui vise à améliorer l’interaction entre l’utilisateur et le logiciel en utilisant des sons. Les sons peuvent être utilisés pour fournir des commentaires à l’utilisateur sur ses actions, pour signaler des événements importants ou pour renforcer la compréhension de l’interface utilisateur.
from microbit import display, button_a, button_b
import time
import music
def attendre_boutonA_ou_boutonB(delai_attente=0, delai_appui_long=1500):
button = "o"
start = time.ticks_ms()
start_button = 0
# Attente appui sur le bouton A ou bouton B ou au bout d'un time out
while (
not (button_a.is_pressed())
and not (button_b.is_pressed())
and ((delai_attente == 0) or ((time.ticks_ms() - start) < delai_attente * 1000))
):
pass
if button_a.is_pressed():
button = "a"
start_button = time.ticks_ms()
if button_b.is_pressed():
button = "b"
start_button = time.ticks_ms()
premierefois = True
while button_a.is_pressed() or button_b.is_pressed():
if ((time.ticks_ms() - start_button) > delai_appui_long):
music.pitch(200, duration=40)
else:
if premierefois:
music.pitch(500, duration=20)
premierefois = False
if (start_button > 0) and ((time.ticks_ms() - start_button) > delai_appui_long):
button = button + "l"
return button
return buttonFlasher pour tester puis bouton reset pour lancer
Voici quelques raisons pour lesquelles la sonorisation des logiciels peut être importante pour améliorer l’utilisation par l’humain des logiciels :
- Fournir des commentaires auditifs : Les sons peuvent être utilisés pour fournir des commentaires auditifs à l’utilisateur sur ses actions. Par exemple pour confirmer l’appui sur un bouton.
- Renforcer la compréhension de l’interface utilisateur : Les sons peuvent être utilisés pour renforcer la compréhension de l’interface utilisateur en fournissant des indices auditifs sur la fonctionnalité des différents éléments de l’interface. Par exemple lors de la confirmation d’un appui long sur un bouton.
- Signaler des événements importants : Les sons peuvent être utilisés pour signaler des événements importants dans le logiciel. Par exemple sur une erreur de saisie, indique par exemple l’erreur de la division par zéro.
- Améliorer l’accessibilité : Les sons peuvent être utilisés pour améliorer l’accessibilité des logiciels pour les personnes malvoyantes ou non voyantes. Les sons peuvent être utilisés pour fournir des commentaires auditifs sur les actions de l’utilisateur, pour décrire les éléments de l’interface utilisateur et pour signaler des événements importants. Les sons peuvent également être utilisés pour fournir une alternative auditive aux informations visuelles. Essaye de rendre la calculette utilisable par une personne non voyante ?
En résumé, la sonorisation des logiciels peut aider à améliorer l’interaction entre l’utilisateur et le logiciel en fournissant des commentaires auditifs, en renforçant la compréhension de l’interface utilisateur, en signalant des événements importants et en améliorant l’accessibilité. Les sons peuvent être utilisés pour fournir des informations supplémentaires à l’utilisateur, pour renforcer la compréhension de l’interface utilisateur et pour améliorer l’expérience utilisateur globale.
# Bibliothèques à importer
from microbit import display, button_a, button_b
import time
t_zero = [
[0, 9, 9, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 9, 9, 0]]
t_un = [
[0, 0, 9, 0, 0],
[0, 9, 9, 0, 0],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
[0, 9, 9, 9, 0]]
t_deux = [
[0, 9, 9, 0, 0],
[9, 0, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 9, 0, 0, 0],
[9, 9, 9, 9, 0]]
t_trois = [
[0, 9, 9, 0, 0],
[0, 0, 0, 9, 0],
[0, 9, 9, 9, 0],
[0, 0, 0, 9, 0],
[0, 9, 9, 0, 0]]
t_quatre = [
[0, 0, 9, 0, 0],
[0, 9, 0, 0, 0],
[9, 9, 9, 9, 0],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0]]
t_cinq = [
[0, 9, 9, 9, 0],
[0, 9, 0, 0, 0],
[0, 9, 9, 9, 0],
[0, 0, 0, 9, 0],
[0, 9, 9, 0, 0]]
t_six = [
[0, 0, 9, 0, 0],
[0, 9, 0, 0, 0],
[9, 9, 9, 0, 0],
[9, 0, 0, 9, 0],
[0, 9, 9, 0, 0]]
t_sept = [
[0, 9, 9, 9, 0],
[0, 0, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0]]
t_huit = [
[0, 0, 9, 0, 0],
[0, 9, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 9, 0, 9, 0],
[0, 0, 9, 0, 0]]
t_neuf = [
[0, 9, 9, 9, 0],
[0, 9, 0, 9, 0],
[0, 9, 9, 9, 0],
[0, 0, 0, 9, 0],
[0, 9, 9, 0, 0]]
# Tableaux pour afficher les opérateurs =,+,-,/,*
t_egal = [
[0, 0, 0, 0, 0],
[9, 9, 9, 9, 9],
[0, 0, 0, 0, 0],
[9, 9, 9, 9, 9],
[0, 0, 0, 0, 0]]
t_plus = [
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0],
[9, 9, 9, 9, 9],
[0, 0, 9, 0, 0],
[0, 0, 9, 0, 0]]
t_moins = [
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[9, 9, 9, 9, 9],
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0]]
t_div = [
[0, 0, 0, 0, 9],
[0, 0, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 9, 0, 0, 0],
[9, 0, 0, 0, 0]]
t_multiple = [
[9, 0, 0, 0, 9],
[0, 9, 0, 9, 0],
[0, 0, 9, 0, 0],
[0, 9, 0, 9, 0],
[9, 0, 0, 0, 9]]
# Tableaux pour afficher un séparateur
t_point = [
[0, 0, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 9, 9, 9, 0],
[0, 9, 9, 9, 0],
[0, 9, 9, 9, 0]]
# Tableau de tous les nombres# Tableau de la liste des chiffres de 0 à 9
chiffres = {
0: t_zero,
1: t_un,
2: t_deux,
3: t_trois,
4: t_quatre,
5: t_cinq,
6: t_six,
7: t_sept,
8: t_huit,
9: t_neuf,
}
# Tableau de tous les opérateurs
operateurs = {"=": t_egal, "+": t_plus, "-": t_moins, "*": t_multiple, "/": t_div}
# Affichage d’un caractère en utilisant le tableau de LEDs
def affichage(caractere):
num_ligne = 0
# Affichage des lignes
for ligne in caractere:
num_colonne = 0
# Affichage des colonnes
for led in ligne:
display.set_pixel(num_colonne, num_ligne, led)
num_colonne += 1
num_ligne += 1
# Test pour attendre l’appui du bouton A ou B ou time out
def attendre_boutonA_ou_boutonB(delai_attente=0,
delai_appui_long=1500):
button = "o"
start = time.ticks_ms()
start_button = 0
# Attente appui sur le bouton A ou bouton B ou au bout d'un time out
while (not (button_a.is_pressed()) and
not (button_b.is_pressed()) and
((delai_attente == 0) or
((time.ticks_ms() - start) < delai_attente * 1000))):
pass
if button_a.is_pressed():
button = "a"
start_button = time.ticks_ms()
if button_b.is_pressed():
button = "b"
start_button = time.ticks_ms()
while button_a.is_pressed() or button_b.is_pressed():
pass
if (start_button > 0) and ((time.ticks_ms()-start_button) > delai_appui_long):
button = button + "l"
return button
"""
Choix des chiffres ou des opérateurs
les boutons A et B pour faire défiler les caractères
Appui long sur A ou B pour valider le caractère
"""
def choix_caractere(caracteres,
item=0,
delai_attente=0,
delai_appui_long=1500):
button = ""
caractereres_keys = list(caracteres.keys())
try:
item = caractereres_keys.index(item)
except ValueError:
item = 0
while True:
if caractereres_keys[item] in caracteres:
# Affichage du caratère
affichage(caracteres[caractereres_keys[item]])
# Attente bouton A ou B
button = attendre_boutonA_ou_boutonB(delai_attente, delai_appui_long)
# Défilement des caratères
if button == "a":
item -= 1
if button == "b":
item += 1
# Appui long sur A ou B
if button == "al" or button == "bl":
return caractereres_keys[item]
# Délai d'attente dépassé
if button == "o":
return None
if item >= len(caractereres_keys):
item = 0
if item < 0:
item = len(caractereres_keys) - 1
# Affichage d'un ascenceur pour les nombres de plusieurs chiffres
def barre_ascenceur(maxi, ascenceur):
if maxi > 5:
maxi = 5
if ascenceur >= maxi:
ascenceur = maxi - 1
# Effacement 5éme colonne
for ligne in range(5):
display.set_pixel(4, ligne, 0)
# Affichage de l'ascenceur
display.set_pixel(4, ascenceur, 5)
# Affichage d’un nombre avec une virgule
def affichage_nombre(nombre,
delai_attente=0,
delai_appui_long=1500):
# Convertir le nombre en une chaine de caractère
nombreString = str(nombre)
grandeur = len(nombreString)
ascenceur = 0
button = ""
# Affichage du nombre jusqu'à appui long ou hors délai d'attente
while (not (button == "al") and
not (button == "bl") and
not (button == "o")):
# Affichage d'un caractère du nombre et de l'ascenceur
if nombreString[ascenceur] == ".":
affichage(t_point)
elif nombreString[ascenceur] == "-":
affichage(t_moins)
else:
affichage(chiffres[int(nombreString[ascenceur])])
barre_ascenceur(grandeur, ascenceur)
# Attente récation de l'utilisateur
button = attendre_boutonA_ou_boutonB(delai_attente, delai_appui_long)
if button == "a":
ascenceur -= 1
if button == "b":
ascenceur += 1
if ascenceur >= grandeur:
ascenceur = 0
if ascenceur < 0 :
ascenceur = grandeur-1
return button
# Calcul avec deux nombres
def calcul(nombre1, operateur="=", nombre2=0):
resultat = 0
if operateur == "=":
resultat = nombre1
if operateur == "+":
resultat = nombre1 + nombre2
if operateur == "-":
resultat = nombre1 - nombre2
if operateur == "*":
resultat = nombre1 * nombre2
if operateur == "/":
if nombre2 > 0:
resultat = nombre1 / nombre2
return resultat
def saisie_operation():
operation = []
item = 0
retour = 0
operateur = "+"
while ((retour is not None) and
(retour != "=")):
item += 1
resultat = None
# Saisie de l'opération nombre opérateur nombre ... jusqu'au égal =
if item % 2 == 0:
retour = choix_caractere(operateurs, operateur,
delai_attente=60,
delai_appui_long=700)
if retour :
operateur = retour
else:
retour = choix_caractere(chiffres,
delai_attente=60,
delai_appui_long=700)
if retour :
operation.append(retour)
if retour :
return operation
else:
return None
def affichage_calcul(operation):
resultat = 0
if operation :
item = 0
for operande in operation:
item += 1
if item % 2 == 0:
operateur = operande
affichage(operateurs[operateur])
attendre_boutonA_ou_boutonB(1)
else:
affichage(chiffres[operande])
attendre_boutonA_ou_boutonB(1)
# Calcul de l'opération
if item == 1 :
resultat = calcul(operande)
else:
resultat = calcul(resultat, operateur, operande)
return resultat
button = ""
while True:
# Saisie de l'opération
operation = saisie_operation()
# Affichage de l'opération et calcul de l'opération
if operation :
# Affichage et calcul de l'opération
resultat = affichage_calcul(operation)
# Affichage du résultat
button = affichage_nombre(resultat,
delai_attente=60,
delai_appui_long=700)
if operation is None or button == "o" :
# Mise en veille
display.clear()
attendre_boutonA_ou_boutonB()
