Az operátorok által leírt műveletek ún. kifejezésfákkal ábrázolhatóak. A kifejezésfa megadja, hogy melyik operátoroknak mely értékek az operandusai.

A kifejezésfa már nem tartalmaz zárójeleket, annak a hierarchiája ugyanis egyértelműen meghatározza, hogy mely művelethez mely operandusok tartoznak. Az alábbi rajzokon sárga színnel jelöltük az operátorokat. Az ezekből lefelé kiinduló vonalak adják meg, hogy az adott operátorhoz mely operandusok tartoznak. A kék szín olyan részkifejezéseket jelöl, amelyek önmagukban kiértékelhetőek; ilyenek a változók és a konstansok. Ezekből már nem indulnak ki vonalak lefelé, nincsenek operandusaik.

A 3*x + 8 kifejezés egy olyan összeget ad meg, amely két tagból áll. Az első tag egy szorzat (3*x), a második tag pedig egy konstans (8). Vegyük észre, hogy ez nem attól van így, mert a szóközökkel a tagokat csoportosítottuk, és nem is azért, mert bal oldalon van a szorzat! Hanem azért, mert a szorzás művelet magasabb rendű, azaz a * operátor magasabb precedenciájú, mint a + operátor.

Ha nem megfelelő a precedencia, zárójelek közé zárhatjuk az egyes részkifejezéseket, ezzel módosíthatjuk az operátor–operandus viszonyt. A 6 * (y-4) kifejezésben a szorzat jobb oldali tényezője a különbség; tehát egy olyan művelet eredménye (a kivonásé), amelynek a precedenciája amúgy alacsonyabb, mint a szorzásé.

Az utolsó példa az a == -b kifejezést ábrázolja. Ebben két operátor szerepel, az összehasonlítás és az ellentett képzése. Az ellentett magasabb precedenciájú, és csak egyetlen operandusa van, a b változó. Az összehasonlítás operandusai pedig az a változó, továbbá az ellentettképzés eredménye, tehát az a szám, amit a -b kifejezés kiértékelésével kapunk.

Az operátorok precedenciáját (erősségét) mutatja a fenti, amúgy hiányos táblázat. (Néhány operátorról később lesz szó.)

A táblázat tetején lévő, magas precedenciájú operátorok erősebben kötődnek az operandusaikhoz, mint az alul lévők. Tehát ha egy kifejezést értelmeznénk, ezekből kell kiindulni. Ahogy az előző példákon is szerepelt, a 3 * x + 8 kifejezésben a szorzás erősebb precedenciájú, mint az összeadás, és ezért adjuk a szorzathoz hozzá a 8-at. Hasonlóképp, a 2 * 3 ** 4 kifejezés is 2 × 34-et jelent így zárójelezés nélkül is, mert a hatványozás a magasabb precedenciájú művelet. Zárójelezve a 2 * (3 ** 4) lenne ugyanez.

A precedenciatáblázatot úgy alkották meg, hogy intuitív legyen, a szokásos használatnál kevés zárójelre legyen szükség. Nem véletlen, hogy az összehasonlító operátorok alacsonyabb precedenciájúak, mint a matematikai műveletek. Például az a * b == c * d kifejezésben intuíció szerint két szorzatot hasonlítunk össze, és ezt a nyelv is pontosan így értelmezi. Ez úgy valósul meg, hogy a szorzó operátor precedenciája magasabb, az összehasonlítóé pedig alacsony; vagyis a szorzások „magukhoz vonzzák” a tényezőket, mintha (a * b) == (c * d) módon zárójelezük volna a kifejezést. Ugyanez a helyzet a not a and b kifejezéssel: a not a magasabb precedenciájú, ezért azt (not a) and b-ként kell értelmezni zárójelezés nélkül is. Az a-t tagadjuk, és az így kapott logikai értéket hozzuk ÉS kapcsolatba b-vel. Tulajdonképp lehetne akár not (a and b) is, de szándékosan nem az – ha mégis ezt szeretnénk, akkor zárójelezni kell.

