Bevezetés a Python nyelvbe

Az előadás nagyvonalakban a hivatalos Python tutorial 3.7-et követi, de lehet használni a w3schools tutorial-ját is.

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ő (free as in free speach not as in free beer), használható, üzleti célra is

Hátrányai

  • Lassú (hatékony szoftverek írására kevésbé alkalmas)
  • Mobil-programozásra nem a legjobb
  • Nagy grafikai igényű (3D) programozásra nem alkalmas

Futtatás

  • a python ú.n. interpretált (interpreteres) nyelv (Interpretált nyelv végrehajtja az utasításokat anélkül, hogy közvetlenül gépi kódra fordítaná azt – ellentétben a fordítóprogramos nyelvekkel)
  • egy általunk írt kód lefuttatásához egy másik programra van szükségünk: ú.n. interpreter (mint egy tolmács az általunk írt kód és a gépi kód között), valójában itt van egy köztes lépés, az interpreter egy ún. Python byte-kódot állít elő,
  • az általunk írt kód gép és operációs rendszer független (többnyire), a futtató program gép illetve oprendszer függő.

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

Parancssorból

Parancssorból futtatható, a Python interaktív interpretere: $ python Ez egy saját prompt-ot ad, ahová közvetlenül írhatunk Python-kódot.

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.

Itt az interpreter a python(.exe)

IDLE (Interactive Development & Learning Environment)

Az IDLE a Pythonnal együtt jön, és egyszerre ad az interaktív interpreternek is és a programkód szerkesztésének is egy ablakot (ha szükséges, többet): $ idle idle

Jupyter notebook

A Jupyter egy böngészőn keresztül használható fejlesztői környezet, többek közöt python-hoz. Ezt lehet saját gépről is használni (ha telepítve van), de gyakorlaton a jupyter.math.bme.hu-t fogjuk használni. Ez ugyan olyan, mintha a saját gépről kiadnánk a jupyter notebook parancsot.

A Jupyter maga egy webes felhasználói felület, a háttérben Python (és akár Sage, R vagy más) interpretert ( kernel ) futtat.

Spyder

A Spyder egy grafikus fejlesztői környezet pythonhoz, a leibniz-en fent van de kényelmesen telepíti bárki bármilyen oprendszerre.

Ez nem interpreter, hanem egy program ami a kód írását és futtatását könnyíti meg, de muszáj használnia egy interpretert.

Otthonra

Az Anaconda disztribúciót javaslom. Van minden főbb asztali oprendszerre (Linux, Mac, Windows)

  • válasszuk ki a megfelelő oprendszert
  • válasszunk a 3.7-es verziót
  • figyeljünk, hogy 32 vagy 64 bites

Ez nagyon sok mindent tartalmaz, pl. parancssori (python, ipython), notebook (jupyter) és grafikus (Spyder) környezetet, statisztikai programnyelvet (R), és sok hasznos függvénykönytárat.

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
  • str (karakterlánc, sztring): "Pál fogyó IQ-jú kun exvő, ím dühös a WC-bűzért.", "öt hűtőházból kértünk színhúst", "ハンガリーからのご挨拶", "هنغاريا", "Венгрия", "헝가리", "הונגריה", "匈牙利", "ฮังการี",

Dolgok típusát lekérdezhetjük a type paranccsal.

In [1]:
type(5.0)
Out[1]:
float

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 eredményük bool

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

  • a and b, „és”
  • a or b, „megengedő vagy”
  • not a, „nem”
  • a != b, „kizáró vagy” (exclusive or, xor)

Stringeken alapvető műveletek:

  • a + b, konkatenálás
  • a in b, tartalmazás vizsgálat (eredménye bool)
In [2]:
5 + 11
Out[2]:
16
In [3]:
2 ** 251
Out[3]:
3618502788666131106986593281521497120414687020801267626233049500247285301248
In [4]:
12 ^ 7 # bitenkénti kizáró vagy: 1100 ^ 0111 = 1011
Out[4]:
11
In [5]:
a = 54
b = a - 50
a * b
Out[5]:
216
In [6]:
54 > 12
Out[6]:
True
In [7]:
b <= 0
Out[7]:
False
In [8]:
54 > 12 or b <= 0
Out[8]:
True
In [9]:
(1 < 2) != (3 == 3) # != exclusive or
Out[9]:
False
In [10]:
(1 < 2) != (3 == 3)
Out[10]:
False
In [11]:
s = "ハンガリー"
"ハン" in s
Out[11]:
True
In [12]:
s = "hon"
s = 'Pyt' + s
s
Out[12]:
'Python'

Változónevek

  • a név betűvel vagy aláhúzással kezdődhet (szumma, almák_száma, _yes)
  • a név további karakterei az előbbieken felül számok is lehetnek: (var1, szumma2)
  • 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 [13]:
s = "kiskutya"
type(s)
Out[13]:
str
In [14]:
s = 'kiskutya'
type(s)
Out[14]:
str
In [15]:
s = """Volt egyszer egy kiskutya.
Elment a vásárba."""
type(s)
Out[15]:
str
In [16]:
s
Out[16]:
'Volt egyszer egy kiskutya.\nElment a vásárba.'

