Scrierea celui mai simplu calculator în Python 3

Plasarea serverelor în centre de date fiabile din Europa. Deschideți serverul VPS / VDS bazat pe cloud pe SSD-uri rapide în 1 minut!

Cel mai bun Gazduire:
- protejează datele de accesul nedorit într-un centru de date european protejat






- va accepta plata cel puțin în taxe.
- vă va permite să vă distribuiți distribuția

- protecția împotriva atacurilor DDos
- copie de rezervă gratuită
- Uptime 99.9999%
- Centrul de date - TIER III
- furnizor - TIER I

Sprijinim în limba rusă 24/7/365 Lucrăm cu persoane juridice și persoane fizice. Acum aveți nevoie de 24 nuclee și 72 GB de memorie RAM. Vă rog!

Tarifele noastre avantajoase vor dovedi că nu ați știut încă ieftinul de găzduire!

Minute: selectați configurația, plătiți și CMS de pe VPS este gata.
Banii înapoi - 30 de zile!

Carduri bancare, e-valută, prin intermediul terminalelor Qiwi, Webmoney, PayPal, Novoplat etc.

Puneți o întrebare la sprijinul 24/7/365

Găsiți răspunsuri în baza noastră de date și cunoașteți recomandările

Limba de programare Python este un instrument excelent pentru procesarea numerelor și a expresiilor matematice. Pe baza acestei calități, puteți crea programe utile.

În acest manual, vi se oferă un exercițiu util: încercați să scrieți un program simplu de linie de comandă pentru a efectua calcule. Deci, în acest tutorial, veți învăța cum să creați cel mai simplu calculator din Python 3.

Manualul utilizează operatori matematici, variabile, expresii condiționate, funcții.

cerinţe

Pentru a rula ghidul, trebuie să instalați Python 3 pe mașina locală și să implementați mediul de dezvoltare. Toate instrucțiunile necesare pot fi găsite aici:

  • Configurarea mediului de dezvoltare locală pentru Python 3 în CentOS 7
  • Configurarea mediului de dezvoltare locală pentru Python 3 în Windows 10
  • Configurarea mediului de dezvoltare locală pentru Python 3 în Mac OS X
  • Configurarea mediului de dezvoltare locală pentru Python 3 în Ubuntu 16.04

1: Șir de introducere

Pentru început, trebuie să scrieți o linie de intrare, cu ajutorul căreia utilizatorii pot introduce date pentru calcule în calculator.

Pentru a face acest lucru, utilizați intrarea funcției încorporate (), care acceptă intrarea de tastatură generată de utilizator. În parantezele funcției input (), puteți trece un șir. Pentru intrarea utilizatorului trebuie să i se atribuie o variabilă.

În acest program, utilizatorul poate introduce două numere. Când solicitați introducerea, trebuie să adăugați un spațiu la sfârșitul liniei pentru a separa intrarea utilizatorului de linia de program.

number_1 = input ('Introduceți primul număr:')
number_2 = input ('Introduceți al doilea număr:')

Înainte de a începe programul, salvați fișierul. De exemplu, să sunăm la calculator.py. Acum puteți rula programul în fereastra terminalului în mediul de dezvoltare cu comanda:

Programul vă va solicita să introduceți două numere:

Introduceți primul număr: 5
Introduceți al doilea număr: 7

În momentul de față, calculatorul acceptă orice date de intrare, care nu se limitează la numere: cuvinte, simboluri, spații, chiar introduceți. Aceasta se datorează faptului că funcția input () ia datele ca un șir și nu știe că în acest caz sunt necesare numai numere.

Pentru ca programul să efectueze calcule matematice, acesta nu trebuie să accepte alte date decât numerele.

În funcție de scopul calculatorului, programul poate converti funcțiile de intrare () la numere întregi sau puncte în virgulă mobilă. În acest caz, numerele întregi sunt mai potrivite. Funcția de intrare () trebuie să fie trecută în interiorul funcției int () pentru a converti intrarea într-un număr întreg.

number_1 = int (introduceți ('Introduceți primul număr:'))
number_2 = int (intrare ('Introduceți al doilea număr:'))

