2. előadás¶

Tartalom: String II. (replace, find, count, lower, stb), feltételek (if, elif, else), boolean logika

Névadási konvenciók¶

Eddig nem esett róla szó, de a Python változóknak, konstansokak stb. is vannak elnevezési irányelvei. Erről részletesen a PEP 8 - Style Guide for Python Code-ban lehet olvasni. A fontosabbak a következők:

Típus	Jelölés
konstansok	`IN_ALL_CAPS`
változók	`snake_case`
metódusok	`snake_case`
függvények	inkább `snake_case`, de ritkávbaan használt és megengedett a `mixedCase` is
osztályok	`StudlyCaps` (`CamelCaps`, `camelCase` nagybetűvel kezdődően)

Stringek¶

In [1]:

palindrom = "Indul a görög aludni"
mondat = "Ez egy példa mondat, python funkciók szemléltetésére"
abece = "A,Á,B,C,Cs,D,Dz,Dzs,E,É,F,G,Gy,H,I,Í,J,K,L,Ly,M,N,Ny,O,Ó,Ö,Ő,P,R,S,Sz,T,Ty,U,Ú,Ü,Ű,V,Z,Zs"
csak_egyes_betuk = "A,Á,B,C,D,E,É,F,G,H,I,Í,J,K,L,M,N,O,Ó,Ö,Ő,P,R,S,T,U,Ú,Ü,Ű,V,Z"
print(mondat)

Ez egy példa mondat, python funkciók szemléltetésére

In [2]:

mondat[0] # Karakterlánc első eleme

Out[2]:

'E'

In [3]:

mondat[-1] # Karakterlánc utolsó eleme

Out[3]:

'e'

mondat[0] = 'h' # Karakterlánc így nem módosítható :(

Erre válaszként a

TypeError: 'str' object does not support item assignment

üzenetet kapnánk. Ehelyett rendelkezésünkre állnak a string "szeletelő jelölések" (célszerűbb az angol terminológia: slice notation), a stringek összefűzése (pl. +=, +), a csere (replace), stb. műveletek.

Nézzünk példákat slice notation-ra.

In [4]:

mondat[:12] # Első 12 karakter

Out[4]:

'Ez egy példa'

In [5]:

mondat[7:] # Karakterlánc vége, 7. eletől

Out[5]:

'példa mondat, python funkciók szemléltetésére'

In [6]:

mondat[-15:] # az utolsó 15 elem

Out[6]:

'szemléltetésére'

In [7]:

mondat[7:36]

Out[7]:

'példa mondat, python funkciók'

In [8]:

len(mondat) # Karakterlánc hossza

Out[8]:

In [9]:

mondat[:-15] + ' kipróbálására'

Out[9]:

'Ez egy példa mondat, python funkciók  kipróbálására'

In [10]:

print(mondat.lower())
print(mondat.upper())

ez egy példa mondat, python funkciók szemléltetésére
EZ EGY PÉLDA MONDAT, PYTHON FUNKCIÓK SZEMLÉLTETÉSÉRE

In [11]:

palindrom[::-1]

Out[11]:

'indula görög a ludnI'

In [12]:

mondat[::-1]

Out[12]:

'erésétetlélmezs kóicknuf nohtyp ,tadnom adlép yge zE'

In [13]:

csak_egyes_betuk # emlékeztetőül

Out[13]:

'A,Á,B,C,D,E,É,F,G,H,I,Í,J,K,L,M,N,O,Ó,Ö,Ő,P,R,S,T,U,Ú,Ü,Ű,V,Z'

In [14]:

csak_egyes_betuk[::2]

Out[14]:

'AÁBCDEÉFGHIÍJKLMNOÓÖŐPRSTUÚÜŰVZ'

In [15]:

abece # emlékeztetőül

Out[15]:

'A,Á,B,C,Cs,D,Dz,Dzs,E,É,F,G,Gy,H,I,Í,J,K,L,Ly,M,N,Ny,O,Ó,Ö,Ő,P,R,S,Sz,T,Ty,U,Ú,Ü,Ű,V,Z,Zs'

In [16]:

abece.replace(",", " ")

Out[16]:

'A Á B C Cs D Dz Dzs E É F G Gy H I Í J K L Ly M N Ny O Ó Ö Ő P R S Sz T Ty U Ú Ü Ű V Z Zs'

In [17]:

mondat.replace("példa", "teszt")

Out[17]:

'Ez egy teszt mondat, python funkciók szemléltetésére'

In [18]:

mondat.replace("e", "_X_")

Out[18]:

'Ez _X_gy példa mondat, python funkciók sz_X_mlélt_X_tésér_X_'

In [19]:

mondat.replace("e", "_X_", 2)  # csak az első 2-t cseréli

Out[19]:

'Ez _X_gy példa mondat, python funkciók sz_X_mléltetésére'

Összefoglalva a Python slice notation (magyarul talán ~szelet):

x[start:end] # az elemek starttól end-1-ig
x[start:]    # az elemek starttól végig
x[:end]      # az elemek az elejétől end-1-ig
x[:]         # az összes elem

Mindegyiket ki lehet egészíteni step értékkel, így minden step-edik elemet érhetjük el:

x[start:end:step]

A legfontosabb észben tartani, hogy az :end érték az első olyan értéket képviseli, amely nincs a kiválasztott szeletben. Tehát a különbség a end és a start között a kiválasztott elemek számát jelenti (ha 1 lépés az alapértelmezett).

A másik lehetőség az, hogy a kezdet vagy a vég negatív szám lehet, ami azt jelenti, hogy az elejétől kezdve a tömb végéig számít. Így:

x[-1]    # az utolsó elem
x[-2:]   # az utolsó 2 elem
x[:-2]   # minden kivéve az utolsó 2 elem

Így már érhető, hogy a negatív érték lépésként is működik:

x[::-1]    # minden elem, de megfordítva
x[1::-1]   # az első 2 elem megfordítva
x[:-3:-1]  # utolsó  2 elem megfordítva
x[-3::-1]  # utolsó 2 elemen kívül minden, megfordítva

Fontos megjegyzés: ez nem csak stringeknél, hanem általánosságban tömböknél is működik

In [20]:

mondat.find("python") # a string helyét adja vissza

Out[20]:

In [21]:

mondat.find("-----") # illetve -1-et, ha nem találja

Out[21]:

-1

In [22]:

mondat.count("él") # megszámoljuk az előfordulást (itt a "példa" és "szemléltetésére" szavakban találhatunk ilyet)

Out[22]:

Összefűzésre használhatjuk a + vagy a += operátort:

In [23]:

str1 = "Hello "
str2 = "világ"
str3 = str1 + str2
print(str3)

Hello világ

In [24]:

str1 += str2
print(str1)

Hello világ

Stringek darabolására alkalmas a split, pl:

In [25]:

print(abece.split(","))

['A', 'Á', 'B', 'C', 'Cs', 'D', 'Dz', 'Dzs', 'E', 'É', 'F', 'G', 'Gy', 'H', 'I', 'Í', 'J', 'K', 'L', 'Ly', 'M', 'N', 'Ny', 'O', 'Ó', 'Ö', 'Ő', 'P', 'R', 'S', 'Sz', 'T', 'Ty', 'U', 'Ú', 'Ü', 'Ű', 'V', 'Z', 'Zs']

In [26]:

print(str1.split(" "))

['Hello', 'világ']

Megjegyzés: a split listát készít, amiről még nem beszéltünk, de később fogunk. A visszatérési érték típusát akár ellenőrizhetjük is:

In [27]:

print(type(abece.split(",")))

<class 'list'>

Input belvasása stringbe¶

Pythonban ez szerencsére szintén egyszerűbb, mint a legtöbb nyelven.

In [28]:

szoveg = input("Adjon meg tetszőleges szöveget: ")
print("A beolvasott szöveg ", szoveg, " volt.", sep = "*")

Adjon meg tetszőleges szöveget: Hello
A beolvasott szöveg *Hello* volt.

Boolean logika¶

Pythonban a legtöbb nyelvhez hasonló logikai műveleteink vannak.

`b`	`Not b`
`True`	`False`
`False`	`True`

`And`	`False`	`True`
`False`	`False`	`False`
`True`	`False`	`True`

`Or`	`False`	`True`
`False`	`False`	`True`
`True`	`True`	`True`

In [29]:

b1 = True
b2 = False
print(b1 is True)

True

In [30]:

b1 and b2

Out[30]:

False

In [31]:

b1 or b2

Out[31]:

True

In [32]:

not b1

Out[32]:

False

In [33]:

not b2

Out[33]:

True

Feltételes utasítások (if, elif, else)¶

Az if, elif, else vezérlési szerkezetek hasonlóan működnek más népszerű programozási nyelvek hasnoló szerkezeteihez. A vezérlési szerkezetek lényege, hogy bizonyos programrészlet végrehajtását feltételhez köthetjük.Ez egy logikai kifejezés, amelynek igaz (True) / hamis (False) voltától függ, hogy végrehajtódik-e az adott programrészlet.

Igaz ág, if

Az a programrészlet, amely akkor hajtódik végre, ha a feltétel igaz volt.

Igaz ág, ha ez előző feltétel nem volt igaz, elif

Az a programrészlet, amely akkor hajtódik végre, ha ez előző feltétel nem volt igaz, de ez a feltétel már igaz volt.

Hamis ág, else ág

Ez akkor hajtódik végre, ha minden felette lévő feltétel hamis volt.

In [34]:

szam = -10

if szam > 0:
    print("Pozitív");
else:
    print("Nem pozitív");

Nem pozitív

In [35]:

for n in range(1, 10) :
    if n == 6:
        print("Az n érteke pontosan hat")
    elif n == 8:
        print("Az n érteke pontosan nyolc")
    else:
        print("n =", n)

n = 1
n = 2
n = 3
n = 4
n = 5
Az n érteke pontosan hat
n = 7
Az n érteke pontosan nyolc
n = 9

String bejárása ciklussal¶

In [36]:

st = "hello"

print("Itt a ch egy konkrét karakter nem pedig integer:")
for ch in st:
    print(ch, end = " ")


print("\n\nWhile ciklus és i (int) változó:")
i = 0
while i < len(st):
    print(st[i], end = " ")
    i += 1
    
    
print("\n\nFor ciklus és i (int) változó:")
i = 0
for _ in st:
    print(st[i], end = " ")
    i += 1
    

Itt a ch egy konkrét karakter nem pedig integer:
h e l l o 

While ciklus és i (int) változó:
h e l l o 

For ciklus és i (int) változó:
h e l l o

String bejárása - comprehension¶

In [37]:

lst = [x for x in st]
print(lst)

['h', 'e', 'l', 'l', 'o']

Used sources / Felhasznált források¶

Shannon Turner: Python lessons repository MIT license (c) Shannon Turner 2013-2014
Siki Zoltán: Python mogyoróhéjban GNU FDL license (c) Siki Zoltán