Calcolatrice Python Avanzata
Calcola operazioni matematiche, statistiche e algoritmi personalizzati con questa calcolatrice Python interattiva. Ottieni risultati precisi con visualizzazione grafica.
Risultato principale
–
Dettagli calcolo
–
Codice Python generato
Guida Completa alla Creazione di una Calcolatrice in Python
Python è diventato uno dei linguaggi di programmazione più popolari per lo sviluppo di applicazioni matematiche e scientifiche grazie alla sua sintassi chiara e alle potenti librerie disponibili. In questa guida approfondita, esploreremo come creare una calcolatrice avanzata in Python, coprendo tutto dalle operazioni di base alle funzionalità scientifiche e finanziarie.
1. Fondamenti di una Calcolatrice in Python
Per creare una calcolatrice funzionale in Python, dobbiamo comprendere alcuni concetti fondamentali:
- Input utente: Come ricevere dati dall’utente (input() o interfacce grafiche)
- Operazioni matematiche: Implementazione delle operazioni di base e avanzate
- Gestione degli errori: Prevenire crash per input non validi
- Output formattato: Presentare i risultati in modo chiaro
Ecco un esempio semplice di calcolatrice per operazioni di base:
def basic_calculator():
print("Calcolatrice Python - Operazioni di base")
print("Seleziona un'operazione:")
print("1. Addizione")
print("2. Sottrazione")
print("3. Moltiplicazione")
print("4. Divisione")
choice = input("Inserisci la tua scelta (1/2/3/4): ")
num1 = float(input("Inserisci il primo numero: "))
num2 = float(input("Inserisci il secondo numero: "))
if choice == '1':
print(f"Risultato: {num1} + {num2} = {num1 + num2}")
elif choice == '2':
print(f"Risultato: {num1} - {num2} = {num1 - num2}")
elif choice == '3':
print(f"Risultato: {num1} * {num2} = {num1 * num2}")
elif choice == '4':
if num2 != 0:
print(f"Risultato: {num1} / {num2} = {num1 / num2}")
else:
print("Errore: Divisione per zero!")
else:
print("Scelta non valida")
basic_calculator()
2. Calcolatrice Scientifica Avanzata
Per implementare funzionalità scientifiche, possiamo utilizzare le seguenti librerie Python:
| Libreria | Funzionalità | Esempio di utilizzo |
|---|---|---|
| math | Funzioni matematiche di base (seno, coseno, logaritmi, etc.) | math.sin(x), math.log(x, base) |
| numpy | Operazioni su array, algebra lineare, statistiche | np.mean(data), np.linalg.inv(matrix) |
| scipy | Funzioni scientifiche avanzate (integrazione, ottimizzazione) | scipy.integrate.quad(func, a, b) |
| statistics | Statistiche descrittive e inferenziali | statistics.mean(data), statistics.stdev(data) |
Ecco un esempio di calcolatrice scientifica che utilizza queste librerie:
import math
import numpy as np
from statistics import mean, median, stdev
def scientific_calculator():
print("\nCalcolatrice Scientifica Python")
print("1. Funzioni trigonometriche")
print("2. Logaritmi")
print("3. Statistiche di base")
print("4. Operazioni su matrici")
choice = input("Seleziona un'opzione (1-4): ")
if choice == '1':
angle = float(input("Inserisci l'angolo in gradi: "))
rad = math.radians(angle)
print(f"Seno: {math.sin(rad):.4f}")
print(f"Coseno: {math.cos(rad):.4f}")
print(f"Tangente: {math.tan(rad):.4f}")
elif choice == '2':
num = float(input("Inserisci un numero positivo: "))
base = input("Inserisci la base del logaritmo (lascia vuoto per naturale): ")
if base:
print(f"Logaritmo in base {base}: {math.log(num, float(base)):.4f}")
else:
print(f"Logaritmo naturale: {math.log(num):.4f}")
elif choice == '3':
data = input("Inserisci i dati separati da virgola: ")
data_list = [float(x) for x in data.split(',')]
print(f"Media: {mean(data_list):.4f}")
print(f"Mediana: {median(data_list):.4f}")
print(f"Deviazione standard: {stdev(data_list):.4f}")
elif choice == '4':
print("Operazioni su matrici 2x2")
print("Inserisci la prima matrice (4 numeri separati da virgola):")
m1 = np.array([float(x) for x in input().split(',')]).reshape(2,2)
print("Inserisci la seconda matrice (4 numeri separati da virgola):")
m2 = np.array([float(x) for x in input().split(',')]).reshape(2,2)
print("\nScegli operazione:")
print("1. Addizione")
print("2. Moltiplicazione")
print("3. Determinante")
op = input("Seleziona (1-3): ")
if op == '1':
print("Risultato:\n", m1 + m2)
elif op == '2':
print("Risultato:\n", np.dot(m1, m2))
elif op == '3':
print(f"Determinante matrice 1: {np.linalg.det(m1):.4f}")
print(f"Determinante matrice 2: {np.linalg.det(m2):.4f}")
scientific_calculator()
3. Calcolatrice Finanziaria con Python
Python è ampiamente utilizzato nel settore finanziario per calcoli complessi. Possiamo implementare funzioni per:
- Calcolo dell’interesse composto
- Valore attuale netto (NPV)
- Tasso interno di rendimento (IRR)
- Piani di ammortamento
Esempio di calcolatrice per interesse composto:
def compound_interest_calculator():
principal = float(input("Capitale iniziale: €"))
rate = float(input("Tasso di interesse annuo (%): ")) / 100
time = float(input("Periodo (anni): "))
compounding = int(input("Frequenza capitalizzazione (1=annuale, 12=mensile): "))
amount = principal * (1 + rate/compounding) ** (compounding * time)
interest = amount - principal
print(f"\nRisultati dopo {time} anni:")
print(f"Montante finale: €{amount:,.2f}")
print(f"Interesse guadagnato: €{interest:,.2f}")
print(f"Tasso effettivo annuo: {(rate/compounding * 100):.2f}%")
# Grafico dell'accumulo nel tempo
import matplotlib.pyplot as plt
years = list(range(1, int(time)+1))
growth = [principal * (1 + rate/compounding) ** (compounding * y) for y in years]
plt.figure(figsize=(10, 6))
plt.plot(years, growth, marker='o')
plt.title("Crescita del capitale con interesse composto")
plt.xlabel("Anni")
plt.ylabel("Montante (€)")
plt.grid(True)
plt.show()
compound_interest_calculator()
4. Interfacce Grafiche per Calcolatrici Python
Per creare calcolatrici con interfaccia grafica (GUI), possiamo utilizzare:
| Libreria | Vantaggi | Esempio di codice |
|---|---|---|
| tkinter | Inclusa in Python, semplice da usare |
import tkinter as tk
root = tk.Tk()
root.title("Calcolatrice")
entry = tk.Entry(root, width=35, borderwidth=5)
entry.grid(row=0, column=0, columnspan=3, padx=10, pady=10)
# Aggiungi pulsanti...
root.mainloop()
|
| PyQt | Potente, interfacce professionali |
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton
app = QApplication([])
window = QMainWindow()
button = QPushButton("Calcola", window)
window.show()
app.exec_()
|
| Kivy | Interfacce touch, multi-piattaforma |
from kivy.app import App
from kivy.uix.button import Button
class CalcApp(App):
def build(self):
return Button(text="Calcolatrice")
CalcApp().run()
|
Esempio completo con tkinter:
import tkinter as tk
from tkinter import messagebox
import math
class CalculatorApp:
def __init__(self, root):
self.root = root
self.root.title("Calcolatrice Scientifica Python")
self.root.geometry("400x600")
self.root.resizable(False, False)
# Variabile per memorizzare l'espressione
self.expression = ""
# Frame per lo schermo
self.screen_frame = tk.Frame(root, height=100, bg="#f0f0f0")
self.screen_frame.pack(fill=tk.BOTH, expand=True)
# Schermo di output
self.screen = tk.Label(
self.screen_frame,
text="0",
anchor=tk.E,
bg="#f0f0f0",
fg="#000000",
font=("Arial", 24, "bold")
)
self.screen.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
# Frame per i pulsanti
self.button_frame = tk.Frame(root)
self.button_frame.pack(fill=tk.BOTH, expand=True)
# Pulsanti - prima riga (7,8,9,/)
self.button7 = self.create_button("7", 0, 0)
self.button8 = self.create_button("8", 0, 1)
self.button9 = self.create_button("9", 0, 2)
self.button_div = self.create_button("/", 0, 3, "#ff9500")
# Pulsanti - seconda riga (4,5,6,*)
self.button4 = self.create_button("4", 1, 0)
self.button5 = self.create_button("5", 1, 1)
self.button6 = self.create_button("6", 1, 2)
self.button_mul = self.create_button("*", 1, 3, "#ff9500")
# Pulsanti - terza riga (1,2,3,-)
self.button1 = self.create_button("1", 2, 0)
self.button2 = self.create_button("2", 2, 1)
self.button3 = self.create_button("3", 2, 2)
self.button_sub = self.create_button("-", 2, 3, "#ff9500")
# Pulsanti - quarta riga (0,.,=,+)
self.button0 = self.create_button("0", 3, 0)
self.button_dot = self.create_button(".", 3, 1)
self.button_eq = self.create_button("=", 3, 2, "#4CAF50", self.evaluate)
self.button_add = self.create_button("+", 3, 3, "#ff9500")
# Pulsanti funzioni - quinta riga
self.button_sin = self.create_button("sin", 4, 0, "#e0e0e0", lambda: self.add_function("math.sin("))
self.button_cos = self.create_button("cos", 4, 1, "#e0e0e0", lambda: self.add_function("math.cos("))
self.button_tan = self.create_button("tan", 4, 2, "#e0e0e0", lambda: self.add_function("math.tan("))
self.button_pow = self.create_button("x^y", 4, 3, "#e0e0e0", lambda: self.add_operator("**"))
# Pulsanti funzioni - sesta riga
self.button_log = self.create_button("log", 5, 0, "#e0e0e0", lambda: self.add_function("math.log10("))
self.button_ln = self.create_button("ln", 5, 1, "#e0e0e0", lambda: self.add_function("math.log("))
self.button_sqrt = self.create_button("√", 5, 2, "#e0e0e0", lambda: self.add_function("math.sqrt("))
self.button_pi = self.create_button("π", 5, 3, "#e0e0e0", lambda: self.add_constant(str(math.pi)))
# Pulsanti speciali - settima riga
self.button_clear = self.create_button("C", 6, 0, "#f44336", self.clear)
self.button_back = self.create_button("⌫", 6, 1, "#ff9800", self.backspace)
self.button_bracket_open = self.create_button("( ", 6, 2, "#e0e0e0", lambda: self.add_to_expression("("))
self.button_bracket_close = self.create_button(" )", 6, 3, "#e0e0e0", lambda: self.add_to_expression(")"))
def create_button(self, text, row, col, bg="#ffffff", command=None, width=5, height=2):
button = tk.Button(
self.button_frame,
text=text,
command=command if command else lambda: self.add_to_expression(text),
bg=bg,
fg="#000000",
font=("Arial", 16),
borderwidth=0,
width=width,
height=height
)
button.grid(row=row, column=col, padx=5, pady=5, sticky="nsew")
self.button_frame.grid_columnconfigure(col, weight=1)
return button
def add_to_expression(self, value):
self.expression += str(value)
self.screen.config(text=self.expression)
def add_operator(self, operator):
self.expression += operator
self.screen.config(text=self.expression)
def add_function(self, function):
self.expression += function
self.screen.config(text=self.expression)
def add_constant(self, constant):
self.expression += constant
self.screen.config(text=self.expression)
def clear(self):
self.expression = ""
self.screen.config(text="0")
def backspace(self):
self.expression = self.expression[:-1]
self.screen.config(text=self.expression if self.expression else "0")
def evaluate(self):
try:
# Sostituisce le funzioni con le loro implementazioni
expr = self.expression.replace("^", "**")
result = str(eval(expr))
self.screen.config(text=result)
self.expression = result
except Exception as e:
messagebox.showerror("Errore", "Espressione non valida")
self.expression = ""
self.screen.config(text="0")
if __name__ == "__main__":
root = tk.Tk()
app = CalculatorApp(root)
root.mainloop()
5. Ottimizzazione e Best Practices
Quando si sviluppa una calcolatrice in Python, è importante seguire queste best practices:
- Gestione degli errori: Utilizzare try-except per gestire input non validi e operazioni impossibili (come la divisione per zero).
- Precisione dei calcoli: Per applicazioni finanziarie, utilizzare il modulo
decimalinvece dei float per evitare errori di arrotondamento. - Modularità: Suddividere il codice in funzioni e classi per migliorare la manutenibilità.
- Testing: Implementare test unitari per verificare la correttezza dei calcoli.
- Documentazione: Aggiungere docstring e commenti per spiegare la logica dei calcoli complessi.
- Performance: Per calcoli intensivi, considerare l’uso di NumPy o la compilazione con Numba.
Esempio di implementazione con gestione degli errori avanzata:
from decimal import Decimal, getcontext
import math
class SafeCalculator:
def __init__(self, precision=10):
self.precision = precision
getcontext().prec = precision
def safe_eval(self, expression):
"""Valuta un'espressione matematica in modo sicuro"""
try:
# Sostituisce le funzioni con le loro versioni sicure
allowed_names = {
'sin': math.sin,
'cos': math.cos,
'tan': math.tan,
'sqrt': math.sqrt,
'log': math.log,
'log10': math.log10,
'pi': math.pi,
'e': math.e
}
# Usa Decimal per una precisione maggiore
if any(op in expression for op in ['+', '-', '*', '/', '**']):
# Converte i numeri in Decimal
expr = expression
for func in allowed_names:
if func in expr:
expr = expr.replace(func, f"allowed_names['{func}']")
return str(eval(expr, {"__builtins__": None}, allowed_names))
else:
return str(Decimal(str(eval(expression))))
except ZeroDivisionError:
return "Errore: Divisione per zero"
except OverflowError:
return "Errore: Risultato troppo grande"
except Exception as e:
return f"Errore: {str(e)}"
def calculate(self, num1, num2, operation):
"""Esegue un'operazione tra due numeri con gestione degli errori"""
try:
n1 = Decimal(str(num1))
n2 = Decimal(str(num2))
if operation == '+':
return float(n1 + n2)
elif operation == '-':
return float(n1 - n2)
elif operation == '*':
return float(n1 * n2)
elif operation == '/':
if n2 == 0:
raise ZeroDivisionError("Divisione per zero")
return float(n1 / n2)
elif operation == '**':
return float(n1 ** n2)
else:
raise ValueError("Operazione non supportata")
except Exception as e:
raise ValueError(f"Errore nel calcolo: {str(e)}")
# Esempio di utilizzo
calc = SafeCalculator(precision=20)
print(calc.safe_eval("2 + 3 * (4 - 1)")) # 11
print(calc.safe_eval("sin(pi/2)")) # 1.0
print(calc.calculate(10, 3, '/')) # 3.333...
print(calc.safe_eval("1/0")) # Errore: Divisione per zero
6. Integrazione con Librerie Esterne
Per estendere le funzionalità della tua calcolatrice Python, puoi integrare varie librerie:
- SymPy: Per calcoli simbolici e algebra avanzata
- Pandas: Per operazioni su dataset e serie temporali
- SciPy: Per funzioni scientifiche avanzate come integrazione numerica
- Matplotlib/Seaborn: Per la visualizzazione grafica dei risultati
- Request: Per recuperare dati in tempo reale (es. tassi di cambio)
Esempio con SymPy per calcoli simbolici:
from sympy import symbols, Eq, solve, diff, integrate, sin, cos
class SymbolicCalculator:
@staticmethod
def solve_equation(equation_str, variable='x'):
"""Risolvi un'equazione simbolica"""
try:
x = symbols(variable)
eq = Eq(eval(equation_str.split('=')[0]), eval(equation_str.split('=')[1]))
solutions = solve(eq, x)
return {variable: solutions}
except Exception as e:
return f"Errore: {str(e)}"
@staticmethod
def derivative(function_str, variable='x'):
"""Calcola la derivata di una funzione"""
try:
x = symbols(variable)
f = eval(function_str)
return diff(f, x)
except Exception as e:
return f"Errore: {str(e)}"
@staticmethod
def integral(function_str, variable='x'):
"""Calcola l'integrale di una funzione"""
try:
x = symbols(variable)
f = eval(function_str)
return integrate(f, x)
except Exception as e:
return f"Errore: {str(e)}"
# Esempi di utilizzo
print(SymbolicCalculator.solve_equation("x**2 - 4 = 0")) # [{x: [-2, 2]}]
print(SymbolicCalculator.derivative("x**2 + 3*x + 2")) # 2*x + 3
print(SymbolicCalculator.integral("sin(x)")) # -cos(x)
7. Distribuzione della tua Calcolatrice Python
Una volta sviluppata la tua calcolatrice, puoi distribuirla in vari modi:
- Script standalone: Semplicemente condividere il file .py
- Eseguibile: Usare PyInstaller per creare un .exe (Windows) o app (macOS)
- Web App: Convertire in applicazione web con Flask/Django o Brython
- Mobile App: Usare Kivy o BeeWare per creare app mobile
- Package Python: Pubblicare su PyPI per installazione via pip
Esempio di conversione in eseguibile con PyInstaller:
# Installa PyInstaller
pip install pyinstaller
# Crea l'eseguibile (da terminale)
pyinstaller --onefile --windowed calculator.py
# Opzioni comuni:
# --onefile: Crea un singolo file eseguibile
# --windowed: Nasconde la console (per app GUI)
# --icon=app.ico: Aggiunge un'icona personalizzata
# --add-data="data/*;data": Include file aggiuntivi
Per distribuire come package Python:
# Struttura del progetto
my_calculator/
├── my_calculator/
│ ├── __init__.py
│ ├── basic.py
│ ├── scientific.py
│ └── financial.py
├── tests/
├── setup.py
└── README.md
# Contenuto di setup.py
from setuptools import setup, find_packages
setup(
name="my_python_calculator",
version="0.1",
packages=find_packages(),
install_requires=[
'numpy>=1.20.0',
'scipy>=1.7.0',
],
entry_points={
'console_scripts': [
'mycalc=my_calculator.cli:main',
],
},
author="Tuo Nome",
description="Una calcolatrice avanzata in Python",
license="MIT",
keywords="calcolatrice python matematica finanza",
)
# Pubblicazione su PyPI
pip install twine
python setup.py sdist bdist_wheel
twine upload dist/*
8. Esempi Pratici e Casi d’Uso
Ecco alcuni esempi pratici di calcolatrici Python per diversi settori:
8.1 Calcolatrice per Ingegneri Civili
def concrete_calculator():
"""Calcola la quantità di calcestruzzo necessaria"""
length = float(input("Lunghezza (m): "))
width = float(input("Larghezza (m): "))
thickness = float(input("Spessore (m): "))
volume = length * width * thickness
bags = volume * 1.1 # 10% in più per scarto
print(f"\nVolume necessario: {volume:.2f} m³")
print(f"Sacchi di cemento (25kg): {bags/0.01:.0f}") # ~0.01 m³ per sacco
concrete_calculator()
8.2 Calcolatrice per Nutrizionisti
def bmi_calculator():
"""Calcola l'indice di massa corporea (BMI)"""
weight = float(input("Peso (kg): "))
height = float(input("Altezza (m): "))
bmi = weight / (height ** 2)
print(f"\nIl tuo BMI è: {bmi:.1f}")
if bmi < 18.5:
print("Classificazione: Sottopeso")
elif 18.5 <= bmi < 25:
print("Classificazione: Normale")
elif 25 <= bmi < 30:
print("Classificazione: Sovrappeso")
else:
print("Classificazione: Obeso")
bmi_calculator()
8.3 Calcolatrice per Fisici
import math
def physics_calculator():
"""Calcoli fisici comuni"""
print("Seleziona un calcolo:")
print("1. Energia cinetica")
print("2. Legge di Ohm")
print("3. Caduta libera")
choice = input("Scelta (1-3): ")
if choice == '1':
mass = float(input("Massa (kg): "))
velocity = float(input("Velocità (m/s): "))
ke = 0.5 * mass * velocity**2
print(f"Energia cinetica: {ke:.2f} J")
elif choice == '2':
voltage = float(input("Tensione (V): "))
resistance = float(input("Resistenza (Ω): "))
current = voltage / resistance
print(f"Corrente: {current:.2f} A")
elif choice == '3':
height = float(input("Altezza (m): "))
time = math.sqrt(2 * height / 9.81)
velocity = 9.81 * time
print(f"Tempo di caduta: {time:.2f} s")
print(f"Velocità finale: {velocity:.2f} m/s")
physics_calculator()
9. Errori Comuni e Come Evitarli
Durante lo sviluppo di una calcolatrice in Python, è facile incorrere in alcuni errori comuni:
| Errore | Causa | Soluzione |
|---|---|---|
| Divisione per zero | Tentativo di divisione per zero | Controllare sempre che il divisore non sia zero |
| Errori di precisione con float | Rappresentazione binaria dei numeri decimali | Usare il modulo decimal o fractions |
| Input non validi | L'utente inserisce testo invece di numeri | Usare try-except e validazione dell'input |
| Overflow | Risultati troppo grandi per essere rappresentati | Usare librerie per numeri arbitrariamente grandi |
| Errori di sintassi in espressioni | Parentesi non bilanciate o operatori mancanti | Implementare un parser o usare eval con cautela |
| Problemi di prestazioni | Calcoli complessi eseguiti in modo non ottimizzato | Usare NumPy per operazioni vettorializzate |
Esempio di gestione robusta degli errori:
def robust_calculator():
"""Calcolatrice con gestione completa degli errori"""
while True:
try:
print("\nCalcolatrice Robusta")
print("1. Addizione")
print("2. Sottrazione")
print("3. Moltiplicazione")
print("4. Divisione")
print("5. Potenza")
print("6. Radice quadrata")
print("7. Esci")
choice = input("Seleziona un'operazione (1-7): ")
if choice == '7':
print("Uscita...")
break
if choice in ('1', '2', '3', '4', '5'):
try:
num1 = float(input("Primo numero: "))
num2 = float(input("Secondo numero: "))
except ValueError:
print("Errore: Inserisci numeri validi!")
continue
if choice == '1':
print(f"Risultato: {num1 + num2}")
elif choice == '2':
print(f"Risultato: {num1 - num2}")
elif choice == '3':
print(f"Risultato: {num1 * num2}")
elif choice == '4':
if num2 == 0:
print("Errore: Divisione per zero!")
else:
print(f"Risultato: {num1 / num2}")
elif choice == '5':
print(f"Risultato: {num1 ** num2}")
elif choice == '6':
try:
num = float(input("Numero: "))
if num < 0:
print("Errore: Radice di numero negativo!")
else:
print(f"Risultato: {math.sqrt(num)}")
except ValueError:
print("Errore: Inserisci un numero valido!")
else:
print("Scelta non valida. Riprova.")
except KeyboardInterrupt:
print("\nOperazione interrotta dall'utente.")
break
except Exception as e:
print(f"Si è verificato un errore inatteso: {str(e)}")
robust_calculator()
10. Tendenze Future e Sviluppi
Il campo delle calcolatrici in Python sta evolvendo rapidamente con diverse tendenze interessanti:
- Intelligenza Artificiale: Integrazione di modelli di machine learning per suggerire calcoli o rilevare errori
- Cloud Computing: Esecuzione di calcoli complessi su server remoti
- Interfacce Vocali: Controllo tramite comandi vocali
- Realtà Aumentata: Visualizzazione 3D di risultati matematici
- Blockchain: Calcolatrici per operazioni crittografiche
- Quantum Computing: Utilizzo di librerie per calcoli quantistici (es. Qiskit)
Esempio di calcolatrice con suggerimenti basati su IA (usando una libreria semplice):
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
class SmartCalculator:
def __init__(self):
# Database di operazioni comuni
self.operations = {
"area cerchio": "math.pi * r ** 2",
"volume sfera": "(4/3) * math.pi * r ** 3",
"interesse semplice": "p * r * t / 100",
"interesse composto": "p * (1 + r/n) ** (n*t)",
"ipotenusa": "math.sqrt(a**2 + b**2)",
"perimetro cerchio": "2 * math.pi * r",
"media": "sum(numbers) / len(numbers)"
}
# Prepara il modello per i suggerimenti
self.vectorizer = TfidfVectorizer()
self.corpus = list(self.operations.keys())
self.tfidf_matrix = self.vectorizer.fit_transform(self.corpus)
def suggest_operation(self, query):
"""Suggerisce operazioni simili alla query dell'utente"""
query_vec = self.vectorizer.transform([query])
similarities = cosine_similarity(query_vec, self.tfidf_matrix)
best_match_idx = similarities.argmax()
return list(self.operations.keys())[best_match_idx]
def calculate(self, operation_name, **params):
"""Esegue un'operazione con i parametri forniti"""
try:
expr = self.operations.get(operation_name.lower())
if not expr:
# Prova a trovare l'operazione più simile
suggested = self.suggest_operation(operation_name)
print(f"Operazione non trovata. Intendevi '{suggested}'?")
expr = self.operations.get(suggested.lower())
if not expr:
return "Operazione non riconosciuta"
# Sostituisce i parametri nell'espressione
for key, value in params.items():
expr = expr.replace(key, str(value))
# Valuta l'espressione in modo sicuro
allowed_names = {'math': math}
result = eval(expr, {"__builtins__": None}, allowed_names)
return result
except Exception as e:
return f"Errore nel calcolo: {str(e)}"
# Esempio di utilizzo
calc = SmartCalculator()
# Calcolo diretto
print(calc.calculate("area cerchio", r=5)) # ~78.54
# Con suggerimento automatico
print(calc.calculate("area del cerchio", r=5)) # Suggerirà "area cerchio"
# Con parametri sbagliati
print(calc.calculate("volume sfera", r=3)) # ~113.10
Conclusione
Sviluppare una calcolatrice in Python offre infinite possibilità, dalle semplici operazioni aritmetiche a complessi calcoli scientifici e finanziari. Questa guida ha coperto i fondamenti e le tecniche avanzate per creare strumenti di calcolo potenti e flessibili.
Ricorda che:
- La chiarezza del codice è fondamentale per la manutenibilità
- La gestione degli errori è cruciale per un'esperienza utente positiva
- Le librerie esterne possono estendere notevolmente le funzionalità
- L'interfaccia utente deve essere intuitiva e responsive
- Il testing è essenziale per garantire l'accuratezza dei calcoli
Con Python e le sue potenti librerie, puoi creare calcolatrici specializzate per qualsiasi dominio - dalla fisica alla finanza, dall'ingegneria alla biologia. Inizia con progetti semplici e gradualmente aggiungi funzionalità più complesse man mano che acquisisci esperienza.
Per continuare il tuo percorso di apprendimento, considera di:
- Esplorare le librerie scientifiche Python (NumPy, SciPy, Pandas)
- Sperimentare con interfacce grafiche (Tkinter, PyQt, Kivy)
- Contribuire a progetti open source di calcolatrici su GitHub
- Creare calcolatrici specializzate per il tuo campo di studio/lavoro
- Implementare funzionalità di machine learning per suggerimenti intelligenti