Egy érdekesség: az unáris + operátor is létezik, viszont nem csinál semmit. 5 és +5 ugyanaz a szám, ahogy x és +x is ugyanannyi, függetlenül attól, hogy x pozitív vagy negatív. Ezt azért van így, hogy a kódban kiemelhessük, hogy pozitív számról beszélünk, ahogy élő szóban is időnként mondjuk ilyeneket: „plusz öt fok van”.

A Python nyelvben nem kell jelezni a forráskódban a változók típusát, mert azok bármilyen típusú objektumok referenciái lehetnek. Ez annyiban kellemetlen, hogy a forráskódból nem mindig látszik, hogy mi történik. Mi a helyzet egy f() + g() kifejezés esetén, ez összeadás vagy összefűzés? Nem tudjuk megmondani, amíg meg nem vizsgáljuk az f() és g() függvényeket – vagy azok dokumentációit –, hogy mit adnak vissza. Ha számokat, akkor összeadás, ha sztringeket vagy listákat, akkor összefűzés. (Ezért is fontos a jó nevek használata a programban: a nev_beolvas() függvénynek már az elnevezése mutatja, hogy sztringet ad vissza.)

Erre már az első időktől fogva figyelünk: ha egy számot akarunk beolvasni a billentyűzetről, az input() függvény visszatérési értékét, a sztringet, át kell alakítanunk: int(input()) vagy float(input()).

Típuskonverzió néha automatikusan is történik. Például egy int-et és egy float-ot összeadva (vagy egy float-ot és egy int-et, a sorrend itt mindegy) az egész számot is valóssá fogja alakítani a nyelv. Így végeredményben az összeg is egy valós szám lesz. Ez az átalakítás logikus, hiszen bővebb halmaz felé megyünk: minden egész szám benne van a valós számok halmazában is. Viszont float → int átalakítást magától nem fog csinálni a nyelv, mert adatot veszítenénk (pl. 2.3-ból 2 lenne, eltűnik a tizedesrész).

Hasonlóképp, automatikus típuskonverzió nem történik akkor, ha nem egyértelmű az eredmény. A 2 + "3" kifejezést nem lehet kiértékelni, TypeError típusú kivételt kapunk. Nem lehet eldönteni, hogy a 2-ből kellene sztringet csinálni (akkor "23" lenne az eredmény), vagy a "3" sztringből int-et (mert akkor viszont 5-öt kapnánk).

Ha szükségünk van konverzióra, akkor az az eddig megismert formában, típusneve(érték) alakú kifejezéssel tehetjük meg. Ilyenkor tulajdonképpen az adott típus konstruktorát használjuk, és az eldönti, hogy miként kell a megadott érték alapján új objektumot létrehozni; ahogyan azt a törtnél is csináltuk.

Ilyen formán a fent említett kifejezések is kiértékelhetők: str(2) + "3" értéke "23", mint sztring; illetve 2 + int("3") értéke 5, mint egész szám. Ezekben az esetekben természetesen az összeadás operátor már nem látja, mi történik; az elsőnél már sztringek vannak az összeadás két oldalán, a második esetben pedig egész számok.

szam = 123
szoveg = szam.__str__()
print(type(szoveg), szoveg)  # <class 'str'>  123

Az ilyen konverziók működését tudjuk vezérelni a saját típusaink (osztályaink) esetén .__float__(self) és .__str__(self) függvények írásával. A float és str típus konstruktorai tulajdonképp nem csinálnak mást, mint meghívják az adott objektum __float__ vagy __str__ nevű függvényeit. Emiatt tudnak bármelyik típus esetén működni, amelyekre ezek definiálva vannak. Ezt használtuk ki a régebbi tört osztályunknál: ott a tört volt sztringgé alakítható, pl. Tort(4, 5)-ből lehetett "4/5" megjelenésű szöveget előállítani.

