30 fajnych trików w Pythonie, które poprawią twój kod — z przykładami

Umiejętności programowania w Pythonie są w ostatnich latach coraz bardziej pożądane. Aby pomóc ci je rozwijać, zebraliśmy 30 fajnych trików w Pythonie, które możesz wykorzystać, by ulepszyć swój kod. Spróbuj uczyć się jednego dziennie przez kolejne 30 dni i zajrzyj do naszego wpisu o najlepszych praktykach Pythona, żeby twój kod był na najwyższym poziomie. 

Jeśli twoje umiejętności w Pythonie wymagają podszlifowania, skorzystaj z naszego ścieżki umiejętności Python.

Triki dotyczące sekwencji i struktur danych

#1 Wycinki (slicing)

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

Wycinki to funkcja w Pythonie, która bazuje na indeksowaniu i pozwala uzyskać dostęp do podzbioru sekwencji. Indeks to po prostu pozycja elementu w sekwencji. Jeśli typ sekwencji jest mutowalny, możesz użyć wycinków do wyodrębniania i modyfikowania danych. 

Uwaga: Możemy też używać wycinków na sekwencjach niemutowalnych, ale próba modyfikacji wycinka spowoduje TypeError. 

Format wycinków to: sequence[start:stop:step]. Jeśli nie przekażesz wartości w parametrach start, stop i step, sekwencja użyje wartości domyślnych. Domyślne to: 

• „start” domyślnie 0 
• „stop” domyślnie długość sekwencji
• „step” domyślnie 1, jeśli nie określono. 

Gdy podamy sequence[start:stop], zwrócone elementy będą od indeksu początkowego do stop - 1 (indeks stop nie jest uwzględniany). 

Możemy też przekazywać ujemne indeksy, co pozwala m.in. odwrócić sekwencję. Przykładowo, w liście z 4 elementami indeks 0 to także indeks -4, a ostatni indeks to również -1. W przykładzie powyżej tę wiedzę zastosowano w parametrze step. W efekcie łańcuch został wypisany wspak, od końca sekwencji do indeksu 0.   

#2 Podmiana w miejscu / jednoczesne przypisanie

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Jeśli na pierwszy rzut oka uznałeś, że wartość b będzie równa 7 zamiast 12, wpadłeś w pułapkę podmiany w miejscu. 

W Pythonie możemy rozpakowywać iterowalne do zmiennych w jednym przypisaniu dzięki automatycznemu rozpakowywaniu. Na przykład: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

Możemy też zebrać kilka wartości do jednej zmiennej używając * – ten trik w Pythonie nazywa się pakowaniem. Poniżej przykład pakowania.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

Połączenie automatycznego pakowania i rozpakowywania daje technikę zwaną jednoczesnym przypisaniem. Możemy jej użyć, by przypisać serię wartości do serii zmiennych.

#3 Lista vs. krotka (tuple) 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

Większość programistów Pythona zna strukturę danych listy. Tego samego nie można powiedzieć o krotkach. Obie są iterowalne, umożliwiają indeksowanie i przechowują dane heterogeniczne. Są jednak sytuacje, w których krotka może być lepszym wyborem niż lista. 

Po pierwsze, listy są mutowalne, co oznacza, że możemy je dowolnie modyfikować: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Krotki natomiast są niemutowalne, więc próba ich modyfikacji podniesie TypeError. 

Z tego powodu krotki są bardziej pamięciooszczędne — Python może przydzielić dokładnie tyle pamięci, ile potrzeba na dane. Dla listy trzeba zwykle przydzielić zapas pamięci na wypadek rozszerzenia — to tzw. dynamiczna alokacja pamięci. 

TL;DR: Gdy nie chcesz, by dane ulegały zmianie, ze względów pamięciowych lepiej wybrać krotkę niż listę. Krotki są też szybsze od list. 

Dowiedz się więcej o strukturach danych w Pythonie w tym poradniku. 

#4 Generatory

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

List comprehension to „pythoniczny” sposób tworzenia listy z innego iterowalnego — dużo szybszy niż pętla for. Ale co się stanie, jeśli przez pomyłkę zamienisz nawiasy [] na ()? Otrzymasz obiekt generatora.

