16 przydatnych jednowierszowych tekstów w języku Python, które upraszczają typowe zadania

Czy pragniesz pisać kod w Pythonie, który będzie zarówno elegancki, jak i zgodny z duchem tego języka? Zapoznaj się z zestawem praktycznych, pojedynczych linii kodu Pythona, które znakomicie sprawdzą się w prostych zadaniach.

Jako początkujący programista Pythona, z pewnością poświęcisz sporo czasu na zgłębianie podstawowych struktur danych, takich jak listy i sekwencje znaków. Niektóre z operacji na tych strukturach można zrealizować za pomocą zwięzłych, jednowierszowych fragmentów kodu.

Każdy programista powinien dążyć do tego, by kod był przede wszystkim czytelny i łatwy w utrzymaniu, a dopiero później – maksymalnie skrócony. Jednak Python oferuje możliwość tworzenia jednolinijkowych konstrukcji, które nie tylko są zwięzłe, ale także zgodne z najlepszymi praktykami kodowania.

W niniejszym artykule skupimy się na jednoliniowych rozwiązaniach do podstawowych zadań związanych z obróbką list i łańcuchów znaków w Pythonie.

Zacznijmy eksplorację!

Tworzenie listy liczb

Najprostszym sposobem na wygenerowanie listy liczb jest skorzystanie z funkcji range(). Funkcja ta generuje obiekt zakresu, który można łatwo przekształcić w listę. Wywołanie range(num) utworzy sekwencję liczb od 0 do num-1.

>>> nums = list(range(10))
>>> nums
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Dowiedz się więcej o wykorzystaniu funkcji range().

Funkcję range() można także użyć z opcjonalnym parametrem kroku. Zatem zakres (start, stop, krok) wygeneruje sekwencję start, start + krok, start + 2*krok i tak dalej. Ostatnią wartością będzie start + k*krok, gdzie (start + k*krok) < stop, a (start + (k+1)*krok) > stop.

Wyszukiwanie wartości maksymalnej i minimalnej w liście

Do obliczenia odpowiednio największego i najmniejszego elementu w liście można wykorzystać wbudowane funkcje max i min.

>>> min_elt, max_elt = min(nums), max(nums)
>>> min_elt
0
>>> max_elt
9

📑 Ważna uwaga o wielokrotnych przypisaniach

Zwróć uwagę, że przypisanie wartości do zmiennych min_elt i max_elt nastąpiło w jednej instrukcji. Python wspiera takie wielokrotne przypisania. Może to być szczególnie przydatne przy rozpakowywaniu iteracji i przypisywaniu wartości do kilku zmiennych naraz.

Usuwanie duplikatów z listy

Kolejną częstą operacją jest eliminacja duplikatów z list w Pythonie. Jest to konieczne, gdy chcemy pracować tylko z unikalnymi wartościami. Najprostszym sposobem na to jest konwersja listy na zbiór (set).

Zbiór to wbudowana struktura danych, której wszystkie elementy są unikatowe i haszowalne.

>>> nums1 = [2,4,7,9,7,10]

W liście nums1 element 7 występuje dwukrotnie. Przekształcenie jej w zbiór usunie duplikat (w tym przypadku 7), pozostawiając jedynie listę unikalnych wartości.

Ponieważ nadal potrzebujemy pracować z listą, ponownie przekonwertujemy zbiór na listę. Możemy to zrobić za pomocą następującego wiersza kodu:

>>> nums1 = list(set(nums1))
>>> nums1
[2, 4, 7, 9, 10]

📒 Jeśli chcesz dowiedzieć się więcej o innych metodach usuwania duplikatów z list Pythona, zapoznaj się z tym przewodnikiem.

Zliczanie wystąpień w liście

Aby zliczyć, ile razy element pojawia się w liście, można użyć wbudowanej metody count(). list.count(element) zwraca liczbę wystąpień elementu w danej liście.

>>> nums
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

W powyższej liście element 7 występuje raz, więc metoda count() zwróci 1.

>>> nums.count(7)
1

Sprawdzanie, czy wszystkie elementy listy spełniają warunek

Aby sprawdzić, czy każdy element w liście spełnia określony warunek, można użyć wbudowanej funkcji all().

Funkcja all() przyjmuje jako argument iterowalny obiekt i zwraca True, jeśli wszystkie elementy tego obiektu mają wartość True (lub są uznawane za prawdę).

Załóżmy, że chcemy sprawdzić, czy wszystkie elementy w liście nums2 są nieparzyste.

>>> nums2 = [3,4,7,11,21,67,12]