A fenti dumalos_negyzet() függvény egyszerre két dolgot csinál:

• Kiír valamit a kimenetre.
• Négyzetre emeli a kapott számot, és visszatér vele.

Erre azt mondjuk, hogy a függvénynek van értéke és mellékhatása is. Az érték a megadott szám négyzete, a mellékhatás pedig a szöveg kiírása. A mellékhatás a programozásban nem jelent rosszat! Tulajdonképpen a print() függvény is egy olyan függvény, aminek mellékhatása van, hogy kiírt valamit. Sőt általában pont azért hívjuk meg, mert ezt várjuk tőle. De ettől még a kiírás technikailag egy mellékhatásnak számít.

Érték és mellékhatás: példák

Összehasonlításképp:

math.sqrt(2)

print("hello")

A fenti példák két függvényhívást mutatnak, és azok értékeit, mellékhatásait. Elvileg még a print() függvényhívásnak is van értéke, mégpedig None – de erre azt szoktuk mondani, hogy nincs neki.

A fenti példák olyan függvényeket mutatnak be, amelyeknek mellékhatásuk és értékük is van.

Az input() esetén az érték a beolvasott szöveg. A mellékhatás pedig az, hogy az a sor be lett olvasva, és a legközelebbi híváskor újra várni fog a gép a felhasználóra, új karaktereket kell begépelni. Ha nem lenne ez a mellékhatás, akkor mindig ugyanazt a szöveget kellene kapnunk.

Hasonló a helyzet a véletlenszámok esetén. Az érték a véletlenszám, a mellékhatás pedig az, hogy a modul belső állapota (az álvéletlenszám-generátor belső változói) megváltoznak. Emiatt tud a függvény minden egyes hívásnál új számot adni. Ennek így is kell lennie: szép is lenne egy olyan „véletlen” számsor, amelyik végig csak egyforma számokból áll...

Általában igyekszünk olyan függvényeket írni, aminek csak értéke van, de mellékhatása nincs (mint pl. a math.sqrt()), vagy esetleg csak mellékhatása van, de értéke nincs (mint pl. a print()). Ezt az elvet úgy nevezzük angolul, hogy command-query-separation. Ettől érthetőbb, követhetőbb lesz a program. De látszik, hogy vannak olyan esetek, amikor ez nem teljesíthető, esetleg eleve nem is cél.

A mellékhatás jelenti a változtatás képességét. Matematikai értelemben egy függvénynek nem lehet mellékhatása (pure function), és így bárhányszor meghívva, mindig ugyanazt az értéket kell kapjuk. A fenti példákban láthatóan ez sem igaz, hiszen ugyanazokra a paraméterekre (0 darab paraméterre) mindig más a válasz.

Az értékadás egy operátor?

Egyes nyelvek néha nagyon eltérően definiálják, hogy egyes operátorok hogyan működnek. Különösen igaz ez az értékadásra. Ezt is operátornak szoktuk nevezni, de valójában a Python nyelvben ez egy utasítás.

a == b + 1
print("almafa")
[1, 2, f()]

a = b + 1 # !
raise ValueError()
while x < 10:

Utasítás: nem írható le egy kifejezés részeként, önálló kódsor.

Egy értékadásból álló sornak nincsen értéke, és egy a = b alakú kódrészlet nem írható le egy másik kifejezés részeként (pl. 3 + (a = b) szintaktikailag helytelen). Ez nem azt jelenti, hogy a fent jelölt sorok nem tartalmaznak kifejezéseket: az a = b + 1 sorból a b + 1 egy kifejezés; az értékadás maga az, ami már utasításnak számít. Hasonlóképp, a ValueError() (függvényhívás) és az x < 10 (összehasonlítás) is kifejezések, de a raise és a while már vezérlésátadó utasítások.

A kóddal tulajdonképp ezt rövidítjük:

