|
|
| (Nie pokazano 4 wersji utworzonych przez jednego użytkownika) |
| Linia 1: |
Linia 1: |
| {{inne znaczenia||[[Python (zwierzęta)]], [[Pyton]]}}
| |
| {{Język tytułu|en}}
| |
| {{Język programowania infobox | | {{Język programowania infobox |
| | nazwa = Python | | | nazwa = Python |
| | logo = Python logo and wordmark.svg | | | logo = Python logo and wordmark.svg |
| | data = 20 lutego [[1991 w informatyce|1991]]<ref>{{cytuj | autor = Guido Van Rossum | tytuł = The History of Python: A Brief Timeline of Python | data = 2009-01-20 | data dostępu = 2025-08-16 | url = https://python-history.blogspot.com/2009/01/brief-timeline-of-python.html}}</ref> | | | data = 20 lutego 1991 |
| | paradygmat = [[Programowanie wieloparadygmatowe|wieloparadygmatowy]] ([[programowanie obiektowe|obiektowy]], [[programowanie imperatywne|imperatywny]], [[programowanie funkcyjne|funkcyjny]])
| | | typowanie = dynamiczne (chujowe) |
| | typowanie = [[Typowanie dynamiczne|dynamiczne]] | | | pochodne = <nowiki>f '(x), f ''(x)</nowiki> |
| | implementacje = [[CPython]], [[IronPython]], [[Jython]], [[PyPy]]
| | | twórca = [[wpl:Szatan|Szatan]] |
| | pochodne = [[Stackless Python]], [[Cython]] | | | licencja = [[Prawo jazdy|Driving License]] (License to kill) |
| | twórca = [[Guido van Rossum]] | | |wersja=brak}} |
| | licencja = Python Software Foundation License<ref name="History and License" /> | | '''Python''' – (pseudo)[[język programowania]] [[Język wysokiego poziomu|wysokiego poziomu]] klasyfikowany jako język ogólnego przeznaczenia; praktycznie służy głównie do szybkiego klejenia skryptów, które ''[[U mnie działa|jakoś działają na mojej maszynie]]''. Posiada rozbudowany pakiet bibliotek standardowych, z czego większość napisana jest w [[Delphi|prawdziwych językach programowania]]. Nie zmienia to jednak faktu, że w tym języku '''nic się nie da zrobić'''. |
| | platforma = [[wieloplatformowość|wieloplatformowy]]
| |
| | system = [[wieloplatformowość|wieloplatformowy]]
| |
| | wikibooks = Zanurkuj w Pythonie
| |
| | commons = Category:Python (programming language)
| |
| | www = | |
| }} | |
| '''Python''' – [[język programowania]] [[język wysokiego poziomu|wysokiego poziomu]] ogólnego przeznaczenia<ref name="A Python Book Beginning Python" />. Posiada rozbudowany pakiet [[biblioteka standardowa|bibliotek standardowych]]<ref name="About Python" />, którego ideą przewodnią jest czytelność i klarowność [[kod źródłowy|kodu źródłowego]]. Jego składnia cechuje się przejrzystością i zwięzłością<ref name="Rapid GUI" /><ref name="Rapid GUI2" />. | |
|
| |
|
| Python wspiera różne [[paradygmat programowania|paradygmaty programowania]]: [[programowanie obiektowe|obiektowy]], [[programowanie imperatywne|imperatywny]] oraz w mniejszym stopniu [[programowanie funkcyjne|funkcyjny]]. Posiada w pełni [[typowanie dynamiczne|dynamiczny]] [[system typów]] i automatyczne [[Odśmiecanie pamięci|zarządzanie pamięcią]], będąc w tym podobnym do języków [[Perl]], [[Ruby (język programowania)|Ruby]], [[Scheme]] czy [[Tcl (język programowania)|Tcl]]. Podobnie jak inne [[dynamiczny język programowania|języki dynamiczne]] jest często używany jako [[język skryptowy]]. [[Interpreter (program komputerowy)|Interpretery]] Pythona są dostępne na wiele [[system operacyjny|systemów operacyjnych]]. | | == Możliwości == |
| | Python jest znany z tego, że '''niemożliwe''' w nim jest m.in: |
|
| |
|
| Python rozwijany jest jako projekt [[Otwarte oprogramowanie|Open Source]] zarządzany przez [[Python Software Foundation]], która jest [[organizacja non-profit|organizacją non-profit]]<ref>{{Cytuj |tytuł = About the Python Software Foundation |data dostępu = 2025-09-28 |opublikowany = Python.org |url = https://www.python.org/psf/about/ |język = en}}</ref>. Standardową [[Implementacja (informatyka)|implementacją]] języka jest [[CPython]] (napisany w [[C (język programowania)|C]]), ale istnieją też inne, np. [[Jython]] (napisany w [[Java|Javie]]), CLPython napisany w [[Common Lisp]], [[IronPython]] (na platformę [[.NET Framework|.NET]]) i [[PyPy]] (napisany w Pythonie, zob. [[bootstrap (programowanie)|bootstrap]]).
| | * manipulowanie słowem sterującym FPU, |
| | * budowa programu wykorzystującego [[Elementy Analizy Numerycznej|arytmetykę przedziałową]], |
| | * rozwiązanie problemów klasy NP [[Sito5|algorytmami metaheurystycznymi]]. |
|
| |
|
| == Rozwój języka == | | == Problemy == |
| [[Plik:Python Powered.png|thumb|Oprogramowanie stworzone m.in. przy użyciu języka Python: [[PyGTK]], [[Django (framework)|Django]], [[Flask (framework)|Flask]], [[Linux Standard Base]], PyUNO, [[Pandas (biblioteka)|pandas]], [[Matplotlib]], [[PyTorch]], [[TensorFlow]]]]
| |
| Pythona stworzył we wczesnych latach 90. [[Guido van Rossum]] – jako następcę [[ABC (język programowania)|języka ABC]], stworzonego w {{link-interwiki|Centrum voor Wiskunde en Informatica|Q=Q1054410}} (CWI – Centrum Matematyki i Informatyki w [[Amsterdam]]ie). 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)<ref>{{Cytuj |tytuł = Origin of BDFL |data dostępu = 2025-09-28 |opublikowany = www.artima.com |url = https://www.artima.com/weblogs/viewpost.jsp?thread=235725}}</ref>.
| |
|
| |
|
| 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ą<ref name="Appetite" />.
| | === Wcięcia jako struktura sterująca === |
| | Python wyróżnia się tym, że: |
|
| |
|
| 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 [[Wirginia|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.
| | * nie posiada jawnych znaczników bloków (np. <code>{}</code>), |
| | * strukturę programu wyznaczają '''wcięcia i spacje'''. |
|
| |
|
| 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 [[GNU General Public License|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.
| | Podejście to umożliwia ono generowanie błędów trudnych do znalezienia, polegających na tym, że jeden blok jest wcięty trzema spacjami, a inny czterema. |
|
| |
|
| 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), [[Organizacja non-profit|niedochodowej organizacji]] (non-profit) wzorowanej na [[Apache Software Foundation]].
| | === GIL === |
| | Centralnym elementem implementacji referencyjnej (CPython) jest '''Global Interpreter Lock (GIL)''' – mechanizm, który: |
|
| |
|
| == Filozofia Pythona ==
| | * uniemożliwia równoczesne wykonywanie bajtkodu w wielu wątkach, |
| Python realizuje jednocześnie kilka paradygmatów. Podobnie do [[C++]], a w przeciwieństwie do [[Smalltalk]]a 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ę [[Odśmiecanie pamięci|garbage collection]].
| | * zapewnia, że każdy problem związany z równoległością zostanie automatycznie zastąpiony problemem z wydajnością. |
|
| |
|
| Choć w jego popularyzacji kładzie się nacisk na różnice w stosunku do [[Perl]]a, 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]].
| | W praktyce oznacza to, że: |
|
| |
|
| == Typy i struktury danych ==
| | * w Pythonie można tworzyć wiele wątków, |
| [[Plik:Python 3. The standard type hierarchy.png|thumb]]
| | * ale tylko jeden może ''naprawdę'' wykonywać kod Pythona w danym momencie. |
| 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 [[Java|Javy]]. W przeciwieństwie do wielu języków, wartości nie są przekazywane ani przez wartość, ani przez referencję, ale przez przypisanie<ref name="Is Python pass by reference" />.
| |
|
| |
|
| 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 <var>long</var> 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.
| | == Zastosowania == |
| | Jedynymi znanymi zastosowaniami języka Python od 25 lat jego istnienia są: |
|
| |
|
| Python oferuje szeroki zakres podstawowych typów danych – w tym typy liczbowe (całkowite, zmiennoprzecinkowe, [[liczby zespolone|zespolone]]) oraz kolekcje. | | * '''Szybkie skrypty i „klejenie” systemów''' – Python pełni rolę spoiwa pomiędzy bardziej poważnymi komponentami. |
|
| |
|
| === Wybrane wbudowane typy danych<ref name="docs.python-stdtypes" /> ===
| | * '''Data science, uczenie maszynowe i AI''' – do Pythona podpinane są wysoko wydajne biblioteki wykonane np. w [[Delphi]], dzięki czemu obliczenia są [[Najszybszy kompilator|szybkie]], bo nie są wykonywane w Pythonie, |
| {| class="wikitable"
| | * '''Aplikacje webowe''' – frameworki typu Django czy Flask pozwalają napisać serwis, który: |
| ! Typ
| | ** działa wystarczająco dobrze, dopóki ruch nie przekroczy pewnego, niewygodnego progu (np. dwóch użytkowników jednocześnie), |
| ! Opis
| | ** a potem można go przepisać na node.js (generując zyski dla teamu deweloperów). |
| ! Przykład
| |
| |-
| |
| |<code>str</code>
| |
| | Ciąg znaków (niezmienny)
| |
| |<code>'Wikipedia'</code>, <code>"Wikipedia"</code> lub
| |
| <syntaxhighlight lang="python" inline>"""Wielolinijkowy
| |
| tekst"""</syntaxhighlight>
| |
| |-
| |
| |<code>bytes</code>
| |
| | Sekwencja bajtów (niezmienna)
| |
| |<code>b'Wikipedia'</code> lub <code>b"Wikipedia"</code>
| |
| |- | |
| | <code>list</code>
| |
| | Lista (zmienna, zawartość, długość)
| |
| | <code>[4.0, 'string', True]</code>
| |
| |-
| |
| | <code>tuple</code>
| |
| | Krotka (niezmienna)
| |
| | <code>(4.0, 'string', True)</code>
| |
| |-
| |
| | <code>set</code>
| |
| | Zbiór (zmienny)
| |
| |<code>{4.0, 'string', True}</code>
| |
| |-
| |
| | <code>frozenset</code>
| |
| | Zbiór (niezmienny)
| |
| |<code>frozenset({4.0, 'string', True})</code>
| |
| |-
| |
| | <code>dict</code>
| |
| | Słownik, czyli tablica asocjacyjna (zmienny).
| |
| | <code>{'key1': 1.0, 3: False}</code>
| |
| |-
| |
| | <code>int</code>
| |
| | Liczba całkowita o dowolnej wartości
| |
| | <code>42</code>
| |
| |-
| |
| | <code>float</code>
| |
| | Liczba zmiennoprzecinkowa
| |
| | <code>3.1415927</code>
| |
| |-
| |
| | <code>complex</code>
| |
| | Liczba zespolona
| |
| | <code>3+2.7j</code>
| |
| |-
| |
| |<code>bool</code>
| |
| | Wartość logiczna (prawda lub fałsz)
| |
| |<code>True</code><br><code>False</code>
| |
| |-
| |
| | <code>NoneType</code>
| |
| | Obiekt reprezentujący brak wartości, będący odpowiednikiem wartości <code>null</code> w innych językach
| |
| | <code>None</code>
| |
| |}
| |
|
| |
|
| === Kolekcje === | | == Opinie eksperckie == |
| Część wyżej wymienionych typów to ''kolekcje''.
| |
|
| |
|
| Listy, [[Krotka (struktura danych)|krotki]] (ang. {{K|en|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)<ref name="docs.python-stdtypes" />.
| | * ''Nie da się'' - [[Andrzej Marciniak]] |
| | | * ''Nie da się'' - [[Krzysztof Zwierzyński]] |
| Innymi typami są kolekcje nieuporządkowane: ''słowniki'' (ang. {{K|en|dictionary}}, typ <code>dict</code>) – znane w innych językach jako odwzorowania (ang. {{K|en|map}}) lub tablice asocjacyjne oraz ''zbiory'' (ang. {{K|en|set}}) reprezentowane przez dwa typy: zbioru zmiennego <code>set</code> i niezmiennego <code>frozenset</code>. Słownikowe klucze oraz elementy zbiorów muszą być tzw. obiektami haszowalnymi (posiadającymi metodę <code>__hash__()</code>) – co na ogół oznacza, że muszą być niezmienne (niemutowalne); np. kluczem słownika nie może być lista ani zbiór zmienny (typu <code>set</code>) – może zaś być krotka bądź zbiór niezmienny (typu <code>frozenset</code>), o ile zawiera wyłącznie elementy niezmienne.
| | * ''Da się'' - nikt |
| | |
| 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<ref name="docs.python-stdtypes" />.
| |
| | |
| 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łą [[Introspekcja (informatyka)|introspekcję]] typów i klas. Typy można odczytywać i porównywać – podobnie, jak w [[Smalltalk]]u, typy (opisy typów) też są typem. Atrybuty obiektu można pobrać jako słownik.
| |
| | |
| W Pythonie '''nie ma [[Hermetyzacja (informatyka)|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 [[kod źródłowy|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:
| |
| | |
| <syntaxhighlight lang="python">
| |
| 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])
| |
| </syntaxhighlight>
| |
| | |
| Uruchomienie powyższego kodu da następujący rezultat:
| |
| | |
| <pre>
| |
| 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
| |
| </pre>
| |
| | |
| === Zmienna liczba argumentów funkcji ===
| |
| Możliwe jest tworzenie funkcji ze [[Zmienna liczba argumentów|zmienną liczbą argumentów]], [[Argument domyślny|argumentami o wartościach domyślnych]] (podobnie jak w C++ lub C#), a także wywoływanie funkcji z użyciem [[Argument nazwany|argumentów nazwanych]], z podaniem nazw [[Parametr (informatyka)|parametrów]].
| |
| | |
| Przykład:
| |
| | |
| <syntaxhighlight lang="python">
| |
| def pokaz_argumenty(x, y, *args, **kwargs):
| |
| print(f'{x=}, {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')
| |
| </syntaxhighlight>
| |
| | |
| Uruchomienie powyższego kodu da następujący rezultat:
| |
| | |
| <pre>
| |
| x=abc, y=123
| |
| Argumenty pozycyjne:
| |
| 456
| |
| def
| |
| Argumenty nazwane:
| |
| k=789
| |
| m=ghi
| |
| </pre>
| |
| | |
| == 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ść [[Kod źródłowy|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 (język programowania)|C]], [[Perl]] czy [[Pascal (język programowania)|Pascal]].
| |
| | |
| Dla czytelności, w Pythonie występują tylko dwa rodzaje pętli: <code>for</code>, w której [[iteracja]] odbywa się po elementach listy (jak w [[perl]]owym <code>foreach</code>), oraz <code>while</code>, która jest powtarzana, dopóki warunek logiczny jest spełniony. Python nie posiada składni <code>for</code> w stylu [[C (język programowania)|C]], <code>do...while</code>, ani perlowego <code>until</code>, choć można uzyskać ich złożone odpowiedniki.
| |
| | |
| Od wersji 2.5 Python posiada [[operator warunkowy]], analogiczny do <code>warunek ? wartość1 : wartość2</code> znanego z [[C (język programowania)|C]] i [[Java|Javy]]. Składnia: <code>wartość1 if warunek else wartość2</code>.
| |
| | |
| === 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 [[Programista|programistom]] niepiszącym w Pythonie.
| |
| | |
| W językach programowania wywodzących strukturę blokową od [[ALGOL|Algola]] (niekoniecznie bezpośrednio) – np. [[Pascal (język programowania)|Pascalu]], [[C (język programowania)|C]], czy [[Perl]]u – bloki kodu zaznaczane są klamrami lub słowami kluczowymi (C i Perl używają <code>{ }</code>, Pascal używa <code>begin</code> i <code>end</code>). 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 (język programowania)|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 (język programowania)|C]] i w Pythonie:
| |
| | |
| ''silnia w C (zapisana bez wcięć):''
| |
| <syntaxhighlight lang="c">
| |
| int silnia(int x) {
| |
| if (x == 0) return 1;
| |
| else return x * silnia(x-1);
| |
| }
| |
| </syntaxhighlight>
| |
| ''silnia w Pythonie:''
| |
| | |
| <syntaxhighlight lang="python">
| |
| def silnia(x):
| |
| if x == 0:
| |
| return 1
| |
| else:
| |
| return x * silnia(x - 1)
| |
| </syntaxhighlight>
| |
| | |
| Dla niektórych programistów przyzwyczajonych do języków stylistycznie wzorowanych na [[ALGOL|Algolu]], gdzie spacja nie ma znaczenia składniowego, może to być mylące. Spotyka się czasem niepochlebne porównanie do sztywnego systemu kolumnowego [[Karta dziurkowana|kart perforowanych]] stosowanego w czasach [[fortran]]owych.
| |
| | |
| 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 (język programowania)|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 [[spacja|spacji]] (i różnej ich liczby) lub [[tabulacja|tabulatorów]], tzw. {{K|en|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 „<code>#</code>” i kończą z końcem wiersza. Komentarze wieloliniowe można wstawiać w postaci wielowierszowych ''stringów'' (ograniczonych przez <code>"""</code> lub <code><nowiki>'''</nowiki></code>) 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 <code>help</code> lub z poziomu [[wiersz poleceń|wiersza poleceń]] za pomocą skryptu <code>{{link-interwiki|pydoc|Q=Q7262948}}</code>.
| |
| | |
| === 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 [[lista składana]] (ang. {{K|en|list comprehension}}), przejęte z funkcjonalnego [[Haskell]]a, jak w przedstawionym poniżej przykładzie obliczania pięciu pierwszych [[potęga dwójki|potęg dwójki]]:
| |
| | |
| <syntaxhighlight lang="python">
| |
| liczby = [1, 2, 3, 4, 5]
| |
| potegi_dwojki = [2 ** n for n in liczby]
| |
| </syntaxhighlight>
| |
| | |
| Za pomocą list składanych można wyrazić algorytm [[Sortowanie szybkie|quicksort]],
| |
| chociaż taka jego implementacja jest mało wydajna:
| |
| | |
| <syntaxhighlight lang="python">
| |
| 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]])
| |
| )
| |
| </syntaxhighlight>
| |
| | |
| Wykorzystując [[programowanie funkcyjne]], można skrócić implementację [[Silnia|silni]] do jednolinijkowca bez uciekania się do [[Rekurencja|rekurencji]]. W poniższym przykładzie użyto operacji redukcji listy:
| |
| | |
| <syntaxhighlight lang="python">
| |
| from functools import reduce
| |
| | |
| def silnia_f(n):
| |
| return reduce(lambda x, y: x * y, range(2, n + 1), 1)
| |
| </syntaxhighlight>
| |
| | |
| ==== Lambda ====
| |
| Nieco mylące dla zwolenników programowania funkcyjnego może być słowo kluczowe <syntaxhighlight lang="python" inline>lambda</syntaxhighlight>. Bloki <syntaxhighlight lang="python" inline>lambda</syntaxhighlight> 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. {{K|en|curry}}):
| |
| | |
| <syntaxhighlight lang="python">
| |
| def zbuduj_sumator(x):
| |
| def temp(y):
| |
| print(f"{x} + {y} = {x + y}")
| |
| | |
| return temp
| |
| </syntaxhighlight>
| |
| | |
| Funkcję tę można zaimplementować także, używając zagnieżdżonych wyrażeń <syntaxhighlight lang="python" inline>lambda</syntaxhighlight> tak, jak to się robi w [[Scheme]]:
| |
| | |
| <syntaxhighlight lang="python">
| |
| zbuduj_sumator = lambda x: lambda y: print(f"{x} + {y} = {x + y}")
| |
| </syntaxhighlight>
| |
| | |
| Oba warianty funkcji <syntaxhighlight lang="python" inline>zbuduj_sumator</syntaxhighlight> 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 <syntaxhighlight lang="python" inline>lambda</syntaxhighlight> zaimplementować dowolne sterowanie przebiegiem [http://www-106.ibm.com/developerworks/linux/library/l-prog.html]. Wykorzystuje się to zwykle tylko do stosunkowo prostych konstrukcji (patrz rozdział o [[Python#Operatory logiczne|operatorach logicznych]]).
| |
| | |
| ==== Generatory ====
| |
| [[generator (informatyka)|Generatory]] są w Pythonie mechanizmem [[Wartościowanie leniwe|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]]:
| |
| | |
| <syntaxhighlight lang="python">
| |
| def generuj_calkowite(n):
| |
| for i in range(n):
| |
| yield i
| |
| </syntaxhighlight>
| |
| | |
| Można teraz użyć tego generatora:
| |
| | |
| <syntaxhighlight lang="python">
| |
| for i in generuj_calkowite(7):
| |
| print i
| |
| </syntaxhighlight>
| |
| | |
| Przed wykonaniem drugiego fragmentu kodu należy zdefiniować zmienną <code>N</code>.
| |
| | |
| Definicja generatora przypomina definicję funkcji, ale zamiast słowa kluczowego <code>return</code> używa się <code>yield</code>. 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 <code>for</code> 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. {{K|en|generator expressions}}), analogiczne do listy składanej. Zapis:
| |
| | |
| <syntaxhighlight lang="python">
| |
| gen_kwadratow = (i ** 2 for i in range(5))
| |
| </syntaxhighlight>
| |
| | |
| jest odpowiednikiem:
| |
| | |
| <syntaxhighlight lang="python">
| |
| def gen_kwadratow():
| |
| for i in range(5):
| |
| yield i ** 2
| |
| </syntaxhighlight>
| |
| | |
| === Operatory logiczne ===
| |
| W Pythonie jako fałsz logiczny traktuje się:
| |
| | |
| * liczbę zero (<code>0</code>, <code>0.0</code>, <code>0j</code> itp.)
| |
| * <code>False</code>
| |
| * <code>None</code> ([[Literał pusty|null]])
| |
| * puste kolekcje (<code>[]</code>, <code>()</code>, <code>{}</code>, <code>set()</code> itp.)
| |
| * puste napisy (<code>""</code>, <code>""""""</code>)
| |
| * obiekty posiadające metodę <code>__bool__()</code>, jeśli zwraca ona <code>False</code>
| |
| | |
| Wszystko inne jest prawdą logiczną.
| |
| | |
| Operatory <code>and</code> i <code>or</code> zwracają wartość ostatnio obliczonego wyrażenia, np. „<code>x==5 or 3</code>” zwróci 3. W Pythonie często pisze się instrukcje w rodzaju <code>print(p or q)</code>, by wykorzystać tę cechę.
| |
| | |
| Wartości logiczne zwracane przez operatory porównania (<code>==</code>, <code>></code>, <code>!=</code>, <code>is</code> itp.), operator zawierania (<code>in</code>) oraz operator [[Negacja|negacji]] (<code>not</code>) reprezentowane są przez obiekty <code>True</code> i <code>False</code>. Gdyby więc w powyższym przykładzie kolejność wyrażeń zamienić na „<code>3 and x==5</code>”, zwrócona zostałaby wartość <code>True</code>, gdyż tak ewaluowane jest <code>x==5</code>. Operatory porównania można łączyć, np. „<code>-1 < x < 0</code>” zwróci <code>True</code> dla <code>x</code> z przedziału (-1, 0) – tak, jak w zapisie matematycznym, a inaczej niż np. w [[C++]].
| |
| | |
| Od Pythona 2.3 <code>True</code> i <code>False</code> są wbudowanymi obiektami typu <code>bool</code>. 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ątek|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.
| |
| | |
| Obsługa wyjątków jest możliwa za pomocą wyrażenia ''try-except''<ref>{{Cytuj |tytuł = 8. Errors and Exceptions |data dostępu = 2025-10-02 |opublikowany = Python documentation |url = https://docs.python.org/3/tutorial/errors.html |język = en}}</ref><ref>{{Cytuj |tytuł = Python Try Except |data = 2017-06-21 |data dostępu = 2025-10-02 |opublikowany = GeeksforGeeks |url = https://www.geeksforgeeks.org/python/python-try-except/ |język = en}}</ref>.
| |
| | |
| Poniżej znajduje się kod, który oczekuje od użytkownika podania liczby. Jeśli zostanie podana inna wartość (np. „xyz”), to kod wypisuje informację o błędzie i prosi o podanie nowej wartości.<syntaxhighlight lang="python3">
| |
| while True:
| |
| try:
| |
| x = int(input("Podaj liczbe: "))
| |
| break
| |
| except ValueError:
| |
| print("Niepoprawna wartosc")
| |
| </syntaxhighlight>Wyrażenie ''try-except'' działa w następujący sposób:
| |
| | |
| * najpierw wykonywany jest kod znajdujący się w bloku <code>try</code>.
| |
| * jeśli nie wystąpi wyjątek, to kod znajdujący się w bloku <code>except</code> zostanie pominięty.
| |
| * jeśli w czasie wykonywania kodu z bloku <code>try</code> pojawi się wyjątek, to pozostałe operacje z tego bloku zostaną pominięte.
| |
| ** jeśli typ wyjątku odpowiada określonemu w klauzuli <code>except</code> (na podstawie powyższego przykładu: <code>ValueError</code>), to wykonywany jest kod określony w bloku <code>except</code>.
| |
| ** jeśli pojawi się wyjątek, który nie został określony w klauzuli <code>except</code>, to jest on przekazywany do nadrzędnych wyrażeń <code>try</code>. W przypadku kiedy żaden z bloków ''try-except'' dostępnych w programie nie przechwytuje danego wyjątku, to jest on nazywany nieobsłużonym wyjątkiem (ang. ''unhandled exception''). W takiej sytuacji wykonanie programu zakończy się z błędem.
| |
| | |
| === Dekoratory ===
| |
| W wersji 2.4 wprowadzono nowy element składni – notację [[Dekorator (wzorzec projektowy)|dekoratora]]. Przykład: w starszych wersjach Pythona, by uzyskać [[Metoda statyczna|metodę statyczną]] klasy, należało napisać:
| |
| | |
| <syntaxhighlight lang="python">
| |
| class C:
| |
| def metoda(obj):
| |
| pass
| |
| | |
| metoda = staticmethod(metoda)
| |
| </syntaxhighlight>
| |
| Notacja dekoratora pozwala, bardziej czytelnie, umieścić informację o konwersji (dekoracji) przed definicją funkcji:
| |
| | |
| <syntaxhighlight lang="python">
| |
| class C:
| |
| @staticmethod
| |
| def metoda(obj):
| |
| pass
| |
| </syntaxhighlight>
| |
| | |
| Ogólnie zapis:
| |
| | |
| <syntaxhighlight lang="python">
| |
| @dekorator
| |
| def funkcja():
| |
| pass
| |
| </syntaxhighlight>
| |
| | |
| jest równoważny zapisowi:
| |
| | |
| <syntaxhighlight lang="python">
| |
| def funkcja():
| |
| pass
| |
| | |
| funkcja = dekorator(funkcja)
| |
| </syntaxhighlight>
| |
| | |
| == Biblioteka standardowa ==
| |
| Python posiada rozbudowaną [[biblioteka standardowa|bibliotekę standardową]], umożliwiającą jego stosowanie do wielu zadań. Twórcy języka stosują politykę tzw. {{K|en|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. [[Multipurpose Internet Mail Extensions|MIME]], [[Hypertext Transfer Protocol|HTTP]]). Dołączone są także moduły do tworzenia [[Graficzny interfejs użytkownika|GUI]] (na bazie [[Tcl (język programowania)|Tcl]]/[[Tk]]), obróbki [[Wyrażenie regularne|wyrażeń regularnych]], nawet prosty serwer [[World Wide Web|WWW]] z obsługą [[Common Gateway Interface|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 [[Unix|Uniksach]], pod [[Microsoft Windows|Windows]], na [[Macintosh]]u i innych platformach. Przeciwnie, niż np. dla [[Java|Javy]], nie ogranicza się zestawu dostępnych funkcji do części wspólnej dla różnych platform; np. na [[Unix|uniksach]] dostępna jest funkcja <code>os.fork()</code>, choć nie ma jej np. w Windows<ref name="os.fork" />.
| |
| | |
| === Standardy dla bibliotek „zewnętrznych” ===
| |
| Podobnie, jak w wypadku innych języków, opracowany został szereg standardów tworzenia [[Interfejs programowania aplikacji|API]] pomocniczego, np. sterowników [[Model relacyjny|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 [[Java DataBase Connectivity|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 ==
| |
| [[Plik:Python's IDLE.png|mały|Python [[IDLE]] (Integrated Development and Learning Environment) działające na systemie [[Ubuntu]]]]
| |
| 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 (Python)|unittest]] do [[test jednostkowy|testów jednostkowych]], pozwalająca na tworzenie wyczerpujących testów poprawności tworzonego oprogramowania<ref name="unittest" />.
| |
| | |
| == Zobacz też ==
| |
| {{wikibooks|Zanurkuj w Pythonie}}
| |
| {{commonscat|Python (programming language)}}
| |
| * [[IronPython]]
| |
| * [[PyQt]], [[PyGTK]], [[wxPython]], [[Tkinter]], [[Pygame]]
| |
| * [[PyCharm]], [[IDLE]], [[Eric|eric3]], [[Boa Constructor]], [[Stani's Python Editor]], [[Wing IDE]]
| |
| | |
| == Przypisy ==
| |
| <references>
| |
| <ref name="os.fork">{{cytuj stronę |url = https://docs.python.org/3/library/os.html#os.fork |tytuł = 16.1. os – Miscellaneous operating system interfaces |autor = Python Software Foundation |język = en |cytat = os.fork() Fork a child process. <nowiki>[szczegółowy opis funkcji]</nowiki> Availability: Unix |data dostępu = 2017-03-07}}</ref>
| |
| <ref name="unittest">{{cytuj stronę |url = https://docs.python.org/3/library/unittest.html |tytuł = 26.4. unittest – Unit testing framework |autor = Python Software Foundation |język = en |cytat = The unittest module provides a rich set of tools for constructing and running tests. |data dostępu = 2017-03-07}}</ref>
| |
| <ref name="About Python">{{cytuj stronę |url = http://www.python.org/about |tytuł = About Python |opublikowany = Python Software Foundation |język = en |data dostępu = 2012-04-24}}</ref>
| |
| <ref name="A Python Book Beginning Python">{{cytuj stronę |url = http://cutter.rexx.com/~dkuhlman/python_book_01.html |tytuł = A Python Book: Beginning Python, Advanced Python, and Python Exercises |autor = Dave Kuhlman |język = en |cytat = Python is a high-level general purpose programming language |archiwum = https://web.archive.org/web/20120623165941/http://cutter.rexx.com/~dkuhlman/python_book_01.html |zarchiwizowano = 2012-06-23 |data dostępu = 2012-07-02}}</ref>
| |
| <ref name="docs.python-stdtypes">[http://docs.python.org/library/stdtypes.html Built-in Types].</ref>
| |
| <ref name="History and License">{{cytuj stronę |url = https://docs.python.org/3/license.html |tytuł = History and License |praca = Python 3.8.1 documentation |język = en |data dostępu = 2020-01-03}}</ref>
| |
| <ref name="Is Python pass by reference">{{cytuj |tytuł = Is Python pass-by-reference or pass-by-value? |data dostępu = 2021-03-27 |opublikowany = Robert Heaton |url = https://robertheaton.com/2014/02/09/pythons-pass-by-object-reference-as-explained-by-philip-k-dick/ |język = en}}</ref>
| |
| <ref name="Rapid GUI">{{cytuj książkę |autor = Mark Summerfield |tytuł = Rapid GUI Programming with Python and Qt |cytat = If you are new to Python: Welcome! You are about to discover a language that is clear to read and write, and that is concise without being cryptic. |język = en}}</ref>
| |
| <ref name="Rapid GUI2">{{cytuj książkę |autor = Mark Summerfield |tytuł = Rapid GUI Programming with Python and Qt |cytat = Python is a very expressive language, which means that we can usually write far fewer lines of Python code than would be required for an equivalent application written in, say, C++ or Java. |język = en}}</ref>
| |
| <ref name="Appetite">{{cytuj stronę |url = http://docs.python.org/tutorial/appetite.html |tytuł = Whetting Your Appetite – Python v2.7.2 documentation |autor = Python Software Foundation |język = en |data dostępu = 2011-08-03}}</ref>
| |
| </references>
| |
| | |
| == Linki zewnętrzne ==
| |
| <!-- ============================================================ -->
| |
| <!-- NIE DODAWAJ WIĘCEJ LINKÓW. TA STRONA NIE JEST ZBIOREM LINKÓW -->
| |
| <!-- Jeżeli sądzisz, że Twój link się może przydać, zamiast tutaj -->
| |
| <!-- umieść go najpierw na stronie dyskusji tego artykułu. Linki -->
| |
| <!-- umieszczone bez przeprowadzonej weryfikacji zostaną usunięte -->
| |
| <!-- ============================================================ -->
| |
| * [https://docs.python.org/pl/ https://docs.python.org/pl] – dokumentacja Pythona w języku polskim (w opracowaniu)
| |
| * [http://www.python.rk.edu.pl/w/p/wprowadzenie-do-pythona/ http://python.rk.edu.pl] – biblioteka języka Python
| |
| * https://www.python.org/ – oficjalna strona języka Python
| |
| | |
| {{Python}}
| |
| {{Języki programowania}}
| |
| | |
| {{Kontrola autorytatywna}}
| |
| | |
| [[Kategoria:Python| ]]
| |
| [[Kategoria:Języki skryptowe]]
| |
| [[Kategoria:Języki programowania maszyny wirtualnej Javy]]
| |