W Pythonie okrągłe nawiasy z logiką list comprehension tworzą tzw. generator. Generatory to szczególny rodzaj iterowalnych. W przeciwieństwie do list nie przechowują elementów — zapisują instrukcje generowania kolejnych elementów i bieżący stan iteracji.

Każdy element jest generowany na żądanie w technice zwanej leniwej ewaluacji. Główna zaleta generatorów to mniejsze zużycie pamięci, bo cała sekwencja nie jest budowana naraz. 

#5 Aliasowanie 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python to język obiektowy — wszystko jest obiektem. Przypisanie obiektu do identyfikatora tworzy referencję do obiektu. 

Gdy przypisujemy jeden identyfikator do drugiego, dostajemy dwa identyfikatory wskazujące ten sam obiekt. To zjawisko nazywa się aliasowaniem. Zmiany w jednym aliasie wpłyną na drugi. Czasem taki efekt jest pożądany, ale często nas zaskakuje. 

Jednym ze sposobów obejścia jest unikanie aliasowania przy obiektach mutowalnych. Innym — stworzenie klona oryginalnego obiektu zamiast referencji. 

Najprościej sklonować listę, korzystając z wycinka: 

b = a[:] 

Utworzy to nową referencję do obiektu listy pod identyfikatorem b. 

Możesz też użyć innych sposobów, jak wywołanie list(a) przy przypisaniu do innego identyfikatora czy metody copy(). 

#6 Operator „not”

a = []
print(not a)

"""
True
"""

Kolejny trik: najprostszy sposób sprawdzenia, czy twoja struktura danych jest pusta, to użycie operatora not. Wbudowany operator logiczny not zwraca True, jeśli wyrażenie nie jest prawdziwe, w przeciwnym razie zwraca False — odwraca wartość logiczną wyrażeń i obiektów.  

Inny częsty sposób użycia to instrukcja if: 

if not a:
    # do something... 

Gdy a jest True, operator not zwróci False, i na odwrót. 

Na początku bywa to mylące — poćwicz.

Triki związane z łańcuchami i wyjściem

#7 F-stringi

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

Czasem musimy sformatować łańcuch; w Pythonie 3.6 pojawiła się świetna funkcja f-stringów, która to upraszcza. Żeby lepiej docenić nową metodę, warto wiedzieć, jak formatowało się napisy wcześniej. 

Tak kiedyś formatowaliśmy łańcuchy: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

Nowy sposób jest szybszy, czytelniejszy, zwięzły i trudniej o pomyłkę.

Inne zastosowanie f-stringów to wypisywanie nazwy identyfikatora wraz z wartością. Dodano je w Pythonie 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Zajrzyj do poradnika Formatowanie f-stringów w Pythonie, żeby dowiedzieć się więcej. 

#8 Parametr „end” funkcji print()

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Często używamy instrukcji print bez definiowania parametrów opcjonalnych. W efekcie wielu Pythonistów nie wie, że można w pewnym stopniu kontrolować wyjście.

Jednym z opcjonalnych parametrów jest end. Określa on, co ma się pojawić na końcu wywołania instrukcji print. 

Domyślna wartość end to "\n", czyli nowa linia. W powyższym kodzie zmieniliśmy to na spację. Dzięki temu wszystkie elementy listy wypisano w jednym wierszu.

#9 Dodawanie do krotki

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Wiemy już, że krotki są niemutowalne — zobacz trik #3 Lista vs. krotki. Próba zmiany stanu krotki wyrzuci TypeError. Jeśli jednak potraktujesz krotkę jako sekwencję nazw powiązanych z obiektami, których powiązań nie można zmienić, spojrzysz na to inaczej.

Dwa pierwsze elementy naszej krotki to liczby całkowite — są niemutowalne. Ostatni element to lista, czyli obiekt mutowalny w Pythonie.

Jeśli uznamy listę za kolejną nazwę w sekwencji z powiązaniem do obiektu, którego powiązania nie zmienimy, to zauważymy, że samą listę wciąż można modyfikować wewnątrz krotki.