Încercați acum să introduceți două numere întregi:

Introduceți primul număr: 23
Introduceți al doilea număr: 674

Totul funcționează fără erori. Cu toate acestea, dacă introduceți caractere, spații sau litere, programul va afișa o eroare:

Introduceți primul număr: salut
Traceback (ultimul ultim apel ultimul):
Fișierul "test.py", rândul 1, în
number_1 = int (introduceți ('Introduceți primul număr:'))
ValueError: literal invalid pentru int () cu baza 10: 'hello'

Deci, ați scris o linie pentru a introduce date în program.

Notă. Încercați să transformați datele de intrare în cifre în virgulă mobilă.

2: Adăugarea operatorilor

Acum trebuie să adăugăm patru operatori de bază: + (plus), - (scădere), * (multiplicare) și / (diviziune).

Este mai bine să dezvolți programul treptat, pentru a putea să îl testezi în fiecare etapă.

Mai întâi adăugați operatorul de adăugare. Plasați cele două numere în imprimare, astfel încât calculatorul să afișeze rezultatul.

number_1 = int (introduceți ('Introduceți primul număr:'))
number_2 = int (intrare ('Introduceți al doilea număr:'))
tipăriți (numărul_1 + număr_2)

Rulați programul și încercați să adăugați două numere:

Introduceți primul număr: 8
Introduceți al doilea număr: 3
11

Acum puteți complica puțin programul. Pe lângă rezultat, calculatorul afișează și numerele introduse de utilizator.

