<jupyter_start><jupyter_text>String-ek Pythonban egy string-et vagy szimpla idézőjelek között, vagy dupla idézőjelek között lehet megadni:<jupyter_code>print('Hello, szakkör')
print("Hello, szakkör")<jupyter_output>Hello, szakkör<jupyter_text>A kétfajta megadási mód között nincs különbség. A különböző idézőjeleket lehet keverni. Ha a string-ben van idézőjel, ami nem ugyanolyan, mint ahogy a string-et megadtuk, akkor az kiíródik. Figyeljük meg az alábbi két string-ben az idézőjelek fajtáját:<jupyter_code>print("Hello, '20-as évek!")
print('Hello, "20-as évek!')<jupyter_output>Hello, "20-as évek!<jupyter_text>Két vagy több string-et össze lehet adni, aminek az eredménye egy string lesz:<jupyter_code>"Hello, " + "szakkör" + "!"<jupyter_output><empty_output><jupyter_text>Egy string-et meg lehet szorozni egy egész számmal, aminek az eredménye egy string lesz az eredeti string számszorosával:<jupyter_code>"Hello" * 3<jupyter_output><empty_output><jupyter_text>**Vigyázat**: más nyelvekben általában egy külön függvény van erre definiálva. A string-ek konkrét karakterét ki lehet szedni *indexeléssel*. Pythonban nincs karakter típus, a karakter is egy string, aminek a hossza 1. Az első karakter indexe 0:<jupyter_code>v = "Hello, szakkör"
print(v[0])  # az első karakter kírása
print(v[2])  # a harmadik karakter kiírása<jupyter_output>l<jupyter_text>Negatív szám is használható indexelésre, ekkor a string hátuljáról kell számolni az indexeket a -1-től kezdve:<jupyter_code>print(v[-1])  # az utolsó karakter kiírása
print(v[-6])  # hátulról a hatodik karakter kírása<jupyter_output>z<jupyter_text>Hátulról miért -1-től számoljuk, amikor elölről 0-től? Az ok egyszerű: -0 = 0, ezért a -0-dik index is az első karaktert fogja kiírni. Hibát kapunk, ha túl nagy indexű karaktert akarunk kiszedni:<jupyter_code>print(v[143])<jupyter_output><empty_output><jupyter_text>Az `IndexError` egy másfajta hibaüzenet (a `NameError` volt a másik), ami akkor jön elő, ha olyan elemre vagyunk kíváncsiak, ami a string-ben (vagy később a listákban) nem létezik. Ezt jelenti a `string index out of range` üzenet. Egy string hosszát lekérhetjük a beépített `len()` függvénnyel:<jupyter_code>print(len(v))  # a "Hello, szakkör" string hossza<jupyter_output>14<jupyter_text>Lehetőség van egy string szeletelése (*slice*), azaz a string egy részének kiszedésére a kettőspont (`:`) operátor segítségével:<jupyter_code>print(v[0:3])<jupyter_output>Hel<jupyter_text>**Figyelem**: ha ilyen módon adjuk meg az indexelést, a kettőspont utáni indexnek megfelelő pozíción lévő karakter már nem íródik ki! Azaz a `v[0:3]` csak a 0,1,2 indexen lévő karaktereket fogja kiírni! A szeleteknek van alapértelmezett értéke. Ha a string elejéről akarunk kiírni néhány karaktert, a 0 elhagyható a `:` előtt:<jupyter_code>print(v[:6])<jupyter_output>Hello,<jupyter_text>Ha a negyedik indexű pozíciótól a string végéig akarjuk azt kiírni, akkor az utolsó karakter indexe elhagyható:<jupyter_code>print(v[4:])<jupyter_output>o, szakkör<jupyter_text>Hasonló igaz a string hátuljáról is. Ha az utolsó néhány karatert akarjuk kiírni, a -1 elhagyható a `:` után:<jupyter_code>print(v[-5:])<jupyter_output>akkör<jupyter_text>A Python le tudja kezelni, ha a szeletelés során túl nagy indexet adunk meg:<jupyter_code>print(v[5:143])
print(v[52:])  # az 52-edik indextől a string végéig írjuk ki (az eredmény egy üres string)<jupyter_output><jupyter_text>Hogyan működik az indexelés? Pythonban minden index 0-val kezdődik és a string, lista, stb. hosszáig tart. Az alábbi példában a "Hello" string hossza 5 (idézőjelek nélkül), a string látható a táblázat első sorában. A közvetlenül alatta lévő sor a string elejétől mutatja, hogy melyik index melyik karakterre mutat. Az utolsó sor pedig ugyanez, csak a string végétől az elejéig mutatja az indexek értékét.| H  | e  | l  | l  | o  ||----|----|----|----|----|| 0  | 1  | 2  | 3  | 4  || -5 | -4 | -3 | -2 | -1 |  Feladatok  **1. feladat**: Adott egy `count` változó, amiben azt tároljuk, hogy hányszor szeretnénk ismételni egy `word` nevű, string típusú változót. A `res` változóban tároljuk el a `count`-szor megismételt `word`-öt, majd írjuk is ki!<jupyter_code>count = 2
word = "palacsinta"

# megoldás:
res = count * word
print(res)<jupyter_output>palacsintapalacsinta<jupyter_text>**2. feladat**: Írd ki az előző feladatban szereplő `word` változónak az első két karakterének és az utolsó három karakterének az összegét! (Eredményül tehát a `panta` string-et kell kapni.)<jupyter_code>word = "palacsinta"

# megoldás:
print(word[:2] + word[-3:])<jupyter_output>panta<jupyter_text>***3. feladat**: Cseréld le a `word`-ben kapott string-ben az első karakternek megegyező karaktereket `*`-ra! Például: a `hahaha` string eredményének a `ha*a*a` kell kapnunk. (Hint: a `word.replace(old, new)` metódus a `word` nevű string típusú változóban az `old` karaktert minden előfordulását kicseréli a `new` karakterre. Pl. `"alma".replace(a, '*')` az `*lm*` string-et eredményezi)<jupyter_code>word = "bubble"

# megoldás:
res = word[0] + word.replace(word[0], '*')[1:]
print(res)<jupyter_output>bu**le<jupyter_text>Műveletek string-ekkel Nézzünk meg néhány műveletet, amit a stringekkel lehet csinálni Pythonban! A vonatkozó dokumentáció [itt érhető el](https://docs.python.org/3/library/stdtypes.htmlstring-methods). Egy string első karakterét nagybetűssé tehetünk a `capitalize()` metódussal:<jupyter_code>s = "hello"
print(s.capitalize())<jupyter_output>Hello<jupyter_text>Ellenőrizhetjük, hogy egy string azzal végződik-e, amivel szeretnénk, hogy végződjön. Erre az `endswith()` metódus használható. Ennek az eredménye egy logikai érték lesz (következő részben részletesen lesz róla szó):<jupyter_code>s = "Hello, szakkör"
print(s.endswith("szakkör"))
print(s.endswith("!"))<jupyter_output>False<jupyter_text>Hasonlóan, a `startswith()` metódus a string elején ellenőrzi, hogy a paraméterül átadott string-el kezdődik-e:<jupyter_code>print(s.startswith("Hello"))
print(s.startswith("hello"))  # nem kisbetűs Hello<jupyter_output>False<jupyter_text>Egy string-ről az `isnumeric()` metódussal lehet ellenőrizni, hogy a string egy számot reprezentál-e:<jupyter_code>n = "137"
print(n.isnumeric())
nn = "137 "  # figyeld meg a szóközt a string végén!
print(nn.isnumeric())<jupyter_output>False<jupyter_text>Egy string-ről az `isalpha()` metódussal eldönthető, hogy csak betűket tartalmaz-e:<jupyter_code>s = "hello"
print(s.isalpha())
s = "hello "  # figyeld meg a szóközt a string végén!
print(s.isalpha())
s = "alma1"
print(s.isalpha())<jupyter_output>False<jupyter_text>Egy string-ről eldönthető az `isupper()` metódussal, hogy csak nagy betűt tartalmaz:<jupyter_code>b = "BATMAN"
print(b.isupper())
b = "BATMAN "
print(b.isupper())
b = "BatMan"
print(b.isupper())
b = " "
print(b.isupper())<jupyter_output>False<jupyter_text>Hasonlóan, az `islower()` metódus megmondja, hogy csak kis betűt tartalmaz-e:<jupyter_code>l = "batman"
print(l.islower())
l = "batman "
print(l.islower())
l = "Batman"
print(l.islower())
l = " "
print(l.islower())<jupyter_output>False<jupyter_text>Egy string-et a `lower()` metódussal kisbetűssé lehet tenni:<jupyter_code>s = "BATMAN!"
print(s.lower())<jupyter_output>batman!<jupyter_text>Az `upper()` metódussal pedig csak nagybetűket tartalmazó string-é lehet tenni az eredeti string-et:<jupyter_code>s = "batman!"
print(s.upper())<jupyter_output>BATMAN!<jupyter_text>A string elején lévő karaktereket az `lstrip()`, a string végén lévő karaktereket az `rstrip()` metódussal, valamint az ezeknek átadott karaktereket lehet levágni. Ha nem adunk át paramétert, akkor a space karaktereket vágja le:<jupyter_code>s = "      Hello                "  # sok space van a string-ben!
s = s.lstrip()
print(len(s), s)  # az `s` string végén ott vannak a space-ek!
s = "www.example.com"
print(s.lstrip(".cmowa"))
s = "      Hello                "  # sok space van a string-ben!
s = s.rstrip()
print(s)  # az `s` string elején ott vannak a space-ek!
s = "mississippi"
print(s.rstrip("piz"))<jupyter_output>mississ<jupyter_text>Egy string-et szét lehet választani az általunk megadott karakter alapján a `split()` metódussal. Ennek az eredménye egy string-eket tartalmazó lista lesz. Ha nem adjuk meg, milyen karakter szerint válasszuk szét a string-ek, akkor szóközök szerint választódik szét:<jupyter_code>s = "Hello, szakkör! Ez itt a Python"
print(s.split())
print(s.split(','))
print(s.split("szakkör"))
s2 = "1,2,,3,4"
print(s2.split(","))
s3 = "    1    2 3     "
print(s3.split())<jupyter_output>['1', '2', '3']<jupyter_text>A `split()` metódusnak még egy opcionális paramétere, amiben megmondhatjuk, hogy *legfeljebb* hányszor válasszuk szét a string-et. Ha ezt nem adjuk meg, vagy `-1`-et adunk neki, akkor annyi részre bontódik a string, amennyire lehet. Ha nem adunk meg karaktert, ami alapján szét akarjuk választani a string-et, akkor a szóközök szerint választja szét:<jupyter_code>print(s.split(maxsplit=2))<jupyter_output>['Hello,', 'szakkör!', 'Ez itt a Python']<jupyter_text>Az `lstrip()` és `rstrip()` metódusok mellett van egy `strip()` metódus, ami a string elején és végén vágja le a megadott karakterek kombinációit. Ha nem adunk át semmit, akkor alapértelmezetten a szóközöket vágja le:<jupyter_code>s = "    Hello,   szakkör!      "
print(s.strip())
s = "www.example.com"
print(s.strip(".cmwo"))<jupyter_output>example
{'fraction_non_alphanumeric': 0.11840700405722827, 'fraction_numerical': 0.009502455690796498, 'mean_word_length': 6.053463855421687, 'pattern_counts': {'":': 0, '<': 91, '<?xml version=': 0, '>': 91, 'https://': 1, 'lorem ipsum': 0, 'www.': 2, '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': '29', 'dir': 'jupyter-structured-clean-dedup', 'id': '423603', 'license': 'Apache-2.0', 'n_tokens_mistral': 4098, 'n_tokens_neox': 4214, 'n_words': 980, 'path': 'teljes/02-Stringek.ipynb', 'repo_name': 'ohanyecz/python', 'size': '9366'}