Bevezetés a Python nyelvbe

Az előadás nagyvonalakban a hivatalos Python tutorial-t követi.

A Python egy olyan általános körben használható magas szintű programozási nyelv, aminek az egyik alapelve az olvasható kód írása egy nagyon tiszta szintaxis használatával. 1991-ben alkotta meg Guido Van Rossum.

Nevét a Monthy Python ihlette, nem az állat.

Miért Python?

Népszerűsége

Előnyei

  • Könnyen tanulható, interaktív, kezdőknek ideális (ld. Raspberry Pi)
  • A kód könnyen olvasható, bonyolult feladatokra egyszerű parancsok
  • Több rendszeren, platformon fut
  • Objektumorientált
  • Web-programozásra alkalmas (Google, Yahoo, IBM, NASA, Disney, Dropbox,...)
  • Gyors fejlesztés, rövid kód, nagy feladatokra is alkalmas
  • Források nagy száma
  • Az adattudományban (data science) erős
  • Nyílt forráskódú, szabadon hozzáférhető, használható, üzleti célra is

Hátrányai

  • Lassú
  • Mobil-programozásra nem a legjobb
  • Nagy grafikai igényű (3D) programozásra nem alkalmas

Futtatás

Több módon is futtathatunk python kódot.

Parancssorból

Parancssorból futtatható, pl interaktívan: $ python Ekkor interaktív pythont kapunk amibe közvetlen írhatunk parancsokat.

De lefuttathatunk parancssorból egy létező python file-t is (.py kiterjesztésű file): $ python hello.py Ekkor lefut a program és ha van szöveges kimenete a programnak az látható lesz a parancssorban.

Jupyter (IPython)

A Jupyter egy böngészőn keresztül használható fejlesztői környezet pythonhoz, mely a tavalyi Sage notebookhoz hasonlít. Ez az amit az előadás írásához használunk és gyakorlaton is fogjuk használni.

Indítani egy IPython szervert a következő paranccsal tudunk a leibniz-en: $ ipython notebook --port=##### --no-browser Ahol a ##### helyére egy 16000 és 20000 közti számot írjunk. Ekkor böngészőben a localhost:##### oldalon érhetjük el az IPython notebookunkat.

Spyder

A Spyder is egy fejlesztői környezet pythonhoz, a leibniz-en fent van és kényelmesen telepíthető bármilyen oprendszerre: Telepítés

Windowsra ajánljuk a WinPython telepítését (ezen belül a 2.7-es verziót), mely kényelmesen tartalmazza a Jupytert és Spydert is.

Objektumok

Az objektumok a nyelv alapelemei, ezekkel fogunk dolgozni. Minden objektumnak van típusa. A következő típusokkal kezdjük:

  • int (egész): 2354, -12
  • float (lebegőpontos szám): 1.0, -23.567, 2.3E4
  • bool (logikai): True, False
  • string (karakterlánc): "kiskutya", "Volt egyszer egy kiskutya"

Műveletek, kifejezések

Az objektumok műveletekkel összekapcsolva kifejezéseket adnak, melyek kiértékelve valamilyen típusú objektumot adnak. Az egész és a lebegőpontos műveletek:

  • a + b összeadás
  • a - b kivonás
  • a * b szorzás
  • a / b osztás (Python 2.7-ben int/int = int, Python 3-tól float)
  • a // b egész osztás
  • a % b maradékképzés
  • a ** b hatványozás (NEM a ^ b, mint a sage-ben!)
  • a == b, a < b, a > b, a <= b, a >= b, a != b, a <> b

Logikai műveletek bool-típusúak közt:

  • a and b, „és”
  • a or b, „megengedő vagy”
  • not a, „nem”

Stringeken alapvető műveletek:

  • a + b, konkatenálás
  • a in b, tartalmazás vizsgálat (eredménye bool)

Például

In [46]:
5 + 11
Out[46]:
16
In [47]:
2 ** 251
Out[47]:
3618502788666131106986593281521497120414687020801267626233049500247285301248L
In [48]:
a = 54
b = a - 50
a * b
Out[48]:
216
In [49]:
54 > 12
Out[49]:
True
In [50]:
b < 0
Out[50]:
False
In [51]:
54 > 12 or b < 0
Out[51]:
True
In [52]:
s = "macska"
"ma" in s
Out[52]:
True
In [53]:
s = "kis" + s
s
Out[53]:
'kismacska'