Czy polecamy to w praktyce? Raczej nie, ale warto wiedzieć!

#10 Łączenie słowników

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

W Pythonie 3.9+ można łączyć słowniki operatorem | (bitowe OR). Niewiele więcej tu dodać — to po prostu znacznie czytelniejsze rozwiązanie! 

Triki stylu kodu i składni

#11 Operator trójargumentowy / wyrażenia warunkowe 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

W powyższym kodzie widzisz tzw. operator trójargumentowy — znany też jako wyrażenie warunkowe. Służy do obliczania wartości w zależności od tego, czy warunek jest True, czy False.

Można to zapisać też tak:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Choć oba fragmenty dają ten sam wynik, zwróć uwagę, że zapis z operatorem warunkowym pozwala napisać kod krótszy i czytelniejszy. To bardziej „pythoniczny” sposób. 

#12 Usuwanie duplikatów z list

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

Najprościej usunąć duplikaty z listy, konwertując listę do zbioru (a potem z powrotem do listy, jeśli chcesz).

Pod względem mutowalności zbiory i listy są do siebie podobne w Pythonie. W obu możemy dodawać i usuwać elementy, ale są między nimi duże różnice.

Listy są uporządkowane, indeksowane od zera i mutowalne. Zbiory są nieuporządkowane i nieindeksowane. Elementy w zbiorze muszą być typu niemutowalnego, mimo że sam zbiór jest mutowalny — próba odczytu elementu przez indeks lub modyfikacji elementu spowoduje błąd.

Inna kluczowa różnica: zbiory nie mogą zawierać duplikatów. Dzięki temu usunęliśmy powtórzenia z listy.

#13 Samodzielny podkreślnik 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

Podkreślnik (_) to legalny identyfikator w Pythonie, więc można go używać do referencji obiektu. Ma jednak też inną rolę: przechowuje wynik ostatniej ewaluacji.

Dokumentacja mówi: „interaktywny interpreter udostępnia wynik ostatniej ewaluacji w zmiennej _. (Jest przechowywana w module builtins, obok funkcji wbudowanych jak print).”

Ponieważ nie przypisaliśmy wcześniej wartości do podkreślnika, pierwsze wywołanie dało błąd. Gdy obliczyliśmy 1 + 2, interpreter zapisał wynik w identyfikatorze _ . 

#14 Podkreślnik do ignorowania wartości

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

W triku #13 zauważyliśmy, że interpreter zapisuje ostatni wynik w identyfikatorze (_), ale to nie jedyny przypadek użycia.

Możemy go też używać jako nazwy dla obiektów, które nas nie interesują lub których nie użyjemy później w programie. To ważne, bo użycie zwykłego identyfikatora zamiast podkreślnika spowoduje błąd F841 podczas lintingu. F841 oznacza, że lokalnej zmiennej przypisano wartość, ale jej nie użyto — to zła praktyka.

#15 Podkreślniki na końcu nazw

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Kontynuując temat podkreślnika (_), kolejnym zastosowaniem jest unikanie konfliktów ze słowami kluczowymi Pythona. 

PEP 8 wspomina, że końcowy podkreślnik powinien być „stosowany zwyczajowo, by unikać konfliktów ze słowami kluczowymi Pythona”. Dodaje też, że „zwykle lepiej dodać pojedynczy podkreślnik na końcu niż używać skrótu czy zniekształconej pisowni. Dlatego list_ jest lepsze niż lst.”

#16 Podkreślniki na początku nazw

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

Często doświadczeni programiści Pythona poprzedzają identyfikator lub metodę podkreślnikiem — i to z dobrego powodu.

Podkreślnik na początku identyfikatora lub metody ma ukryte znaczenie: ta zmienna lub metoda jest przeznaczona tylko do użytku wewnętrznego. To w zasadzie zastrzeżenie dla innych programistów, opisane w PEP 8, ale nieegzekwowane przez Pythona. Zatem wiodące podkreślniki to słaby wskaźnik.