if x < 0:
    y = -x
else:
    y = x

A feltételes operátor itt azért jó, mert egyértelműsíti, hogy a nagyobb nevű változónak adunk értéket. Ha utasításokkal fejtjük ki, akkor ez az értékadás már duplikáltan kell megjelenjen. Ilyenkor a kódot olvasva csak akkor fogunk rájönni, hogy a változó mindenképp kapott értéket, ha megnézzük a hamis és az igaz ágat is:

if a > b:
    nagyobb = a
else:
    nagyobb = b

Gondoljunk egy pillanatra az ÉS, illetve a VAGY műveletek igazságtáblájára. Az alábbiakat mondhatjuk:

• A and B: ha A=HAMIS, nem számít B, az egész biztosan HAMIS
• A or B: ha A=IGAZ, a kifejezés értéke biztosan IGAZ

def egy():
    print("egy")
    return 1
    
def ketto():
    print("kettő")
    return 2

print(egy(), ketto())

Ha mellékhatások vannak a programban, akkor nem mindegy a műveletek sorrendje. Az a = b után b += 1 nem ugyanazt csinálja, mint a b += 1 után a = b: nem mindegy, hogy a növelés előtti vagy utáni értéket másoljuk.

A fenti programrészben meghívjuk az egy() és a ketto() függvényeket is. Az teljesen biztos, hogy az alsó print egy sorba "1 2"-t fog írni, mivel pozicionálisan balról jobbra halad a neki átadott paraméterek megjelenítésével. A kérdés csak az, hogy melyik függvény hívódik meg előbb, tehát hogy a paraméterek milyen sorrendben állnak elő; ugyanis a paramétereket előállító függvényeknek is van kimenete. Vajon előbb az egy, vagy előbb a kettő sztring jelenik meg?

Szerencsére ez definiálva van: a kiértékelési sorrend adott (evaluation order), a függvény paramétereit balról jobbra határozza meg a nyelv. Tehát biztosak lehetünk abban, hogy előbb az egy(), utána pedig a ketto() függvény hívódik.

Elindítjuk ezt a programot, és megadunk neki két számot. Legyenek ezek 4 és 5. Mit ír ki a program, 4/5-öt, azaz 0.8-at, vagy esetleg 5/4-et, 1.25-öt? A két teljesen egyforma beolvas() függvényhívás közül melyik hajtódik végre először, amelyik az osztandót, vagy amelyik az osztót adja?

A válasz itt 0.8, mivel a kiértékelés balról jobbra halad. A bal oldali beolvas() lesz az első, vagyis az első beírt szám az osztandó, a második lesz az osztó.

Ha nem szeretnénk feleslegesen terhelni magunkat, és a programunk következő olvasóját, akkor nem érdemes ilyet írni. Jobb ez külön sorokban: tároljuk el az értékeket a változókban, adjunk azoknak a változóknak érthető nevet, és máris sokkal tisztább a kép!

szamok = [111, 222, 333]
while szamok != []:
    print(len(szamok), szamok.pop())

Ebben a kódban fordított sorrendben írjuk ki a lista elemeit: 333, 222, 111. Kérdés csak az, hogy előtte a sorszámok mik lesznek. A lista hosszát a .pop() előtt vagy után vizsgáljuk? Mert ez nem mindegy. Tegyük fel, hogy épp az utolsó elemnél tartunk, amit kivennénk. Ekkor az elem eltávolítása előtt a lista hossza még 1, utána viszont már 0.

Szerencsére ez definiálva, egyértelműsítve van: mivel a print() függvényhívás paramétereit balról jobbra haladva határozzuk meg, a len() előbb hívódik, mint a .pop().

Még egy nagyon zűrös példa:

szamok = [1, 2, 3]
szamok[int(input())] = int(input())

