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.

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
  • 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 [ ]:
5 + 11
In [ ]:
2 ** 25
In [ ]:
a = 54
b = a - 50
a * b
In [ ]:
54 > 12
In [ ]:
b < 0
In [ ]:
54 > 12 or b < 0
In [ ]:
s = "macska"
"ma" in s
In [ ]:
s = "kis" + s
s

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 [ ]:
s = "kiskutya"
In [ ]:
s = 'kiskutya'
In [ ]:
s = """Volt egyszer egy kiskutya.
Elment a vasarba."""
In [ ]:
s

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 [ ]:
"Egy 'macskakorom' " + 'ketto "macskakorom"'
In [ ]:
'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 [ ]:
5 + 8
5 + 7
In [ ]:
a = 5
print a
a = 15
print a * 2
a
In [ ]:
string = "kiskutya"
print "Volt egyszer egy " + string
In [ ]:
print "Volt egyszer egy %s, elment a vasarba." % string

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 [ ]:
print "Volt %s egy %s, elment a %s." % ("egyszer", "kiskutya", "vasarba")

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

In [ ]:
print "A %d egy decimalis egesz szam. A %f pedig egy floating point szam." % (23, 1.0/3)

Beolvasás

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

In [ ]:
raw_input()
In [ ]:
a = 5
nev = raw_input("Mi a neved? ")
print "Szia %s!" % nev
In [ ]:
input() > 10
In [ ]:
input() ** 10

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

In [ ]:
a = raw_input()
a + " macska"
In [ ]:
b = input()
b + " 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 [ ]:
type(input())

Elágazás

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

Az elif-ek száma tetszőleges, se elif se else írása nem kötelező.

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

Itt megjegyezzük, hogy az indentálások jelzésére a legelterjedtebb mód a négy szóköz minden behúzás jelölésére.

While ciklus

In [ ]:
n = 1000
a = 1
while a ** 3 < n:
    print a ** 3,  # a vessző miatt egy sorba kerülnek
    a = a + 1
print "vege"

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:

In [ ]:
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

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 [ ]:
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"

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

In [ ]:
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"

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! :("

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