2.3. Matemaattiset operaatiot

Python toimii laskimena suoraan paketista. Tämä sivu käsittelee operaattorit, joita käytät useimmin: numeroiden aritmetiikan, totuusarvoja tuottavat vertailut, ehtoja yhdistelevät loogiset operaattorit ja bittitason työhön tarkoitetut bittioperaattorit.

2.3.1. Aritmetiikka

Tavalliset aritmeettiset operaattorit int- ja float-arvoille:

  • + – yhteenlasku

  • - – vähennyslasku (tai etuliitteenä negaatio: -x)

  • * – kertolasku

  • / – jakolasku. Palauttaa aina float-arvon, vaikka molemmat operandit olisivat kokonaislukuja.

  • // – kokonaislukujako. Palauttaa kokonaislukuosamäärän pyöristettynä kohti miinusääretöntä.

  • % – modulo (jakojäännös).

  • ** – potenssiinkorotus (2 ** 10 on 1024).

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

Eri tyyppejä sekoittava aritmetiikka muuntaa kokonaisluvut automaattisesti liukuluvuiksi:

>>> 3 + 0.5
3.5

Yhdistetty sijoitus liittää operaattorin merkkiin = tiiviin paikallaan tapahtuvan päivityksen aikaansaamiseksi:

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

Operaattorien etusijajärjestys noudattaa perinteistä järjestystä: ensin **, sitten unaarinen -, sitten *, /, // ja %, sitten + ja -. Käytä sulkeita kun olet epävarma – ne eivät maksa mitään ajonaikaisesti.

2.3.2. Vertailu

Vertailuoperaattorit palauttavat bool-arvon (True tai False):

  • == ja != – yhtä suuri / eri suuri.

  • <, <=, >, >= – järjestys.

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

Viimeinen esimerkki on ketjutettu vertailu ja täsmälleen yhtäpitävä ilmaisun 3 < 5 and 5 <= 5 kanssa.

Varoitus

= sijoittaa; == vertailee. Ilmaisu if x = 5: on syntaksivirhe juuri siksi, että Python kieltäytyy hiljaisesti sekoittamasta näitä kahta.

2.3.3. Boolen logiikka

Kolme operaattoria yhdistelee totuusarvoja:

  • and – True vain kun molemmat puolet ovat tosia.

  • or – True kun jompikumpi puoli on tosi.

  • not – kääntää yksittäisen totuusarvon.

and ja or oikosulkevat: ne lopettavat evaluoinnin heti kun tulos on tiedossa. False and slow_check() ei koskaan kutsu slow_check-funktiota.

and ja or myös palauttavat jommankumman operandinsa eivätkä kirjaimellista arvoa True tai False, mikä mahdollistaa oletusarvojen kirjoittamisen tiiviisti:

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

2.3.4. Bittioperaattorit

Laitteistotyöhön – rekisterikenttien pakkaamiseen, bittien maskaamiseen, protokollaotsakkeiden jäsentämiseen – tartut bittioperaattoreihin. Ne vaikuttavat int-arvon binääriesitykseen:

  • & – bitti-JA

  • | – bitti-TAI

  • ^ – bitti-XOR

  • ~ – bitti-EI (yhden komplementti)

  • << – siirto vasemmalle

  • >> – siirto oikealle

Heksadesimaali- ja binäärimuotoiset literaalit ovat käteviä näitä luettaessa ja kirjoitettaessa:

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

Kullekin on olemassa yhdistetty muoto: |=, &=, ^=, <<=, >>=.

Muista

and / or toimivat totuusarvoilla (tai todenkaltaisuudella); & / | toimivat biteillä. Älä sekoita niitä keskenään. 0b1100 and 0b1010 evaluoituu arvoksi 0b1010, koska molemmat operandit ovat tosia – mikä ei yleensä ole se mitä haluat bittejä käsitellessäsi.

2.3.5. Hyödyllisiä lukujen sisäänrakennettuja funktioita

Kourallinen sisäänrakennettuja funktioita kattaa tavallisia numeerisia operaatioita, joita pelkät operaattorit eivät hoida:

  • round() – lähin kokonaisluku, tai lähin ndigits-määrä desimaaleja kun toinen argumentti annetaan. Palauttaa int-arvon kutsulle round(x) ja float-arvon kutsulle round(x, n). Tasapelit (0.5, 1.5, …) pyöristyvät lähimpään parilliseen lukuun, eivät aina ylöspäin.

  • divmod() – palauttaa (quotient, remainder) yhdellä kutsulla. Kätevä yhden määrän jakamiseen yksiköihin (sekunnit minuuteiksi ja sekunneiksi, tavut sivuiksi ja siirtymiksi).

  • pow() – sama kuin ** kaksiargumenttisessa muodossa. Kolmiargumenttinen muoto pow(base, exp, mod) laskee arvon (base ** exp) % mod ilman, että jättimäistä välituloa koskaan muodostetaan, mikä on ainoa käytännöllinen tapa tehdä modulaarista potenssiinkorotusta suurille eksponenteille.

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

Kokonaisluvusta merkkijonoksi tapahtuvat lukujärjestelmämuunnokset (bin, oct, hex) käsitellään luvussa Merkkijonometodit ja muotoilu.

2.3.6. math-moduuli

Tavalliset matemaattiset funktiot sijaitsevat math-moduulissa. Tuo se kerran sisään ja kutsu sen funktioita pisteellisen nimen kautta:

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

MicroPythonin math-moduuli kattaa tavalliset epäillyt (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Satunnaislukuja varten katso random-moduuli; kiinteän pisteen bittikäsittelyyn yllä olevat operaattorit riittävät yleensä.

2.3.7. Kompleksiluvut

Imaginaarikomponentteja tarvitsevaan numeeriseen työhön Pythonissa on complex-tyyppi, jossa on j-päätteiset literaalit (1 + 2j). cmath-moduuli peilaa math-moduulia kompleksisille syötteille. Molemmat ovat mukana useimmissa MicroPython-käännöksissä, mutta niitä tarvitaan harvoin kameratyössä; mainitsemme ne lähinnä siksi, etteivät ne yllätä jos siirrät koodia, joka käyttää niitä.