Metody napisów, list, słowników i zbiorów
Metody napisów, list, słowników i zbiorów w Pythonie - ściąga na maturę z informatyki.
Nie jest to wyczerpanie tematu - tylko metody najbardziej przydatne na maturze.
Napisy są niemodyfikowalne: wszystkie metody napisów zwracają nową wartość i nie zmieniają oryginalnego ciągu znaków. Wynik trzeba zapisać, np. s = s.upper().
Wielkość liter
- .lower() -> zamienia wszystkie litery na małe
- .upper() -> zamienia wszystkie litery na wielkie
- .capitalize() -> zamienia pierwszy znak na wielką literę, a pozostałe na małe
- .title() -> zamienia pierwszą literę każdego słowa na wielką, a pozostałe na małe
- .swapcase() -> zamienia małe litery na wielkie, a wielkie na małe
Szukanie i liczenie
- .count(sub, start=0, end=len(s)) -> zwraca liczbę wystąpień podciągu
sub(wystąpienia nie mogą na siebie nachodzić:"aaaa".count("aa") == 2). Opcjonalnie tylko w zakresies[start:end] - .find(sub, start=0, end=len(s)) -> zwraca indeks początku pierwszego wystąpienia
sub, a -1, jeżeli go nie ma - .rfind(sub, start=0, end=len(s)) -> jak
.find(), ale zwraca indeks ostatniego wystąpienia - .index(sub, start=0, end=len(s)) -> to samo co
.find(), tylko gdysubnie występuje, zgłasza błądValueError(analogicznie.rindex()) - .startswith(prefix, start=0, end=len(s)) ->
True, jeżeli napis zaczyna się odprefix(można podać krotkę kilku możliwości) - .endswith(suffix, start=0, end=len(s)) ->
True, jeżeli napis kończy się nasuffix(można podać krotkę kilku możliwości) - Samo sprawdzenie, czy podciąg występuje:
"ab" in s
Sprawdzanie zawartości
Dla pustego napisu wszystkie poniższe metody zwracają False. Żadna z nich nie uzna za liczbę napisu "-5" ani "3.14".
- .isalpha() ->
True, jeżeli same litery (także polskie, np."żółw") - .isdigit() ->
True, jeżeli same cyfry (także np. indeks górny"²") - .isdecimal() ->
True, jeżeli same cyfry dziesiętne ("0"-"9") - najbezpieczniejszy test przedint() - .isnumeric() ->
True, jeżeli same znaki liczbowe Unicode: cyfry, ale też np."½","Ⅻ"(najszersza z trzech metod) - .isalnum() ->
True, jeżeli same litery i cyfry - .isspace() ->
True, jeżeli same białe znaki (spacja, tabulator, znak nowej linii...) - .islower() ->
True, jeżeli wszystkie litery są małe (i jest co najmniej jedna litera) - .isupper() ->
True, jeżeli wszystkie litery są wielkie (i jest co najmniej jedna litera) - .istitle() ->
True, jeżeli każde słowo zaczyna się wielką literą, a dalej ma małe
Dzielenie, łączenie, zamiana
- .split(sep=None, maxsplit=-1) -> zwraca listę fragmentów napisu oddzielonych separatorem
sep. Bez argumentu dzieli po dowolnych białych znakach i pomija puste fragmenty.maxsplitogranicza liczbę podziałów (-1 = bez limitu) - .rsplit(sep=None, maxsplit=-1) -> jak
.split(), ale przymaxsplitdzieli od końca - .splitlines(keepends=False) -> zwraca listę linii napisu (podział na końcach linii);
keepends=Truezostawia znaki końca linii - .partition(sep) -> zwraca krotkę
(przed, sep, po)podzieloną na pierwszym wystąpieniusep - "sep".join(iterable) -> łączy napisy z obiektu iterowalnego, wstawiając między nie
sep, np.".".join(["a", "b"]) == "a.b". Elementy muszą być napisami - .replace(old, new, count=-1) -> zamienia wystąpienia
oldnanew;countogranicza liczbę zamian (domyślnie wszystkie) - .strip(chars=None) -> usuwa z początku i końca białe znaki lub znaki podane w argumencie (
charsto zbiór znaków, a nie podciąg) - .lstrip(chars=None) / .rstrip(chars=None) -> jak
.strip(), ale tylko z lewej / z prawej strony - .translate(str.maketrans(skąd, dokąd)) -> zamienia znaki według tabeli: i-ty znak
skądna i-ty znakdokąd(np. szyfry podstawieniowe). Trzeci argumentmaketransto znaki do usunięcia
Wyrównywanie
- .center(width, fillchar=" ") -> zwraca napis wyśrodkowany w polu o szerokości
width, dopełniony znakiemfillchar - .ljust(width, fillchar=" ") -> wyrównuje do lewej (dopełnia z prawej)
- .rjust(width, fillchar=" ") -> wyrównuje do prawej (dopełnia z lewej), np.
"101".rjust(8, "0") == "00000101" - .zfill(width) -> dopełnia zerami z lewej do szerokości
width(uwzględnia znak minus)
Wycinki i odwracanie napisów (s[2:5], s[::-1]) oraz formatowanie f-stringami (f"{x:.2f}", f"{n:08b}") opisane są w dziale Funkcje wbudowane.
s = " Ala ma kota "
print(s.strip().upper(), s.strip().lower(), "aLA mA".capitalize())
#Output: ALA MA KOTA ala ma kota Ala ma
print("abrakadabra".count("a"), "abrakadabra".find("ra"), "abrakadabra".rfind("ra"), "abc".find("x"))
#Output: 5 2 9 -1
print("plik.txt".endswith((".txt", ".csv")), "0101".startswith("01"))
#Output: True True
print("123".isdecimal(), "-5".isdecimal(), "żółw".isalpha(), "abc1".isalnum(), "".isalpha())
#Output: True False True True False
print("1 2 3".split(), "1;2;;3".split(";"), "a b c d".split(" ", 2))
#Output: ['1', '2', '3'] ['1', '2', '', '3'] ['a', 'b', 'c d']
print("klucz=wartość".partition("="))
#Output: ('klucz', '=', 'wartość')
print("-".join(["2024", "05", "08"]), " ".join(map(str, [1, 2, 3])))
#Output: 2024-05-08 1 2 3
print("banan".replace("a", "o"), "banan".replace("a", "o", 1))
#Output: bonon bonan
print("abc cab".translate(str.maketrans("abc", "xyz")), "a-b-c".translate(str.maketrans("", "", "-")))
#Output: xyz zxy abc
print("xxhixx".strip("x"), "[" + "ok".center(6, "*") + "]")
#Output: hi [**ok**]
print("7".zfill(3), "101".rjust(8, "0"), "ab".ljust(4, ".") + "|")
#Output: 007 00000101 ab..|Metody list zmieniają listę w miejscu i większość z nich zwraca None - nie pisz lista = lista.sort().
- .append(x) -> dodaje element
xna koniec listy - .extend(iterable) -> dodaje na koniec wszystkie elementy z obiektu iterowalnego (rozszerza listę)
- .insert(i, x) -> wstawia element
xprzed indeksemi - .remove(x) -> usuwa pierwszy element o wartości
x; zgłaszaValueError, jeżeli go nie ma - .pop(i=-1) -> usuwa element o indeksie
i(domyślnie ostatni) i go zwraca - .clear() -> usuwa wszystkie elementy
- .index(x, start=0, end=len(lista)) -> zwraca indeks pierwszego wystąpienia
x; zgłaszaValueError, jeżeli go nie ma - .count(x) -> zwraca liczbę wystąpień
x - .sort(key=None, reverse=False) -> sortuje listę w miejscu (zwraca
None).key- funkcja, według której wyniku sortujemy;reverse=True- malejąco - .reverse() -> odwraca kolejność elementów w miejscu (zwraca
None) - .copy() -> zwraca płytką kopię listy (to samo co
lista[:])
.sort() czy sorted()?
- lista.sort() -> zmienia oryginalną listę, działa tylko dla list
- sorted(obiekt) -> zwraca nową listę, oryginał zostaje bez zmian; działa dla dowolnego obiektu iterowalnego (napisu, krotki, zbioru, słownika)
lista = [3, 1, 2]
lista.append(5)
lista.extend([7, 1])
lista.insert(0, 9)
print(lista)
#Output: [9, 3, 1, 2, 5, 7, 1]
print(lista.pop(), lista.pop(0), lista)
#Output: 1 9 [3, 1, 2, 5, 7]
lista.remove(1)
print(lista, lista.index(5), lista.count(3))
#Output: [3, 2, 5, 7] 2 1
wynik = lista.sort()
print(wynik, lista)
#Output: None [2, 3, 5, 7]
lista.sort(reverse=True)
print(lista)
#Output: [7, 5, 3, 2]
lista.reverse()
print(lista)
#Output: [2, 3, 5, 7]
slowa = ["kot", "Ala", "pies", "be"]
slowa.sort(key=len)
print(slowa, sorted(slowa, key=str.lower))
#Output: ['be', 'kot', 'Ala', 'pies'] ['Ala', 'be', 'kot', 'pies']
# pułapka: płytka kopia listy dwuwymiarowej
a = [[0, 0], [0, 0]]
b = a.copy()
b[0][0] = 1
print(a)
#Output: [[1, 0], [0, 0]]
# poprawnie: kopia każdego wiersza (albo copy.deepcopy)
a = [[0, 0], [0, 0]]
c = [wiersz[:] for wiersz in a]
c[0][0] = 1
print(a, c)
#Output: [[0, 0], [0, 0]] [[1, 0], [0, 0]]
# sortowanie listy krotek: malejąco po punktach, przy remisie rosnąco po imieniu
wyniki = [("Ola", 87), ("Jan", 92), ("Ewa", 87)]
wyniki.sort(key=lambda w: (-w[1], w[0]))
print(wyniki)
#Output: [('Jan', 92), ('Ewa', 87), ('Ola', 87)]Odczyt d[klucz] zgłasza błąd KeyError, gdy klucza nie ma. Od Pythona 3.7 słownik pamięta kolejność dodawania elementów.
- .get(key, default=None) -> zwraca wartość dla klucza
key, a jeżeli klucza nie ma -default(bez błędu) - .setdefault(key, default=None) -> zwraca wartość dla klucza; jeżeli klucza nie ma, najpierw wstawia go z wartością
default - .keys() -> zwraca widok kluczy (można po nim iterować, listę daje
list(d.keys())) - .values() -> zwraca widok wartości
- .items() -> zwraca widok par
(klucz, wartość), np.for k, v in d.items(): - .pop(key, default) -> usuwa element o danym kluczu i zwraca jego wartość; jeżeli klucza nie ma, zwraca
default, a gdy go nie podano - zgłaszaKeyError - .popitem() -> usuwa i zwraca ostatnio wstawioną parę
(klucz, wartość) - .update(inny) -> dodaje pary z innego słownika (lub z listy par); istniejące klucze nadpisuje
- dict.fromkeys(klucze, value=None) -> tworzy nowy słownik z podanymi kluczami i jedną wartością dla wszystkich
- .copy() -> zwraca płytką kopię słownika
- .clear() -> usuwa wszystkie elementy
- Sprawdzenie, czy klucz istnieje:
klucz in d
d = {"a": 1, "b": 2}
print(d.get("a"), d.get("z"), d.get("z", 0))
#Output: 1 None 0
print(list(d.keys()), list(d.values()), list(d.items()))
#Output: ['a', 'b'] [1, 2] [('a', 1), ('b', 2)]
d.update({"b": 5, "c": 3})
print(d)
#Output: {'a': 1, 'b': 5, 'c': 3}
print(d.pop("a"), d.pop("x", -1), d)
#Output: 1 -1 {'b': 5, 'c': 3}
print(d.popitem(), d)
#Output: ('c', 3) {'b': 5}
grupy = {}
for slowo in ["kot", "koza", "pies"]:
grupy.setdefault(slowo[0], []).append(slowo)
print(grupy)
#Output: {'k': ['kot', 'koza'], 'p': ['pies']}
# zliczanie wystąpień
licznik = {}
for znak in "abracadabra":
licznik[znak] = licznik.get(znak, 0) + 1
print(licznik)
#Output: {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}
# sortowanie po wartościach (malejąco)
print(sorted(licznik.items(), key=lambda p: p[1], reverse=True)[:2])
#Output: [('a', 5), ('b', 2)]
print(max(licznik, key=licznik.get), dict.fromkeys("ab", 0))
#Output: a {'a': 0, 'b': 0}Zbiór przechowuje elementy bez powtórzeń i bez kolejności. Pusty zbiór to set() - zapis {} tworzy pusty słownik.
- .add(x) -> dodaje element
x - .update(iterable) -> dodaje wszystkie elementy z obiektu iterowalnego
- .remove(x) -> usuwa element
x; zgłaszaKeyError, jeżeli go nie ma - .discard(x) -> usuwa element
x; nie zgłasza błędu, jeżeli go nie ma - .pop() -> usuwa i zwraca dowolny element (nie wiadomo który)
- .clear() -> usuwa wszystkie elementy
- .copy() -> zwraca kopię zbioru
- x.union(y) lub
x | y-> suma: wszystkie elementy z obu zbiorów (bez powtórzeń) - x.intersection(y) lub
x & y-> część wspólna: elementy, które są w obu zbiorach - x.difference(y) lub
x - y-> różnica: elementy zx, których nie ma wy - x.symmetric_difference(y) lub
x ^ y-> różnica symetryczna: elementy, które są dokładnie w jednym ze zbiorów (wszystko poza częścią wspólną) - x.issubset(y) lub
x <= y->True, jeżeli wszystkie elementyxsą wy - x.issuperset(y) lub
x >= y->True, jeżelixzawiera wszystkie elementyy - x.isdisjoint(y) ->
True, jeżeli zbiory nie mają wspólnych elementów
x = {1, 2, 3, 4}
y = {3, 4, 5}
print(sorted(x.union(y)), sorted(x | y))
#Output: [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
print(sorted(x.intersection(y)), sorted(x.difference(y)), sorted(x.symmetric_difference(y)))
#Output: [3, 4] [1, 2] [1, 2, 5]
print({3, 4}.issubset(x), x.issuperset({1, 2}), x.isdisjoint({7, 8}))
#Output: True True True
x.add(10)
x.discard(99)
x.remove(1)
print(sorted(x), len(set("abracadabra")))
#Output: [2, 3, 4, 10] 5Krotki są niemodyfikowalne - mają tylko dwie metody.
- .count(x) -> zwraca liczbę wystąpień wartości
x - .index(x) -> zwraca indeks pierwszego wystąpienia
x; zgłaszaValueError, jeżeli go nie ma
t = (1, 2, 2, 3)
print(t.count(2), t.index(3))
#Output: 2 3Obiekt pliku zwraca funkcja open() (opisana w dziale Funkcje wbudowane). Najwygodniej używać jej z with - plik zamknie się sam. Plik czytany jest od miejsca, w którym skończył poprzedni odczyt: po .read() kolejny odczyt zwraca pusty napis.
- .read() -> zwraca całą (pozostałą) zawartość pliku jako jeden napis
- .readline() -> zwraca kolejną linię razem ze znakiem
"\n"; na końcu pliku zwraca pusty napis"". Przydaje się do pominięcia wiersza nagłówkowego - .readlines() -> zwraca listę wszystkich (pozostałych) linii, każda ze znakiem
"\n"na końcu - for linia in plik: -> czytanie linia po linii - najprostsze i oszczędza pamięć
- .write(napis) -> zapisuje napis (tylko typu
str, liczby trzeba zamienić przezstr()lub f-string) i nie dodaje"\n"; zwraca liczbę zapisanych znaków - .writelines(lista_napisów) -> zapisuje kolejne napisy z listy, także bez dodawania
"\n" - .close() -> zamyka plik (przy
withniepotrzebne) - Tryby
open():"r"- odczyt (domyślny),"w"- zapis od nowa (czyści plik),"a"- dopisywanie na końcu
with open("liczby.txt", "w") as f:
f.write("10\n20\n")
f.writelines(["30\n", "40\n"])
with open("liczby.txt") as f:
print(repr(f.readline()), repr(f.readline()))
print(f.readlines())
#Output: '10\n' '20\n'
#Output: ['30\n', '40\n']
with open("liczby.txt") as f:
tekst = f.read()
print(repr(tekst), repr(f.read()))
#Output: '10\n20\n30\n40\n' ''
print(tekst.split(), tekst.splitlines())
#Output: ['10', '20', '30', '40'] ['10', '20', '30', '40']
with open("liczby.txt", "a") as f: # dopisywanie na końcu pliku
print(50, file=f)
with open("liczby.txt") as f:
print([int(linia) for linia in f]) # int() ignoruje "\n" na końcu linii
#Output: [10, 20, 30, 40, 50]