Catégories
MICRO PYTHON MICRO:BIT

Créer une calculatrice

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 :

  1. Affichage d’un caractère
  2. Affichage des nombres et des opérateurs
  3. Attendre la saisie de la touche A ou B
  4. Affichage d’une liste de caractères et le choix
  5. Affichage d’un chiffre avec virgule avec la notion d’un ascenseur
  6. Calcul des différentes opérations
  7. Choix d’un nombre puis d’un opérateur
  8. Mémorisation des différentes opérations
  9. 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+=1

Le 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 a

B)

def fonction(a):
    a = 1
    return a

C)

def fonction():
    a = 1
    return a

D) 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 args

B)

def fonction(args):
    return args

C)

def fonction(**args):
    return args

D) 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 = 0

Flasher 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 = 0

Flasher 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 :

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

Il 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 : 1

L’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 : 2

L’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

  1. 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
  2. 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
  3. Valide ton calcul par le choix de l’opérateur « = » par un appui long sur A ou B
  4. 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 button

Flasher 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 :

  1. 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.
  2. 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.
  3. 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.
  4. 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()