<jupyter_start><jupyter_text>3. előadás_Tartalom_: Ciklusok II., listák, join és split (string listává illetve fordítva), lista- és stringműveletek  ListákEddig négy típussal találkoztunk: a szövegeket _stringek_ (str), az egész számokat _int_-ek, a törtszámokat _float_-ok jelölték, és külön típust képeztek még az állítások, amiknek az értéke csak igaz (True) és hamis (False) lehet.Listákat akkor fogunk használni, ha össze szeretnénk gyűjteni több különböző objektumot. A lista arról ismerszik meg, hogy szögletes zárójelek ([]) közötti, vesszővel elválasztott objektumokból áll. Az objektumok bármilyen típusúak lehetnek és keveredhetnek is.Itt egy lista:<jupyter_code>[3, "pingvin", 2.76, "zsiráf"]<jupyter_output><empty_output><jupyter_text>Ez pedig egy üres lista, ez is teljesen szabályos objektum:<jupyter_code>[]<jupyter_output><empty_output><jupyter_text>Ezekben a listákban pedig mind csak stringek szerepelnek:<jupyter_code>torpok = ['Tudor', 'Vidor', 'Szende', 'Szundi', 'Hapci', 'Kuka', 'Morgó']
weasleyk = ['Bill', 'Charlie', 'Percy', 'Fred', 'George', 'Ron', 'Ginny']
zsirafok = ["Abigél", "Benő", "Zsebi"]<jupyter_output><empty_output><jupyter_text>Változókat is betehetünk egy listába:<jupyter_code>vezeteknev = "Hosszú"
keresztnev = "Katinka"
teljes_nev = [vezeteknev, keresztnev]
print(teljes_nev)<jupyter_output>['Hosszú', 'Katinka']<jupyter_text>Először nézzünk pár olyan műveletet, amit már ismerünk. Vajon ezek mit csinálnak a listákkal? A _len_ függvény viselkedése nem túl meglepő, a lista hossza azt mondja meg, hogy hány eleme van a listának<jupyter_code>len(torpok)<jupyter_output><empty_output><jupyter_text>Az összeadás is azt csinálja, amit várunk tőle: összefűz két listát.<jupyter_code>torpok + weasleyk<jupyter_output><empty_output><jupyter_text>Egy listának hivatkozhatunk egyes elemeire, a sorszámuk alapján. A számozás nullától indul, tehát a lista első elemét Pythonban a lista nulladik elemének fogjuk hívni. Ezt leírni pedig így kell:<jupyter_code>torpok[0]<jupyter_output><empty_output><jupyter_text>A számozás tehát el van eggyel "tolódva", az utolsó törp pl. a 6-os sorszámú:<jupyter_code>torpok[6]<jupyter_output><empty_output><jupyter_text>Ha nem létező sorszámra hivatkozunk, hibát kapunk:``` python >>> torpok[7]IndexError: list index out of range``` Hátulról kezdve is számolhatjuk az elemeket, ilyenkor negatív számokat kell használni. Tehát a lista utolsó eleme a -1-es, a hátulról második elem a -2, és így tovább:<jupyter_code>torpok[-1]<jupyter_output><empty_output><jupyter_text>Nyilván itt is túl tudunk indexelni és hibát kapunk:``` python >>> torpok[-8]IndexError: list index out of range```<jupyter_code>torpok[-2]<jupyter_output><empty_output><jupyter_text>A sorszámok (más néven: indexek) segítségével hivatkozhatunk a lista egyes szakaszaira is. Pl. az első 4 törpöt így kérdeznénk le, ahogy más megismertük a itt is működnek a "szeletelő jelölések" (célszerűbb az angol terminológia: `slice notation`)<jupyter_code>torpok[:4]<jupyter_output><empty_output><jupyter_text>A másodikat és a harmadikat így:<jupyter_code>torpok[1:3]<jupyter_output><empty_output><jupyter_text>Tehát a kettőspont bal oldalán áll az első olyan sorszám, amire kiváncsiak vagyunk, a jobb oldalán pedig az első olyan sorszám, amire már nem. (más néven: balról zárt, jobbról nyílt intervallum). Ezt időbe telhet megszokni, de vannak előnyei is, pl. a két sorszám különbsége megadja, milyen hosszú lesz az új lista. Sorszámként használhatjuk a negatív számokat is, tehát egyszerűen mondhatunk olyat, hogy pl. a második elemtől az utolsó előttiig:<jupyter_code>torpok[1:-1]<jupyter_output><empty_output><jupyter_text>Ez az eljárás a __slicing__, vagyis szeletelés, és tulajdonképpen egy művelet, ami listából listát csinál. Pont ugyanígy működik stringekre is, ott a betűket "szeleteljük": Persze ilyen kifejezésekből is kombinálhatunk többet. Pl. megkérdezhetjük, mi az utolsó előtti törpe nevének első három betűje:<jupyter_code>torpok[-2][:3]<jupyter_output><empty_output><jupyter_text>Ahogy azt a stringeknél megszokhattuk, amikor listát vagy stringet "szeletelünk", azt is megtehetjük, hogy két pozíció között nem mindegyik elemet vesszük ki a listából/stringből, hanem pl. minden másodikat, minden harmadikat, stb. Ilyenkor egy második kettőspontot is írunk, és ezután adjuk meg, hogy mekkora "ugrásokat szeretnénk". Az alábbi példa azt jelenti, hogy a lista harmadik elemétől induljunk, minden második elemet vegyünk ki, és ne menjünk tovább, mint a hetedik:<jupyter_code>lista = [1,2,3,4,5,6,7,8,9,10]
lista[2:7:2]<jupyter_output><empty_output><jupyter_text>Ha az első vagy második indexet üresen hagyjuk, az a lista elejét ill. végét jelenti. Az alábbi tehát azt jelenti, hogy az egész listából kérünk minden harmadik elemet:<jupyter_code>lista[::3]
lista[-1::-1]
lista[-1:2:-1]<jupyter_output><empty_output><jupyter_text>Most nézzünk néhány egyszerű műveletet, amivel a listát manipulálhatjuk. Például megváltoztathajuk egy-egy elemét:<jupyter_code>lista = [1,2,3]
lista[0] = 7
lista<jupyter_output><empty_output><jupyter_text>Vagy egy listának egy egész szelete felülírható egy másik listával:<jupyter_code>lista = [1,2,3,4,5]
lista[1:3] = [102, 103]
lista<jupyter_output><empty_output><jupyter_text>Az __append__ paranccsal új elemeket fűzhetünk egy lista végére:<jupyter_code>lista.append(9)
lista<jupyter_output><empty_output><jupyter_text>Törölhetünk elemeket a __remove__ paranccsal:_Megjegyzés:_ listák esetén a __remove__ csak az első előfordulást törli.<jupyter_code>lista.remove(102)
lista<jupyter_output><empty_output><jupyter_text>A listát sorbarendezhetjük a __sort__ paranccsal:<jupyter_code>lista.sort()
lista<jupyter_output><empty_output><jupyter_text>Ha a listában stringek vannak, a __sort__ ábécébe rendezi őket:<jupyter_code>torpok.sort()
torpok<jupyter_output><empty_output><jupyter_text>Olyan listát, amiben string és szám is van, nem tudunk rendezni, hibát kapunk. ``` pythonlista = [3, "pingvin", 2, "jegesmedve"]lista.sort()listaTypeError: '<' not supported between instances of 'str' and 'int'``` De számokból lehet kétféle (int és float):<jupyter_code>lista = [4, 2.3, 1, 3.2]
lista.sort()
lista<jupyter_output><empty_output><jupyter_text>A listákat megfordíthatjuk a __reverse__ paranccsal:<jupyter_code>lista.reverse()
lista<jupyter_output><empty_output><jupyter_text>Megkérdezhetjük egy elemről, hogy a lista hányadik helyén található, erre való az __index__ parancs:_Megjegyzés:_ listák esetén az __index__ az első előfordulást adja vissza.<jupyter_code>weasleyk.index("Ron")<jupyter_output><empty_output><jupyter_text>Megszámolhatjuk, hogy egy elem hányszor szerepel egy listában, a __count__ paranccsal:<jupyter_code>lista.count(2)<jupyter_output><empty_output><jupyter_text>Mindezen műveletek stringekre is működnek, az alábbi kód pl. megmondja, hogy a legidősebb Weasley testvér nevében hány l betű van:<jupyter_code>weasleyk[0].count('l')<jupyter_output><empty_output><jupyter_text>Egy listát le is másolhatunk, ha módosítani akarjuk, de nem akarjuk az eredetit elveszíteni:<jupyter_code>weasleyk2 = weasleyk.copy()
weasleyk2.sort()
weasleyk2<jupyter_output><empty_output><jupyter_text>Az __in__ szóval ellenőrizhetjük, hogy egy elem benne van-e egy listában/stringben:<jupyter_code>"Ron" in weasleyk
"Kuka" in weasleyk
"k" in "Kuka"
"c" in "Kuka"<jupyter_output><empty_output><jupyter_text>Ezek állítások, tehát egy __if__ vagy __elif__ után is állhatnak. Az alábbi program például ellenőrzi, hogy van-e egy szóban i betű:<jupyter_code>#print("Írd be a szót!")
#szo = input()
szo = "Csabi"
if "i" in szo:
    print("Ebben van i")
