Z roku na rok Python zyskuje kolejnych zwolenników wśród programistów systemów internetowych. Nie ma tutaj rewolucji jak w przypadku Ruby, brak mu też wciąż popularności na miarę PHP. Python oferuje za to ciekawe możliwości oraz ogromną ilość bibliotek. Warto go poznać, szczególnie że to właśnie w Pythonie napisano framework Django, który może śmiało konkurować z opisywanym niedawno Ruby On Rails.
Python od dawna był dostępny w ramach
licznych usług hostingowych w trybie CGI (podobnie
jak np. Perl). Taka forma nie sprzyjała jednak
intensywnym zastosowaniom webowym, w odróżnieniu
od PHP – który jest zresztą językiem nieco
prostszym do opanowania. Nic więc dziwnego,
że Python nie cieszył się szczególnym uznaniem
wśród twórców aplikacji internetowych.
Zmieniło się to po pojawieniu się frameworków
w modelu MVC, takich jak Django, Pylons czy TurboGear.
Już dziś można spotkać usługi hostingowe
oferujące Pythona wraz z frameworkami w trybie
FastCGI (szybszym i wydajniejszym niż klasyczny
CGI). Istnieje także możliwość implementowania
Pythona z wykorzystaniem modułu serwera
Apache mod_python. To spora przewaga nad
konkurencyjnym frameworkiem Ruby On Rails.
Zanim jednak zapoznasz się bliżej z frameworkami
napisanymi w Pythonie, warto przyjrzeć się
bliżej samemu językowi. Ten artykuł ma za zadanie
wprowadzić cię w jego podstawy.
Dlaczego Python?
Istnieje już tak wiele języków programowania,
że zadania, które można wykonać w Pythonie,
z powodzeniem udałoby się wdrożyć w większości
pozostałych. Jednak są cechy, które sprawiają, że
Python ma swoich sympatyków. Jego domeną są
zastosowania sieciowe.
W internecie można znaleźć różnorodne porównania
Pythona z Perlem, PHP oraz Javą. Python
jest w równym stopniu podobny do każdego
z wymienionych, jak i różny od nich. Podobieństwa
i różnice łatwo wychwycić, zapoznając się z jego
kilkoma podstawowymi cechami:
- Python jest językiem w pełni obiektowym.
Odróżnia go to zarówno od Perla, jak i od PHP
(pomimo faktu, że PHP z wersji na wersję coraz
bardziej wspiera obiektowość – wciąż jednak
czyni to słabo). - Pomimo tego, że jest językiem obiektowym, Python
nie wymusza obiektowego stylu programowania.
Pozwala programiście tworzyć również
programy strukturalne i funkcyjne. - Zmienne nie mają typów, wartości natomiast
tak. Ściślej rzecz ujmując, typy zmiennych
w Pythonie są w pełni dynamiczne. Oznacza to
podobną do PHP łatwość zmiany zastosowania
zmiennych, choć jednocześnie takie rozwiązanie
potrafi dawać inne efekty niż w Javie czy
C++, gdzie przypisywane wartości muszą być
zgodne z typem zmiennej i kompilator ściśle
tego pilnuje. - Python jest językiem interpretowanym – podobnie
jak PHP czy Perl, a w przeciwieństwie do
C/C++ czy Javy. To znacznie ułatwia tworzenie
i modyfikowanie programów, jednak nieco
negatywnie odbija się na wydajności. Sytuację
nieco poprawia wbudowany mechanizm
konwersji kodów źródłowych do zrozumiałej dla
interpretera postaci binarnej, co przy kolejnych
uruchomieniach skryptu może dawać spore
wzrosty wydajności. - Python, podobnie jak Java, jest dostarczany
wraz z bogatym zestawem bibliotek (głównie
dedykowanych operacjom sieciowym).
Ponieważ Python szeroko korzysta z dziedziczenia,
łatwo jest nie tylko implementować
biblioteki w swoich programach, ale także
je dziedziczyć, rozszerzać i tworzyć nowe.
Dzięki temu, podobnie jak w przypadku Javy,
powstaje wiele ciekawych rozszerzeń tych
bibliotek, tworzonych przez niezależnych
programistów. - Środowisko Pythona jest w pełni interaktywne.
Zauważysz to, uruchamiając interpreter. Możesz
na bieżąco wprowadzać kolejne polecenia
i oglądać wyniki. Bardzo ułatwia to tworzenie
i debugowanie programów pisanych w tym
języku. - Python intensywnie się rozwija, z tendencją do
wprowadzania maksymalnej zwięzłości kodu.
Przybliża go to do Perla, co nie podoba się części
webmasterów, którzy twierdzą, że dzieje się to
ze szkodą dla przejrzystości kodu.
Kilka słów wstępu
Artykuł napisany został w oparciu o wersję
2.4 języka Python. Od 2006 roku jest dostępna
również nowsza wersja 2.5, jednak pobieżny
przegląd jej dostępności w firmach hostingowych
nakazuje zachowanie na razie wstrzemięźliwości
w jej wykorzystaniu. Opisane w tym artykule
operacje będą jednak w pełni kompatybilne także
z nowszym Pythonem.
W artykule szeroko prezentujemy kody źródłowe.
Dla zwiększenia czytelności część z nich
prezentowana będzie zgodnie z interaktywnym
duchem języka. Kody te poznasz po znaku zachęty
\”>>>\”. Poprzedza ono polecenie wprowadzone
do Pythona. Poleceń takich używaj
z pominięciem znaku zachęty. Linie niemające takiego
symbolu oznaczają odpowiedź otrzymaną
od interpretera.
Za chwilę przekonasz się również, jak ważne
dla działania programów w Pythonie są właściwe
wcięcia bloków kodu oraz przejścia do nowej linii
we właściwych miejscach. Ponieważ technika
składu magazynu rządzi się swoimi prawami,
część kodu może posiadać przejścia do nowej linii
w niewłaściwych miejscach. Zwróć na to baczną
uwagę. Dość łatwo wychwycisz, w których sytuacjach
masz do czynienia z całkiem nową linią, a w
których z kontynuacją poprzedniej.
No to zaczynamy!
Krotki
Istnieje jeszcze jeden, bardzo podobny do list
typ danych, charakterystyczny dla języka Python.
Są to tzw. \”krotki\” (ang. \”tupple\”). Krotki to specyficzne
listy, które po ich pierwotnym zdefiniowaniu
nie mogą zostać zmodyfikowane. Są symbolizowane
nawiasami okrągłymi.
>>> krotka = (\"Tekst1\", 12, 3.5, \"Tekst2\",
True)
>>> print krotka
(\'Tekst1\', 12, 3.5, \'Tekst2\', True)
>>> print krotka[2]
3.5
Krotki nie mają żadnych metod pozwalających
na ich modyfikację. Do czego są więc potrzebne?
Obsługa krotek jest realizowana zdecydowanie
szybciej niż list. Dlatego jeżeli masz do czynienia ze
zbiorem danych, który pozostanie w czasie działania
programu niezmienny, lepiej będzie zastosować
dla niego krotkę. Tym bardziej, że w razie potrzeby
stosunkowo łatwo przekonwertujesz krotki na listę.
>>> lista3 = list(krotka)
>>> print lista3
[\'Tekst1\', 12, 3.5, \'Tekst2\', True]
Słowniki
Jeżeli listy w Pythonie przyrównaliśmy do tablic
w innych językach programowania, to słowniki
należałoby z kolei porównać do tablic asocjacyjnych.
Pozwalają one na zapamiętanie określonych
wartości pod pewnymi literałami.
Musisz jednak zawsze pamiętać, że podstawą
dostępu do elementów słownika są właśnie te literały.
Dlatego interpreter nie gwarantuje określonej
kolejności zwracania zbiorczo elementów ze słownika.
Elementy są wówczas zwracane w porządku
losowym.
Słowniki w Pythonie są reprezentowane
poprzez nawiasy klamrowe. Oto jak możesz je
stworzyć:
>>> slownik = {\'imie\': \'Jan\', \'nazwisko\':\'Kowalski\'}
>>> print slownik
{\'imie\': \'Jan\', \'nazwisko\': \'Kowalski\'}
>>> print slownik[\'imie\']
Jan
Aby usunąć klucz o określonej nazwie możesz
użyć polecenia del.
>>> del slownik[\'nazwisko\']
>>> print slownik
{\'imie\': \'Jan\'}
Pętle
W Pythonie stosowane są dwa rodzaje pętli.
Pierwsza z nich to while. Ponieważ zachowuje
się ona identycznie do swojego odpowiednika
w wielu innych językach programowania, nie
wymaga szczegółowego omówienia. Oto krótki
przykład:
n = 0
suma = 0
while suma < 20:
suma += n
n += 1
Kod ten ma za zadanie dodawać do sumy
kolejne liczby naturalne, aż do momentu, gdy
suma przekroczy 20. Pętle możesz w każdej chwili
przerwać instrukcją break. Do następnego przebiegu
pętli możesz przejść, używając instrukcji
continue.
Nieco ciekawszą funkcją jest for/in. Oto przykład
jej konstrukcji:
for rok in (2005, 2006, 2007, 2008):
if rok < 2008:
print \"%s juz byl!\" % rok
else:
print \"%s trwa aktualnie\" % rok
Pętla for w Pythonie nie zachowuje się w sposób
podobny do swoich odpowiedników z innych
języków programowania. Nie ma zmiennej, po
której następuje iterowanie. Zamiast tego do
wskazanej zmiennej rok przypisywane są kolejne
elementy z krotki zawartej za słowem kluczowym
\"in\". Zamiast krotki moglibyśmy użyć również listy
lub słownika. Funkcjonalnie jest to więc odpowiednik
pętli foreach z PHP.
Co ciekawe, możesz również definiować blok
else do pętli foreach w Pythonie. Zostanie on wykonany
zawsze na końcu, chyba że działanie pętli
zostało przerwane przez instrukcję break.
Tworzenie klas
Python, jako język obiektowy, pozwala również
tworzyć własne klasy. Oto w jaki sposób możesz to
zrealizować.
class Liczba(int):
n = 0
def podzielna(self, b):
if (self.n % b) == 0: return True
return False
def parzysta(self):
return self.podzielna(2)
Jest to przykład prostej klasy, która przechowuje
atrybut w postaci liczby całkowitej. Klasa
posiada także dwie metody znane już z wcześniejszej
części artykułu.
Ponieważ podstawy struktury Pythona nie
powinny być ci już obce, a z innych języków
programowania znasz też ogólne zasady
tworzenia klas i obiektów, skoncentrujemy się
wyłącznie na cechach charakterystycznych dla
języka Python.
W nawiasie okrągłym w pierwszej linii kodu
jest wstawiona nadklasa, po której nowa klasa
będzie dziedziczyć. Jeśli nie dziedziczysz po żadnej
z klas użytkownika, powinieneś przynajmniej
dziedziczyć po klasach wbudowanych. Jeśli żaden
ze standardowo dostępnych typów danych nie jest
dla ciebie satysfakcjonujący, możesz dziedziczyć po
\"pustej\" klasie object.
Formalnie nie jest to wymagane przez interpreter
z uwagi na zachowanie zgodności z Pythonem
sprzed wersji 2.2 (gdzie nie było konieczności dziedziczenia
po klasie wbudowanej). Jednak obecnie
programiści Pythona zgodnie promują wskazywanie,
po czym będziesz dziedziczyć w przypadku
każdej tworzonej klasy.
Kolejną specyficzną dla tego języka kwestią jest
pierwszy argument każdej tworzonej metody. Jak
zauważyłeś, do obu metod wstawiliśmy parametr
o nazwie \"self\".
Python przesyła w taki sposób referencję do
instancji klasy (obiektu) aktualnie wykonywanego.
Funkcjonalnie jest to więc odpowiednik słowa
kluczowego this z innych języków programowania,
jednak w Pythonie nie występuje on w postaci
słowa kluczowego, a właśnie jako pierwszy argument
metody. Należy więc zawsze pamiętać o jej
stworzeniu.
Parametr ten jest według konwencji stosowanej
przez programistów Pythona nazywany zawsze
tak samo i w sposób podany w przykładzie, czyli
\"self\". Nie jest to wymóg języka, jednak warto tej
konwencji się trzymać - przede wszystkim ułatwi
to migrację kodu.
Co ważne, referencji do obiektu nie musisz
przesyłać przy wywoływaniu metody - interpreter
dołączy ją automatycznie.
Obiekty można tworzyć, a następnie obsługiwać
w następujący sposób:
liczba = Liczba()
liczba.n = 9
print liczba.parzysta()
Uruchomienie takiego programu spowoduje
wyświetlenie wartości False, ponieważ liczba 9 nie
jest parzysta.
Wiesz już, jak tworzyć prostą klasę. Czas jednak
nieco ją rozszerzyć o kilka innych elementów, bez
których trudno byłoby mówić o dobrze zaimplementowanej
obiektowości.
class Liczba(int):
__n = 0
def __init__(self, n = 0):
self.__n = n
int.__init__(self)
def podzielna(self, b):
if (self.__n % b) == 0: return True
return False
def parzysta(self):
return self.podzielna(2)
Kod trochę się skomplikował. Przede wszystkim
stworzyliśmy specjalną metodę {stala}__init__{/stala}, która będzie
wywoływana podczas tworzenia obiektu. Jest
ona funkcjonalnie zgodna z pojęciem konstruktora
z innych języków programowania, nieznacznie
się jednak od tradycyjnego konstruktora różni.
W Pythonie najpierw tworzony jest bowiem
obiekt, a dopiero potem wywoływana jest metoda
{stala}__init__{/stala} - w trakcie jej wywoływania obiekt już
istnieje.
W metodzie {stala}__init__{/stala} można umieścić rozmaite
czynności potrzebne do prawidłowego skonfigurowania
obiektu. W powyższym przykładzie metoda
ta przyjmuje jeden parametr zewnętrzny (czyli bez
wliczania automatycznego \"self\"). Jest to parametr
domyślny. Jeśli nie zostanie przekazany, użyta
zostanie wskazana wartość 0.
W ramach metody {stala}__init__{/stala} zawsze warto
zastosować wywołanie konstruktora klasy nadrzędnej,
chyba że celowo uznamy to za działanie niepożądane.
W Pythonie konstruktory klas, po których
dziedziczymy, nie są wywoływane automatycznie.
Kolejną modyfikacją w stosunku do poprzedniego
przykładu jest zmiana nazwy zmiennej n na
{stala}__n{/stala}. W praktyce oznacza to, że atrybut ten staje
się prywatny.
Python nie stosuje słów kluczowych
do określenia zakresu dostępności atrybutów. Efekt
ten jest osiągany wyłącznie przez z góry narzuconą
konwencję nazewniczą. Metody rozpoczynające
się od podwójnego znaku podkreślenia (ale nie
kończące się w ten sposób) będą uważane za
prywatne (odpowiednik słowa kluczowego \"private\").
Zasięg chroniony (\"protected\") w Pythonie
praktycznie nie występuje.
Poprawioną wersję klasy wywołać można
w taki sposób:
liczba = Liczba2(8)
liczba.__n = 9
print liczba.parzysta()
Po uruchomieniu tego programu otrzymamy
w wyniku True, ponieważ liczba 8 jest parzysta.
Próba zmodyfikowania prywatnego atrybutu
w drugiej linii została zignorowana.
Na koniec jeszcze mała zabawa. Rozszerzmy
klasę o przeciążenie metody specjalnej{stala} __str__{/stala}:
def __str__(self):
return str(\"%s (%s)\" % ( int(self.__n),hex(self.__n)) )
Metoda {stala}__str__{/stala} jest wywoływana w celu
uzyskania reprezentacji tekstowej obiektu. Możesz
teraz spróbować następującej sztuczki:
liczba = Liczba(8)
liczba2 = Liczba(14)
print \"%i\" % liczba
print \"%s\" % liczba2
print liczba + liczba2
W rezultacie otrzymasz następujące wyniki:
8
14 (0xe)
22
Co tak naprawdę się wydarzyło? W trzeciej
linijce kodu wywołania wyświetlony został obiekt
w kontekście liczby całkowitej (formatowanie
%i). W rzeczywistości wywoływana jest metoda
specjalna obiektu o nazwie {stala}__int__{/stala}. Ponieważ jej
nie przeciążaliśmy, została użyta domyślna metoda
wbudowanej klasy int, po której dziedziczyliśmy.
Dzięki temu zwrócono wartość liczbową.
W czwartej linii dokonujemy użycia obiektu
w kontekście łańcucha tekstu (formatowanie %s).
Tę metodę już przeciążyliśmy w taki sposób, by
zwracała wartość w postaci liczby dziesiętnej oraz
dodatkowo w postaci heksadecymalnej (w nawiasie),
co widać w zwróconym wyniku.
Ostatnia linia wywołuje niejawnie metodę specjalną
{stala}__add__{/stala}, która odpowiada za dodawanie
obiektów. Tej metody również nie przeciążaliśmy,
zostało więc wykorzystane domyślne zachowanie
wbudowanego typu int.
Może kusić chęć stworzenia konstrukcji:
liczba3 = liczba + liczba2
Nie zadziała to jednak w sposób oczekiwany,
ponieważ w Pythonie nie można przeciążać operatora
przypisania. Jest to następstwem zastosowania
dynamicznych typów zmiennych.
Instalacja duetu Apache + Python pod Windows
{tlo_1}
1. Pobierz apache2triad
Aby móc swobodnie testować pisany kod,
wykorzystamy pakiet apache2triad, który
dostarcza serwer Apache pod Windows, wraz
z zestawem dodatkowych narzędzi - w tym interpreter
Pythona. Źródła programu ściągniesz ze
strony http://www.apache2triad.net/ . Znajdziesz
je także na naszej płycie CD (wersja 1.5.4).
{/tlo}
{tlo_0}
2. Ustal hasło administratora
Instalator zawiera kilka podstawowych pytań
związanych z instalacją. Warto zwrócić
uwagę na pytanie o hasło administratora tworzonego
systemu WWW. Powinno mieć ono nie mniej
niż 8 znaków. Sama instalacja zajmuje ok. 350 MB
na dysku i może zająć kilka minut.
{/tlo}
{tlo_1}
3. Uruchom interpreter
Poznawanie Pythona najlepiej rozpocząć
w trybie interaktywnym. Interpreter w tym
trybie natychmiast zwraca odpowiedzi i pozwala
pracować nawet na fragmentach programu. Jeśli
instalacja przebiegła poprawnie, uruchom konsolę
(\"Start\" > \"Uruchom\" > wpisz \"cmd\"). Gdy przywita
cię ekran konsoli, wpisz po prostu \"python\".
{/tlo}
{tlo_0}
4. Przetestuj przykładowy skrypt
Jeśli chcesz uruchomić realny skrypt CGI,
przejdź do katalogu, który wskazałeś podczas
instalacji apache2triad. Odnajdź w nim folder
\"htdocs\". Zawiera on pliki i katalogi wyświetlane
na twoim lokalnym serwerze WWW. Utwórz plik
o dowolnej nazwie i rozszerzeniu .py.
{/tlo}
{tlo_1}
5. Napisz pierwszy program
Stwórz swój pierwszy program w Pythonie.
Możesz wzorować się na powyższym
przykładzie. Jest to prosty program testujący, który
wykonuje zadanie podobne do funkcji {stala}info(){/stala} z PHP
- wyświetla informacje na temat środowiska serwera.
Do edycji kodu możesz wykorzystać zwykły
notatnik, polecamy jednak program Notepad++,
który koloruje składnię.
{/tlo}
{tlo_0}
6. Sprawdź efekty
Jeśli wszystko zrobiłeś dobrze, uruchamiając
adres http://localhost/twojskrypt.py
w przeglądarce, zobaczysz efekt swojej pracy. Jeśli
plik próbuje się ściągać na dysk, prawdopodobnie
zawiera on błąd. W takim przypadku spróbuj
uruchomić skrypt z linii poleceń (konsola), aby
dowiedzieć się, gdzie zaszła pomyłka.
{/tlo}
Wyjątki
Na zakończenie kilka słów należy się tematowi
wyjątków. Jest to podstawowy sposób sygnalizowania
wszelkich błędów występujących w programach.
Zachowanie to jest podobne do znanego
z Javy oraz częściowo z PHP i zupełnie odmienne
od stosowanego w C/C++, gdzie powszechnie
znana jest konwencja, zgodnie z którą w przypadku
pomyślnego zakończenia działania funkcji
zwracana jest wartość zerowa, a w przypadku
błędu - jego niezerowy kod.
W Pythonie konwencja informowania o błędach
jest inna. W przypadku istnienia błędu wyrzucany
jest wyjątek, który powinien zostać przechwycony
przez programistę w zagrożonym miejscu
programu, a następnie odpowiednio obsłużony.
Jeśli wyjątek nie zostanie obsłużony, dotrze on
do interpretera, co najprawdopodobniej zakończy
działanie programu.
Obsługa wyjątków następuje instrukcjami
try/except.
slownik = {\'imie\': \'Jan\', \'nazwisko\':\'Kowalski\'}
try:
print slownik[\'adres\']
except KeyError, error:
print \"Brak klucza %s!\" % error
except:
print \"Dowolny inny blad\"
W przypadku wystąpienia wyjątku typu KeyError
zostanie wykonana zdefiniowana akcja. Obsługę
wyjątków różnego rodzaju możesz powielać, a na
końcu możesz również podać domyślny sposób
obsługi nieprzewidzianych wyjątków.
Pamiętaj, aby praktycznie na każdym kroku
sprawdzać, czy nie nastąpiło wyrzucenie wyjątku.
Instrukcje do sprawdzania najlepiej grupować
w określone bloki funkcjonalne.
Python zawiera również instrukcję finally, która
wykonuje kod kończący obsługę danego fragmentu
tekstu, niezależnie od wystąpienia wyjątku.
Niestety w Pythonie 2.4 jest ona niekompatybilna
z instrukcją except - nie można ich używać równocześnie,
przez co użycie obu jest dość karkołomne
(należy podzielić sprawdzanie na dwie niezależne
części). W Pythonie 2.5 sytuacja ta została już
poprawiona.
W kodzie programu możesz łatwo wywołać
własny wyjątek. Najprościej skorzystać z macierzystej
dla wyjątków klasy Exception:
def test(x):
if not 0 <= x <= 20: raise Exception, \"Liczba musi być z zakresu <0; 20>!\"
try:
test(25)
except Exception, error:
print \"Blad: %s\" % error
Możesz także tworzyć własne zachowania wyjątków
poprzez utworzenie klas je obsługujących.
Powinny one dziedziczyć po klasie Exception.
Na zakończenie artykułu pragniemy przypomnieć,
że był to jedynie wstęp do tematu Pythona.
Mamy nadzieję, że pozwolił on zapoznać się
z podstawową składnią i semantyką tego języka.
Sądzimy, że jesteś już w stanie w miarę swobodnie
pisać i rozumieć programy napisane w Pythonie.
Zachęcamy jednak do poszukiwania dodatkowych
materiałów na jego temat.
Swoją wiedzę możesz rozszerzyć poprzez
lekturę książek rekomendowanych w ramkach
oraz lekturę licznej dokumentacji i przewodników
poświęconych temu językowi w internecie.
Python i aplikacje webowe
Jako webmaster będziesz wykorzystywać
Pythona do tworzenia skryptów po stronie
serwera WWW, komunikujących się z użytkownikiem
korzystającym z przeglądarki - czyli tak
zwanych aplikacji webowych. Poniżej znajdziesz
kilka drobnych uwag, z którymi powinieneś się
zapoznać, zanim rozpoczniesz programowanie
w tym zakresie.
Najczęściej skrypty webowe będziesz pisać,
korzystając z trybu CGI - tak udostępniany jest
zwykle Python u dostawców hostingu. Aby
skrypt zadziałał, pamiętaj przesłać go na serwer
koniecznie w trybie tekstowym (a nie binarnym
- może być to przyczyną problemów) oraz nadać
mu atrybut uprawnień wykonywalności.
Na samym początku skryptu wstaw poniższe
dwie linie.
#!/usr/bin/python
# -*- coding: iso-8859-2 -*-
W pierwszej linii wskazujesz systemowi operacyjnemu
ścieżkę do interpretera Pythona. W razie
wątpliwości co do tego, czy ścieżka jest zgodna
z konfiguracją serwera, zapytaj administratora
swojego serwera. Druga linia to specjalna dyrektywa
dla interpretera Pythona, która informuje
go o tym, jakiego kodowania znaków będziesz
używać w skrypcie (jest to konieczne do poprawnej
obsługi polskich znaków).
Skrypty CGI komunikują się z serwerem
poprzez standardowe wyjście. Tak więc używając
instrukcji print, wygenerujesz dokument, który
zostanie przesłany do serwera WWW, a następnie
- po prostym przetworzeniu - powędruje dalej do
przeglądarki użytkownika. Nie wymaga to żadnych
dodatkowych czynności.
Musisz jednak zawsze pamiętać o tym, że
każdy skrypt CGI musi na samym początku zwrócić
serwerowi nagłówek HTTP. Dlatego zanim wyślesz
dowolne inne dane, koniecznie wstaw poniższą
linię:
print \"Content-type: text/html\n\"
Nieco rzadziej na serwerach spotkasz implementację
Pythona w postaci modułu mod_python.
Jego obsługa wygląda nieco inaczej. Na początku
skryptu musisz zaimportować klasy obsługujące
komunikację z serwerem WWW:
from mod_python import apache
Generowanie odpowiedzi dla przeglądarki
odbywa się mniej więcej w poniższy sposób:
def index(req):
req.content_type=\"text/html\"
req.send_http_header()
req.write(\"Hello world!\")
W pierwszej linii funkcji {stala}index(){/stala} zdefiniowany
został typ dokumentu, który następnie posłuży do
stworzenia nagłówka. Sam nagłówek wysyłany
jest w linii drugiej. W linii trzeciej, przy wykorzystaniu
metody {stala}write(){/stala}, wysłany został fragment
właściwego dokumentu.
Dlaczego całość została opakowana funkcją {stala}index(){/stala}?
Moduł mod_python udostępnia ciekawy parser
URL. Zakładając, że skrypt został nazwany skrypt.py
i znajduje się w macierzystym katalogu domeny, to
przy odwołaniu się do niego poprzez adres:
http://twojadomena.pl/skrypt.py
zostanie automatycznie wywołana funkcja {stala}index(){/stala}.
Natomiast, gdyby do skryptu odwołać się w taki
sposób:
http://twojadomena.pl/skrypt.py/test
to zostałaby wywołana funkcja o nazwie test().
Znacznie ułatwia to tworzenie aplikacji i zwiększa
ich przejrzystość, choć wymaga też większej uwagi
- w przypadku zaniechania stosownych zabezpieczeń
łatwo o nieuprawniony dostęp do funkcji
z poziomu przeglądarki.
Istnieje jeszcze jeden sposób tworzenia skryptów
Pythona. Można skorzystać z rozszerzenia Python
Server Pages (w skrócie PSP), który pełni analogiczną
funkcję jak Java Server Pages dla Javy. Pozwala
wplatać fragmenty kodu Pythona w znaczniki dokumentu
HTML (lub innego). W praktyce jednak jest to
rozwiązanie dobre głównie dla niewielkich i mało
skomplikowanych aplikacji. Przy większych projektach
oznacza bowiem zmniejszenie czytelności kodu.
Podstawowe operacje arytmetyczne
Sposób wykonywania operacji arytmetycznych
nie odbiega od standardu uznawanego przez inne
języki programowania. Oto kilka przykładów:
>>> print 12+10
22
>>> print 12-10
2
>>> print 12*10
120
>>> print 12/10
1
>>> print 12%10
2
Pierwsze 4 działania nie wymagają komentarza.
Ostatnim wykonanym poleceniem jest
operacja modulo (reszta z dzielenia). Warto zwrócić
uwagę, że dzieląc 12 przez 10, otrzymaliśmy wynik
niezgodny z matematyczną rzeczywistością. Jest
on jednak zgodny z rzeczywistością informatyczną
- pracujemy bowiem na liczbach całkowitych
(integer).
W Pythonie zmienne nie mają swoich typów
(lub inaczej - typy zmiennych są w pełni dynamiczne).
Funkcjonują natomiast typy przynależące do
wprowadzanych wartości. To właśnie od wartości
będzie zależeć, jak zachowa się określone działanie
czy polecenie. Aby więc wymusić wykonanie
operacji dzielenia na zakresie liczb zmiennoprzecinkowych,
powinieneś wykonać operację w taki
sposób:
>>> print 12.0/10.0
1.2
W powyższym przykładzie obie wartości są
typu zmiennoprzecinkowego. W praktyce dla
wymuszenia wykonania działania na takim typie
wystarczyłoby, aby choć jedna z nich była z nim
zgodna.
Operacje logiczne
Podstawowe operacje logiczne wykonywane są
w sposób dość typowy dla języków podobnych do
C. Oto kilka przykładów:
>>> 1 == 1
True
>>> 1 < 2
True
>>> 2 < 1
False
>>> 1 > 2
False
>>> 1 != 2
True
>>> 1 <> 2
True
>>> 1 <= 2
True
>>> 1 >= 2
False
W powyższym przykładzie mogą zwrócić
uwagę dwie formy sprawdzenia, czy wartości są
od siebie różne.
Operacji logicznych na stringach dokonuje się
podobnie do PHP.
>>> \'aaa\' == \'aaa\'
True
>>> \'aaa\' != \'aaa\'
False
Możliwe jest korzystanie z operatorów logicznych
\"and\" oraz \"or\".
>>> 1 < 2 or 2 < 1
True
>>> 1 < 2 and 2 < 1
False
Ważna jest kolejność wykonywania operacji,
ale nie odbiega ona od reguł z innych języków i ich
najpopularniejszych interpreterów czy kompilatorów.
W razie wątpliwości zawsze warto stosować
nawiasy.
Choć pokazane operatory \"and\" oraz \"or\"
zostały wykorzystane w kontekście operacji
logicznych, to w praktyce w Pythonie nie zwracają
one typu boolean. Zwracana jest natomiast
jedna z wartości. W przypadku \"and\" będzie to
pierwsza napotkana wartość fałszywa lub ostatnia
prawdziwa, jeśli fałszywej nie było. W przypadku
\"or\" zwrócona zostanie pierwsza prawdziwa lub
ostatnia fałszywa.
>>> 1 and 2
2
>>> 1 or 2
1
Taka obsługa operatorów logicznych ma swoje
liczne konsekwencje w stosunku do użyć znanych
z C, czy tym bardziej z Javy (która restrykcyjnie
wymaga użycia typu booelan). Nie będziemy tych
sytuacji poruszać, ale tworząc bardziej złożone
wyrażenia logiczne, warto mieć świadomość tej
właściwości.
Ciekawostką może być poniższa konstrukcja:
>>> 1 < 2 < 3
True
>>> 3 < 2 < 1
False
Konstrukcja ta działa w sposób właściwy dla
logiki matematycznej - czyli zwraca prawdę, jeśli
liczby ustawione są w odpowiednim porządku
i fałsz, gdy jest inaczej. Właściwość tę można wykorzystać
na przykład do sprawdzenia, czy jakaś liczba
znajduje się w zakresie pomiędzy dwiema innymi:
>>> x = 5
>>> y = 0.5
>>> 1 < x < 10
True
>>> 1 < y < 10
False
Przy okazji dowiedziałeś się, w jaki sposób
w Pythonie dokonujemy przypisania wartości
do zmiennej. Dodajmy jeszcze, że zmiennych
w Pythonie nie trzeba deklarować (co jest wprost
związane z faktem, że nie posiadają one żadnego
konkretnego typu). Zmienna jest deklarowana automatycznie
w momencie przypisania jej wartości
i będzie widoczna do momentu wyjścia z zakresu,
w którym jest widoczna - po tym zostanie automatycznie
usunięta.
Operacje arytmetyczne na tej samej zmiennej
można wykonywać w formie skrótowej:
>>> x = 5
>>> x += 3
>>> print x
8
>>> x *= 2
>>> print x
16
Niestety w Pythonie nie zadziała inkrementacja
ani dekrementacja (np. x++).
Operacje na łańcuchach
Łańcuchy tekstu (ang. \"strings\") można
w Pythonie zapisywać, korzystając z apostrofu lub
znaku cudzysłowu. Można je stosować pojedynczo
lub potrójnie (do wyboru). Kilka przykładów:
>>> \"Przykladowy lancuch\"
\'Przykladowy lancuch\'
>>> \'Przykladowy lancuch\'
\'Przykladowy lancuch\'
>>> \"\"\"Przykladowy lancuch\"\"\"
\'Przykladowy lancuch\'
>>> \'\'\'Przykladowy lancuch\'\'\'
\'Przykladowy lancuch\'
Inaczej niż w PHP, stosowanie apostrofu i znaku
cudzysłowu nie jest rozróżniane z punktu widzenia
interpretera (jak zapewne wiesz, interpreter PHP
w przypadku tekstu w cudzysłowach dokonywał
jego parsowania).
Cudzysłowy i apostrofy można stosować
wymiennie (ale zawsze koniecznie parami), co jest
szczególnie przydatne w sytuacjach, gdy wewnątrz
samego łańcucha zawarłeś któryś z tych znaków.
Masz wówczas do wyboru - wskazanie interpreterowi
poprzez znak odwrotnego ukośnika, że jest
to znak należący do łańcucha lub też zastosowanie
innego ogranicznika łańcucha niż znaku znajdującego
się w jego wnętrzu:
>>> \"To jest przyklad z uzyciem \\"cudzyslowiu\\"\"
\'To jest przyklad z uzyciem \"cudzyslowiu\"\'
>>> \'To jest przyklad z uzyciem \"cudzyslowiu\"\'
\'To jest przyklad z uzyciem \"cudzyslowiu\"\'
Wariant drugi wydaje się czytelniejszy. Również
zastosowanie konstrukcji trzech apostrofów pozwala
uzyskać podobny efekt:
>>> \'\'\'Inny przyklad z uzyciem \'apostrofu\'.\'\'\'
\"Inny przyklad z uzyciem \'apostrofu\'.\"
Jednak to samo z użyciem trzech cudzysłowów
i pojedynczym cudzysłowem w samym tekście nie
będzie już konstrukcją poprawną. Potrójne cudzysłowy
natomiast, podobnie zresztą jak potrójne
apostrofy, służą w Pythonie do wprowadzania
tekstu podzielonego na wiele linii:
\"\"\"Linia pierwsza tekstu.
Linia druga tekstu.\"\"\"
Co w efekcie zostanie zapamiętane w postaci:
\'Linia pierwsza tekstu.\\nLinia druga
tekstu.\'
Próba wprowadzenia wieloliniowego tekstu za
pomocą pojedynczego apostrofu lub cudzysłowu
zakończy się niepowodzeniem.
Przypisywanie łańcuchów do zmiennych
następuje w sposób analogiczny do przypisywania
wartości liczbowych:
>>> tekst = \"Przykladowy lancuch\"
>>> print tekst
Przykladowy lancuch
Konkatenacja (łączenie) łańcuchów tekstu w Pythonie
jest realizowana poprzez znak plusa (\"+\").
>>> \"Ala ma\" + \' \' + \"\"\"konta\"\"\"
\'Ala ma konta\'
Inną kwestią jest łączenie łańcuchów i liczb
jednocześnie. Python nie dokonuje automatycznej
konwersji typów danych w pełnym zakresie, jak
robi to chociażby PHP. Dokonywana automatycznie
konwersja dotyczy jedynie typów numerycznych.
Istnieją dwa sposoby na to, aby dokonać
połączenia łańcucha z liczbą. Pierwszym jest ręczna
zamiana liczby na łańcuch i wykonanie konkatenacji:
>>> x = 3
>>> print \"x = \" + str(x)
\'x = 3\'
Druga metoda polega na formatowaniu łańcucha
tekstu. Koncepcja jest podobna do stosowanej
w innych językach programowania w ramach
funkcji typu printf. Jednak sposób zapisu jest tutaj
bardziej finezyjny. Oto przykład:
>>> a = 2
>>> b = 4
>>> print \"a = %i\" % a
\'a = 2\'
>>> print \"%i + %i = %i\" % (a, b, a + b)
2 + 4 = 6
Wewnątrz łańcucha tekstowego możesz wstawiać
specjalne znaki formatujące. Do wyboru: %s
(dla łańcuchów), %c (dla pojedynczych znaków), %i
(dla liczb całkowitych), %f (dla liczb zmiennoprzecinkowych).
Następnie podajesz listę (a właściwie
krotkę), zawierającą odpowiednie zmienne. Jest to
powszechnie stosowana konwencja formatowania
tekstu w Pythonie i warto ją wykorzystywać,
ponieważ jest przejrzysta i wygodna.
Na koniec mała uwaga. Instrukcja print po wypisaniu
tekstu automatycznie wstawia znak nowej
linii. Jeśli chcesz tego uniknąć - po jednej instrukcji
print, a przed kolejną wstaw znak przecinka.
Komentarze
Każdy kod należy dokumentować - przynajmniej
poprzez stosowanie komentarzy. Tak
uczy stara szkoła programowania. Komentarze
jednolinijkowe w Pythonie można wykonywać za
pomocą znaku \"#\", czyli podobnie jak w Perlu,
PHP czy Bashu.
Nieco bardziej skomplikowane jest wykonywanie
komentarzy wieloliniowych. Python nie
udostępnia takiej funkcjonalności w sposób dedykowany.
Jednak istnieje pewna metoda radzenia
sobie z jej brakiem.
Wykorzystuje się do tego celu potrójne cudzysłowy,
które jak już wiesz - tworzą łańcuchy
tekstowe i zezwalają na stosowanie przejść do
nowej linii. Jeśli taki tekst nie zostanie przypisany
do żadnej zmiennej, to nie będzie mieć
wpływu na rzeczywiste działanie programu.
W ten prosty sposób możesz tworzyć tekst, który
będzie wyraźnie widoczny w kodzie źródłowym,
natomiast zostanie praktycznie zignorowany
przez interpreter.
Struktura programu
Jeśli bacznie obserwujesz dotychczas przedstawione
kody źródłowe, prawdopodobnie już zauważyłeś
pierwszą różnicę strukturalną w stosunku do
kilku innych popularnych języków programowania.
Polecenia nie kończą się znakiem średnika - do ich
rozróżnienia wystarczy przejście do nowej linii.
Python w dużej mierze operuje na układzie
programu i jego strukturze wizualnej. To jedna
z pierwszych dużych zmian, które rzucają się
w oczy osobom przyzwyczajonym do języków
wywodzących się z Algola.
Jeszcze większą rewolucją będzie dla ciebie
sposób konstrukcji bloków poleceń, takich jak pętle
czy funkcje. W Pythonie do ich wyodrębniania nie
stosuje się nawiasów klamrowych. Nie ma też słów
kluczowych wyodrębniających bloki (np. \"begin\"
i \"end\"). Zamiast tego bloki definiowane są przez
same tylko wcięcia tekstu (tabulacje lub spacje).
Nie ma reguły dotyczącej tego, w jaki sposób wcięcia
są reprezentowane, ale ważna jest konsekwencja.
Jeśli zastosujesz trzy spacje, to trzymaj się tej
konwencji w całym bloku wyrażeń.
Oto przykład:
suma = 0
for x in range(10):
suma = suma + x
print x
print \"Suma: \" + str(suma)
W wyniku otrzymamy kolejno wyświetlone
cyfry od 0 do 9. Po zakończeniu przebiegu pętli zostanie
wyświetlona suma. Do omówienia samych
pętli, jak i użytych poleceń, jeszcze wrócimy.
Chociaż używanie wcięć do wyznaczania bloków
w Pythonie może się wydawać nieco dziwne,
a wcześniejsze nawyki mogą początkowo nieco
przeszkadzać w tworzeniu programów, to jednak
takie podejście ma pewne zalety.
Przede wszystkim uczy porządku. Języki
opierające się na Algolu, w tym m.in. C/C++, Java
czy PHP nie zwracają uwagi na tzw. \"białe znaki\"
(spacje, tabulatory, znaki przejścia do nowej linii)
w kodzie programu. Wyjątkiem są tu oczywiście
użycia na przykład w łańcuchach.
W praktyce pozwala to programiście tworzyć
bardzo nieprzejrzysty kod, co wiele osób chętnie
czyni. Istnieje zresztą wiele, czasem sprzecznych,
szkół stylu programowania - każda z nich narzuca
własny sposób formatowania kodu. Twórcy Pythona
postanowili to uporządkować. Styl jest jeden,
wszyscy programiści formatują kod w podobny
sposób. Nie ma też problemów związanych z tym,
że w wyniku nieczytelnego sformatowania programista
zapoznający się z kodem odczytał go inaczej,
niż będzie on widoczny dla interpretera.
Do stylu tworzenia programów w Pythonie
należy się przyzwyczaić, jednak przychodzi to
w sposób dość łatwy i naturalny.
Instrukcje warunkowe
Podobnie jak i w innych językach programowania,
rozgałęzień programu dokonujemy za pomocą
instrukcji if. Oto jej konstrukcja:
a = 2
b = 10
if a < b:
print \"%i jest mniejsze od %i\" % (a, b)
else:
print \"%i nie jest mniejsze od %i\" % (a, b)
Pamiętaj o tym, że bloki tekstu wyodrębniamy
z głównego programu, stosując wcięcia.
W powyższym przykładzie wykonujemy jedno
tylko polecenie dla każdego rozgałęzienia, a więc
zastosowanie bloku tekstu nie jest tutaj konieczne.
Zamiast tego, polecenie mógłbyś wpisać po dwukropku
następującym po zakończeniu warunku,
bez przechodzenia do nowej linii.
Taki układ wykorzystany zostanie w kolejnym
przykładzie, gdzie dodatkowo znajdzie się słowo
kluczowe elif, służące do tworzenia warunków
alternatywnych.
a = 2
b = 10
if a < b: print \"%i jest mniejsze od %i\" % (a, b)
elif a == b: print \"%i jest rowne %i\" % (a, b)
else: print \"%i jest wieksze od %i\" % (a, b)
Jak zauważyłeś już wcześniej, wyrażenia logiczne
w Pythonie zwracają wartość typu logicznego
\"boolean\" (zwracający True lub False). W obecnych
wersjach Pythona istnieje typ wbudowany
boo lean, wcześniej jednak (przed wersją 2.2.1)
wartości te były reprezentowane odpowiednio
przez 1 oraz 0. Pewnym następstwem tego faktu
jest zachowanie matematycznych właściwości typu
boolean w wyrażeniach arytmetycznych.
>>> print (10 > 8) * 3
3
Z zaszłości historycznych wynika jeszcze
jeden fakt. Warto wiedzieć, że Python nie jest tak
rygorystyczny jak Java w zakresie akceptowania
w instrukcjach warunkowych jedynie wartości typu
boolean N. Jako logiczny fałsz odczytywane są
następujące sytuacje:
- Wyrażenia i wartości typu False
- Wartość liczbowa równa 0.
- Pusty łańcuch znaków.
- Pusta lista, krotka i słownik (o tych typach
dowiesz się w dalszej części artykułu). - Obiekty, w których zaimplementowano metodę {stala}__nonzero__{/stala} i zwraca ona fałsz.
- Symbol None (będący specjalnym pustym obiektem i stanowiący pewien odpowiednik pod względem użytkowym słów kluczowych NULL i NIL w innych językach programowania).
Wszystko inne jest traktowane jako logiczna
prawda.
Niestety Python nie ma instrukcji switch.
Sytuacje typowe dla tej instrukcji wyboru należy
implementować w postaci złożonych instrukcji
warunkowych if/elif/else.
Listy
Python ma kilka typów przeznaczonych do zbierania
wielu różnych danych. Są to listy, słowniki
oraz krotki.
Listy są w zasadzie odpowiednikami tablic
z innych języków programowania. Możesz
w nich przechowywać dane w sposób ponumerowany.
Symbolizowane są przez nawiasy kwadratowe
[]. Python nie narzuca typów danych,
które będziesz przechowywać wewnątrz list.
Mogą to być więc nawet przemiennie - łańcuchy,
liczby czy obiekty.
Oto w jaki sposób można stworzyć listę w Pythonie:
>>> lista = [\"Tekst1\", 12, 3.5, \"Tekst2\", True]
>>> print lista
[\'Tekst1\', 12, 3.5, \'Tekst2\', True]
>>> print lista[0]
Tekst1
>>> print lista[2]
3.5
W pierwszym kroku stworzyliśmy listę i zapisaliśmy
ją w zmiennej o nazwie lista. Następnie
wyświetliliśmy jej zawartość w całości, a później
dokonaliśmy wyboru i wyświetlenia poszczególnych
jej elementów. Jak widzisz, obsługa list na
tym etapie do złudzenia przypomina obsługę tablic
w innych językach programowania.
Co ciekawe, do elementów listy można dostać
się również indeksami ujemnymi - będą one wówczas
wyszukiwane od końca:
>>> print lista[-1]
True
Możesz również odnieść się do fragmentów listy,
na przykład do elementów od 1 do 3 włącznie.
>>> lista2 = lista[1:4]
>>> print lista2
[12, 3.5, \'Tekst2\']
Przy podaniu zakresu z prawej strony została
podana liczba 4, ponieważ Python przy określaniu
zakresu stosuje zbiór lewostronnie domknięty,
natomiast prawostronnie - otwarty (nie dołącza
ostatniego wskazanego indeksu).
Jak już wiesz, wszystko w Pythonie jest
obiektem. Również listy. Co więcej, posiadają one
cały zestaw metod do swojej obsługi. Oto kilka
przykładów:
>>> lista2.append(8)
>>> lista2.insert(1, \"Test\")
>>> print lista2
[12, \'Test\', 3.5, \'Tekst2\', 8]
Metoda {stala}append(){/stala} dołącza element do końca
listy, natomiast metoda {stala}insert(){/stala} wstawia element
we wskazanym indeksem miejscu.
>>> len(lista2)
5
>>> lista2.extend(lista)
>>> print(lista2)
[12, \'Test\', 3.5, \'Tekst2\', 8, \'Tekst1\',12, 3.5, \'Tekst2\', True]
Metoda {stala}len(){/stala} zwraca aktualną liczbę elementów,
natomiast dzięki {stala}extend(){/stala} możesz dołączyć
inną listę. Usuwanie elementów z listy następuje
poprzez metodę {stala}remove(){/stala}, która pozwala na usunięcie
wskazanego w parametrze elementu z listy,
natomiast {stala}pop(){/stala} usuwa i zwraca ostatni element.
>>> lista2.remove(\"Tekst2\")
>>> print lista2.pop()
True
>>> print lista2
[12, \'Test\', 3.5, 8, \'Tekst1\', 12, 3.5,\'Tekst2\']
Jak zauważyłeś, usunięte zostało jedynie
pierwsze wystąpienie łańcucha \"Tekst2\". Do
usunięcia kolejnego należałoby ponownie wywołać
wskazaną metodę.
Bardzo przydatną rzeczą są zaimplementowane
mechanizmy wyszukiwania informacji w listach.
Możesz bardzo łatwo sprawdzić, czy w zbiorze
znajduje się określony element oraz zwrócić jego
indeks.
>>> if \"Tekst1\" in lista2: print lista2.
index(\"Tekst1\")
4
Musisz uważać na metodę {stala}index(){/stala}. Jeżeli nie
znajdzie ona podanego elementu, to zwrócony
zostanie wyjątek. Więcej o wyjątkach dowiesz się
pod koniec artykułu. Ponadto listy mdają jeszcze
wiele innych przydatnych metod, które nie zostały
tutaj opisane.
Deklarowanie funkcji
W Pythonie nie jest stosowane deklarowanie
nagłówka i definiowanie ciała funkcji w sposób
odrębny. Funkcję deklarujesz w miejscu, w którym
definiujesz jej ciało, poprzez użycie słowa kluczowego
def.
Ponadto Python nie rozróżnia funkcji i procedur.
Nie wymaga także deklarowania zwracanego
typu. Typ ten jest w pełni dynamiczny i zależy od
wartości, którą programista zwróci poprzez słowo
kluczowe return. Jeśli interpreter wykonując kod
funkcji nie napotka instrukcji return lub wystąpi
ona bez podania wartości lub wyrażenia, zwrócony
zostanie typ None.
Oto przykład funkcji:
def podzielna(a, b):
if (a % b) == 0: return True
return False
Wywołanie następuje dość standardowo:
print podzielna(5, 2)
print podzielna(10, 2)
print podzielna(15, 5)
Otrzymamy wyniki kolejno: False, True, True.
Ciekawą kwestią, o której warto wspomnieć,
jest automatyczne wspieranie przez Pythona tworzenia
tekstów dokumentujących. Jeśli na samym
początku ciała funkcji umieścisz łańcuch tekstowy,
bez przypisywania go do zmiennej, zostanie on
potraktowany właśnie jako tekst dokumentujący.
Jest to specjalna własność funkcji, metod i klas.
Istnieją rozszerzenia Pythona, które wyciągają tekst
dokumentujący z kodu źródłowego i tworzą dokument
- prostą dokumentację, ułatwiającą analizę
programu. Wszystko to dzieje się automatycznie.
Przykład zastosowania tekstu dokumentującego:
def parzysta(a):
\"\"\"Funkcja sprawdza czy liczba a jest parzysta.
Parametr: a
Zwracana wartosc: True / False\"\"\"
return podzielna(a, 2)
Pamiętaj, że każda funkcja ma własny, w pełni
niezależny zakres działania zmiennych. Zmienne
deklarowane wewnątrz funkcji nie będą widoczne
na zewnątrz. Natomiast zmienne deklarowane na
zewnątrz funkcji działają w obrębie zakresu wyższego
poziomu (globalnego) i mogą być widoczne
w środku po użyciu słowa kluczowego global.
Oto przykłady:
a = 5
def funkcja():
a = 3
return a
def funkcja2():
global a
return a
print funkcja()
print funkcja2()
Otrzymamy kolejno wyniki 3 oraz 5.
Wszystko jest obiektem
Python należy do grona tych języków programowania,
w których wszystko jest obiektem.
Dotychczas używaliśmy określenia zmiennych
w kontekście podobnym do użycia w wielu innych
językach programowania. Ściślej jednak zmienna nie jest strukturą samą w sobie, a jedynie reprezentacją
odpowiedniego obiektu. Jest to sytuacja
podobna do znanej chociażby z Javy.
Co ważne, klasy odpowiadające typom wbudowanym
(dostarczonym bezpośrednio w ramach
interpretera) możesz dziedziczyć we własnych
programach i rozbudowywać. Jeśli wszystko
jest obiektem, to obiektem w szczególności są
również funkcje. Niesie to z sobą wiele ciekawych
możliwości. Dowiedziałeś się już, jak tworzyć
tekst dokumentujący dla danej funkcji oraz że jest
on zapamiętywany dla potrzeb specjalnych. Czy
wiesz, że z poziomu własnego programu możesz
się dostać do tego tekstu?
print parzysta.__doc__
Jeśli wcześniej zdefiniowałeś funkcję {stala}parzysta(){/stala},
zgodnie z przykładem podanym powyżej, to interpreter
powinien wyświetlić zawartość wprowadzonego
tekstu dokumentującego. Jak widać, mamy
do czynienia z w pełni funkcjonalnym obiektem,
który posiada atrybut {stala}__doc__{/stala}. Atrybutów
specjalnych jest więcej, ale nie będziemy ich w tym
miejscu wszystkich opisywać.
