2.3. Matematikai műveletek

A Python alapból kalkulátorként működik. Ez az oldal azokat az operátorokat tárgyalja, amelyeket a leggyakrabban fogsz használni: aritmetika számokon, összehasonlítások, amelyek logikai értékeket állítanak elő, logikai operátorok, amelyek feltételeket kombinálnak, és bitenkénti operátorok a hardverszintű munkához.

2.3.1. Aritmetika

A szabványos aritmetikai operátorok int és float értékeken:

  • + – összeadás

  • - – kivonás (vagy előjelváltás prefixként: -x)

  • * – szorzás

  • / – osztás. Mindig float értéket ad vissza, még akkor is, ha mindkét operandus egész szám.

  • // – egész osztás. A mínusz végtelen felé kerekített egész hányadost adja vissza.

  • % – maradékos osztás (maradék).

  • ** – hatványozás (2 ** 10 az 1024).

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

A vegyes típusú aritmetika automatikusan átkonvertálja az egész számokat lebegőpontossá:

>>> 3 + 0.5
3.5

A bővített értékadás az operátort a = jellel kombinálja egy tömör, helyben végzett frissítéshez:

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

Az operátorok precedenciája a megszokott sorrendet követi: először a **, majd az unáris -, aztán a *, /, // és %, végül a + és -. Használj zárójeleket, ha bizonytalan vagy – futásidőben semmibe sem kerülnek.

2.3.2. Összehasonlítás

Az összehasonlító operátorok bool értéket adnak vissza (True vagy False):

  • == és != – egyenlő / nem egyenlő.

  • <, <=, >, >= – rendezés.

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

Az utolsó példa egy láncolt összehasonlítás, és pontosan egyenértékű a 3 < 5 and 5 <= 5 kifejezéssel.

Figyelem

A = értéket ad; a == összehasonlít. Az if x = 5: kifejezés pontosan azért szintaktikai hiba, mert a Python nem hajlandó csendben összekeverni a kettőt.

2.3.3. Logikai műveletek

Három operátor kombinál logikai értékeket:

  • and – csak akkor True, ha mindkét oldal igaz.

  • or – True, ha bármelyik oldal igaz.

  • not – megfordít egyetlen logikai értéket.

Az and és az or rövidre zár: abbahagyják a kiértékelést, amint az eredmény ismertté válik. A False and slow_check() soha nem hívja meg a slow_check függvényt.

Az and és az or ráadásul az egyik operandusukat adják vissza, nem pedig egy literális True vagy False értéket, ami lehetővé teszi, hogy tömören írj alapértékeket:

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

2.3.4. Bitenkénti operátorok

Hardveres munkához – regisztermezők összeállításához, bitek maszkolásához, protokollfejlécek elemzéséhez – a bitenkénti operátorokhoz fogsz nyúlni. Ezek egy int bináris reprezentációján működnek:

  • & – bitenkénti ÉS

  • | – bitenkénti VAGY

  • ^ – bitenkénti KIZÁRÓ VAGY (XOR)

  • ~ – bitenkénti NEM (egyes komplemens)

  • << – balra léptetés

  • >> – jobbra léptetés

A hexadecimális és bináris literálformák kényelmesek ezek olvasásakor és írásakor:

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

Mindegyikhez létezik bővített forma: |=, &=, ^=, <<=, >>=.

Megjegyzés

Az and / or logikai értékeken (vagy igazságértéken) működik; az & / | biteken. Ne keverd össze őket. A 0b1100 and 0b1010 kifejezés 0b1010 értékre értékelődik ki, mert mindkét operandus igaz – nem az, amit általában szeretnél bitek manipulálásakor.

2.3.5. Hasznos szám-beépített függvények

Néhány beépített függvény lefedi azokat a gyakori numerikus műveleteket, amelyeket önmagukban az operátorok nem:

  • round() – a legközelebbi egész szám, vagy a legközelebbi ndigits tizedesjegy, ha egy második argumentumot is megadsz. round(x) esetén int, round(x, n) esetén float értéket ad vissza. A holtversenyek (0.5, 1.5, …) a legközelebbi páros számra kerekülnek, nem mindig felfelé.

  • divmod() – egyetlen hívásban adja vissza a (quotient, remainder) értéket. Hasznos egy mennyiség egységekre bontásához (másodpercek percekre és másodpercekre, byte-ok oldalakra és eltolásokra).

  • pow() – a kétargumentumú formában ugyanaz, mint a **. A háromargumentumú pow(base, exp, mod) forma kiszámítja a (base ** exp) % mod értéket anélkül, hogy valaha is létrehozná az óriási köztes értéket, ami az egyetlen praktikus módja a moduláris hatványozásnak nagy kitevők esetén.

>>> 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

Az egész szám szöveggé alakítása különböző számrendszerekben (bin, oct, hex) a Szöveges metódusok és formázás oldalon van tárgyalva.

2.3.6. A math modul

A gyakori matematikai függvények a math modulban élnek. Importáld egyszer, és hívd meg a függvényeit pontozott névvel:

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

A MicroPython math modulja lefedi a szokásos elemeket (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Véletlenszámokhoz lásd a random modult; fixpontos bitműveletekhez általában elegendők a fenti operátorok.

2.3.7. Komplex számok

Az olyan numerikus munkához, amely képzetes komponenseket igényel, a Python rendelkezik egy complex típussal j utótagú literálokkal (1 + 2j). A cmath modul a math modult tükrözi komplex bemenetekhez. Mindkettő jelen van a legtöbb MicroPython build-ben, de a kameramunkához ritkán van rájuk szükség; főként azért említjük őket, hogy ne legyenek meglepetés, ha olyan kódot portolsz, amely használja őket.