Możemy użyć konstrukcji listowej (list comprehension), aby utworzyć listę wartości boolowskich, którą następnie przekażemy jako argument do funkcji all().

W naszym przypadku, wyrażenie num%2!=0 zwróci False dla elementów 4 i 12, które są parzyste. W rezultacie, lista wartości boolowskich, wygenerowana za pomocą list comprehension, będzie zawierała wartość False (a all(lista) zwróci wartość False).

>>> all([num%2!=0 for num in nums2])
False

💡 Warto zauważyć, że all([]) (czyli all z pustym obiektem iterowalnym) zwraca True.

Sprawdzanie, czy jakikolwiek element listy spełnia warunek

Aby sprawdzić, czy choć jeden element listy spełnia określony warunek, można wykorzystać funkcję any(). any(lista) zwraca True, jeśli przynajmniej jeden element ma wartość True.

>>> nums2 = [3,4,7,11,21,67,12]

Podobnie jak w poprzednim przykładzie, używamy list comprehension, aby wygenerować listę wartości boolowskich. Lista nums zawiera liczby parzyste, więc funkcja any() zwróci wartość True.

>>> any([num%2 for num in nums2])
True

Odwracanie ciągu znaków

W Pythonie łańcuchy są niezmienne, co oznacza, że jeśli chcesz odwrócić łańcuch, musisz utworzyć jego odwróconą kopię. Istnieją dwa powszechnie stosowane sposoby – oba mogą być zrealizowane jako jednolinijkowe wyrażenia – wykorzystujące mechanizm wycinania (slicing) łańcuchów i wbudowane funkcje.

Wykorzystanie wycinania łańcuchów

Wycinanie łańcucha z ujemną wartością kroku powoduje zwrócenie wycinka łańcucha, począwszy od końca. Składnia to: łańcuch[start:stop:step]. Co zatem da ustawienie kroku na -1 i pominięcie indeksów startu i stopu?

Spowoduje to zwrócenie kopii łańcucha, zaczynając od jego końca – uwzględniając każdy znak.

>>> str1[::-1]
'olleh'

Wykorzystanie funkcji reversed()

Wbudowana funkcja reversed() zwraca odwrócony iterator dla sekwencji.

>>> reversed(str1)
<reversed object at 0x008BAF70>
>>> for char in str1:
...     print(char)
...
h
e
l
l
o

Można jej użyć w połączeniu z metodą join(), jak pokazano poniżej:

>>> ''.join(reversed(str1))
'olleh'

Konwersja łańcucha znaków na listę znaków

Załóżmy, że chcemy rozbić łańcuch znaków na listę pojedynczych znaków. Możemy to osiągnąć za pomocą wyrażenia listowego.

>>> str1 = 'hello'

List comprehension są jednym z najpotężniejszych narzędzi w Pythonie do tworzenia zwięzłych jednoliniowych wyrażeń.

📒 Dowiedz się więcej o list comprehension w Pythonie.

Przechodzimy przez łańcuch znaków i zbieramy każdy jego znak.

>>> chars = [char for char in str1]
>>> chars
['h', 'e', 'l', 'l', 'o']

Aby podzielić dłuższy łańcuch na listę podłańcuchów przy każdym wystąpieniu spacji, można użyć metody split().

>>> str2 = 'hello world'
>>> str2.split()
['hello', 'world']

Widzieliśmy już, jak można użyć list comprehension do rozdzielenia łańcucha na listę znaków. W tym przypadku zebraliśmy wszystkie znaki, iterując po łańcuchu.

A co zrobić, jeśli chcemy przejść przez łańcuch znaków i zebrać tylko cyfry? Jak tego dokonać?

• Możemy użyć warunku filtrującego w list comprehension za pomocą metody isdigit().
• c.isdigit() zwróci True, jeśli c jest cyfrą, w przeciwnym wypadku zwróci False.

>>> str3 = 'python3'
>>> digits = [c for c in str3 if c.isdigit()]
>>> digits
['3']

Sprawdzanie, czy łańcuch zaczyna się od określonego podłańcucha

Aby sprawdzić, czy łańcuch zaczyna się od danego podłańcucha, można skorzystać z metody startswith(). str1.startswith(podłańcuch) zwróci True, jeśli str1 zaczyna się od podłańcucha, w przeciwnym wypadku zwróci False.

Oto kilka przykładów:

>>> str4 = 'coding'
>>> str4.startswith('co')
True

>>> str5 = 'python'
>>> str5.startswith('co')
False

Sprawdzanie, czy łańcuch kończy się określonym podłańcuchem

Jak można się spodziewać, aby sprawdzić, czy łańcuch kończy się na określonym podłańcuchu, można użyć metody endswith().

