Python

Python

Logo języka
Pojawienie się	1991
Paradygmat	wieloparadygmatowy (obiektowy, imperatywny, funkcyjny)
Typowanie	dynamiczne
Implementacje	CPython, IronPython, Jython, PyPy
Pochodne	Stackless Python, Cython
Aktualna wersja stabilna	3.9.7 / 30 sierpnia 2021; ponad 3 lata temu
Aktualna wersja testowa	3.10.0rc1 / 2 sierpnia 2021; ponad 3 lata temu
Twórca	Pyton
Licencja	Python Software Foundation License
Platforma sprzętowa	wieloplatformowy
Platforma systemowa	wieloplatformowy
Strona internetowa

{{Język programowania infobox}} Nieznane pola: "wielkość_loga".

Python – język programowania wysokiego poziomu ogólnego przeznaczenia, o rozbudowanym pakiecie bibliotek standardowych, którego ideą przewodnią jest czytelność i klarowność kodu źródłowego. Jego składnia cechuje się przejrzystością i zwięzłością.

Python wspiera różne paradygmaty programowania: obiektowy, imperatywny oraz w mniejszym stopniu funkcyjny. Posiada w pełni dynamiczny system typów i automatyczne zarządzanie pamięcią, będąc w tym podobnym do języków Perl, Ruby, Scheme czy Tcl. Podobnie jak inne języki dynamiczne jest często używany jako język skryptowy. Interpretery Pythona są dostępne na wiele systemów operacyjnych.

Python rozwijany jest jako projekt Open Source zarządzany przez Python Software Foundation, która jest organizacją non-profit. Standardową implementacją języka jest CPython (napisany w C), ale istnieją też inne, np. Jython (napisany w Javie), CLPython napisany w Common Lisp, IronPython (na platformę .NET) i PyPy (napisany w Pythonie, zob. bootstrap).

Rozwój języka

Python Powered

Pythona stworzył we wczesnych latach 90. Guido van Rossum – jako następcę języka ABC, stworzonego w Centrum voor Wiskunde en Informatica (CWI – Centrum Matematyki i Informatyki w Amsterdamie). Van Rossum jest głównym twórcą Pythona, choć spory wkład w jego rozwój pochodzi od innych osób. Z racji kluczowej roli, jaką van Rossum pełnił przy podejmowaniu ważnych decyzji projektowych, często określano go przydomkiem „Benevolent Dictator for Life” (BDFL).

Nazwa języka nie pochodzi od zwierzęcia lecz od serialu komediowego emitowanego w latach siedemdziesiątych przez BBC – „Monty Python’s Flying Circus” (Latający cyrk Monty Pythona). Projektant, będąc fanem serialu i poszukując nazwy krótkiej, unikalnej i nieco tajemniczej, uznał tę za świetną.

Wersja 1.2 była ostatnią wydaną przez CWI. Od 1995 roku Van Rossum kontynuował pracę nad Pythonem w Corporation for National Research Initiatives (CNRI) w Reston w Wirginii, gdzie wydał kilka wersji Pythona, do 1.6 włącznie. W 2000 roku van Rossum i zespół pracujący nad rozwojem jądra Pythona przenieśli się do BeOpen.com by założyć zespół BeOpen PythonLabs. Pierwszą i jedyną wersją wydaną przez BeOpen.com był Python 2.0.

Po wydaniu wersji 1.6 i opuszczeniu CNRI przez van Rossuma, który zajął się programowaniem komercyjnym, uznano za wysoce pożądane, by Pythona można było używać z oprogramowaniem dostępnym na licencji GPL. CNRI i Free Software Foundation (FSF) podjęły wspólny wysiłek w celu odpowiedniej modyfikacji licencji Pythona. Wersja 1.6.1 była zasadniczo identyczna z wersją 1.6, z wyjątkiem kilku drobnych poprawek oraz licencji, dzięki której późniejsze wersje mogły być zgodne z licencją GPL. Python 2.1 pochodzi zarówno od wersji 1.6.1, jak i 2.0.

Po wydaniu Pythona 2.0 przez BeOpen.com Guido van Rossum i inni programiści z PythonLabs przeszli do Digital Creations. Cała własność intelektualna dodana od tego momentu, począwszy od Pythona 2.1 (wraz z wersjami alpha i beta), jest własnością Python Software Foundation (PSF), niedochodowej organizacji wzorowanej na Apache Software Foundation.