Változónevek

  • a név betűvel vagy aláhúzással kezdődhet: [_a-zA-Z]
  • a név további karakterei az előbbieken felül számok is lehetnek: [_a-zA-Z0-9]
  • elméletileg bármilyen hosszú lehet a név
  • név nem lehet foglalt szó
  • nagybetű-kisbetű érzékeny, tehát a val1 név nem azonos a Val1 névvel

Karakterláncok

Három módon adhatunk meg karakterláncokat:

In [54]:
s = "kiskutya"
In [55]:
s = 'kiskutya'
In [56]:
s = """Volt egyszer egy kiskutya.
Elment a vásárba."""
In [57]:
s
Out[57]:
'Volt egyszer egy kiskutya.\nElment a v\xc3\xa1s\xc3\xa1rba.'

Itt a vezérlő karaketerek (\n a sorvége jel) és az ékezetes karakterek UTF-8 kódja (á betű kódja c3a1, \x után a bájt hexa kódja) jelenik meg. A print utasítás olvashatóan írja ki:

In [58]:
print s
Volt egyszer egy kiskutya.
Elment a vásárba.

Az első kettőnek kényelmi szerepe van, mert amelyik idézőjelet nem használjuk a string jelzésére azt használhatjuk a stringben. Például:

In [59]:
print "Egy 'macskaköröm' " + 'ketto "macskaköröm"'
Egy 'macskaköröm' ketto "macskaköröm"
In [60]:
'Van ilyen: \' meg ilyen: "'
Out[60]:
'Van ilyen: \' meg ilyen: "'
In [61]:
print 'Van ilyen: \' meg ilyen: "'
Van ilyen: ' meg ilyen: "

A harmadikban használhatunk sortörést és ez a stringben is sortörésként fog megjelenni. Míg a többi jelöléssel sortörést a \n kifejezéssel tudunk tenni.

További speciális karakterek stringekben: \\\\ (\\), \' ('), \" ("), \n (új sor), \t (tab)

Kiírás

Itt a Jupyterben az egyes cellák eredménye az utolsó érték ami kiértékelődött, de például, ha parancssorban futtatunk egy korábban megírt python file-t, akkor még ez sem lesz kiírva. Ha valamit ki akarunk írni azt konkrétan meg kell tennünk:

In [62]:
5 + 8
5 + 7
Out[62]:
12
In [63]:
a = 5
print a
a = 15
print a * 2
a
5
30
Out[63]:
15
In [64]:
string = "kiskutya"
"Volt egyszer egy " + string
Out[64]:
'Volt egyszer egy kiskutya'
In [65]:
print "Volt egyszer egy %s, elment a vásárba." % string
Volt egyszer egy kiskutya, elment a vásárba.

Ha egy stringben %s szerepel akkor utána % jellel behelyettesíthetünk erre a pozícióra egy másik stringet. Több behelyettesítés esetén:

In [66]:
print "Volt %s egy %s, elment a %s." % ("egyszer", "kiskutya", "vásárba")
Volt egyszer egy kiskutya, elment a vásárba.

Nem csak stringeket lehet behelyettesíteni, egész vagy lebegőpontos számokat is lehet:

In [67]:
print """A %d egy decimális egész (integer), 
a %f pedig egy lebegőpontos (floating point) szám.""" % (23, 1.0/3)
A 23 egy decimális egész (integer), 
a 0.333333 pedig egy lebegőpontos (floating point) szám.

Beolvasás

Ha már kiírni tudunk dolgokat, akkor tanuljunk meg beolvasni is:

In [68]:
raw_input()
123
Out[68]:
'123'
In [69]:
a = 5
nev = raw_input("Mi a neved? ")
print "Szia %s!" % nev
Mi a neved? Laci
Szia Laci!
In [70]:
input() > 10
123
Out[70]:
True
In [71]:
input() ** 10
123
Out[71]:
792594609605189126649L

A különbség a raw_input és input között ez:

In [72]:
a = raw_input()
a + " macska"
kutya
Out[72]:
'kutya macska'
In [73]:
b = input()
b + " macska"
"kutya"
Out[73]:
'kutya macska'

Azaz a raw_input mindig stringként olvassa be bármit is adunk meg, míg az input megpróbálja értelmezni azt amit beírtunk:

