2.3. Operații matematice

Python funcționează ca un calculator din start. Această pagină acoperă operatorii pe care îi vei folosi cel mai des: aritmetica pe numere, comparațiile care produc valori booleene, operatorii logici care combină condiții și operatorii pe biți pentru lucrul la nivel hardware.

2.3.1. Aritmetică

Operatorii aritmetici standard pe valori int și float:

  • + – adunare

  • - – scădere (sau negație, ca prefix: -x)

  • * – înmulțire

  • / – împărțire. Returnează întotdeauna un float, chiar și când ambii operanzi sunt numere întregi.

  • // – împărțire întreagă (floor division). Returnează câtul întreg rotunjit spre minus infinit.

  • % – modulo (restul).

  • ** – ridicare la putere (2 ** 10 este 1024).

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> -7 // 2
-4
>>> 7 % 2
1
>>> 2 ** 16
65536

Aritmetica cu tipuri mixte promovează automat numerele întregi la valori în virgulă mobilă:

>>> 3 + 0.5
3.5

Atribuirea augmentată combină operatorul cu = pentru o actualizare compactă pe loc:

counter = 0
counter += 1                # equivalent to counter = counter + 1
counter *= 2                # works for *= /= //= %= **= too

Precedența operatorilor urmează ordinea convențională: mai întâi **, apoi unarul -, apoi *, /, // și %, apoi + și -. Folosește parantezele când nu ești sigur – nu costă nimic la execuție.

2.3.2. Comparație

Operatorii de comparație returnează un bool (True sau False):

  • == și != – egal / diferit.

  • <, <=, >, >= – ordonare.

>>> 3 == 3
True
>>> 3 == 3.0
True
>>> 3 < 5 <= 5
True

Ultimul exemplu este o comparație înlănțuită și este exact echivalent cu 3 < 5 and 5 <= 5.

Atenționare

= atribuie; == compară. Expresia if x = 5: este o eroare de sintaxă tocmai pentru că Python refuză să le confunde în tăcere pe cele două.

2.3.3. Logică booleană

Trei operatori combină valori booleene:

  • and – True doar când ambele părți sunt adevărate.

  • or – True când oricare dintre părți este adevărată.

  • not – inversează o singură valoare booleană.

and și or au scurtcircuitare: opresc evaluarea de îndată ce rezultatul este cunoscut. False and slow_check() nu apelează niciodată slow_check.

and și or returnează, de asemenea, unul dintre operanzii lor în loc de un literal True sau False, ceea ce îți permite să scrii valori implicite în mod compact:

name = user_name or "anonymous"   # "" / 0 / None are falsy

2.3.4. Operatori pe biți

Pentru lucrul cu hardware – împachetarea câmpurilor de registru, mascarea biților, parsarea antetelor de protocol – vei recurge la operatorii pe biți. Aceștia acționează asupra reprezentării binare a unui int:

  • & – ȘI pe biți (AND)

  • | – SAU pe biți (OR)

  • ^ – SAU exclusiv pe biți (XOR)

  • ~ – NU pe biți (complement față de unu)

  • << – deplasare la stânga

  • >> – deplasare la dreapta

Formele literalilor hexazecimali și binari sunt convenabile la citirea și scrierea acestora:

>>> 0b1100 & 0b1010
8                              # 0b1000
>>> 0b1100 | 0b1010
14                             # 0b1110
>>> 0xFF ^ 0x0F
240                            # 0xF0
>>> 1 << 8
256
>>> (0xABCD >> 8) & 0xFF
171                            # extract the high byte

Există forme augmentate pentru fiecare: |=, &=, ^=, <<=, >>=.

Notă

and / or operează pe valori booleene (sau pe veridicitate); & / | operează pe biți. Nu le confunda. 0b1100 and 0b1010 se evaluează la 0b1010 deoarece ambii operanzi sunt adevărați – ceea ce de obicei nu vrei când manipulezi biți.

2.3.5. Funcții încorporate utile pentru numere

Câteva funcții încorporate acoperă operații numerice comune pe care operatorii singuri nu le pot realiza:

  • round() – cel mai apropiat număr întreg sau cele mai apropiate ndigits zecimale când este dat un al doilea argument. Returnează un int pentru round(x) și un float pentru round(x, n). La egalitate (0.5, 1.5, …) se rotunjește la cel mai apropiat număr par, nu întotdeauna în sus.

  • divmod() – returnează (quotient, remainder) într-un singur apel. Util pentru împărțirea unei cantități în unități (secunde în minute-și-secunde, octeți în pagini-și-deplasament).

  • pow() – la fel ca ** în forma cu două argumente. Forma cu trei argumente pow(base, exp, mod) calculează (base ** exp) % mod fără a materializa vreodată valoarea intermediară uriașă, ceea ce este singura modalitate practică de a face exponențiere modulară pentru exponenți mari.

>>> round(3.7)
4
>>> round(3.14159, 2)
3.14
>>> round(0.5)               # ties go to even, not always up
0
>>> round(1.5)
2

>>> divmod(125, 60)          # 125 seconds = 2 min, 5 sec
(2, 5)
>>> minutes, seconds = divmod(125, 60)

>>> pow(3, 4)                # same as 3 ** 4
81
>>> pow(3, 100, 7)           # (3 ** 100) mod 7, efficient
4

Conversiile dintr-un număr întreg într-un șir de caractere în diferite baze (bin, oct, hex) sunt tratate în Metode pentru șiruri de caractere și formatare.

2.3.6. Modulul math

Funcțiile matematice comune se află în modulul math. Importă-l o dată și apelează funcțiile sale printr-un nume cu punct:

import math

print(math.sqrt(2))              # 1.4142135
print(math.sin(math.pi / 2))     # 1.0
print(math.floor(3.7))           # 3
print(math.log(100, 10))         # 2.0

Modulul math din MicroPython acoperă funcțiile obișnuite (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Pentru numere aleatorii, vezi modulul random; pentru manipularea biților în virgulă fixă, operatorii de mai sus sunt de obicei suficienți.

2.3.7. Numere complexe

Pentru lucrul numeric care necesită componente imaginare, Python are un tip complex cu literali ce poartă sufixul j (1 + 2j). Modulul cmath reflectă math pentru intrări complexe. Ambele sunt prezente în majoritatea versiunilor MicroPython, dar rareori sunt necesare pentru lucrul cu camera; le menționăm în principal ca să nu fie o surpriză dacă portezi cod care le folosește.