>>> str5 = 'python'
>>> str5.endswith('on')
True

Możemy równie dobrze użyć tej metody w wyrażeniu list comprehension, aby otrzymać listę wartości boolowskich.

>>> strs = ['python','neon','nano','silicon']

>>> ends_with = [str.endswith('on') for str in strs]
>>> ends_with
[True, True, False, True]

Łączenie elementów listy w łańcuch

Widzieliśmy już, jak podzielić łańcuch na listę znaków. A jak wykonać operację odwrotną, czyli połączyć elementy listy w jeden łańcuch?

W tym celu możemy skorzystać z metody join() o składni: separator.join(lista).

Chcemy jedynie połączyć elementy listy w jeden łańcuch, nie potrzebujemy żadnego separatora. Zatem ustawimy separator jako pusty łańcuch.

>>> list_1 = ['p','y','t','h','o','n','3']
>>> ''.join(list_1)
'python3'

Tworzenie słownika Pythona

Podobnie jak list comprehension może pomóc nam tworzyć nowe listy na podstawie istniejących obiektów iterowalnych, tak dictionary comprehension może ułatwić konstruowanie nowych słowników.

Dictionary comprehension to potężne narzędzie Pythona, dzięki któremu możemy szybko tworzyć słowniki.

Załóżmy, że mamy listę łańcuchów znaków zawierających imiona.

>>> names = ['Joe','Amy','Jake','Florence']

Utworzymy słownik names_d, w którym kluczami będą imiona, a wartościami – długość tych imion.

>>> names_d = {name:len(name) for name in names}
>>> names_d
{'Joe': 3, 'Amy': 3, 'Jake': 4, 'Florence': 8}

Warunkowe przypisywanie wartości do zmiennych

Czasami konieczne jest przypisanie wartości do zmiennych w zależności od określonego warunku.

Na przykład, możemy pobrać od użytkownika dane wejściowe, takie jak wiek, i w zależności od tej wartości zadecydować, czy dana osoba może uczestniczyć w jakimś wydarzeniu.

Aby dokonać takiego warunkowego przypisania w Pythonie, możemy użyć następującego, jednoliniowego wyrażenia z operatorem trójskładnikowym.

>>> age = 21
>>> allowed = True if age >= 18 else False
>>> allowed
True

🔖 Dowiedz się więcej o operatorze trójskładnikowym w Pythonie.

Generowanie wszystkich permutacji

Permutacja to możliwe ułożenie elementów w grupie. Jeśli mamy grupę n unikalnych elementów, to istnieje n! możliwych sposobów ich ułożenia, czyli n! permutacji.

Użyjmy listy liter:

>>> letters = ['a','b','c']

Możemy użyć funkcji permutations z modułu itertools, aby wygenerować wszystkie możliwe permutacje danej sekwencji.

>>> letters_p = permutations(letters)
>>> letters_p
<itertools.permutations object at 0x0127AF50>

Jak widać, wywołanie permutations(obiekt_iterowalny) zwraca obiekt permutacji, po którym możemy iterować za pomocą pętli for:

>>> for p in letters_p:
...     print(p)
...
('a', 'b', 'c')
('a', 'c', 'b')
('b', 'a', 'c')
('b', 'c', 'a')
('c', 'a', 'b')
('c', 'b', 'a')

Możemy jednak zapisać to w formie jednoliniowego wyrażenia, konwertując obiekt permutacji na listę:

>>> letters_p = list(permutations(letters))
>>> letters_p
[('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]

W naszym przypadku mamy trzy unikalne elementy, więc istnieje 3! = 6 możliwych permutacji.

Generowanie podzbiorów listy

Czasami konieczne jest wygenerowanie wszystkich możliwych podzbiorów o określonej wielkości z danej listy lub innego obiektu iterowalnego. Użyjmy listy liter i wygenerujmy wszystkie podlisty o rozmiarze 2.

W tym celu użyjemy funkcji combinations z modułu itertools:

>>> from itertools import combinations

>>> letters_2 = list(combinations(letters,2))
>>> letters_2
[('a', 'b'), ('a', 'c'), ('b', 'c')]

Podsumowanie

W tym poradniku zaprezentowaliśmy zestaw przydatnych, jednoliniowych wyrażeń Pythona do wykonywania typowych operacji na listach i łańcuchach znaków. Omówiliśmy również takie konstrukcje jak list i dictionary comprehension, i pokazaliśmy, jak można je wykorzystać w połączeniu z wbudowanymi funkcjami do wykonywania pożądanych zadań.

Następnie zachęcamy do zapoznania się z listą projektów w Pythonie, które są przyjazne dla początkujących.