In [74]:
type(input())
123
Out[74]:
int

Elágazás

In [75]:
x = input()
if x < 0:
    print "ez negatív"
elif x == 0:
    print "ez nulla"
elif x == 1:
    print "ez egy"
else:
    print "ez sok"
1/2
ez nulla

Az elif-ek száma tetszőleges, de se az elif se az else megadása nem kötelező.

Ha az eredeti feltétel teljesül (igazra értékelődik), akkor az ő blokkjába eső (alatta behúzott) kód fut le, ha nem teljesül akkor az első olyan elif blokk fut le aminek a feltétele igaz, ha ezek se igazak akkor az else ág blokkja fut le, feltéve hogy van.

A behúzás (indentálás) legelterjedtebb mértéke a négy szóköz.

While ciklus

In [76]:
n = 1000
a = 1
while a ** 3 < n:
    print a ** 3,  # a vessző miatt egy sorba kerülnek
    a = a + 1
print "vége"
1 8 27 64 125 216 343 512 729 vége

A while ciklus blokkja lefut újra és újra, amíg teljesül a ciklus feltétele.

Így tehát a fenti kód addig növeli az a változót, amíg annak köbe legalább 1000 nem lesz.

Ciklusokat és elágazásokat egymásba ágyazhatunk:

A híres Collatz- vagy $3x+1$-probléma:

In [77]:
a = input()
while a != 1:
    print a,  # a vessző miatt egy sorba kerülnek
    if a % 2 == 0:
        a = a / 2
    else:
        a = a * 3 + 1
27
27 82 41 124 62 31 94 47 142 71 214 107 322 161 484 242 121 364 182 91 274 137 412 206 103 310 155 466 233 700 350 175 526 263 790 395 1186 593 1780 890 445 1336 668 334 167 502 251 754 377 1132 566 283 850 425 1276 638 319 958 479 1438 719 2158 1079 3238 1619 4858 2429 7288 3644 1822 911 2734 1367 4102 2051 6154 3077 9232 4616 2308 1154 577 1732 866 433 1300 650 325 976 488 244 122 61 184 92 46 23 70 35 106 53 160 80 40 20 10 5 16 8 4 2

Ezt megtehetjük akárhány mélységig (ciklusok is ágyazhatók egymásba):

In [ ]:
a = input()
if type(a) == int:
    while a != 1:
        print a,  # a vessző miatt egy sorba kerülnek
        if a % 2 == 0:
            a = a / 2
        else:
            a = a * 3 + 1
else:
    print "Egesz szamot adjunk meg"

A fenti kód már azt is teszteli, hogy a felhasználó egész számot adott-e meg. Védjük ki azt is, ha negatív számot adott meg:

In [79]:
a = input()
if type(a) == int:
    if a < 0:
        a = -1 * a
    while a != 1:
        print a,  # a vessző miatt egy sorba kerülnek
        if a % 2 == 0:
            a = a / 2
        else:
            a = a * 3 + 1
else:
    print "Egesz szamot adjunk meg"
-26
26 13 40 20 10 5 16 8 4 2

Végül már csak a 0 alesetet kell kizárni, hisz 0-ra se működik:

In [80]:
a = input()
if type(a) == int and a != 0:
    if a < 0:
        a = -1 * a
    while a != 1:
        print a,  # a vessző miatt egy sorba kerülnek
        if a % 2 == 0:
            a = a / 2
        else:
            a = a * 3 + 1
else:
    print "Nullatol kulonbozo egesz szamot adjunk meg"
0
Nullatol kulonbozo egesz szamot adjunk meg

Break

Ciklusokban használható a break utasítás, hogy a feltételt figyelmen kívül hagyva azonnal kiugorjunk a ciklusból:

In [ ]:
n = input("Adj meg egy negyzetszamot 10000 alatt! ")
a = 0
while a ** 2 < 10000:
    if a ** 2 == n:
        break
    a = a + 1
if a ** 2 < 10000:
    print "A négyzetszám gyöke: %d" % a
else:
    print "Hazudtál! :("
Adj meg egy negyzetszamot 10000 alatt! 87*87
A négyzetszám gyöke: 87

Ha több ciklus van egymásba ágyazva, akkor a legbelső ciklusból ugrik ki, melynek blokkjában van.