uj_sor = "\n" #
horizontalis_tab = "\t" # vizszintes tabulator
rep = "\\" # rep = forditott per
egyes_idezojel = "\'" # '
kettes_idezojel = "\"" # "
print(egyes_idezojel + uj_sor + kettes_idezojel)
a = "That's"
b = "fine"
| Operator | Description | Input | Output | ||
|---|---|---|---|---|---|
| + | Concatenation | a + b | That'sfine | ||
| * | Repetition | 2 * b | finefine | ||
| [] | Slice | a[1] | h | ||
| [:] | Range Slice | a[1:4] | hat | ||
| in | Membership | 'a' in a | True | ||
| not in | Membership | 'a' not in b | True | ||
| r/R | Raw String suppresses escape chars | r'\n' | \n |
A str() függvénnyel tudunk stringgé konvertálni.
s = "ez egy sztring"
print("egy" in s)
s.find("egy")
hi = "how ARE you"
| Method | Description | Input | Output |
|---|---|---|---|
| .capitalize() | first letter into upper case | hi.capitalize() | How are you |
| .lower() | lower case | hi.lower() | how are you |
| .upper() | upper case | hi.upper() | HOW ARE YOU |
| .title() | every word capitalized | hi.title() | How Are You |
s = "hol KIS-, hol NAGYbetűk"
Az első szó kezdődjön nagybetűvel, az összes többi betű legyen kicsi:
s.capitalize()
Csupa nagybetűssé tevés:
s.upper()
Csupa kisbetűssé tevés:
s.lower()
| Method | Boolean value |
|---|---|
| .isalnum() | alphanumeric characters (no symbols)? |
| .isalpha() | alphabetic characters (no symbols)? |
| .islower() | lower case? |
| .isnumeric() | numeric characters? |
| .isspace() | whitespace characters? |
| .istitle() | is in title case? |
| .isupper() | upper case? |
Csak az ábécé betűit tartalmazza-e (emlékeztető: a szóköz nem az ábécé betűje):
"a b".isalpha()
alnum = "23 apples"
num = "-1234"
title = "Big Apple"
print(alnum.isalnum(), num.isnumeric(), title.istitle())
alnum = "23apples"
num = "1234"
white = " \t \n\n "
print(alnum.isalnum(), num.isnumeric(), white.isspace())
hi = "how ARE you"
seq = ['h', 'o', 'w'] #OR seq = 'h', 'o', 'w'
wh = "\t this \n "
| Method | Description | Input | Output |
|---|---|---|---|
| .join() | concatenates with separator string | " < ".join(seq) | h < o < w |
| .lstrip() | removes leading whitespaces | wh.lstrip() | "this \n " |
| .rstrip() | removes trailing whitespaces | wh.rstrip() | "\t this" |
| .strip() | performs lstrip() and rstrip() | wh.strip() | "this" |
| .replace(old, new [, m]) | replaces old with new at most m times | hi.replace("o", "O") | hOw ARE yOu |
| .split(s[,m]) | splits at s max m times, returns list | hi.split() | [ "how", "ARE", "you" ] |
Karakterlánc felbontása megadott szeparátor karakter segítségével (ha a szeparátor nincs megadva, nem látható (white spaces) karaktereknél vág szét). Eredményül visszakapjuk a részsztringek listáját:
wh = 'tab\túj sor\nszóköz'
wh.split()
s.split() # nem láthatónál vágja szét (white space)
s = "elso masodik\tharmadik\nnegyedik" # szokozokkel szavakra vagjuk
s.split(" ")
s = "elso masodik, harmadik, negyedik"
s.split(", ") # itt egy vesszo es egy szokoz is van!
Nem látható (whitespace) karakterek törlése a karakterlánc elejéről és végéről, vagy megadott karakterek törlése az elejéről és végéről:
s = ' \t szóközök \t \n\n '
s.strip()
s = "...vesszővel vagy ponttal kezdődik vagy vegződik,"
print(s.strip(".,")) # mindket vegerol
print(s.rstrip(".,")) # csak jobbrol torol
print(s.lstrip(".,")) # csak balrol torol
Formázásra a % operátor könnyen használható:
name = "Lucy"
"Hi %s!" % name
A lehetőségeket összefoglaljuk a következő táblázatban:
| %char | short for | example | output | |
|---|---|---|---|---|
| %s | string | "Hi %s" % "Joe" | "Hi Joe" | |
| %d | digits: 0123456789 | "%d is prime" % 7 | "7 is prime" | |
| %o | octal: 01234567 | "8 = octal %o" % 8 | "8 = octal 10" | |
| %x | hex: 0123456789abcdef | "10 = hex %x" % 10 | "10 = hex a" | |
| %X | hex: 0123456789ABCDEF | "10 = hex %X" % 10 | "10 = hex A" | |
| %f, %F | floating point | "1.2 = %f" % 1.2 | '1.2 = 1.200000' | |
| %e, %E | exponential | "12 = %e" % 12 | '12 = 1.200000e+01' | |
| %g, %G | general | "1.2e2 = %g" % 1.2e2 | '1.2e2 = 120' |
x = -12.345
y = 12.3e10
print("f: %f, e: %e, g: %g" % (x, x, x))
print("f: %f, e: %e, g: %g" % (y, y, y))
"Hi %s! You have got %d points!" % ("Joe", 5)
name = "Lucy"
points = 10
"Hi %s! You have got %d points!" % (name, points)
format metódussal¶Itt az objektum a formátumot leíró karakterlánc és a format metódus argumentumai a behelyettesítendő értékek. A formátumban { és } között először a format argumentumának indexe szerepel, majd opcionálisan : után a formátum leírása:
'{0}-{1}-{2} {0}, {1}, {2}, {0}{0}{0}'.format('X', 'Y', 'Z')
| Jel | Jelentés |
|---|---|
| d | Decimális (ezt kell tudni) |
| b | Bináris |
| o | Oktális |
| x, X | hex, HEX formátum |
| f, F | (float) lebegőpontos szám |
| e, E | (exp) lebegőpontos szám exponenciális alakban |
| < | balra igazít |
| > | jobbra igazít |
| ^ | középre igazít |
| c^ | középre igazít és körülötte az opcionális 'c' karakterrel kitölt |
print("01234 01234 01234 0123456789")
print('{0:5} {1:5d} {2:_>5} {3:_^10}'.format('0123', 1234, '|', 'kozepe'))
"int {0:d}, hex {0:x} {0:X}, oct {0:o}, bin {0:0>8b}".format(42)
"{0}, {0:e}, {0:f}, {0:10.4f}, {0:15.1f}".format(-12.345)
Nem csak a format-on belüli index használható az érték azonosítására, de nevek is használhatók:
'A középpont: ({x:5}, {y:f})'.format(y=5, x=3)
x1 = 3; y1 = 4
print('A középpont: ({x}, {y})'.format(x=x1, y=y1))
tablazat = [["Első sor", -2, -310],
["Második sor", 3, 1],
["Harmadik sor", -321, 11]]
formazott_tablazat = ""
for sor in tablazat:
formazott_tablazat += "{0:_<13}".format(sor[0])
for i in range(1, len(sor)):
formazott_tablazat += "{0:>7d}".format(sor[i])
formazott_tablazat += "\n"
print(formazott_tablazat)
F-sztring az, ami elé 'f' vagy 'F' betűt írunk. Ezekben kapcsos zárójelek közé Python kifejezések rakhatók, melyek futás közben értékelődnek ki. (Az előző változatokban csak konstans értékek kerülhettek be.)
name = "Lucy"
points = 100
f"Hi {name}! You have {points} points!"
a, b = 3, 5
f"2({a} + {b}) = {2*(a+b)}"
width = 8
precision = 4
value = -123.4567
f"result: {value:{width}.{precision}}" # nested fields
num = 300
f'{num}, {num:x}, {num:o}, {num:b}, {num:10}, {num:10X}'
num, numb, numo, numx = 12, 0b10010, 0o371, 0xabc
f"{num}, {numb}, {numo}, {numx}"
d = {"one": 1, "two": 2}
f"{d['one']} is one" # f"{d["one"]} is one" hibaüzenetet adna!!!
s = "hol vagyok"
print('0123456789'*3)
print(s.center(30))
print(s.rjust(30))
print(s.ljust(30))
A paraméterként átadott érték szabályozza a létrejött string hosszát.
Így egy táblázat (tömb) kiírása jobban kezelhető:
karakteres_tablazat = ""
for sor in tablazat:
karakteres_tablazat += sor[0].ljust(13)
for i in range(1, len(sor)):
karakteres_tablazat += str(sor[i]).rjust(7)
karakteres_tablazat += "\n"
print(karakteres_tablazat)
Adott jellemzőkkel rendelkező karakterláncok felismerése a cél (pl. érvényes email-cím, dátum, római szám, IP-cím,...)
Olvasnivalók:
Vannak online tesztoldalak, ahol programozás nélkül lehet próbálgatni a reguláris kifejezéseket: https://regex101.com/#python, https://extendsclass.com/regex-tester.html#python, https://www.regextester.com/, https://pythex.org/ (itt van puska is).
A reguláris kifejezésekben használt metakarakterek: . ^ $ * + ? { } [ ] ( ) \ |
| Jel | Jelentése (mire illeszkedik) | Példa | Illeszkedik |
|---|---|---|---|
| . | bármely karakterre illeszkedik (kivéve új sor) | "t.t." | tatu, tütü |
| ^ | a minta elejére illeszkedik | "^Mélységes mély" | |
| $ | a minta végére illeszkedik | "és bízva bízzál.\$" | |
| | | logikai vagy a környező RE-ekre | "Informati(cs|ka)" | Informatics, Informatika |
| [] | a felsorolt karakterek bármelyikére illeszkedik | [xq] | x, q |
| [^chars] | bármi, kivéve a felsoroltak | [^xq] | a, b, c,... |
| [a-z] | tartomány | "[0-9a-fA-F]" | bármely hexa jegy |
| () | hivatkozható csoportosítás | ||
| ? | előző RE 0 vagy egyszeri ismétlése | "colou?r" | color, colour |
| * | a megelőző RE 0 vagy többszöri ismétlése (mohó) | "woo*w" | wow, woooooow |
| + | a megelőző RE 1 vagy többszöri ismétlése (mohó) | "wo+w" | wow, woooooow |
| *? | a * lusta változata | ||
| +? | a + lusta változata | ||
| {n} | az előző RE pontosan n-szer | "al{2}e{2}" | allee |
| {n,} | az előző RE legalább n-szer | "wo{3,}w" | wooow, woooow |
| {,n} | az előző RE legföljebb n-szer | ||
| {n,m} | legalább n-szer, legföljebb m-szer | ||
| \ | a spec. karakterek escape-elésére |
| Általános karakterosztályok | |
|---|---|
| \d | decimális szám |
| \D | nem decimális szám, minden más |
| \s | szóköz karakter |
| \S | bármely más karakter a szóközön kívül |
| \w | bármely szókarakter: alfanumerikus karakter vagy aláhúzás |
| \W | bármi, ami nem szókarakter (nem alfanumerikus és nem aláhúzás) |
| \b | szóhatár |
Először be kell töltenünk a re csomagot, mely tartalmazza a python regexp függvényeit:
import re
A re modul néhány függvénye:
| Függvény | Leírás |
|---|---|
| findall(p, s) | a p minta összes előfordulása az s sztringben |
| search(p, s) | visszaad egy „match object”-et ha p illeszkedik s egy részére |
| split(p, s) | elvágja p minden illeszkedésénél az s sztringet, listát ad vissza |
| sub(p, n, s[, m]) | helyettesíti p-t n-re az s-ben m-szer |
| finditer(p, s) | "match object"-ek iterálható objektuma |
A „match object” megadja, hogy a minta hol illeszkedik és mire. Ezt az infot a .span() és a .group() metódus adja vissza.
A karakterláncokban az eszképelt, azaz a \ jellel kezdődő karakterek (\n, \t, \) és a reguláris kifejezések \ jellel kezdődő parancsaiból adódó bizonytalanságok elkerülésére helyesebb, ha a reguláris kifejezések karakterláncait nyers (raw) formában adjuk meg, vagy minden karaktert eszképeljünk. Nyers formában tehát a \ repjelet jelent! Nyers karakterláncot az elé írt r betűvel jelöljük.
nyers = r"aa\txx\s"
nem_nyers = "aa\txx\s"
eszkepelt = "aa\txx\\s"
print("Nyers: " + nyers)
print("Nem nyers: " + nem_nyers)
print("Eszképelt: " + eszkepelt)
s = "confirmation"
p = ".i"
print(re.findall(p, s))
print(re.search(p, s))
x = re.search(p, s)
print(x.span())
print(x.group())
print(re.split(p, s))
x = re.finditer(p, s)
for y in x:
print(y.group(), y.span())
s = "Hú, de szép"
p = "([úé])"
print(re.sub(p, r"\1\1\1\1", s))
s = "This 'string' has two 'quoted' words"
p1 = "'.*'" # mohó, greedy
p2 = "'.*?'" # lusta, lazy
print(re.findall(p1, s), " --> greedy")
print(re.findall(p2, s), " --> lazy")