info1-prog-osszefoglalo

Zsbán Ambrus, 2010
Kovács Krisóf, 2014

Aritmetika

137 * 10 # szorzás

137 / 10 # osztás

137 % 10 # és a maradék

5**4 # hatványozás

10 < 137 # összehasonlítás: kisebb

True

137 == 10

False

0 < 137 and 137 < 200

True

Hat összehasonlító operátor van: < <= == != > >=

Igaz-hamis értékekből lehet újabb igaz-hamis értékeket kapni az and (és), or (vagy), not (nem) operátorokkal.

0 < -19 and -19 < 200

False

Utasítások

mu = 137 # értékadás, létrehozza az új "mu" nevű változót, mivel eddig még nem volt ilyen

10 * mu

mu = mu + 1 # először kiértékeli az egyenlőségjel jobb oldalán álló kifejezést, majd megváltoztatja a változó értékét

10 * mu

k10 = 3 k4 = 5 if 10 < 4: print "a 10 kisebb" k10 = 100 if 4 < 10: print "a 4 kisebb" k4 = 5 print "k10 =", k10, "; k4 = ", k4

a 4 kisebb
k10 = 3 ; k4 =  5

A feltételes utasítás egy vagy több utasítást akkor hajt végre, ha a feltétel igaz. A feltétel alá tartozó utasításokat jobbrább kell kezdeni, mint a feltételes utasítás elejét: az mindegy, hogy mennyivel, de ha egy feltételes utasítás belsejében több utasítás van, akkor mindegyiket ugyanannyival.

sa = 4 sb = 9 sc = 3 print "a sorrend:", if sa < sb: if sb < sc: print "sa < sb < sc" else: if sa < sc: print "sa < sc < sb" else: print "sc < sa < sb" else: if sb < sc: if sa < sc: print "sb < sa < sc" else: print "sb < sc < sa" else: print "sc < sb < sa"

a sorrend: sc < sa < sb

Az else alatti parancsok akkor hajtódnak végre, ha a feltétel hamis. Ha az else ágban egyetlen if utasítás áll, akkor e helyett lehet használni az elsif rövidítést, tehát az előbbit így is írhatjuk.

print "a sorrend:", if sa < sb: if sb < sc: print "sa < sb < sc" elif sa < sc: print "sa < sc < sb" else: print "sc < sa < sb" else: if sb < sc: if sa < sc: print "sb < sa < sc" else: print "sb < sc < sa" else: print "sc < sb < sa"

a sorrend: sc < sa < sb

Ez leginkább a következőhöz hasonló többszörös elágazásnál hasznos.

pont = 61 if 68 <= pont: jegy = 5 elif 56 <= pont: jegy = 4 elif 44 <= pont: jegy = 3 elif 32 <= pont: jegy = 2 else: jegy = 1 jegy

if 68 <= pont: jegy = 5 else: if 56 <= pont: jegy = 4 else: if 44 <= pont: jegy = 3 else: if 32 <= pont: jegy = 2 else: jegy = 1 jegy

A while utasítás ugyanolyan, mint az if, csak ha a feltétel igaz, akkor az utasítások végrehajtása után újra ellenőrzi a feltételt, és ha megint igaz, akkor megint végrehajtja az utasításokat, majd újra ellenőrzi a feltételt stb.

n = 90 while 0 < n: print n, n = n / 2

90 45 22 11 5 2 1

n = -3 while 0 < n: print n, n = n / 2

Listák

vek = [6, 3, 6, 10, 3, 7, 8, 4]

vek[0]

vek[1]

vek[7]

vek[4] = 99 vek

[6, 3, 6, 10, 99, 7, 8, 4]

vek.append(33) vek

[6, 3, 6, 10, 99, 7, 8, 4, 33]

len(vek)

for elem in vek: neg = -elem print neg

-6
-3
-6
-10
-99
-7
-8
-4
-33

A szögletes zárójelek írható listát hoznak létre. Az a tömb egy elemét az a[k] éri el, ahol a k az index (0-tól kezdődik). Az a[k] = x utasítás módosítja a k indexű elemet. Az a.append(x) megnöveli eggyel a tömb hosszát azzal, hogy a végére beszúrja az x elemet. A len függvény a tömbben lévő elemek számát adja vissza. A for utasítás egy tömb minden elemére végrehajt néhány utasítást, az éppen vizsgált elemet egy változónak adja értékül.

ossz = 0 huszszor = [] for t in [3, 4, 5]: ossz = ossz + t huszszor.append(20 * t) print ossz print huszszor

12
[60, 80, 100]

A range(n) egy n hosszú tömböt hoz létre, aminek az elemei az első n szám. Ez leginkább a for ciklushoz hasznos.

range(8)

[0, 1, 2, 3, 4, 5, 6, 7]

veka = [0, 10, 4] vekb = [7, -1, 10] szorzat = 0 for t in range(len(veka)): szorzat = szorzat + veka[t] * vekb[t] print szorzat # veka és vekb skaláris szorzata

Függvények

def ketszer(x): return 2 * x

ketszer(10)

def abszolutertek(x): if x < 0: return -x else: return x

print abszolutertek(4) print abszolutertek(-2)

4
2

print 1 + abszolutertek(-3) print abszolutertek(abszolutertek(10) - 1)

4
9

def skalarszorzat(u, v): szorzat = 0 for k in range(len(veka)): szorzat = szorzat + veka[k] * vekb[k] return szorzat

skalarszorzat([0, 10, 4], [7, -1, 10])

A fentiek mutatják, hogy a def paranccsal lehet saját függvényt definiálni. Egy ilyen függvényt úgy hívhatunk meg, hogy a neve után zárójelek között felsoroljuk az argumentumait (vesszővel elválasztva). Ekkor a függvény törzsében lévő utasítások lefutnak, és a return utasítás adja meg a függvény visszatérési értékét. Azt is látjuk, hogy függvényhívást bárhol használhatunk, ahol egy kifejezés állhat.

A fenti három függvény matematikai értelemben is függvény, mert nincs mellékhatása: nem csinál semmit azon kívül, hogy visszatérési értéke van, és a visszatérési értéke csak az argumentumoktól függ. Lehet olyan függvényeket is definiálni, amire ez nem teljesül.

def belepiszkit(tomb): tomb[2] = -tomb[2]

vek = range(8) vek

[0, 1, 2, 3, 4, 5, 6, 7]

belepiszkit(vek)

vek

[0, 1, -2, 3, 4, 5, 6, 7]

belepiszkit(vek)

vek

[0, 1, 2, 3, 4, 5, 6, 7]

Szótárak

A szótárak olyan adatszerkezetek melyekben kulcsokhoz rendelhetünk értékeket. Majd a kulcsokkal érjük el a hozzájuk tartozó értéket. Kulcsnak majdnem minden adattípust használhatunk, leggyakrabban stringet, vagy számot használunk kulcsként. Értékként bármilyen adattípus tárolható. A szótárakon való iterálás (for ciklussal bejárás) a kulcsokat járja be.

d = {"Jozsef":500, "Andras":300} d["Jozsef"]

d["Bela"] = 700 d

{"Jozsef":500, "Andras":300, "Bela":700}

for k in d: print k

Jozsef
Andras
Bela

for k in d: print d[k] / 10

50
30
70