Adott egy lista. Ennek a felhasználó által adott indexű elemét felülírjuk egy értékkel, amit szintén a felhasználótól kaptunk. Honnan lehet tudni, hogy előbb az indexet, és utána az új értéket kell megadni, vagy fordítva? Ez nem derül ki ránézésre a kódból, hacsak nem kezdünk el a kiértékelési szabályokon gondolkodni (melyik input() hívódik előbb). De nem derül ki a felhasználó számára sem, mert szótlanul csak bemenetre várunk, ő pedig nem tudja, mi a kérdés.

Jobb a kódot így átalakítani:

szamok = [1, 2, 3]
mit = int(input("Mit: "))
hova = int(input("Hova: "))
szamok[hova] = mit

Így a felhasználó is tudja, mi a kérdés. És bármelyik programozó is, aki ránéz a kódra, tudni fogja, melyik beolvasás történik meg előbb; és mi lesz a kapott értékekkel, hogyan lesz felhasználva. A változónevek kifejezik a szándékot (intentional programming).

A létező legegyszerűbb számrendszer a kettes alapú. Ebben csak kétféle számjegy van, a 0 és az 1. Hogy miért ez a legegyszerűbb? Mert ebben az összeadó és a szorzótábla nem tízszer tízes, hanem mindössze kétszer kettes.

bináris összeadás

+	0	1
0	0	1
1	1	10

bináris szorzás

×	0	1
0	0	0
1	0	1

Bitek és bitcsoportok

bit

Az információ alapegysége: 0 vagy 1.

bájt (byte): a memória (adatkezelés) egysége

Jellemzően 8 bites csoport.

szó (word): több bájtos adategység

Általában 4 bájt (32 bit), vagy 8 bájt (64 bit).

Előtagok (prefix)

A kettes számrendszerbeli működés miatt a szokásos mértékegységeknek megvan a bináris párja. Bár a kilo- előtag általában ezret jelent, a számítástechnikában inkább 1024-et, azaz 2¹⁰-t. Ezt azért választották meg így, mert a kettő között nagyon kicsi a különbség. Sajnos gyakran keverik is a kettőt. A merevlemezgyártók például előszeretettel használják a kilo=1000 jelölést, mert így nagyobb kapacitást írhatnak rá az eladott merevlemezekre. Hogy ne kelljen mindig hozzátenni, ha pontosak akarunk lenni, hogy a bináris vagy a decimális prefixumról beszélünk, bevezették a kibibájt, mebibájt stb. jelöléseket. Egy DVD kapacitása így 4,7 gigabájt, azaz 4,3 gibibájt.

kilobájt (kB) és kibibájt (KiB)

10³=1000 ≈ 2¹⁰=1024 bájt.

megabájt (MB) és mebibájt (MiB)

10⁶=1000000 ≈ 2²⁰=1048576 bájt.

gigabájt (GB, GiB), terabájt (TB, TiB)

10⁹≈2³⁰ és 10¹²≈2⁴⁰ bájt.

Érdekesség: A „binary digit”, azaz bináris számjegy szókapcsolatot eredetileg „bigit” vagy „binit” néven rövidítették. Később a „bit” szót John Tukey, amerikai matematikus javasolta. (Ő találta ki a „software” szót is.) A bit szó tudományos írásban először Claude Shannon diplomamunkájában szerepelt, amelynek címe A Symbolic Analysis of Relay and Switching Circuits. Ebben megmutatta, hogy az addig telefonközpontokban használt relék segítségével logikai problémák is megoldhatóak. Pár évvel később megépült az első relékből felépített, kettes számrendszert használó számítógép, a Harvard Mark I. Azóta gyakorlatilag nem készül olyan számítógép, amely nem bináris elven működne.

Míg az 1000² százezerszeri kiszámításához elég volt 50 ezredmásodperc, addig a (1000!)² százezerszeri kiszámításához több, mint 3 másodpercre volt szükség.

