Quiz sulle frazioni

Sommario

Abbiamo scritto il nostro primo programma Python e siamo diventati maestri nelle frazioni. A proposito, abbiamo anche imparato come è strutturato un programma Python e come possiamo controllare i processi nel programma.
Nel primo capitolo abbiamo imparato a cosa servono le variabili, quali tipi possono avere e come possiamo generare numeri casuali. Abbiamo anche imparato come estendere Python con l’aiuto del comando import per poter utilizzare funzioni aggiuntive.

Frazioni

Le frazioni sono ancora oggi considerate molto impopolari. Non è così difficile e facile imparare e allenarsi con il quiz sulle frazioni che svilupperemo.
Le frazioni sono costituite da un numero superiore, chiamato numeratore, e da un numero inferiore, il denominatore. La frazione è rappresentata nella forma a/b, dove a è il numeratore e b è il denominatore.
Al fine di anticipare le fratture, ci sono varie operazioni che possono essere eseguite. Ecco alcuni concetti di base:
Addizione e sottrazione di frazioni: per sommare o sottrarre frazioni con lo stesso denominatore, si sommano o sottraggono i numeratori e si mantiene invariato il denominatore. Ad esempio: 1/4 + 3/4 = 4/4 = 1. Se i denominatori sono diversi, devono prima essere portati al minimo comune denominatore (rapporto P/E).
Moltiplicazione delle frazioni: per moltiplicare le frazioni, si moltiplicano i numeratori tra loro e i denominatori tra loro. Il risultato viene quindi visualizzato come frazione. Ad esempio: (2/3) * (3/5) = 6/15 = 2/5.
Divisione delle frazioni: per dividere le frazioni, invertire la seconda frazione (il divisore) e moltiplicarla per la prima frazione (il dividendo). Il risultato è rappresentato come una frazione. Ad esempio: (2/3) / (3/5) = (2/3) * (5/3) = 10/9.
Accorciamento delle frazioni: una frazione può essere accorciata dividendo sia il numeratore che il denominatore per lo stesso divisore. Si divide per il massimo comun divisore (GCD) fino a quando non è possibile un’ulteriore divisione. Ad esempio: 8/12 può essere abbreviato dividendo il numeratore e il denominatore per 4 e dà 2/3.

Ora trasformeremo tutte queste operazioni in un programma di quiz con l’aiuto di Python.

Nel primo programma, abbiamo appena scritto tutto nella funzione principale. Questo è anche utile per iniziare. Tuttavia, se diamo un’occhiata più da vicino al programma, vediamo che in realtà consiste di diverse parti. Abbiamo una parte che determina i numeri, una parte che determina l’operazione e una parte che esegue l’input e la verifica.
Se dividiamo un programma in tali parti, sarà più chiaro e più facile da leggere. Ci sono funzioni per questo scopo. Una funzione è un blocco di codice riutilizzabile che esegue un’attività specifica. È un concetto fondamentale nella programmazione che aiuta a organizzare e modularizzare il codice suddividendolo in unità più piccole e autonome. Le funzioni rendono il codice più leggibile, gestibile ed efficiente.

Per definire una funzione in Python, di solito si usa la parola chiave def, seguita dal nome della funzione, dalle parentesi per i parametri opzionali e dai due punti.
Ecco una sintassi di base per definire una funzione:

def function_name(parameter1, parameter2, …):

# code statements
# return statement (optional)

Ora diamo un’occhiata ai componenti di una funzione:

function_name: Questo è il nome che si dà alla funzione, che segue le stesse convenzioni di denominazione dei nomi delle variabili.

Parametro:
Si tratta di segnaposto facoltativi che rappresentano i valori che si desidera vengano ricevuti dalla funzione quando viene chiamata. I parametri ci consentono di passare i dati alla funzione. Le funzioni non possono avere più parametri separati da virgole.

Istruzioni del codice:
Queste sono le dichiarazioni o le azioni effettive eseguite dalla funzione. Può essere qualsiasi codice Python valido, incluse le strutture di controllo (istruzioni if, loop, ecc.), le assegnazioni di variabili e le chiamate di funzione. Tuttavia, è importante che il codice appartenente alla funzione sia rientrato.

return statement: si tratta di un’istruzione facoltativa che specifica il valore che deve essere restituito dalla funzione. Utilizzando la parola chiave return seguita da un’espressione, la funzione può inviare un risultato al chiamante. Se l’istruzione return non viene utilizzata, la funzione restituisce None per impostazione predefinita.
Ecco un esempio di una semplice funzione che calcola la somma di due numeri e restituisce il risultato:

def add_numbers(a, b):
sum = a + b
return sum

E la chiamata

result = add_numbers(5, 3)
print(result) # Ausgabe: 8