else:
    print("Ebben nincs i")<jupyter_output>Ebben van i<jupyter_text>A __split__ parancsról már volt szó, szétvág egy stringet a szóközök mentén (_paraméterek nélkül hívva legalábbis_), és a kapott szavakat egy listában adja vissza:<jupyter_code>mondat = "A kockázatok és mellékhatások tekintetében olvassa el a betegtájékoztatót vagy kérdezze meg kezelőorvosát, gyógyszerészét"
szavak = mondat.split()
szavak<jupyter_output><empty_output><jupyter_text>A __join__ parancs stringet ad vissza, egy megadott string szeparátorral fűzi össze a lista elemeit.<jupyter_code>"--".join(szavak)<jupyter_output><empty_output><jupyter_text>Lista bejárása ciklussal<jupyter_code>print("Itt az elem egy konkrét listaelem nem pedig integer:")
for elem in szavak:
    print(elem, end = " ")


print("\n\nWhile ciklus és i (int) változó:")
i = 0
while i < len(szavak):
    print(szavak[i], end = " ")
    i += 1
    
    
print("\n\nFor ciklus és i (int) változó:")
i = 0
for _ in szavak:
    print(szavak[i], end = " ")
    i += 1<jupyter_output>Itt az elem egy konkrét listaelem nem pedig integer:
A kockázatok és mellékhatások tekintetében olvassa el a betegtájékoztatót vagy kérdezze meg kezelőorvosát, gyógyszerészét 

While ciklus és i (int) változó:
A kockázatok és mellékhatások tekintetében olvassa el a betegtájékoztatót vagy kérdezze meg kezelőorvosát, gyógyszerészét 

For ciklus és i (int) változó:
A kockázatok és mellékhatások tekintetében olvassa el a betegtájékoztatót vagy kérdezze meg kezelőorvosát, gyógyszerészét<jupyter_text>Lista bejárása - comprehensionA listaértelmezések (list comprehension) a listák létrehozásának rövidebb módja.<jupyter_code>print([elem for elem in szavak])<jupyter_output>['A', 'kockázatok', 'és', 'mellékhatások', 'tekintetében', 'olvassa', 'el', 'a', 'betegtájékoztatót', 'vagy', 'kérdezze', 'meg', 'kezelőorvosát,', 'gyógyszerészét']
{'fraction_non_alphanumeric': 0.09461027317793481, 'fraction_numerical': 0.00854340259466301, 'mean_word_length': 7.534653465346534, 'pattern_counts': {'":': 1, '<': 135, '<?xml version=': 0, '>': 139, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '34', 'dir': 'jupyter-structured-clean-dedup', 'id': '243778', 'license': 'MIT', 'n_tokens_mistral': 4142, 'n_tokens_neox': 4258, 'n_words': 946, 'path': 'eload/ea03.ipynb', 'repo_name': 'horverno/sze-academic-python', 'size': '9481'}