Filozofia Pythona

Python realizuje jednocześnie kilka paradygmatów. Podobnie do C++, a w przeciwieństwie do Smalltalka nie wymusza jednego stylu programowania, pozwalając na stosowanie różnych. W Pythonie możliwe jest programowanie obiektowe, programowanie strukturalne i programowanie funkcyjne. Typy sprawdzane są dynamicznie, a do zarządzania pamięcią stosuje się garbage collection.

Choć w jego popularyzacji kładzie się nacisk na różnice w stosunku do Perla, Python jest pod wieloma względami do niego podobny. Jednakże projektanci Pythona odrzucili złożoną składnię Perla na rzecz bardziej oszczędnej i – ich zdaniem – bardziej czytelnej. Mimo że podobnie do Perla, Python jest czasem klasyfikowany jako język skryptowy, wykorzystuje się go do tworzenia dużych projektów jak serwer aplikacji Zope, system wymiany plików Mojo Nation czy nawet oprogramowanie klasy ERP – Odoo.

Typy i struktury danych

W Pythonie wartości, a nie zmienne, posiadają typ – tak więc Python jest językiem z typami dynamicznymi, podobnie jak Lisp, a w przeciwieństwie do Javy. W przeciwieństwie do wielu języków, wartości nie są przekazywane ani przez wartość, ani przez referencję, ale przez przypisanie.

W porównaniu z innymi językami programowania Python jest dość silnie typowany. Nie jest ani tak liberalny, jak Perl, ani tak restrykcyjny jak OCaml. Reguły składniowe Pythona umożliwiają wyrażanie pojęć bez pisania dodatkowego kodu. Dla typów numerycznych zdefiniowana jest automatyczna konwersja, tak więc możliwe jest np. mnożenie liczby zespolonej przez liczbę całkowitą typu long bez rzutowania. Jednak w przeciwieństwie do Perla nie ma np. automatycznej konwersji pomiędzy napisami i liczbami; liczba nie jest prawidłowym argumentem dla operacji napisowej.

Python oferuje szeroki zakres podstawowych typów danych – w tym typy liczbowe (całkowite, zmiennoprzecinkowe, zespolone) oraz kolekcje.

Wybrane wbudowane typy danych

Typ	Opis	Przykład
str	Ciąg znaków (niezmienny)	'Wikipedia' lub "Wikipedia"
bytes	Sekwencja bajtów (niezmienna)	b'Wikipedia' lub b"Wikipedia"
list	Lista (zmienna, zawartość, długość)	[4.0, 'string', True]
tuple	Krotka (niezmienna)	(4.0, 'string', True)
set	Zbiór (zmienny)	{4.0, 'string', True}
frozenset	Zbiór (niezmienny)	frozenset({4.0, 'string', True})
dict	Słownik, czyli tablica asocjacyjna (zmienny).	{'key1': 1.0, 3: False}
int	Liczba całkowita o dowolnej wartości	42
float	Liczba zmiennoprzecinkowa	3.1415927
complex	Liczba zespolona	3+2.7j
bool	Wartość logiczna (prawda lub fałsz)	True False
NoneType	Obiekt reprezentujący brak wartości, będący odpowiednikiem wartości null w innych językach	None

Kolekcje

Część wyżej wymienionych typów to kolekcje.

Listy, krotki (ang. tuple) i napisy są sekwencjami, w związku z czym udostępniają pewną liczbę wspólnych operacji (np. w identyczny sposób można iterować po kolejnych znakach napisu jak po elementach listy, czy też wskazywać elementy za pomocą indeksów). Listy to tablice o zmiennej liczbie elementów (z możliwością ich usuwania, dodawania i podmiany), zaś krotki to tablice o stałej liczbie elementów (bez możliwości usuwania, dodawania i podmiany).

Innymi typami są kolekcje nieuporządkowane: słowniki (ang. dictionary, typ dict) – znane w innych językach jako odwzorowania (ang. map) lub tablice asocjacyjne oraz zbiory (ang. set) reprezentowane przez dwa typy: zbioru zmiennego set i niezmiennego frozenset. Słownikowe klucze oraz elementy zbiorów muszą być tzw. obiektami haszowalnymi (posiadającymi metodę __hash__()) – co na ogół oznacza, że muszą być niezmienne (niemutowalne); np. kluczem słownika nie może być lista ani zbiór zmienny (typu set) – może zaś być krotka bądź zbiór niezmienny (typu frozenset), o ile zawiera wyłącznie elementy niezmienne.