Questa chiamata deve sempre avvenire dopo la funzione. Quindi prima la funzione, poi la chiamata.

Quindi torniamo al nostro programma delle frazioni:

In Python c’è una libreria chiamata fractions, che importiamo volte e anche la nostra libreria casuale.

import random
from fractions import Fraction

La libreria di frazioni in Python fornisce un insieme di classi e funzioni per lavorare con numeri razionali (frazioni). I numeri razionali sono numeri che possono essere espressi come il rapporto di due interi, come 1/2 o 3/4.

Per rendere il codice più bello, vogliamo usare le funzioni. Per il nostro quiz sulle frazioni abbiamo bisogno di una funzione che generi una frazione per noi. Per non renderlo troppo difficile, vogliamo frazioni da 1 a 10.
Quindi la nostra prima funzione fa una pausa casuale:

def bruch():
    zaehler = random.randint(1, 10)
    nenner = random.randint(zaehler + 1, 10)
    zufallBruch = Fraction(zaehler, nenner)
    return zufallBruch

Prima generiamo il numeratore, poi il denominatore. Da entrambi i numeri facciamo una variabile di tipo Frazione, questo viene fatto nella linea:

zufallBruch = Fraction(zaehler, nenner)

Restituiamo anche questa pausa!

Se guardiamo il nostro primo programma, possiamo anche estrarre un’altra funzione dalla nostra fonte. L’esame del risultato.
Quindi di cosa abbiamo bisogno per scrivere la funzione. Una volta le due frazioni e l’operatore matematico con cui vogliamo calcolare il risultato.

def antwort_berechnen(fraction1, fraction2, operator):
    if operator == '+':
       result = fraction1 + fraction2
    elif operator == '-':
         result = fraction1 - fraction2
    elif operator == '*':
         result = fraction1 * fraction2
    elif operator == '/':
          result = fraction1 / fraction2
    else:
       raise ValueError("Falsche Operation")

    decimal_answer = result.numerator / result.denominator
    return decimal_answer, result

Diamo un’occhiata più da vicino a questa funzione, in quanto contiene due interessanti pezzi di codice che sono nuovi per noi.
Da un lato, generare ValueError(„Operazione errata“).
L’istruzione raise ValueError („Operazione errata“) in Python genera un’eccezione di tipo ValueError e restituisce il messaggio di errore specificato „Operazione errata“.
L’eccezione ValueError viene in genere utilizzata quando un valore non è valido o imprevisto. La generazione di questa eccezione indica che è stata eseguita un’operazione errata o che è presente un valore non valido.
Ciò significa anche che, se, come nel nostro caso, l’operatore variabile contiene, ad esempio, „?“, il righe raise ValueError interrompe l’elaborazione e ritorna alla funzione chiamante. Se non viene „catturato“ lì, l’applicazione verrà terminata. Ma come si fa a „catturare“ un’eccezione. Questo è in realtà abbastanza semplice, c’è il costrutto try / except . Questo costrutto può essere utilizzato per gestire le eccezioni.
Per esempio:

def divide(a, b):
     if b == 0:
     raise ValueError("Falsche Operation: Division durch Null ist nicht erlaubt.")
     return a / b

try:
    result = divide(10, 0)
    print(result)
except ValueError as error:
    print("Ein Fehler ist aufgetreten:", error)

Qui viene eseguita la funzione di divisione. Poiché la divisione per 0 non funziona, abbiamo creato un’eccezione ValueError nella funzione.
Prima di chiamare la funzione, scriviamo try: tutto ciò che vogliamo provare, indentiamo di nuovo.
Dopo i comandi, scriviamo except e l’eccezione che vogliamo gestire. Quindi indentato di nuovo cosa dovrebbe accadere – nel caso sopra diamo un messaggio di errore.
La seconda stranezza è che restituiamo due variabili in questa funzione. Questo ha così, la sua correttezza in Python è che è possibile. Questo è quindi chiamato così:
user_antwort_decimal, user_antwort_fraction = antwort_berechnen(frazione1; frazione2; operatore)
Ma attenzione, l’ordine dei valori restituiti deve essere uguale a quello previsto.
Ora possiamo tornare al nostro programma e iniziare con la funzione principale effettiva:
def main():

È sempre bello fare un regalo di benvenuto.

print("Willkommen beim Bruchrechnen!")

Successivamente, definiamo una variabile in cui memorizziamo le risposte corrette e quante domande vogliamo fare.

score = 0
num_Frage = 5

Inoltre, abbiamo bisogno di una variabile in cui memorizzare tutti i possibili operatori. In Python c’è la possibilità di dichiarare i cosiddetti array.
Gli array non sono altro che una raccolta di dati dello stesso tipo. Quindi può contenere stringhe, numeri, ecc.
Con questa conoscenza, ora possiamo dichiarare un array di tutti gli operatori.