W przeciwieństwie do Javy, Python nie ma silnego rozróżnienia na zmienne prywatne i publiczne. Innymi słowy, ma to znaczenie, bo społeczność tak się umówiła. Ich użycie nie wpływa na działanie programu.

#17 Podkreślnik jako separator

Ostatnia wskazówka o podkreśleniach; omówiliśmy trzy różne zastosowania, ale zajrzyj do naszego poradnika, by dowiedzieć się więcej o roli podkreślnika (_) w Pythonie. 

number = 1_500_000
print(number)

"""
15000000
"""

Kolejne zastosowanie to wizualny separator cyfr w literałach całkowitych, zmiennoprzecinkowych i zespolonych — wprowadzony w Pythonie 3.6. 

Chodziło o poprawę czytelności długich literałów lub takich, które warto wyraźnie podzielić na części — więcej w PEP 515.

Triki stylu kodu i składni

#18 __name__ == „__main__” 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

Jest duża szansa, że widziałeś tę składnię w wielu programach Pythona; Python używa specjalnej nazwy "__main__" i ustawia ją w identyfikatorze __name__, jeśli uruchamiany plik jest głównym programem.

Jeśli zaimportujemy moduł pokazany na zrzucie do innego modułu (pliku Pythona) i uruchomimy tamten plik, wartość wyrażenia będzie fałszywa. Dzieje się tak, bo przy imporcie z innego modułu identyfikator __name__ jest ustawiany na nazwę modułu (pliku). 

#19 Metoda „setdefault” 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Możesz chcieć ustawić wartości dla różnych kluczy w słowniku — np. zliczając słowa w korpusie. Zwykle robimy to tak: 

1. Sprawdź, czy klucz istnieje w słowniku
2. Jeśli tak, zwiększ wartość o 1.
3. Jeśli nie, dodaj go i ustaw wartość na 1.

Tak wygląda to w kodzie:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Bardziej zwięzłym sposobem jest użycie metody setdefault() na obiekcie słownika.

Pierwszy argument to klucz do sprawdzenia. Drugi to wartość, jaką ustawimy, jeśli klucza nie ma w słowniku — jeśli jest, metoda zwróci bieżącą wartość klucza, więc nic nie zmieni.

Triki dotyczące struktury programu

#20 Dopasowanie regex

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Wyrażenia regularne pozwalają określić wzorzec tekstu do wyszukania; większość osób wie, że można szukać przez CTRL + F (Windows), ale co jeśli nie znasz dokładnego tekstu? Szukaj wzorców.  

Na przykład numery w UK mają podobny wzorzec: zaczynają się od zera i dziesięciu cyfr albo od +44 zamiast zera i dziesięciu cyfr — drugi wariant to format międzynarodowy. 

Regexy świetnie oszczędzają czas. Gdybyśmy zamiast nich kodowali reguły, by złapać przypadki z obrazka, mogłoby to zająć 10+ linii. 

Nauka regexów jest ważna nawet, jeśli nie piszesz kodu — większość nowoczesnych edytorów i procesorów tekstu pozwala używać ich w funkcji „znajdź i zamień”.

#21 Operator „|” w regex

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Wyrażenia regularne mają specjalny znak „pipe” (|), który pozwala dopasować jedno z wielu wyrażeń i można go używać wszędzie. Przydaje się, gdy masz kilka podobnych wzorców.

Na przykład „Superman”, „Superwoman” i „Superhuman” mają ten sam prefiks. Możesz więc użyć „|”, by zachować część wspólną i zmienić końcówkę. Znowu oszczędność czasu.

Uwaga na pułapkę: jeśli wszystkie dopasowania występują w tym samym tekście, zostanie zwrócone pierwsze pasujące wystąpienie — np. „An example text containing Superwoman, Superman, Superhuman” zwróci Superwoman.

#22 Parametr „sep” funkcji print()

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

Liczba programistów Pythona, którzy nie znają pełnych możliwości funkcji print(), jest zaskakująca; jeśli „Hello World” było twoim pierwszym programem, print() pewnie było jedną z pierwszych funkcji wbudowanych, które poznałeś. Używamy print() do wyświetlania komunikatów, ale potrafi znacznie więcej. 

