Szerkesztés alatt!

Az oldal további része szerkesztés alatt áll, a tartalma minden további értesítés nélkül többször, gyakran, jelentősen megváltozhat!

Fájlkezelés

Tartalom

A python fájlkezelése, open(), .close(), .read(), stb. Fájlkezelés a with segítségével.

Gyakorló feladatok a ZH-ra: Halmazok és listák

1. feladat - Halmaz tartalmazás, törlés

János nagyon szereti a finom ételeket, viszont a felesége nem szeretné hogy egészségtelenül étkezzen, ezért bizonyos ételeket János próbál kerülni, bármennyire is szereti. Ettől persze kerül János olyan ételeket is, amiket a felesége nem tiltana, csak ő nem szereti. Néha tart azért kivételes napokat János: a mai napon ehet pizzát, még ha azt esetleg amúgy kerülné is. Nagyon nehéz azonban Jánosnak kerülnie ételeket amiket szeret, szóval inkább bemeséli magának, hogy nem is szereti annyira... egyelőre legalábbis.

Írj egy függvényt dieta néven, mely három paramétert vár: szeretett ételek halmaza, kerülendő ételek halmaza, kivételes étel. A függvény törölje az összes kerülendő ételt a szeretett ételek halmazból (amennyiben az benne van), kivéve a kivételes ételt, az maradhat benne (ha alapból is benne volt). A függvény visszaadja, hány különböző szeretett ételről kellett Jánosnak lemondania ma.

Példa:

Szeretett ételek: {"alma", "hot-dog", "gyros", "hamburger", "pizza", "csirkemell", "tojás"}
Kerülendő ételek: {"lángos", "hot-dog", "pizza", "virsli", "hamburger"}
Kivételes étel: "pizza"

Elvárt végső "Szeretett ételek" halmaz: {"alma", "gyros", "pizza", "csirkemell", "tojás"}
Elvárt visszatérési érték: 2

Példamegoldás

def dieta(szeretett_etelek, kerulendo_etelek, kivetel):
    mennyit_hanyagol = 0
    for kerulendo in kerulendo_etelek:
        if kerulendo in szeretett_etelek and kerulendo != kivetel:
            szeretett_etelek.remove(kerulendo)
            mennyit_hanyagol += 1
    return mennyit_hanyagol

2. feladat - Halmaz kiegészítése

János nagyon babonás, és nagyon hisz a szerencseszámokban. Minden héten más szerencseszámokban hisz azonban: már kiválogatott pár szerencseszámot a hétre, de szeretné kiegészíteni még a múlt hét időjárása alapján. Sorszámozta a múlt hét napjait: múlt hét hétfő az 1-es, múlt hét vasárnap a 7-es. Azon napok sorszáma, melyeken esett az eső, szeretné ha a szerencseszámai közé tartozna a héten. Azaz ki szeretné egészíteni a már meglévő szerencseszámait ezekkel a sorszámokkal. Fontos azonban számára, hogy minden szám legfeljebb egyszer szerepeljen, szerinte egyenesen balszerencsés lenne ha többször is szerepelne.

Írj egy szerencse függvényt, mely két paramétert vár: szerencseszámok halmaza, múlt heti időjárás lista. A lista minden eleme "esős", "napos" vagy "felhős". A függvény egészítse ki a szerencseszámok halmazát a megfelelő sorszámokkal, majd adja is vissza.

Példa:

Szerencseszámok: {1, 42, 55, 7, 2, 0, 80}
Időjárás: ["esős", "napos", "felhős", "felhős", "esős", "esős", "napos"]

Elvárt végső "Szerencseszámok" halmaz, és visszatérési érték: {1, 42, 55, 7, 2, 0, 80, 5, 6}

Példamegoldás

def szerencse(szerencseszamok, idojaras):
    for i in range(len(idojaras)):
        if idojaras[i] == "esős":
            szerencseszamok.add(i+1)

    return szerencseszamok

3. feladat - Bonyolultabb halmaz és lista algoritmus

János kicsit túlzásba esett a babonáival, és kitalált valami egészen újat: az elkövetkezendő napokban négylevelű lóheréket szed, és ha az adott naphoz tartozó szerencseszám és az aznap talált lóherék számának összege nagyobb mint 10 és páros, akkor az adott napja szerencsés. Ha balszerencsés, akkor inkább lefekszik aludni, nehogy valami rossz történjen. János azon napok számjegyeit, melyeken nem ment aludni, felveszi új szerencseszámoknak.

Írj egy szerencses_jegyek függvényt, mely 2 listát vár paraméterként. Az első lista azt tartalmazza, hogy a következő napokban hány négylevelű lóherét szed majd János. A második lista szerencseszámokat tartalmaz: alapvetően az azonos indexen lévő elemek összetartoznak a két listában, de a szerencseszámok listája lehet, rövidebb mint a napok listája. Ha kifutunk a szerencseszámokból, újra bejárjuk őket az elejéről. A függvény adja vissza az összes különböző számjegyet, melyek előfordultak a szerencsés napok indexében. Akkor szerencsés egy nap, ha az aznap talált négylevelű lóherék száma és a hozzá tartozó szerencseszám összege nagyobb mint 10 és páros. A számjegyeket növekvő sorrendben adjuk vissza egy listában, és minden számjegy legfeljebb egyszer szerepelhet.

Példa: Talált négylevelű lóherék száma: [0, 5, 1, 2, 7, 8, 1, 2, 3, 4, 5, 0] Szerencseszámok: [3, 7, 12]

Egyes napokhoz tartozó összegek: [0+3, 5+7, 1+12, 2+3, 7+7, 8+12, 1+3, 2+7, 3+12, 4+3, 5+7, 0+12] Egyes napokhoz tartozó összegek: [3, 12, 13, 5, 14, 20, 4, 9, 15, 7, 12, 12] Szerencsés napok indexei: [1, 4, 5, 10, 11]

Szerencsés számjegyek halmaza: {1, 4, 5, 0}

Elvárt visszatérési érték: [0, 1, 4, 5]

Példamegoldás

def szerencses_jegyek(loherek_szama, szerencseszamok):
    i = 0
    szerencses_szamjegyek = set()
    for nap_index, lohere_szam in enumerate(loherek_szama):
        if i == len(szerencseszamok):
            i = 0

        osszeg = lohere_szam + szerencseszamok[i]
        if osszeg > 10 and osszeg % 2 == 0:
            szamjegyek_szovegekkent_halmaz = set(str(nap_index))
            for str_szam in szamjegyek_szovegekkent_halmaz:
                szerencses_szamjegyek.add(int(str_szam))

        i += 1
    return sorted(szerencses_szamjegyek)

A fájlkezelés alapjai

Tanultuk, hogy felhasználótól az input függvény segítségével tudunk beolvasni adatot. Nem csak így tudunk azonban bekérni adatot, hanem fájlból is, illetve természetesen mi magunk is írhatunk fájlokba dolgokat.

Fontos, hogy olvasni akarunk fájlból vagy írni bele. Ha olvasni akarunk, akkor "read" (egy "r" betű fogja rövidíteni) módban kell megnyitni a fájlt, ha írni, akkor "write" (egy "w" betű fogja rövidíteni) módban.

A másik ami számít, az a fájl neve (pontosabban az elérési útja). Ha olvasni próbálunk olyan fájlból ami nem létezik, az hibát ad. Ha írni próbálunk olyan fájlba ami nem létezik, az létre fogja hozni a fájlt. Ha olyan fájlba próbálunk írni, ami már létezik, a tartalmát felülírjuk, nem kiegészítjük. Kiegészítéshez "append" ("a" betű rövidíti) módban kell megnyitni, de erre külön nem lesz szükség a tárgyon, ezért itt nem kerül részletezésre.

Fájból olvasás és fájlba írás analógiája.

Hogyan olvasunk egy könyvet, és hogyan írunk le egy szöveget?

Olvasásnál folyamatosan olvassuk az egymás után következő karaktereket. Ha elolvastunk egy betűt (írásjelet), a következő betűre nem szándékosan vagy aktívan térünk át, hanem természetes módon, az áttérés része az olvasás folyamatának. Írásnál ugyanez van, nem érezzük kényszernek vagy külön tevékenységnek azt, hogy a következő betűt ne az előzőre, hanem utána írjuk, mert ez a természetes.

A fájlból olvasás, fájlba írás ugyanezen logika szerint működik. Ha beolvastam valamit, legközelebb automatikusan a beolvasott rész után folytatom az olvasást. Ha már kiírtam valamit, a következő kiírást e mögé fogom írni.

Természetesen ahogyan egy könyvben is vissza tudunk ugrani egy szó, mondat, fejezet, vagy akár az egész könyv elejére, vagy előre is lapozhatunk, ugyanúgy egy fájl tartalmában is mozoghatunk, mégegyszer beolvashatjuk ugyanazt a részt, vagy kihagyhatunk részeket. Ez viszont már aktív tevékenység, szándékosan tennünk kell érte.

Fájlba írásnál hasonló megfontolások érvényesek, aktívan ott is visszamehetünk bármely pozícióra, és újraírhatjuk a tartalmát. Legalábbis amíg be nem csuktuk, mert ott a becsukás és (írási módban való) újranyitás törli a teljes korábban kiírt tartalmat. (A való életben ez kicsit bonyolultabb, mert ott még radírozni is kellene előtte.)

Fájl beolvasása

Az alábbi módon lehet beolvasni egy fájl tartalmát, például egy alma.txt nevű fájlét:

Fájlbeolvasás

with open("alma.txt", "r") as f:
    tartalom = f.read()

Többszöri beolvasás

A read metódust ha megpróbálnánk ugyanazon a with blokkon belül többször is hívni, másodjára már nem olvasna be semmit! Csak egyszer működik (egyéb módosítások nélkül)!

Analógia

Ha egy könyvet végigolvastunk, akkor abban a könyvben nincs mit továbbolvasni. Természetesen becsukhatjuk és kinyithatjuk újra az elején, vagy visszamehetünk bármelyik oldalára, de ez már aktív tevékenység.

Nem létező fájl beolvasása

Ha nem létezik a fájl amit be próbálunk olvasni, akkor már a megnyitásánál hibát kapunk!

Fájlba írás

Az alábbi módon lehet írni egy alma.txt nevű fájlba:

Fájlba írás

with open("alma.txt", "w") as f:
    f.write("valami szoveg amit be akarok irni a fajlba")

Felülírás

Ha írásra (w) nyitjuk meg a fájlt, a fájl nem kiegészül, hanem tartalma felülíródik.

A with kulcsszó

A with segítségével egy context managerben kezeljük a fájlt. Érdemes megfigyelni, hogy megnyitjuk a fájlt de látszólag nem zárjuk be: ez azért történik, mert miután elhagyjuk a with kódblokkot, az automatikusan be fog záródni (hála a context managernek). E nélkül a kulcsszó nélkül is megnyithatjuk a fájlt, de általában ezzel együtt érdemes használni az open függvényt, a gyakorlat során minden alkalommal érdemes lesz használni. Egyébként "kézzel" a close metódussal zárhatnánk be a fájlt (például: f.close()), de a with blokk miatt erre nincs szükség.

Az encoding paraméter

Szöveges fájloknak többfajta kódolása lehet (az egyik leggyakoribb és legismertebb például az utf-8). Az open függvénynek gyakran érdemes megadni a szöveg kódolását paraméterként:

Fájlbeolvasás utf-8 kódolással

with open("alma.txt", "r", encoding="utf-8") as f:
    tartalom = f.read()

Rossz encoding

Ha nem megfelelő kódolással próbálnánk kezelni a fájlt, az hibákhoz vezethet. Az encoding paraméter alapértelmezett értéke rendszerfüggő, ezért érdemes specifikálni (bár erre számonkéréseken a benti gépekről várhatóan nem lesz szükség).

Összefoglalás

Szinte majdnem ugyanezt kell írnotok minden esetben ha olvasni/írni akartok (az "r" és "w" -re nagyon kell figyelni, mert nem mindegy), csak az "alma.txt" helyett az a fájlnév kell amit mondjuk a feladat kér. Ez a fájlnév persze érkezhet függvény paraméterként is: ez csak egy egyszerű szöveges (str) érték.

Ahogy az látható, a példákban az f változón keresztül érhetitek el az olvasó/író metódust. Nem muszáj ezt a változót f-nek hívni, nevezhetitek akármi másnak is, ez is csak egy változónév mint az összes többi: az f viszont egy gyakran használt név rá.

---

További hasznos függvények fájlkezeléshez

Olvasáshoz még érdemes tudni két másik függvényt is, nagyon gyakran fog jól jönni (a kurzus számonkérésein is).

A readlines függvény

Nem csak simán a read függvénnyel tudtok olvasni, hanem a readlines függvénnyel is, ami soronként olvas a fájlból, és egy listát ad vissza, melynek elemei sztringek (minden sztring egy-egy sor a fájlból).

Vegyünk példának egy gyumolcsok.txt fájlt az alábbi tartalommal. A szöveg kódolása a példában utf-8, a beolvasás erre is ügyel.

alma
szilva
körte
eper

Ezt beolvashatjuk soronként.

Fájlbeolvasás soronként

with open("gyumolcsok.txt", "r", encoding="utf-8") as f:
    sorok = f.readlines()
print(sorok)

Output

["alma\n", "szilva\n", "körte\n", "eper\n"]

További módszerek soronkénti beolvasásra

Más módokon is be lehet olvasni soronként fájlokat, például ismét a korábbi gyumolcsok.txt példával élve, a beolvasás történhet az alábbi módon is:

Fájlbeolvasás soronként - for ciklus az f-re

sorok = []
with open("gyumolcsok.txt", "r", encoding="UTF-8") as f:
    for sor in f:
        # Itt fel lehet dolgozni az éppen beolvasott sort.
        # Mi most "csak" új elemként hozzáadjuk a sorok listájához.
        sorok.append(sor)
print(sorok)

Illetve történhet while ciklus segítségével is:

Fájlbeolvasás soronként - while ciklus, readline() a feltételben

sorok = []
with open("gyumolcsok.txt", "r", encoding="UTF-8") as f:
    while (sor := f.readline()):
        # Itt fel lehet dolgozni az éppen beolvasott sort.
        # Mi most "csak" új elemként hozzáadjuk a sorok listájához.
        sorok.append(sor)
print(sorok)

Ennek a két megoldásnak a sorok értéke azonos a korábban látottal:

Output

["alma\n", "szilva\n", "körte\n", "eper\n"]

A fenti feldolgozási módok preferencia szerint használhatóak. Azért nagyon nagy fájlok esetén érdemes nem egyszerre beolvasni az egész fájlt (mert az sok memóriát foglalhat), hanem soronként feldolgozni (ha lehet).

Az lstrip, rstrip és strip függvények

A sztringek végén a readlines használata után mind ott fog maradni a sortörés karakter is, azaz a "\n". Ez sok esetben lehet kellemetlen, például ha beolvasunk egy sort amit azután ki is iratunk, könnyen lehet hogy véletlenül kettő sortörés lesz a végén (mert nem számolunk azzal, hogy alapból van a sor végén sortörés). Ez ellen nagyon jól működik az alábbi 3 függvény:

Fájlbeolvasás soronként

szoveg = "\nalma\n"
uj_szoveg = szoveg.rstrip() # uj_szoveg erteke: "\nalma"
uj_szoveg = szoveg.lstrip() # uj_szoveg erteke: "alma\n"
uj_szoveg = szoveg.strip() # uj_szoveg erteke: "alma"

A strip függvény leveszi egy sztring mindkét végéről az összes whitespace karaktert (whitespace karakterek az olyan karakterek amiknek "csak a hatása látható": sortörés, szóköz, tabulátor). Az rstrip és az lstrip ugyanezt csinálják, csak az előbbi csak jobb oldalról szedi le, az utóbbi pedig csak bal oldalról. Fájlokból readlines függvényes beolvasás után jobb oldalról érdemes általában leszedni a whitespace-t, azaz az rstrip kell.

A strip egy alkalmazása

Éles felhasználás során útban lehet a sortörés a beolvasott fájlból, ha például be akarunk olvasni egy jelszót vagy kódot. Egy gyakori esete ennek, amikor akár egy .env fájlból (nem csak .txt fájlokat lehet természetesen beolvasni, hanem egyéb szöveges fájlokat is) szeretnénk beolvasni egy API kulcsot, viszont szerepel a kulcs után egy sortörés: ha a sortöréssel együtt próbálnánk felhasználni a kulcsot, a kulcs nem működne.

Akár egy jelszót is megpróbálhatunk beolvasni (bár a gyakorlatban nem jellemző fájlokban tárolni jelszavakat, és nem tanácsos jelszavakat eredeti formájukban tárolni).

Példa felhasználás, adott jelszavak.txt fájl, tartalma a következő:

jelszo1=asdFGhjkLASDfgJKLasd
jelszo2=LKJhgeruNjkASfjliUNm

Ha be szeretnénk olvasni a jelszavak értékeit, így tehetjük meg:

Jelszavak beolvasása fájlból soronként

with open("jelszavak.txt", "r", encoding="UTF-8") as f:
    sorok = f.readlines()

jelszavak = []
for sor in sorok:
    jelszo = sor.split("=")[1].rstrip()
    jelszavak.append(jelszo)

Például az rstrip nélkül az 'asdFGhjkLASDfgJKLasd' string helyett az 'asdFGhjkLASDfgJKLasd\n' kerülne a jelszavak listájába. Ez eltérne a tényleges jelszótól, nem működne.

Whitespace karakterek

Informatikusok vagyunk. A whitespace karakterek is karakterek, akkor is, ha a hatásuk éppen nem látszik! Ha például a fájl egy sorában több szóköz van közvetlenül a sorvége előtt, azt a terminálra kiíratásnál, illetve egyes szövegszerkesztő programokban nem fogjuk észrevenni. Ettől még azok a karakterek ott vannak! Ha a fájl ténylegesen "csak" olvasható szöveget tartalmaz, akkor ezek a karakterek feleslegesek! (A számoknál például a nulla az semmi, mégsem mindegy, hogy a fizetendő összeg a végén pár nullával több vagy kevesebb. A számok elejére viszont nem írunk nullákat, mert ott tényleg nem számít, felesleges, a szám értékét nem befolyásolja, és rondán is néz ki.) Figyeljünk tehát arra, hogy például a sorok végén a sorvége karakter előtt egy látható (nem whitespace) karakter legyen! (Ebből a szempontból a Python programfájlok is szövegfájlok!)

Soronként írás fájlba

Ha szeretnénk soronként írni egy fájlba, legegyszerűbb minden sort odaadni a write függvénynek, hozzátoldva egy sortörést, azaz "\n" karaktert.

Példa, ha szeretnék egy listányi gyümölcsöt beleírni egy gyumolcsok.txt fájlba:

Fájlba írás soronként

gyumolcsok = ["meggy", "ribizli", "málna", "barack"]
with open("gyumolcsok.txt", "w", encoding="utf-8") as f:
    for gyumolcs in gyumolcsok:
        f.write(gyumolcs + "\n")

A fájlba írt szövegben minden gyümölcs neve szerepel, mindegyik név után sortöréssel. Akár vissza is olvashatnánk (most ebben a példában csak egyben, nem soronként):

Fájlból olvasás

with open("gyumolcsok.txt", "r", encoding="utf-8") as f:
    szoveg = f.read()

Ekkor szoveg értéke az alábbi lenne: "meggy\nribizli\nmálna\nbarack\n"

Sortörés a fájl végén

Egy szöveges fájl sorokból áll. Egy-egy sor tetszőleges számú karaktert tartalmazhat, de a végén mindig ott van egy '\n' (sorvége, LF - linefeed) karakter. Az utolsó sor végén is! Egy szöveges fájl utolsó karaktere tehát egy sorvége ('\n') karakter.

Ha egy fájl beolvasásakor az utolsó sort reprezentáló sztring végén nincs '\n' karakter, akkor abban a fájlban az utolsó sor nem volt lezárva! Ha egy fájl beolvasásakor az utolsó sort reprezentáló sztring csak egyetlen '\n' karaktert tartalmaz, akkor a fájl végén van egy (vagy több) felesleges üres sor! Mindkét eset kerülendő!

A fenti elv minden szöveges fájlra vonatkozik! A Python nyelvű programokra is!

Sajnos a szövegszerkesztő programok nem egységesek. Van, amelyik "normálisan" működik, azaz ha a szerkesztőben az utolsó sor végén <ENTER>-t ütök, akkor lezárja a fájl utolsó sorát. Ilyenkor a kurzor látszólag az utolsó sor utáni sorban villog, de abban a sorban nem tudok vele mozogni, és következő sorba sem tudok átmenni. Azután van olyan szövegszerkesztő, amelyik a fájl mentésénél biztos ami biztos alapon mindenképpen hozzáfűz egy sorvége karaktert. Ilyen esetben a fájl utolsó karaktere egy üres sor lehet (a fájl végén egymás után két sorvége karakter, '\n\n' lesz.) Végül van olyan, amelyik mentésnél szándékosan lehagyja az utolsó sorvége karaktert. Ez egyértelműen nem kívánatos működés, mert ilyenkor a mentett fájl utolsó sora nem lesz lezárva.

Utolsó sorvége elhelyezése

Amikor sorvége karaktereket rakol a te fájlodnak végére egyig számlálj. Se többet, se kevesebbet. Egy legyen, ameddig számolsz, s ameddig számolsz, az egyig legyen. Kettőig ne számolj hát ezért, sem pediglen nulláig, hacsak nem folytatod a te számolásodat egyig. A hármat szádra ne vedd. Midőn az egyeshez érsz, mely sorrendben a második leszen -- végtére is majdan informatikus lehendsz --, ott azonnal lezárod te a te fájlodat, hogy üres sor annak végén ne legyen, mivel ez így kedves nekem.

-- Az Úr szavai után szabadon (Monthy Python: Gyalog Galopp)

Sorvége különböző rendszerekben.

Amikor egy szöveges (text) módban megnyitott fájl tartalmát beolvassuk egy sztringbe, a sztringben a sorok vége mindenképpen '\n' karakterként jelenik meg. Amikor egy sztring tartalmát kiírjuk egy szöveges (text) módban megnyitott fájlba, a sztringben lévő '\n' karakterek különböző rendszereken különbözőképpen jelenhetnek meg.

• Unix és Linux alatt a fájlban egy '\n' (0xa kódú LF - Line Feed) karakter fog megjelenni, azaz a sztring értéke egy az egyben íródik ki.
• Windows alatt a sor végét a fájlban egy '\r\n' (0xd kódú CR - Carriage Return és 0xa kódú LF - Line Feed) karakterpár jelzi.
• MacOS alatt a sor végét a fájlban egy '\r' (0xd kódú CR - Carriage Return) karakter jelzi.

Beolvasásnál és kiírásnál szöveges módban megnyitott fájlok esetén a sorvége konverziója automatikus. Ha viszont ugyanazt a fájlt bináris módban nyitjuk meg, a fájlban tárolt karaktereket fogjuk visszakapni, akkor nincs konverzió.

A join függvény

A join függvény szöveget csinál listából olyan módon, hogy összefűzi a karaktereket egy sztring mentén (ez mondhatni a split "testvére"). Példa:

A join függvény

gyumolcsok = ["meggy", "ribizli", "málna", "barack"]
szoveg = "\n".join(gyumolcsok)

A példában a lista minden elemét a "\n" karakterrel összefűztük egy szövegbe, ezzel gyakorlatilag minden listalem közé tettünk sortörést. Az így kapott szöveget is kiírhatjuk fájlba (és akkor nem kell külön ciklust írni), csak ügyeljünk rá, hogy a végén így alapból nincs sortörés (mert csak az elemek között van).

Azaz szoveg értéke most az alábbi: "meggy\nribizli\nmálna\nbarack"

Ahhoz, hogy legyen a végén is sortörés, szükséges a végéhez hozzáfűzni egy "\n" karaktert.

A korábbi, for ciklusos példa egyszerűbben:

Fájlba írás soronként, join függvénnyel

gyumolcsok = ["meggy", "ribizli", "málna", "barack"]
with open("gyumolcsok.txt", "w", encoding="utf-8") as f:
    f.write("\n".join(gyumolcsok) + "\n")

Ekkor a fájl tartalma ugyanaz lesz, mint a korábbi példában: "meggy\nribizli\nmálna\nbarack\n" Ezt jól láthatjuk, ha például beolvassuk, mint korábban.

A join csak sztringekből álló listára működik

Ha olyan listára használjuk a join függvényt, amiben nem minden elem str (például van benne int), a join függvény hibát fog adni!

---

Összefoglalás

Összegzésül a with open-es ("r" meg "w" verziós) szintaxis ami fontos, és az alábbi függvények:

• read (sima olvasás string változóba)
• readlines (soronként olvasás egy listába, sortörések bent maradnak a listaelemekben)
• write (string írása fájlba)
• join (egy string mentén összekapcsolni egy listányi stringet egyetlen stringbe)
• lstrip, rstrip, strip (whitespace karakterek, pl. sortörések törlése a szöveg bal/jobb/mindkettő végéről)