operators = ['+', '-', '*', '/']

Successivamente, abbiamo bisogno di un ciclo For che ponga tutte le domande definite nel num_Frage.

for _ in range(num_Frage):

Ora diamo un’occhiata più da vicino:
for: la parola chiave „for“ avvia la costruzione di un ciclo e indica che è in esecuzione un ciclo.

Il simbolo di sottolineatura (_) viene spesso utilizzato come variabile con caratteri jolly quando il valore di una variabile nel ciclo non è necessario. In questo caso, viene utilizzato per indicare che il valore del passaggio non viene utilizzato e può essere ignorato.

in: la parola chiave „in“ viene utilizzata per specificare l’intervallo o l’iterabilità su cui il ciclo deve scorrere.

range(num_Frage): La funzione range() produce una sequenza di numeri che vanno da 0 a num_Frage – 1. L’argomento è il numero di ripetizioni che il ciclo dovrebbe attraversare. Ad esempio, intervallo(5) produce i numeri 0, 1, 2, 3 e 4.

Ora ci trasferiamo di nuovo e scriviamo il nostro quiz. Innanzitutto, determiniamo le due frazioni che vogliamo calcolare. Questo è ciò per cui abbiamo scritto una funzione.

fraction1 = bruch()
  fraction2 = bruch()

Quindi ora abbiamo bisogno di un operatore per la nostra domanda. Lo facciamo con il seguente comando:

operator = random.choice(operators)

Sappiamo già casuale, la scelta è ora una funzione che seleziona casualmente un valore da una lista. Nel nostro esempio, random.choice seleziona un operatore dalla matrice di operatori.

Cosa manca: chiedi all’utente.
Quindi produciamo la domanda, lo facciamo con il comando di stampa.

print(f"Was ergibt {fraction1} {operator} {fraction2}?")

L’istruzione print(f „What yields?“) in Python usa f-strings {Fraktion1} {Operator} {Fraktion2}(stringhe formattate) per formattare e visualizzare dinamicamente una stringa di variabili e altri valori.
Per illustrare questo:
Supponiamo che frazione1 sia 1/2, l’operatore sia + e frazione2 sia 1/2. Nel caso precedente, il comando precedente sarebbe „Che cos’è 1/2 + 1/2?“. Senza la f davanti al “ il comando precedente produrrebbe „What yields {fraction1} {operator} {fraction2}?“. La f rende la nostra vita più facile e rende anche il codice più facile da leggere.
Successivamente, stiamo aspettando l’input dell’utente. L’input, come già sappiamo dal primo programma, è una stringa e non di tipo frazione.
Abbiamo quindi bisogno di convertire l’input dell’utente. Per fare ciò, creiamo una funzione separata

def parse_fraction(fraction_str):
    try:
       fraction = Fraction(fraction_str)
       return fraction
    except ValueError:
        return None

In questa funzione, usiamo il Prova usato in precedenza per verificare se l’input era una frazione. La frazione di riga = Fraction(fraction_str), genera un’eccezione se la stringa non può essere riconosciuta come frazione.
Se non è un input valido, la funzione restituisce None. Nessuno è nient’altro che niente, nullo e viene utilizzato anche quando il programmatore vuole che il risultato sia fermo o non definito.
Ora torniamo al programma:

user_input = input("Deine Antwort: ")
user_fraction = parse_fraction(user_input)
if user_fraction is not None:
    user_antwort_decimal, user_antwort_fraction = antwort_berechnen(fraction1, fraction2, operator)
    if user_fraction == user_antwort_fraction:
       print("Super! Richtig!")
       score += 1
    else:
        print(f"Falsch! Die richtige Antwort ist {user_antwort_decimal} oder {user_antwort_fraction}.")
else:
print("Ungueltige Eingabe. Bitte geben Sie eine gueltige Bruch- oder Dezimalzahl ein.")

Questa è ora la nostra parte centrale del nostro programma.
Innanzitutto, attendiamo che l’utente entri.
Ora cerchiamo di trasformare questo input in una frazione con la nostra funzione che abbiamo appena scritto. Ora, se l’utente ha effettuato un input valido, cioè il risultato non è Nessuno, possiamo controllare il risultato:

user_antwort_decimal, user_antwort_fraction = antwort_berechnen(fraction1, fraction2, operator)

È qui che applichiamo il nostro antwort_berechnen. Va notato qui che i due valori restituiti, i valori restituiti della funzione corrispondono a come promemoria: return decimal_answer, result .

Ora tutto ciò che dobbiamo fare è confrontare la domanda con la risposta e produrre il risultato!
Pronto!
Non è stato così difficile. È possibile scaricare l’intero programma su: gpiwonka/Fractions (github.com).