number_1 = int (introduceți ('Introduceți primul număr:'))
number_2 = int (intrare ('Introduceți al doilea număr:'))
print ('<> + <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 + număr_2)

Rulați programul din nou și încercați să introduceți numere:

Introduceți primul număr: 90
Introduceți al doilea număr: 717
90 + 717 =
807

Acum, utilizatorul poate fi sigur că a introdus numerele corecte.

În această etapă, puteți adăuga restul operatorilor utilizând același format:

number_1 = int (introduceți ('Introduceți primul număr:'))
number_2 = int (intrare ('Introduceți al doilea număr:'))
# Addition
print ('<> + <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 + număr_2)
# Scădere
print ('<> - <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 - numărul_2)
# Înmulțire
print ('<> * <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 * numărul_2)
# Divizia
print ('<> / <> = '.format (număr_1, număr_2))
tipăriți (număr_1 / număr_2)

Acum, calculatorul poate efectua calcule matematice folosind operatorii +, -, * și / sau operatori. Apoi, trebuie să limitați numărul de operații pe care le poate efectua programul la un moment dat.







3: Adăugarea unui operator condiționat

Adăugați o mică descriere la începutul programului calculator.py cu o listă cu operațiunile disponibile. Selectând unul dintre operatori, utilizatorul va spune programului exact ce va trebui să facă.

'' '
Introduceți operația de matematică pe care doriți să o completați:
+ pentru adăugare
- pentru scădere
* pentru multiplicare
/ pentru divizare
'' '

Notă. De fapt, puteți folosi orice caractere aici (de exemplu, 1 pentru adăugare, b pentru scădere și așa mai departe).

Treceți șirul în interiorul funcției de intrare () și atribuiți o variabilă valorii de intrare (de exemplu, aceasta va fi o variabilă de operare).

operație = intrare ('' '
Introduceți operația de matematică pe care doriți să o completați:
+ pentru adăugare
- pentru scădere
* pentru multiplicare
/ pentru divizare
'' ')
number_1 = int (introduceți ('Introduceți primul număr:'))
number_2 = int (intrare ('Introduceți al doilea număr:'))
print ('<> + <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 + număr_2)
print ('<> - <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 - numărul_2)
print ('<> * <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 * numărul_2)
print ('<> / <> = '.format (număr_1, număr_2))
tipăriți (număr_1 / număr_2)

În această linie, utilizatorul poate introduce oricare dintre caracterele sugerate, dar nu se va întâmpla nimic. Pentru ca programul să funcționeze, trebuie să adăugați o declarație condiționată. Instrucțiunea if va fi responsabilă pentru adăugarea celor trei operatori elif pentru operațiile rămase; declarația else va returna o eroare dacă utilizatorul a introdus un alt caracter în locul operatorilor propuși.

operație = intrare ('' '
Introduceți operația de matematică pe care doriți să o completați:
+ pentru adăugare
- pentru scădere
* pentru multiplicare
/ pentru divizare
'' ')
number_1 = int (introduceți ('Introduceți primul număr:'))
number_2 = int (intrare ('Introduceți al doilea număr:'))
dacă operația == '+':
print ('<> + <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 + număr_2)
operațiunea elif == '-':
print ('<> - <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 - numărul_2)
operațiunea elif == '*':
print ('<> * <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 * numărul_2)
operațiunea elif == '/':
print ('<> / <> = '.format (număr_1, număr_2))
tipăriți (număr_1 / număr_2)
altceva:
print ("Nu ați tastat un operator valid, vă rugăm să rulați programul din nou.")

Deci, mai întâi programul cere utilizatorului să intre în simbolul de operare. Apoi cere două numere. După aceasta, afișează intrarea utilizatorului și rezultatul calculelor. De exemplu, utilizatorul introduce *, apoi 58 și 40.

Introduceți operația de matematică pe care doriți să o completați:
+ pentru adăugare
- pentru scădere
* pentru multiplicare
/ pentru divizare
*
Introduceți primul număr: 58
Introduceți al doilea număr: 40
58 * 40 =
2320

Dacă, la prima solicitare a programului, utilizatorul introduce caracterul%, el va primi o eroare.

În momentul în care programul efectuează toate calculele necesare. Cu toate acestea, pentru a efectua o altă operație, programul va trebui repornit.

4: Definirea funcțiilor

Pentru a vă asigura că programul nu trebuie repornit după fiecare exemplu prelucrat, trebuie să definiți mai multe funcții. Mai întâi, puneți tot codul existent în funcția calculate () și adăugați încă un strat în program. Pentru a porni programul, trebuie să adăugați o funcție la sfârșitul fișierului.

# Definiția funcției
def calculate ():
operație = intrare ('' '
Introduceți operația de matematică pe care doriți să o completați:
+ pentru adăugare
- pentru scădere
* pentru multiplicare
/ pentru divizare
'' ')
number_1 = int (intrare ('Introduceți primul număr:'))
number_2 = int (intrare ('Introduceți al doilea număr:'))
dacă operația == '+':
print ('<> + <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 + număr_2)
operațiunea elif == '-':
print ('<> - <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 - numărul_2)
operațiunea elif == '*':
print ('<> * <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 * numărul_2)
operațiunea elif == '/':
print ('<> / <> = '.format (număr_1, număr_2))
tipăriți (număr_1 / număr_2)
altceva:
print ("Nu ați tastat un operator valid, vă rugăm să rulați programul din nou.")
# Apelarea funcției calculează () în afara funcției
calcula ()

Creați o altă funcție care constă în declarații condiționale. Acest bloc de coduri va permite utilizatorului să aleagă: continuați lucrul cu programul sau completați-l. În acest caz, vor exista trei operatori: unul dacă, un elif și altul pentru manipularea erorilor.

Lăsați funcția să fie apelată din nou (). Adăugați-l la sfârșitul blocului def calculează ():


# Definirea din nou a funcției ()
def again ():
# Intrare utilizator
calc_again = intrare ('' '
Doriți să calculați din nou?
Introduceți Y pentru YES sau N pentru NO.
'' ')
# Dacă utilizatorul introduce Y, programul pornește funcția calculate ()
dacă calc_again == 'Y':
calcula ()
# Dacă utilizatorul introduce N, programul va spune la revedere și va finaliza lucrarea
elif calc_again == 'N':
print ("Vă vedem mai târziu.")
# Dacă utilizatorul introduce un alt caracter, programul pornește din nou funcția din nou ()
altceva:
din nou ()
# Call calculate ()
calcula ()

De asemenea, este posibil să se elimine sensibilitatea: literele y și n-au perceput la fel ca și Y și N. Pentru a adăuga acest str.upper () linii de funcții:


def again ():
calc_again = intrare ('' '
Doriți să calculați din nou?
Introduceți Y pentru YES sau N pentru NO.
'' ')
# Acceptați "y" sau "Y" adăugând str.upper ()
dacă calc_again.upper () == 'Y':
calcula ()
# Acceptați "n" sau "N" adăugând str.upper ()
elif calc_again.upper () == 'N':
print ("Vă vedem mai târziu.")
altceva:
din nou ()
.

Acum trebuie să adăugăm funcția din nou () la sfârșitul funcției calculate (), astfel încât programul să execute codul care îi cere utilizatorului dacă dorește să continue să lucreze.

def calculate ():
operație = intrare ('' '
Introduceți operația de matematică pe care doriți să o completați:
+ pentru adăugare
- pentru scădere
* pentru multiplicare
/ pentru divizare
'' ')
number_1 = int (intrare ('Introduceți primul număr:'))
number_2 = int (intrare ('Introduceți al doilea număr:'))
dacă operația == '+':
print ('<> + <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 + număr_2)
operațiunea elif == '-':
print ('<> - <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 - numărul_2)
operațiunea elif == '*':
print ('<> * <> = '.format (număr_1, număr_2))
tipăriți (numărul_1 * numărul_2)
operațiunea elif == '/':
print ('<> / <> = '.format (număr_1, număr_2))
tipăriți (număr_1 / număr_2)
altceva:
print ("Nu ați tastat un operator valid, vă rugăm să rulați programul din nou.")
# Adăugarea funcției din nou () pentru a calcula ()
din nou ()
def again ():
calc_again = intrare ('' '
Doriți să calculați din nou?
Introduceți Y pentru YES sau N pentru NO.
'' ')
dacă calc_again.upper () == 'Y':
calcula ()
elif calc_again.upper () == 'N':
print ("Vă vedem mai târziu.")
altceva:
din nou ()
calcula ()

Rulați programul în terminal folosind comanda:

Acum programul nu trebuie să fie repornit.

5: Acțiuni adiționale

Programul pe care l-ați scris este pe deplin pregătit pentru utilizare. Cu toate acestea, există mai multe suplimente pe care le puteți adăuga la cod dacă doriți. De exemplu, puteți scrie un mesaj de salut și îl puteți adăuga în partea de sus a codului:

def welcome ():
print ('' '
Bine ați venit la Calculator
'' ')
.
# Apoi trebuie să apelați funcția
bun venit ()
calcula ()

De asemenea, puteți adăuga mai multe funcții în program pentru tratarea erorilor. De exemplu, programul ar trebui să continue să funcționeze chiar dacă utilizatorul introduce un cuvânt în loc de un număr. În acest moment nu este cazul: programul va da utilizatorului o eroare și nu mai funcționează.

În plus, dacă utilizatorul alege numitorul 0 atunci când selectează operatorul diviziei (/), ar trebui să primească o eroare:

ZeroDivisionError: împărțire la zero

Pentru a face acest lucru, scrieți o excepție cu ajutorul ... cu excepția operatorului.

Programul este limitat la 4 operatori, însă puteți extinde această listă:


operație = intrare ('' '
Introduceți operația de matematică pe care doriți să o completați:
+ pentru adăugare
- pentru scădere
* pentru multiplicare
/ pentru divizare
** pentru putere
% pentru modulo
'' ')
.
# Pentru a ridica și procesa modulul, trebuie să adăugați instrucțiuni condiționate la cod.

De asemenea, puteți adăuga instrucțiuni de buclă la program.

Există multe modalități de a configura modul de gestionare a erorilor și de a îmbunătăți fiecare proiect. Este întotdeauna important să vă amintiți că nu există o singură modalitate corectă de a rezolva această problemă.

concluzie

Acum știi cum să scrii cel mai simplu calculator. După executarea manualului, puteți adăuga propriile funcții ale programului.







Pagina anterioară

Pagina următoare

Trimiteți-le prietenilor: