Matura informatyka

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.

Python

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 zakresie s[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 gdy sub nie występuje, zgłasza błąd ValueError (analogicznie .rindex())
  • .startswith(prefix, start=0, end=len(s)) -> True, jeżeli napis zaczyna się od prefix (można podać krotkę kilku możliwości)
  • .endswith(suffix, start=0, end=len(s)) -> True, jeżeli napis kończy się na suffix (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 przed int()
  • .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. maxsplit ogranicza liczbę podziałów (-1 = bez limitu)
  • .rsplit(sep=None, maxsplit=-1) -> jak .split(), ale przy maxsplit dzieli od końca
  • .splitlines(keepends=False) -> zwraca listę linii napisu (podział na końcach linii); keepends=True zostawia znaki końca linii
  • .partition(sep) -> zwraca krotkę (przed, sep, po) podzieloną na pierwszym wystąpieniu sep
  • "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 old na new; count ogranicza liczbę zamian (domyślnie wszystkie)
  • .strip(chars=None) -> usuwa z początku i końca białe znaki lub znaki podane w argumencie (chars to 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ąd na i-ty znak dokąd (np. szyfry podstawieniowe). Trzeci argument maketrans to znaki do usunięcia
Wyrównywanie
  • .center(width, fillchar=" ") -> zwraca napis wyśrodkowany w polu o szerokości width, dopełniony znakiem fillchar
  • .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.

Python · metody napisów
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..|
↑
Python

Metody list zmieniają listę w miejscu i większość z nich zwraca None - nie pisz lista = lista.sort().

  • .append(x) -> dodaje element x na koniec listy
  • .extend(iterable) -> dodaje na koniec wszystkie elementy z obiektu iterowalnego (rozszerza listę)
  • .insert(i, x) -> wstawia element x przed indeksem i
  • .remove(x) -> usuwa pierwszy element o wartości x; zgłasza ValueError, 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łasza ValueError, 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)
Python · metody list
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)]
↑
Python

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łasza KeyError
  • .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
Python · metody słowników
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}
↑
Python

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łasza KeyError, 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 z x, których nie ma w y
  • 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 elementy x są w y
  • x.issuperset(y) lub x >= y -> True, jeżeli x zawiera wszystkie elementy y
  • x.isdisjoint(y) -> True, jeżeli zbiory nie mają wspólnych elementów
Python · metody zbioró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] 5
↑
Python

Krotki są niemodyfikowalne - mają tylko dwie metody.

  • .count(x) -> zwraca liczbę wystąpień wartości x
  • .index(x) -> zwraca indeks pierwszego wystąpienia x; zgłasza ValueError, jeżeli go nie ma
Python · metody krotek
t = (1, 2, 2, 3)
print(t.count(2), t.index(3))
#Output: 2 3
↑
Python

Obiekt 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ć przez str() 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 with niepotrzebne)
  • Tryby open(): "r" - odczyt (domyślny), "w" - zapis od nowa (czyści plik), "a" - dopisywanie na końcu
Python · metody plików
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]
↑