Il programma EHFgeo è un calcolatore di geometria scritto in Python.
Prima di scrivere il codice vediamo di strutturarlo:
- Importazione delle librerie: math per eseguire calcoli matematici, time per gestire il ritardo tra le animazioni, sys per gestire l'output, e os per ottenere la larghezza del terminale.
- Introduzione del programma.
- Lista calcoli.
- Loop principale, un while True dove ci si assicura che l'utente possa eseguire sempre calcoli.
- Funzione calcolo_geometrico(): fa il calcolo vero e proprio che un utente imposta e restituisce il risultato.
- arrotondamento(): che permette la scelta delle cifre decimali a cui arrotondare il risultato.
- storico_calcoli(): per la cronologia delle operazioni.
- Risposta dell'utente e ripetizione: dove si chiede all'utente se terminare o continuare con altre operazioni.
- Stop del programma.
La funzione di animazione del testo l'ho trovata in questo video YouTube.
Analizziamo in dettaglio la parte delle operazioni facendo anche qualche confronto, in particolare:
Area del Cerchio (1):
Formula: A = π * r2
Confronto Python: return (math.pi * (radius)**2)
Circonferenza del Cerchio (2):
Formula: C = 2 * π * r
Confronto Python: return (2 * math.pi * radius)
Area del Settore Circolare (3):
Formula: A = (θ / 360) * π * r2
Confronto Python: return ((angle / 360) * math.pi * (radius)**2)
Lunghezza dell'Arco (4):
Formula: L = (θ / 360) * (2 * π * r)
Confronto Python: return ((angle / 360) * (2 * math.pi * radius))
Area del Segmento Circolare (5):
Formula: A = [(θ / 360) * π * r2] - [(1/2) * sin(θ) * r2]
Confronto Python: return (((angle / 360) * math.pi * (radius)2) - ((1 / 2) * math.sin(math.radians(angle)) * (radius)2))
Volume della Sfera (6):
Formula: V = (4/3) * π * r3
Confronto Python: return (4 / 3 * math.pi * (radius)**3)
Area Superficiale della Sfera (7):
Formula: A = 4 * π * r2
Confronto Python: return (4 * math.pi * (radius)**2)
Volume del Cono (8):
Formula: V = (1/3) * π * r2 * h
Confronto Python: return (1 / 3 * math.pi * (radius)**2 * v_height)
Volume del Prisma (9):
Formula: V = area_base * l
Confronto Python: return (cross_section * length)
Area Superficiale del Cono (10):
Formula: A = (π * r * s) + (π * r2)
Confronto Python: return ((math.pi * radius * slant_height) + (math.pi * (radius)**2))
Regola del Coseno per Angolo (11):
Formula: A = arccos((AB2 + AC2 - BC2) / (2 * AB * AC))
Confronto Python: return (math.degrees(math.acos(fraction)))
Regola del Coseno per Lato (12):
Formula: lato_mancante = √(AB2 + AC2 - 2 * AB * AC * cos(A))
Confronto Python: return (math.sqrt(answer))
Regola del Seno per Angolo (13):
Formula: A = arcsin((sin(θ) / y) * z)
Confronto Python: return (b)
Codice:
import math
import time
import sys
import os
# Librerie
size = os.get_terminal_size().columns
history = []
warning = "Prima di inserire i valori, ETICHETTA correttamente il triangolo con la lettera A come angolo!"
count = 0
calcoli = [
"1) Area Cerchio", "2) Circonferenza Cerchio", "3) Area Settore Circolare",
"4) Lunghezza Arco", "5) Area Segmento Circolare", "6) Volume Sfera",
"7) Area Superficiale Sfera", "8) Volume Cono", "9) Volume Prisma",
"10) Area Superficiale Cono", "11) Regola del Coseno per Angolo", "12) Regola del Coseno per Lato",
"13) Regola del Seno per Angolo", "14) Regola del Seno per Lato (WIP)"
]
def anima_testo(testo, ritardo):
for char in str(testo):
sys.stdout.write(char)
sys.stdout.flush()
time.sleep(ritardo)
print()
def separatore(stile):
if stile == stile:
print(stile * size)
anima_testo("Avvio del Calcolatore di Geometria...", 0.2)
anima_testo("\nBenvenuto nel mio Calcolatore di Geometria!", 0.05)
separatore("-")
while count <= len(calcoli):
for calcolo in calcoli:
count += 1
time.sleep(0.75)
print(calcolo)
break
separatore("-")
while True:
time.sleep(1.5)
def calcolo_geometrico():
anima_testo("Digita il numero corrispondente al calcolo che desideri eseguire: ", 0.02)
scelta = str(input())
if scelta == "1":
# Area Cerchio
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
return (math.pi * (raggio)**2)
elif scelta == "2":
# Circonferenza Cerchio
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
return (2 * math.pi * raggio)
elif scelta == "3":
# Area Settore Circolare
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
anima_testo("Inserisci l'angolo: ", 0.05)
angolo = float(input())
return ((angolo / 360) * math.pi * (raggio)**2)
elif scelta == "4":
# Lunghezza Arco
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
anima_testo("Inserisci l'angolo: ", 0.05)
angolo = float(input())
return ((angolo / 360) * (2 * math.pi * raggio))
elif scelta == "5":
# Area Segmento Circolare
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
anima_testo("Inserisci l'angolo: ", 0.05)
angolo = float(input())
return (((angolo / 360) * math.pi * (raggio)**2) - ((1 / 2) * math.sin(math.radians(angolo)) * (raggio)**2))
elif scelta == "6":
# Volume Sfera
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
return (4 / 3 * math.pi * (raggio)**3)
elif scelta == "7":
# Area Superficiale Sfera
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
return (4 * math.pi * (raggio)**2)
elif scelta == "8":
# Volume Cono
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
anima_testo("Inserisci l'altezza verticale: ", 0.05)
altezza_verticale = float(input())
return (1 / 3 * math.pi * (raggio)**3 * altezza_verticale)
elif scelta == "9":
# Volume Prisma
anima_testo("Inserisci la lunghezza: ", 0.05)
lunghezza = float(input())
anima_testo("Inserisci l'area della sezione trasversale: ", 0.05)
area_sezione = float(input())
return (area_sezione * lunghezza)
elif scelta == "10":
# Area Superficiale Cono
anima_testo("Inserisci il raggio: ", 0.05)
raggio = float(input())
anima_testo("Inserisci l'altezza laterale: ", 0.05)
altezza_laterale = float(input())
return ((math.pi * raggio * altezza_laterale) + (math.pi * (raggio)**2))
elif scelta == "11":
# Regola del Coseno per Angolo
anima_testo("Inserisci il lato AB: ", 0.05)
AB = float(input())
anima_testo("Inserisci il lato BC: ", 0.05)
BC = float(input())
anima_testo("Inserisci il lato AC: ", 0.05)
AC = float(input())
anima_testo("Inserisci l'angolo mancante (A, B o C): ", 0.05)
angolo_mancante = str(input()).upper()
somma_quadrati = {"A": AB**2 + AC**2, "B": AB**2 + BC**2, "C": BC**2 + AC**2}
quadrato_lato_opp = {"A": BC**2, "B": AC**2, "C": AB**2}
denominatore_somma = {"A": 2 * AB * AC, "B": 2 * BC * AB, "C": 2 * AC * BC}
fraction = (somma_quadrati[angolo_mancante] - quadrato_lato_opp[angolo_mancante]) / denominatore_somma[angolo_mancante]
return (math.degrees(math.acos(fraction)))
elif scelta == "12":
# Regola del Coseno per Lato
separatore("-")
print(warning)
separatore("-")
anima_testo("Inserisci il lato AB: ", 0.05)
AB = float(input())
anima_testo("Inserisci il lato AC: ", 0.05)
AC = float(input())
anima_testo("Inserisci l'angolo A: ", 0.05)
angolo_A = math.radians(float(input()))
lato_mancante = "A"
somma_quadrati = {"A": AB**2 + AC**2}
somma_lato_opp = {"A": 2 * AB * AC * math.cos(angolo_A)}
risposta = somma_quadrati[lato_mancante] - somma_lato_opp[lato_mancante]
return (math.sqrt(risposta))
elif scelta == "13":
# Regola del Seno per Angolo
anima_testo("Inserisci l'angolo NOTO in gradi: ", 0.05)
x = float(input())
if x > 180 or x < 0:
return "Errore: L'angolo deve essere compreso tra 0 e 180 gradi."
anima_testo("Lunghezza del lato opposto all'angolo NOTO: ", 0.05)
y = float(input())
anima_testo("Lunghezza del lato opposto all'angolo SCONOSCIUTO: ", 0.05)
z = float(input())
a = (math.sin(math.radians(x)) / y) * z
b = math.degrees(math.asin(a))
return b
else:
return "Errore: Scelta non valida."
def arrotondamento(risultato_calcolo):
if isinstance(risultato_calcolo, (int, float)):
anima_testo("Vuoi arrotondare la risposta (S/N): ", 0.05)
risposta_arrotondamento = str(input()).upper()
if risposta_arrotondamento == "S":
anima_testo("Inserisci il numero di cifre decimali a cui vuoi arrotondare: ", 0.05)
cifre_decimali = int(input())
risposta_arrotondata = round(risultato_calcolo, cifre_decimali)
anima_testo(f"\nLa tua risposta è: {str(risposta_arrotondata)}", 0.05)
history.append(risposta_arrotondata)
elif risposta_arrotondamento == "N":
anima_testo(f"\nLa tua risposta è: {risultato_calcolo}", 0.05)
history.append(risultato_calcolo)
else:
anima_testo("Errore Rilevato!", 0.05)
pass
else:
anima_testo(f"\n{risultato_calcolo}", 0.05)
def storico_calcoli():
anima_testo("\nVuoi visualizzare la cronologia dei tuoi calcoli (S/N): ", 0.05)
controllo_storico = str(input()).upper()
if controllo_storico == "S":
anima_testo(str(history), 0.02)
elif controllo_storico == "N":
pass
else:
anima_testo("\nErrore Rilevato!", 0.05)
pass
arrotondamento(calcolo_geometrico())
storico_calcoli()
anima_testo("\nVuoi ripetere il programma? (S/N)", 0.05)
ripeti = input().upper()
separatore("~")
if ripeti.upper() != 'S':
anima_testo("\nIl Calcolatore di Geometria è stato interrotto...", 0.2)
break
Il codice potete provarlo online qui!
Chiaramente era molto più comodo da fare su Excel ma perché no?😁