Itt a vezérlő karaketerek (\n a sorvége jel), a print utasítás a vezérlő karaktereket is megjeleníti:

In [17]:
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 [18]:
print("Egy 'macskaköröm', " + 'kettő "macskaköröm".')

Egy 'macskaköröm', kettő "macskaköröm".
In [20]:
sztring = 'Van ilyen: \', meg ilyen: ".'
In [21]:
sztring
Out[21]:
'Van ilyen: \', meg ilyen: ".'
In [22]:
print(sztring)

Van ilyen: ', meg ilyen: ".

A harmadik változatban 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 (ún. escape) karakterek stringekben: \\\\ (\\), \\\' ('), \\\" ("), \n (új sor), \t (tab)

In [23]:
print("""első sor,
második sor""")

első sor,
második sor
In [24]:
print("\home\name")

\home
ame
In [25]:
print(r"\home\name")    # raw text, no escape sequences

\home\name

Kiírás

Interaktív módban (akár parancssori, akár itt a Jupyterben) az egyes cellák eredménye az utolsó érték ami kiértékelődött, de ha futtatunk egy korábban megírt python programot, akkor csak az lesz kiírva, amit meg akarunk jeleníteni (pl. a print() függvénnyel.)

In [26]:
5 + 8
5 + 7
Out[26]:
12
In [27]:
a = 5
print(a)
a = 15
a + 1
print(a * 2)
a

5
30
Out[27]:
15
In [28]:
print("Volt egyszer egy %s, elment a vásárba." % "nagykutya")

Volt egyszer egy nagykutya, 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 [29]:
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 [30]:
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.
% típus példa eredmény
%s sztring "Volt egyszer egy %s" % "kiscica" "Volt egyszer egy kiscica"
%d egész "Volt egyszer %d kiscica" % 1 "Volt egyszer 1 kiscica"
%f lebegőpontos "Volt egyszer %f kiscica" % math.pi "Volt egyszer 3.141593 kiscica"
"Volt egyszer %d %s és osztozniuk kellett %fdkg sajton" % (3, 'kisegér', math.pi) "Volt egyszer 3 kisegegér és osztozniuk kellett 3.141593dkg sajton"

Az hogy mi történjen a sor végén, az end= opcióval adható meg. Értéke alapértelmezésben '\n'. Egy üres print egyszerűen új sort kezd.

In [31]:
print(1, 3.14, "kutya")
print("macska", end=' ')  # egy szóköz
print("teve", end='')     # üres string
print("gel", end=' ')
print()
print("vége")

1 3.14 kutya
macska tevegel 
vége

Beolvasás

In [32]:
input()

12
Out[32]:
'12'
In [33]:
nev = input("Hogy hívnak? ")
print("Szia %s!\nÖrülök, hogy megismerkedtünk!" % nev)

Hogy hívnak? Lacika
Szia Lacika!
Örülök, hogy megismerkedtünk!
In [34]:
input() > 10    # amit beolvas, az string

12

-------------------------------------------------------------------------
TypeError                               Traceback (most recent call last)
<ipython-input-34-9eabec642491> in <module>
----> 1 input() > 10    # amit beolvas, az string

TypeError: '>' not supported between instances of 'str' and 'int'
In [35]:
int(input()) > 10    # konvertáljuk egésszé

12
Out[35]:
True
In [36]:
type(input())

12
Out[36]:
str

Elágazás

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

.5
ez sok

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 [38]:
n = 1000
a = 1
while a ** 3 <= n:
    print(a ** 3, end=' ')
    a = a + 1
print("vége")

1 8 27 64 125 216 343 512 729 1000 vége

A while ciklus blokkja újra és újra lefut, amíg teljesül a ciklus feltétele. Ciklusokat és elágazásokat egymásba ágyazhatunk:

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

In [39]:
a = int(input())
while a != 1:
    print(a, end=' ')
    if a % 2 == 0:
        a = a // 2
    else:
        a = a * 3 + 1
print(a)

7
7 22 11 34 17 52 26 13 40 20 10 5 16 8 4 2 1

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

In [41]:
a = int(input())
if a > 0:
    while a != 1:
        print(a, end=' ')
        if a % 2 == 0:
            a = a // 2
        else:
            a = a * 3 + 1
    print(a)
else:
    print("Pozitív egész számot adjunk meg!")

-3
Pozitív egész számot adjunk meg!

A fenti kód már azt is teszteli, hogy a felhasználó pozitív egész számot adott-e meg. Változtassunk a kódon úgy, hogy többször egymás után is lefusson, és 0 érték megadása esetén álljon le! Ehhez a break parancsot használhatjuk, mellyel kiugorunk a ciklusból!

In [42]:
while True:
    a = int(input())
    if a > 0:
        while a != 1:
            print(a, end=' ')
            if a % 2 == 0:
                a = a // 2
            else:
                a = a * 3 + 1
        print(a)
    elif a == 0:
        break
    else:
        print("Nemnegatív egész számot adjunk meg, a 0-val befejezzük a futtatást!")

17
17 52 26 13 40 20 10 5 16 8 4 2 1
71
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 1
-2
Nemnegatív egész számot adjunk meg, a 0-val befejezzük a futtatást!
0

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