W powyższym kodzie pokazaliśmy różne sposoby formatowania. Parametr sep to opcjonalny argument funkcji print(), który określa, jak rozdzielać obiekty, gdy jest ich więcej niż jeden. 

Domyślnie rozdzielane są spacją, ale zmieniliśmy to — raz ustawiając sep na "", a innym razem na ".".

#23 Funkcje lambda 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Funkcje lambda wprowadzają cię w bardziej średnio zaawansowane/zaawansowane możliwości Pythona — naucz się Pythona na poziomie średniozaawansowanym w tym kursie. Na pierwszy rzut oka wyglądają skomplikowanie, ale są dość proste.

W przykładzie użyliśmy jednego argumentu, ale moglibyśmy użyć wielu:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

W skrócie słowo kluczowe lambda pozwala tworzyć małe, ograniczone, anonimowe funkcje w jednej linii. Zachowują się jak zwykłe funkcje deklarowane przez def, tyle że bez nazwy.

#24 Metoda „swapcase”

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

Metoda swapcase() zastosowana do łańcucha zamienia wielkie litery na małe i odwrotnie w jednej linii kodu. Zastosowań nie ma wiele, ale warto znać.

#25 Metoda „isalnum”

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Załóżmy, że tworzysz program wymagający podania hasła składającego się z liter i cyfr. Możesz to sprawdzić jedną linią, wywołując isalnum() na łańcuchu.

Metoda sprawdza, czy wszystkie znaki to litery (A-Za-z) lub cyfry (0-9). Spacja lub symbol (!#%$&? itp.) zwróci False.

#26 Obsługa wyjątków

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Programy w Pythonie kończą działanie po napotkaniu błędu.

Czasem nie chcemy takiego zachowania — np. gdy nasz kod obsługuje użytkownika końcowego. Jak źle byłoby, gdyby program zakończył się przedwcześnie?

Istnieje kilka szkół radzenia sobie z wyjątkami. Większość Pythonistów przyjmuje zasadę, że łatwiej jest prosić o wybaczenie niż o pozwolenie. To znaczy, wolą łapać wyjątki, zapewniając kontekst zdolny je obsłużyć, zamiast zabezpieczać się przed wszystkimi możliwymi przypadkami.

Ale to ma sens tylko wtedy, gdy masz mechanizm radzenia sobie z problemem po jego wystąpieniu.

#27 Wyszukiwanie różnic między listami

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Oto trzy różne metody porównania różnic między dwiema listami w Pythonie. 

Uwaga: Jeśli nie masz pewności, że list_1 jest podzbiorem list_2, rozwiązanie 1 nie jest tym samym co pozostałe dwa.

#28 Args i kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

Używamy *args i **kwargs jako parametrów funkcji, gdy nie wiemy, ilu argumentów powinna się spodziewać. 

Parametr *args pozwala przekazać zmienną liczbę argumentów pozycyjnych (bez nazw). Z kolei **kwargs pozwala przekazać dowolną liczbę argumentów nazwanych.

W gruncie rzeczy magiczne są gwiazdki (*), nie same nazwy. Moglibyśmy użyć innych słów po gwiazdkach, ale args i kwargs to powszechna praktyka wśród programistów Pythona. 

#29 Wielokropek (Ellipsis)

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis to obiekt w Pythonie, który można wywołać podając sekwencję trzech kropek (...) lub wywołując sam obiekt (Ellipsis).

Najbardziej znane zastosowanie to dostęp i wycinanie tablic wielowymiarowych w NumPy, na przykład:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Inne zastosowanie wielokropka to placeholder w niezaimplementowanej funkcji. 

Oznacza to, że możesz użyć Ellipsis, ... lub pass — wszystkie będą poprawne.

#30 List comprehension

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Ostatni trik to list comprehensions — elegancki sposób tworzenia listy z innej sekwencji. Pozwalają zastosować złożoną logikę i filtrowanie, jak w przykładzie.

Można to osiągnąć też inaczej; np. funkcją lambda:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Ale wielu Pythonistów uzna to rozwiązanie za mniej czytelne niż list comprehension.