Python obsługuje typowy zestaw operacji na łańcuchach tekstowych. Łańcuchy w Pythonie są niezmienne. Każda operacja, która zmieniłaby zawartość napisu (np. zamiana małych liter na wielkie) zwróci nowy napis, pozostawiając oryginalny napis bez zmian.

Należy dodać, że podstawowe kolekcje w standardowej implementacji Pythona w C są wysoce zoptymalizowane pod kątem szybkości przeszukiwania, sortowania itp.

Wszystko jest obiektem

System typów w Pythonie jest silnie powiązany z systemem klas. Chociaż typy wbudowane nie są właściwie klasami, klasa może dziedziczyć z dowolnego typu. Można więc dziedziczyć klasy z napisów czy słowników, a nawet z liczb całkowitych. Ponadto możliwe jest dziedziczenie wielokrotne.

Język umożliwia rozległą introspekcję typów i klas. Typy można odczytywać i porównywać – podobnie, jak w Smalltalku, typy (opisy typów) też są typem. Atrybuty obiektu można pobrać jako słownik.

W Pythonie nie ma enkapsulacji, jak to ma miejsce w C++ czy Javie, istnieją jednak mechanizmy pozwalające osiągnąć zbliżony efekt. Jednocześnie Python znacząco ułatwia introspekcję obiektów, tak więc właściwe użycie atrybutów obiektu pozostawia się programiście.

Dodatkowo każda funkcja, klasa i moduł mogą zostać opatrzone dokumentacją w kodzie źródłowym. Nie posiada ona wprawdzie rozbudowanych funkcji podobnych do javadoc, ale jest dostępna w czasie wykonania programu, a więc i w trybie interaktywnym.

Emulowanie typów, przeciążanie operatorów, wywoływanie jako funkcje

Python pozwala dopasowywać własności danej klasy w szerokim zakresie. Implementując odpowiednie metody można sprawić, by obiekty danej klasy zachowywały się jak kolekcje, liczby, a nawet funkcje.

Przykład:

class Emulator:
    def __call__(self, x):
        print(f'Ten Emulator wywołano jako funkcję z parametrem x = {x}')

    def __getitem__(self, key):
        return f'{key}-ty element w kontenerze klasy Emulator'


e = Emulator()
e('abc')
e(123)
print(e['def'])
print(e[456])

Uruchomienie powyższego kodu da następujący rezultat:

Ten Emulator wywołano jako funkcję z parametrem x = abc
Ten Emulator wywołano jako funkcję z parametrem x = 123
def-ty element w kontenerze klasy Emulator
456-ty element w kontenerze klasy Emulator

Zmienna liczba argumentów funkcji