Amíg egész számokról van szó, a Python nyelvben bármekkora értékekkel tudunk dolgozni. Ha annyira nagyok a számok, hogy azok már nem férnek el a processzor egy regiszterében, akkor a Python környezet gondoskodik róla, hogy máshogy kezelje. Ilyenkor minél nagyobb a szám, annál több memóriát foglal hozzá, ahol a számot ábrázoló bitek, vagyis a szám kettes számrendszerbeli alakja eltárolható.

Ez nagyjából úgy kell elképzelni, mintha fognánk egy listát, és abba biteket, 0-kat és 1-eket tennénk csak: a listában tárolt egyes számok kicsik, a lista hossza viszont szabadon változhat. Ilyenkor természetesen az elvégzett műveletek is egyre lassabbak; az összeadáshoz annyi műveletet kell végezni, ahány bitből áll a szám, a szorzáshoz pedig annyit, mint a két összeszorzott szám számjegyei számának szorzata (gondoljunk az írásbeli szorzás algoritmusára, amit általános iskolában mindenki tanult). Ezért lassabb látványosan – kb. 60-szor – az 1000 faktoriálisának négyzetre emelése, mint az 1000-é.

Emiatt a számítások eredménye sokszor pontatlan! Még az is előfordulhat, hogy a+b=a, ahol a egy nagy, b pedig egy kicsi szám. Ez történik (színezve az értékes jegyek):

a    10000000000000.0000000
b   +             0.0000001
    ───────────────────────
a+b  10000000000000.0000001 → 10000000000000 lesz!

Így az == és != operátorokat valós számokon elvileg nem is lenne szabad használni, de a többi is adhat váratlan eredményt. Ehelyett a módszer az, hogy az összehasonlításokat egy adott tűréssel végezzük. Például egyenlőség helyett ezt a kifejezést használjuk: abs(a-b)<0.0001. Tehát ha a két szám különbsége kevesebb egy tízezrednél, akkor egyenlőnek tekintjük őket.

A tizedek nem ábrázolhatóak pontosan kettes számrendszerben, mert 1/10 = 1/(2*5), tehát nem 2 hatványa. Emiatt sem a 0,1, sem a 0,2 nem ábrázolható, csak közelítőleg; az összegük a kerekítési hiba miatt nem adja ki a 0,3 értéket, hanem 0,30000000000000004-et kaptunk, ami pedig tényleg nem ugyanannyi, mint a 0,3. (Vegyük észre, hogy tízes számrendszerben is pont azok a törtek ábrázolhatóak pontosan, amelyek nevezőjének prímtényezői 2 és 5. Minden másból végtelen, szakaszos tizedes tört lesz.)

A második rész ciklusát vizsgálva is úgy gondolnánk, az 10 sort fog a kimenetre írni. Az első szám a 0,0; az utolsó pedig a 0,9 lesz. 1,0 már nem íródik ki, mert az nem kisebb, mint 1,0.

Ha elindítjuk a programot, akkor viszont 11 sor jelenik meg. Olyan, mintha a ciklustörzs még 1,0-nál is lefutna... A kimeneten viszont látjuk a számítási pontatlanságot: az eredmény hol „eltalálja” a tizedet, hol egy kicsit „mellémegy”.

A harmadik rész egy túlcsordulást mutat. A 3 ** 1000 érték kiszámítható. Ott egész számokkal dolgozunk. A 3.0 ** 1000 már nem. Bár matematikailag a 3,0 egész szám, a tizedesrész kiírása miatt a 3.0 float típusú adatnak számít, így lebegőpontos számként tárolódik. A nagy kivetőjű hatvánnyal pedig beleütközünk a számábrázolás korlátaiba: „elhasználjuk” a legnagyobb karakterisztikát, nincs már több bitünk, ahol a kapott számot tárolni lehetne.

Tömbök: összefüggő memóriaterület

