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. Errol részletesen a PEP 8 - Style Guide for Python Code-ban lehet olvasni. A fontosabbak a következok:

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)

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,Ó,Ö,O,P,R,S,Sz,T,Ty,U,Ú,Ü,U,V,Z,Zs"
csak_egyes_betuk = "A,Á,B,C,D,E,É,F,G,H,I,Í,J,K,L,M,N,O,Ó,Ö,O,P,R,S,T,U,Ú,Ü,U,V,Z"
print(mondat)

Ez egy példa mondat, python funkciók szemléltetésére
In [2]:
mondat[0] # Karakterlánc elso 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 "szeletelo jelölések" (célszerubb az angol terminológia: slice notation), a stringek összefuzése (pl. +=, +), a csere (replace), stb. muveletek.

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

In [4]:
mondat[:12] # Elso 12 karakter
Out[4]:
'Ez egy példa'
In [5]:
mondat[7:] # Karakterlánc vége, 7. eletol
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]:
52
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ékeztetoül
Out[13]:
'A,Á,B,C,D,E,É,F,G,H,I,Í,J,K,L,M,N,O,Ó,Ö,O,P,R,S,T,U,Ú,Ü,U,V,Z'
In [14]:
csak_egyes_betuk[::2]
Out[14]:
'AÁBCDEÉFGHIÍJKLMNOÓÖOPRSTUÚÜUVZ'
In [15]:
abece # emlékeztetoül
Out[15]:
'A,Á,B,C,Cs,D,Dz,Dzs,E,É,F,G,Gy,H,I,Í,J,K,L,Ly,M,N,Ny,O,Ó,Ö,O,P,R,S,Sz,T,Ty,U,Ú,Ü,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 Ó Ö O P R S Sz T Ty U Ú Ü 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 elso 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étol 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 elso 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 lehetoség az, hogy a kezdet vagy a vég negatív szám lehet, ami azt jelenti, hogy az elejétol 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 érheto, hogy a negatív érték lépésként is muködik:

x[::-1]    # minden elem, de megfordítva
x[1::-1]   # az elso 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 muködik

In [20]:
mondat.find("python") # a string helyét adja vissza
Out[20]:
21
In [21]:
mondat.find("-----") # illetve -1-et, ha nem találja
Out[21]:
-1
In [22]:
mondat.count("él") # megszámoljuk az elofordulást (itt a "példa" és "szemléltetésére" szavakban találhatunk ilyet)
Out[22]:
2

Összefuzé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', 'Ó', 'Ö', 'O', 'P', 'R', 'S', 'Sz', 'T', 'Ty', 'U', 'Ú', 'Ü', 'U', 'V', 'Z', 'Zs']
In [26]:
print(str1.split(" "))

['Hello', 'világ']

Megjegyzés: a split listát készít, amirol még nem beszéltünk, de késobb fogunk. A visszatérési érték típusát akár ellenorizhetjük is:

In [27]:
print(type(abece.split(",")))

<class 'list'>

Input belvasása stringbe

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

In [28]:
szoveg = input("Adjon meg tetszoleges szöveget: ")
print("A beolvasott szöveg ", szoveg, " volt.", sep = "*")

Adjon meg tetszoleges szöveget: Hello
A beolvasott szöveg *Hello* volt.

Boolean logika

Pythonban a legtöbb nyelvhez hasonló logikai muveleteink 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 muködnek más népszeru 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 elozo feltétel nem volt igaz, elif

  • Az a programrészlet, amely akkor hajtódik végre, ha ez elozo 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évo 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

Used sources / Felhasznált források