Możliwe jest tworzenie funkcji ze zmienną liczbą argumentów, argumentami o wartościach domyślnych (podobnie jak w C++ lub C#), a także wywoływanie funkcji z użyciem argumentów nazwanych, z podaniem nazw parametrów. Przykład:

def pokaz_argumenty(x, y, *args, **kwargs):
    print(f'x={x}, y={y}')
    print('Argumenty pozycyjne:')
    for arg in args:
        print(arg)
    print('Argumenty nazwane:')
    for klucz, wartosc in kwargs.items():
        print(f'{klucz}={wartosc}')


pokaz_argumenty('abc', 123, 456, 'def', k=789, m='ghi')

Uruchomienie powyższego kodu da następujący rezultat:

x=abc, y=123
Argumenty pozycyjne:
456
def
Argumenty nazwane:
k=789
m=ghi

Składnia

Czytanie kodu zajmuje wielokrotnie więcej czasu niż pisanie, a czytelny program można łatwiej zrozumieć i rozwijać. Python został zaprojektowany tak, by zapewnić możliwie dużą czytelność kodu źródłowego. Posiada prosty układ tekstu, używa wcięć lub angielskich słów tam, gdzie inne języki korzystają ze znaków interpunkcyjnych i posiada zdecydowanie mniej konstrukcji składniowych, niż wiele języków strukturalnych, takich jak C, Perl czy Pascal.

Dla czytelności, w Pythonie występują tylko dwa rodzaje pętli: for, w której iteracja odbywa się po elementach listy (jak w perlowym foreach), oraz while, która jest powtarzana, dopóki warunek logiczny jest spełniony. Python nie posiada składni for w stylu C, do...while, ani perlowego until, choć oczywiście można uzyskać ich złożone odpowiedniki.

Od wersji 2.5 Python posiada operator warunkowy, analogiczny do warunek ? wartość1 : wartość2 znanego z C i Javy. Składnia: wartość1 if warunek else wartość2.

Struktura przez wcięcia

Cechą wyróżniającą Pythona spośród innych języków jest stosowanie wcięć do wydzielania bloków kodu. Jest to cecha unikatowa wśród powszechnie stosowanych języków programowania, jako pierwsza rzucająca się w oczy programistom niepiszącym w Pythonie.

W językach programowania wywodzących strukturę blokową od Algola (niekoniecznie bezpośrednio) – np. Pascalu, C, czy Perlu – bloki kodu zaznaczane są klamrami lub słowami kluczowymi (C i Perl używają { }, Pascal używa begin i end). Jednakże we wszystkich tych językach programiści tradycyjnie stosują wcięcia, by wyróżnić bloki w otaczającym kodzie.

Natomiast Python dziedziczy cechę mniej znanego języka ABC – zamiast interpunkcji czy słów kluczowych używa samych wcięć do zaznaczania bloków. Wyjaśnić to można na prostym przykładzie zamieszczonym poniżej. Przedstawiona jest w nim funkcja licząca silnię w C i w Pythonie:

silnia w C (zapisana bez wcięć):

int silnia(int x) {
    if (x == 0) return 1;
    else return x * silnia(x-1);
}

silnia w Pythonie:

def silnia(x):
    if x == 0:
        return 1
    else:
        return x * silnia(x - 1)

Dla niektórych programistów przyzwyczajonych do języków stylistycznie wzorowanych na Algolu, gdzie spacja nie ma znaczenia składniowego, może to być mylące. Spotyka się czasem niepochlebne porównanie do sztywnego systemu kolumnowego kart perforowanych stosowanego w czasach fortranowych.

Istotnie, w swoim czasie możliwość stosowania zapisu, w którym decydujące były jedynie symbole, była dużym postępem. Jednak dla programistów piszących w Pythonie stosowanie składniowo znaczących wcięć jest po prostu przedłużeniem konwencji, która i tak jest stosowana np. w C. Zwolennicy tego języka zwracają także uwagę na wadę „swobodnej” składni, polegającą na tym, że skoro wcięcia kodu są ignorowane, nie można wymusić jednej dobrej konwencji (stąd też konflikty między programistami, dotyczące stosowania spacji (i różnej ich liczby) lub tabulatorów, tzw. indentation wars). Nieprawidłowo wcięty kod może być mylący, gdyż czytający go programista i kompilator mogą go różnie zinterpretować.

Komentarze

Komentarze zaczynają się od znaku „#” i kończą z końcem wiersza. Komentarze wieloliniowe można wstawiać w postaci wielowierszowych stringów (ograniczonych przez """ lub ''') bez żadnych działań (np. przypisań); stringi te nie są traktowane jako wyrażenia przez interpreter.

Wielowierszowy string umieszczony w pierwszej linii ciała funkcji lub klasy albo na początku modułu, traktowany jest jako tzw. docstring (napis dokumentacyjny) dla tegoż obiektu. System dokumentacji Pythona może automatycznie tworzyć sformatowaną dokumentację z docstringów, dając w ten sposób ograniczoną wersję literate programming. Dokumentację można przeglądać w trybie interaktywnym interpretera za pomocą funkcji help lub z poziomu wiersza poleceń za pomocą skryptu pydoc.

Programowanie funkcyjne

Inną cechą Pythona jest dostępność składni funkcyjnej. Jak można oczekiwać, upraszcza to znacznie obróbkę list i innych kolekcji. Jedną z takich konstrukcji jest tzw. lista składana (ang. list comprehension), przejęte z funkcjonalnego Haskella, jak w przedstawionym poniżej przykładzie obliczania pięciu pierwszych potęg dwójki:

liczby = [1, 2, 3, 4, 5]
potegi_dwojki = [2 ** n for n in liczby]

Za pomocą list składanych można wyrazić algorytm quicksort, chociaż taka jego implementacja jest mało wydajna:

def qsort(L):
    if L == []:
        return []
    return (
        qsort([x for x in L[1:] if x < L[0]])
        + L[0:1]
        + qsort([x for x in L[1:] if x >= L[0]])
    )

Wykorzystując programowanie funkcyjne można skrócić implementację silni do jednolinijkowca bez uciekania się do rekurencji. W poniższym przykładzie użyto operacji redukcji listy:

from functools import reduce

def silnia_f(n):
    return reduce(lambda x, y: x * y, range(2, n + 1), 1)

Lambda

Nieco mylące dla zwolenników programowania funkcyjnego może być słowo kluczowe lambda. Bloki lambda mogą zawierać jedynie wyrażenia, nie instrukcje. Nie są one więc najbardziej ogólnym sposobem tworzenia funkcji. Zamiast tego można zdefiniować i zwrócić funkcję używając nazwy w zasięgu lokalnym, jak w poniższym przykładzie prostej funkcji generującej inną funkcję (ang. curry):

def zbuduj_sumator(x):
    def temp(y):
        print(f"{x} + {y} = {x + y}")

    return temp

Funkcję tę można zaimplementować także używając zagnieżdżonych wyrażeń lambda tak, jak to się robi w Scheme:

zbuduj_sumator = lambda x: lambda y: print(f"{x} + {y} = {x + y}")

Oba warianty funkcji zbuduj_sumator zachowują się identycznie: dla podanej liczby x zwracają funkcję, która dla podanej liczby y wydrukuje wyrażenie arytmetyczne. Choć pierwszy styl jest częściej spotykany, drugi może być czytelniejszy dla programistów wyspecjalizowanych w programowaniu funkcyjnym.

Unikalne cechy pythonowych operatorów logicznych and i or dają jeszcze jedną unikalną możliwość programowania funkcyjnego. Przy wykorzystaniu tych dwóch operatorów można w wyrażeniach lambda zaimplementować dowolne sterowanie przebiegiem [1]. Wykorzystuje się to zwykle tylko do stosunkowo prostych konstrukcji (patrz rozdział o operatorach logicznych).

Generatory

Generatory są w Pythonie mechanizmem leniwej ewaluacji funkcji, która w przeciwnym razie musiałaby zwracać obciążającą pamięć lub kosztowną w obliczaniu listę. Stosowanie generatorów jest podobne do strumieni w Scheme:

def generuj_calkowite(n):
    for i in range(n):
        yield i

Można teraz użyć tego generatora:

 for i in generuj_calkowite(7):
     print i

Przed wykonaniem drugiego fragmentu kodu należy oczywiście zdefiniować zmienną N.

Definicja generatora przypomina definicję funkcji, ale zamiast słowa kluczowego return używa się yield. Jednakowoż generator jest obiektem przechowującym stan, mogącym wielokrotnie wchodzić do i opuszczać ten sam dynamiczny zakres. Wywołanie generatora może być użyte zamiast listy lub innej struktury, po której elementach będziemy iterować. Za każdym razem, gdy pętla for w powyższym przykładzie potrzebuje następnego elementu, wywoływany jest generator, który daje następny element.

W wersji 2.4 dodano wyrażenia generatorowe (ang. generator expressions), analogiczne do listy składanej. Zapis:

gen_kwadratow = (i ** 2 for i in range(5))

jest odpowiednikiem:

 def gen_kwadratow():
     for i in range(5):
         yield i ** 2

Operatory logiczne

W Pythonie jako fałsz logiczny traktuje się:

• liczbę zero (0, 0.0, 0j itp.)
• False
• None (null)
• puste kolekcje ([], (), {}, set() itp.)
• puste napisy ("", """""")
• obiekty posiadające metodę __bool__(), jeśli zwraca ona False

Wszystko inne jest prawdą logiczną.

Operatory and i or zwracają wartość ostatnio obliczonego wyrażenia, np. „x==5 or 3” zwróci 3. W Pythonie często pisze się instrukcje w rodzaju print(p or q), by wykorzystać tę cechę.

Wartości logiczne zwracane przez operatory porównania (==, >, !=, is itp.), operator zawierania (in) oraz operator negacji (not) reprezentowane są przez obiekty True i False. Gdyby więc w powyższym przykładzie kolejność wyrażeń zamienić na „3 and x==5”, zwrócona zostałaby wartość True, gdyż tak ewaluowane jest x==5. Operatory porównania można łączyć, np. „-1 < x < 0” zwróci True dla x z przedziału (-1, 0) – tak, jak w zapisie matematycznym, a inaczej niż np. w C++.

Od Pythona 2.3 True i False są wbudowanymi obiektami typu bool. Wcześniej do identyfikatorów tych przypisane były obiekty liczb całkowitych, odpowiednio 1 i 0.

Obsługa wyjątków

Python udostępnia i intensywnie wykorzystuje obsługę wyjątków jako sposób wykrywania błędów.

Styl programowania w Pythonie zaleca stosowanie wyjątków zawsze, gdy może pojawić się błąd wykonania. Na przykład nie testuje się praw dostępu do pliku przed jego otwarciem, lecz po prostu próbuje się go otworzyć, przechwytując wyjątek w razie braku dostępu.

Dekoratory

W wersji 2.4 wprowadzono nowy element składni – notację dekoratora. Przykład: w starszych wersjach Pythona, by uzyskać metodę statyczną klasy, należało napisać:

class C:
    def metoda(obj):
        pass
    
    metoda = staticmethod(metoda)

Notacja dekoratora pozwala, bardziej czytelnie, umieścić informację o konwersji (dekoracji) przed definicją funkcji:

class C:
    @staticmethod
    def metoda(obj):
        pass

Ogólnie zapis:

@dekorator
def funkcja():
    pass

jest równoważny zapisowi:

def funkcja():
    pass

funkcja = dekorator(funkcja)

Biblioteka standardowa

Python posiada rozbudowaną bibliotekę standardową, umożliwiającą jego stosowanie do wielu zadań. Twórcy języka stosują politykę tzw. Batteries Included, czyli dostarczenia wraz z pakietem instalacyjnym możliwie dużej liczby narzędzi. Moduły standardowej biblioteki można uzupełniać modułami pisanymi w C lub w Pythonie. Biblioteka standardowa jest szczególnie dobrze dostosowana do tworzenia aplikacji sieciowych, jako że obsługuje znaczną liczbę standardowych formatów i protokołów (np. MIME, HTTP). Dołączone są także moduły do tworzenia GUI (na bazie Tcl/Tk), obróbki wyrażeń regularnych, nawet prosty serwer WWW z obsługą CGI.

Większa część biblioteki standardowej dostępna jest na wszystkich platformach, dzięki czemu nawet duże aplikacje mogą często być uruchamiane bez konieczności modyfikacji na Uniksach, pod Windows, na Macintoshu i innych platformach. Przeciwnie, niż np. dla Javy, nie ogranicza się zestawu dostępnych funkcji do części wspólnej dla różnych platform; np. na uniksach dostępna jest funkcja os.fork(), choć nie ma jej np. w Windows.

Standardy dla bibliotek „zewnętrznych”

Podobnie, jak w wypadku innych języków, opracowany został szereg standardów tworzenia API pomocniczego, np. sterowników relacyjnych baz danych. Ze względu na w pełni dynamiczny system typów nie ma konieczności dołączania do biblioteki standardowej „interfejsu bazowego”, jak to ma miejsce np. w przypadku JDBC. Twórca biblioteki zewnętrznej musi po prostu zapewnić, by stworzone przez niego moduły, funkcje i klasy posiadały odpowiednie atrybuty.

Inne cechy

Interpreter Pythona posiada także tryb interaktywny, w którym wyrażenia można wprowadzać z terminala, otrzymując natychmiast wyniki. Zgodnie z założeniem twórców Pythona ułatwiać ma to naukę programowania, gdyż pozwala wypróbowywać fragmenty kodu ze skutkiem natychmiastowym. Standardowy shell nie jest jednakże zbyt wygodny ani nie posiada zbyt wielu funkcji (brak np. uzupełniania TAB-em) – braków tych jest pozbawiony IPython, będący częścią pakietu SciPy.

Wraz z Pythonem rozpowszechniana jest także biblioteka unittest do testów jednostkowych, pozwalająca na tworzenie wyczerpujących testów poprawności tworzonego oprogramowania.

Zobacz też

• IronPython
• PyQt, PyGTK, wxPython, Tkinter, Pygame
• PyCharm, IDLE, eric3, Boa Constructor, Stani's Python Editor, Wing IDE

Linki zewnętrzne

• https://docs.python.org/pl – dokumentacja Pythona w języku polskim (w opracowaniu)
• http://python.rk.edu.pl – biblioteka języka Python