Bizonyos típusú adatokhoz nagyon sok számot kell eltárolnunk, de tudjuk, hogy ezek korlátos tartományban lesznek. Ilyen például egy kép: a fekete színt a 0 jelképezi, a fehéret az 1, és közte a szürkék. Nem szükséges sem kisebb, sem nagyobb számokat ábrázolnunk, és tudjuk, hogy az összes képpont egyforma típusú adat lesz.

Ilyenkor sokkal hatékonyabb lehet a programunk – mind memóriahasználat, mind sebesség – terén, ha egyforma típusú adatokat nem listába tesszük, hanem egy tömbbe (array). Ez egyrészt nem referenciákat tárol, hanem az adatokat érték szerint (tehát a memóriában a tényleges számértékek egymás mellett lesznek), másrészt pedig fix, ismert típusú és méretű (ismert számú bájtból álló) adatokat egymás mellett.

Az array modul array típusával hozhatunk létre ilyen tömböt. Ennek meg kell adni az egyes tárolt számok típusát (lásd lentebb), ez meghatározza az ábrázolható számtartományt. Másrészt pedig megadhatunk kezdeti értékeket, amik meghatározzák a tömb méretét; vagy később .append() segítségével nyújthatjuk a tömböt.

Az összefoglaló táblázat az array típus első paramétereként használható típusjeleket tartalmazza. A byte, short és long típusok egész számokat képesek tárolni. Mindegyiknek van előjeles (kisbetűs) és előjel nélküli (nagybetűs) változata. A tartományt az előjel nélküli változatra adtuk meg; előjeles változat esetén ugyanekkora tartományról van szó, de felével el van tolva a negatív irányba. (Például 'b' esetén –128 ... +127 értékű.)

A float és a double típus lebegőpontos számokat tárol. Ezek mindig lehetnek negatívak is, viszont a fentebb részletezett számítási pontatlanságok előjöhetnek a használatuk közben bármikor. Mindkét típus mérete véges, tehát adott egy pontosság: a floatnál ez kb. 6 tizedesjegy, a double-nél kb. 15), és egy ábrázolási tartomány – ahogy a táblázat mutatja. A Python kódunkban használt lebegőpontos számok egyébként az itteni double típussal egyeznek meg.

Van még két típus, amelyek a fenti array-hez hasonlóak; ezek a bytes és a bytearray. Fájlkezelésben fogjuk használni őket később. Amúgy a működésük nagyjából megegyezik a B-vel (előjel nélküli bájt típussal) használt array-ével.

A számítógépek processzorai – mivel maguk is bitekkel dolgoznak – általában tartalmaznak olyan gépi utasításokat, amelyekkel a tárolt számok egyes bitjeit tudjuk állítgatni, mégpedig a Boole-féle algebrából ismert műveletekkel. Ebben az algebrában a változóknak két értékük lehet: HAMIS és IGAZ, vagy bitekben gondolkodva 0 és 1.

A bitműveletek segítségével az egész szám típusú értékek egyes bitjeit is elérjük. Ezeket a műveleteket sok területen alkalmazhatjuk:

• Minden bit kihasználása, tömörítés: egy 8 bites változóba 8 IGAZ/HAMIS értéket sűríthetünk.
• Hardverközeli programozás: hardvereszközben adott bit 1-esbe állításával bekapcsolunk egy funkciót, pl. grafikus kártyán egérmutató láthatósága.
• Hálózatprogramozás: egy internet adatcsomag adott bitjei jelzik, hogy kapcsolat létrehozása, lebontása stb. történik-e.
• Kriptográfia és véletlenszámok: titkosítási és ellenőrző összegeket előállító algoritmusok, pszeudo-véletlenszámokat előállító algoritmusok.

Érdemes megvizsgálni ezen műveletek tulajdonságait egy különös szemszögből: az egyik bemenetet változatlanul hagyva azt figyelni, hogyan reagál a kimenet a másik bemenet megváltozására. Az igazságtáblák alapján:

• Az ÉS műveletnél: ha az egyik bemenet A = 0, akkor a másik, B bemenet értékétől függetlenül 0 jelenik a kimeneten. Ha az előbbi bemenet A = 1-es, akkor a kimenet értéke azonos lesz a másik bemenettel; mintha lemásolná azt.
• A VAGY műveletnél: ha A = 0 bemenetet adunk, akkor a kimeneten mintha a B értéke jelenne meg. Ha A = 1-et, akkor viszont fixen 1 a kimenet. Másképp fogalmazva, ez a művelet lemásolja az egyik bemenetét, ha a másik 0, és fixen 1-et ad a tőle függetlenül, ha a másik 1.
• XOR (exclusive or): ha az egyik bemenet 0, akkor a másikat lemásolja. Ha az előbbi 1-es, akkor pedig az utóbbit negálva másolja. Vagyis mintha egy ki-bekapcsolható inverter lenne.

A következő pontok feladatainál kiderül majd, hogy miért hasznosak ezek a megfigyelések.

Egy nagyon fontos megjegyzés előzetesen: a bitenkénti műveletek nem keverendőek a logikai műveletekkel! Míg a bitenkénti műveletek egy vagy két szám, azaz int típusú érték azonos helyiértékű bitjein dolgoznak páronként, addig a logikai műveletek bool típusú értékekkel. Míg a bitenkénti ~ művelet egy egész szám összes bitjét ellentettjére állítja, a logikai not művelet a True–False értékeket cseréli. Ugyanígy, a bitenkénti | nem ugyanaz, mint a logikai or, és a bitenkénti & mást csinál, mint a logikai and művelet. A ^ kizáró vagy műveletnek nincsen logikai párja. Vagyis de: a != operátor végülis az, ha bool típusra használjuk.

Figyelem! A bitenkénti léptetés operátorok ugyanolyanok, mint az összeadás vagy a szorzás: két operandusuk van, és létrehoznak egy harmadik számot, az eredményt. Eközben a két operandusukat nem változtatják meg, nincs mellékhatásuk! A b = a << 3 kifejezés így az a változó értékét változatlanul hagyja, és csak b változik. A többihez hasonlóan viszont ezeknek is megvan a rövidített, értékadó párjuk:

• x <<= 3 ugyanaz, mint x = x<<3, és
• x >>= 2 ugyanaz, mint x = x>>2.

A program elején „teli”, csupa 1-ekből álló tömbbel indulunk: mindent prímszámnak tekintünk. Ezért a tömböt feltöltjük olyan értékekkel, amely csupa 1-es bitekből áll.

Ezután megyünk végig a szitán az sz-es ciklussal. A tömb 1000 elemű, de minden elem 8 bitet tárol, ezért 8000-ig tudjuk vizsgálni a számokat. Amint találunk egy prímet, annak a többszöröseit húzzuk majd ki. A bit vizsgálatához a bitenkénti ÉS & műveletet használjuk: előállítjuk az 1 << sz%8 maszkot, amely csupa 0-ból áll, kivétel az sz%8-adik bitet, ahol 1-es van. Ezt a maszkot ÉS-elve a tömb eleméhez 0-t kapunk, ha a vizsgált bit nulla értékű, amúgy pedig nem nullát.

A t-s ciklus húzza ki az sz többszöröseit a tömbből, vagyis jelöli be, hogy nem prímek. Ehhez nullába kell állítania a többszöröshöz tartozó bitet, ami a bitenkénti ÉS & művelettel tehető meg.

A program végére a következő apró kódrészletet téve láthatóvá válik a tömb eleje:

print()
for b in range(0, 10):
    bits = f"{prim[b]:08b}"
    print(bits[::-1])

Ebben az 1-es bitek jelölik a prímszámokat (kivéve a legelső kettőt, mert azok a 0-nak és az 1-nek felelnek meg, de azokkal nem foglalkozunk):

11110101
00010100
01010001
00000101
00000100
01010001
00000100
00010100
00010001
01000001