Załóżmy, że aplikacja zainstalowana jest w katalogu /usr/local/www/aplikacja/ i nasłuchiwać będzie na porcie 8080, a serwer na standardowym porcie 80. Wtedy do pliku /usr/local/etc/nginx/nginx.conf w sekcji http wpisujemy:

server {
    listen 80;
    server_name localhost;

    location /media {
        root /usr/local/www/aplikacja/;
    }

    location / {
        fastcgi_pass 127.0.0.1:8080;
        fastcgi_param SERVER_ADDR $server_addr;
        fastcgi_param SERVER_NAME $server_name;
        fastcgi_param SERVER_PORT $server_port;
        fastcgi_param SERVER_PROTOCOL $server_protocol;
        fastcgi_param PATH_INFO $fastcgi_script_name;
        fastcgi_param REQUEST_METHOD $request_method;
        fastcgi_param CONTENT_TYPE $content_type;
        fastcgi_param CONTENT_LENGTH $content_length;
    }
}

Teraz wystarczy zrestartować Nginx i uruchomić aplikację:

python manage.py runfcgi host=127.0.0.1 port=8080 --settings=settings

I to wszystko. Chyba zmieściliśmy się w pięciu minutach.

Pakiety wykorzystane w instalacji

• Python 2.7.2
• Django 1.2.7
• Psycopg2 2.4.2
• PostgreSQL 9.0.4
• Apache 2.2.20
• mod_wsgi-3.3

Opis instalacji

Przed przystąpieniem do instalacji musimy wiedzieć, że Apache Software Foundation nie dostarcza 64 bitowych binarek swojego serwera. Jeśli chcemy mieć wersję 64 bitową musimy sobie ją sami skompilować bądź znaleźć w sieci gotowe, nieoficjalne 64 bitowe binaria. Jeśli zainstalujemy oficjalną, 32 bitową wersję serwera, Python oraz psycopg2 również muszą być 32 bitowe.

Po zainstalowaniu pakietów Python, Django i psycopg2 instalujemy PostgreSQL, po czym uruchamiamy pgAdmin i zakładamy bazę danych dla wdrażanej aplikacji Django, a następnie w katalogu wspomnianej aplikacji wstukujemy polecenie:

python manage.py syncdb

Jeżeli okaże się, że system nie widzi polecenia python należy do zmiennej środowiskowej PATH dopisać katalog z zainstalowanym Pythonem. W naszym przypadku jest to C:\Python27. Jeśli poprzednie polecenie wykonało się prawidłowo możemy sprawdzić działanie naszej aplikacji uruchamiając ją przy pomocy testowego serwera WWW:

python manage.py runserver

Aplikacja powinna działać pod adresem http://127.0.0.1:8008/. Jeśli wszystko jest w porządku wyłączamy serwer testowy i przechodzimy do instalacji serwera Apache. W trakcie instalacji instalator zapyta nas o nazwę serwera, domenę i email administratora. Wystarczy podać localhost w przypadku serwera i domeny oraz root@localhost w przypadku adresu email.

Po zainstalowaniu serwera Apache należy przekopiować moduł mod_wsgi-win32-ap22py27-3.3.so do odpowiedniej lokalizacji. W naszym przypadku jest to:

C:\Program Files\Apache Software Foundation\Apache2.2\modules

i zmienić nazwę na mod_wsgi.

W tym momencie mamy wszystko przygotowane do uruchomienia aplikacji przez serwer Apache. Teraz musimy stworzyć plik django.wsgi i umieścić go w naszej aplikacji oraz odpowiednio zmodyfikowac plik konfiguracyjny serwera Apache httpd.conf. Załóżmy, że nasza aplikacja znajduje się w katalogu:

C:\Projekty\mojprojekt\

Umieszczamy w tym katalogu plik django.wsgi o treści:

import os, sys

sys.path.append('C:\\Projekty')
sys.path.append('C:\\Projekty\\mojprojekt')
os.environ['DJANGO_SETTINGS_MODULE'] = 'mojprojekt.settings'

import django.core.handlers.wsgi
application = django.core.handlers.wsgi.WSGIHandler()

Następnie modyfikujemy plik httpd.conf znajdujący się, w naszym przypadku, w katalogu:

C:\Program Files\Apache Software Foundation\Apache2.2\conf

dopisując do niego:

LoadModule wsgi_module modules/mod_wsgi.so

Alias /media/ "C:/Projekty/mojprojekt/media/"

<Directory C:/Projekty/mojprojekt>
  Order deny,allow
  Allow from all
</Directory>

WSGIScriptAlias / "C:/Projekty/mojprojekt/django.wsgi"

Jeśli wszystko zrobiliśmy dobrze możemy zrestartować serwer Apache i cieszyć się działającą aplikacją Django. Ponieważ PostgreSQL i Apache instalują się jako usługi, po restarcie komputera użytkownik nie musi wykonywać żadnych dodatkowych czynności – wystarczy, że wpisze w swojej przeglądarce adres http://127.0.0.1 i może korzystać z aplikacji.

Jeśli kolor elementu o identyfikatorze id_elem chcemy zmienić na czerwony wystarczy w kodzie HTML wpisać:

<script type="text/javascript">
   var e = document.getElementById("id_elem");
   e.style.color = "red";
</script>

Zmianę koloru elementów p na czerwony w klasie klasa możemy przeprowadzić w taki sposób:

<script type="text/javascript">
   var e = document.getElementsByTagName("p");
   for (var i=0; i<e.length; i++) {
      if (e[i].className.indexOf("klasa") != -1) {
         e[i].style.color = "red";
      }
   }
</script>

SAX jest strumieniowym interfejsem odczytywania danych z dokumentów XML opartym na zdarzeniach. Zdarzenia wywoływane są dwukrotnie (na początku i na końcu) podczas napotkania któregokolwiek z elementów dokumentu XML. Wystąpienie zdarzenia powoduje wywołanie metody zdefiniowanej przez programistę. Dokument XML jest przetwarzany jednorazowo od początku do końca dokumentu. Takie podejście powoduje, że SAX sprawdza się dobrze przy przetwarzaniu dużych dokumentów nie obciążając mocno pamięci. Obsługa interfejsu SAX realizowana jest w Pythonie przez moduł xml.sax.

DOM przedstawia dokument w postaci hierarchicznej struktury podobnej do drzewa. Elementy XML w modelu DOM nazywane są węzłami. Na szczycie drzewa mamy węzeł korzeń, który zawiera pozostałe węzły elementów XML. Teksty w elementach są węzłami tekstów, a atrybuty węzłami atrybutów. Również komentarze w dokumencie są węzłami komentarzy. Pomiędzy węzłami istnieje związek hierarchiczny oznaczający, że każdy węzeł (oprócz korzenia) ma dokładnie jednego rodzica i może mieć dowolną liczbę dzieci. Węzły z tymi samymi rodzicami nazywane są rodzeństwem, natomiast węzeł bez dzieci nazywany jest liściem.

Interfejs DOM zanim rozpocznie przetwarzanie dokumentu XML ładuje go do pamięci, dlatego zalecany jest do przetwarzania niewielkich dokumentów ze względu na obciążenie pamięci. W porównaniu do SAX uznawany jest za wolniejszy, ale za to łatwiejszy w obsłudze.

Poniżej przykład jak utworzyć dokument XML przy użyciu interfejsu DOM:

# -*- coding: utf-8 -*-
from xml.dom import minidom

# Utworzenie obiektu DOM
DOMimpl = minidom.getDOMImplementation()

# Utworzenie dokumentu
xmldoc = DOMimpl.createDocument(None, "kontakty", None)
kontakty = xmldoc.documentElement

# Dodanie kontaktu
kontakt = xmldoc.createElement("kontakt")
kontakt_atr = xmldoc.createAttribute("nick")
kontakt_atr.nodeValue = "janek"
kontakt.setAttributeNode(kontakt_atr)

imie = xmldoc.createElement("imie")
imie.appendChild(xmldoc.createTextNode("Jan"))
kontakt.appendChild(imie)

nazwisko = xmldoc.createElement("nazwisko")
nazwisko.appendChild(xmldoc.createTextNode("Kowalski"))
kontakt.appendChild(nazwisko)

telefon = xmldoc.createElement("telefon")
telefon.appendChild(xmldoc.createTextNode("123 456 789"))
kontakt.appendChild(telefon)

kontakty.appendChild(kontakt)

# Zapisanie dokumentu
plik = open("kontakty.xml", "wb")
plik.write(xmldoc.toxml("utf-8"))
plik.close()

Przykład w jaki sposób przy pomocy DOM dostać się do danych z pliku utworzonego w poprzednim przykładzie:

# -*- coding: utf-8 -*-
from xml.dom import minidom

xmldoc = minidom.parse("kontakty.xml")
kontakty = xmldoc.getElementsByTagName("kontakt")

for kontakt in kontakty:
    nick = kontakt.getAttribute("nick")

    imie = kontakt.getElementsByTagName("imie")[0]
    imie = imie.firstChild.nodeValue

    nazwisko = kontakt.getElementsByTagName("nazwisko")[0]
    nazwisko = nazwisko.firstChild.nodeValue

    telefon = kontakt.getElementsByTagName("telefon")[0]
    telefon = telefon.firstChild.nodeValue

    print "Kontakt: %s" % nick
    print "   Imie:     %s" % imie
    print "   Nazwisko: %s" % nazwisko
    print "   Telefon:  %s" % telefon

A oto wynik:

Kontakt: janek
   Imie:     Jan
   Nazwisko: Kowalski
   Telefon:  123 456 789

Dla najnowszej, stabilnej wersji 0.12.2 wtyczkę obsługującą Mercurial ściągniemy z repozytorium:

svn co http://svn.edgewall.com/repos/trac/plugins/0.12/mercurial-plugin

Instalacja wtyczki polega na stworzeniu egg:

cd mercurial-plugin
python setup.py bdist_egg

a następnie zainstalowaniu go globalnie:

easy_install dist/TracMercurial-0.12.0.[x]-py2.[x].egg

lub lokalnie w katalogu plugins utworzonego wcześniej środowiska projektu:

cp dist/TracMercurial-0.12.0.[x]-py2.[x].egg /sciezka/do/srodowiska/projektu/plugins

Domyślnie wtyczka obsługuje repozytoria z plikami w formacie latin-1. Jeśli mamy pliki w formacie latin-2 lub utf-8, przed stworzeniem egg musimy w pliku mercurial-plugin/tracext/hg/backend.py znaleźć i zmienić zmienną środowiskową HGENCODING na właściwe kodowanie:

os.environ['HGENCODING'] = 'utf-8'

Po zalogowaniu się na shell wystarczy wydać polecenie:

pkg_add -r py26-django

Jeśli wystąpią problemy z pobieraniem pakietu z serwera należy zmienić wartość zmiennej PACKAGESITE:

setenv PACKAGESITE ftp://ftp.freebsd.org/pub/FreeBSD/ports/i386/packages-7-stable/Latest/

i ponownie spróbować zainstalować pakiet py26-django wraz z zależnościami. Powinniśmy otrzymać:

• python26-2.6.6
• libiconv-1.13.1_1
• gettext-0.18.1.1
• py26-django-1.2.4

Aby Django mógł współpracować z Nginx należy wykonać:

pkg_add -r py26-flup

a następnie zainstalować serwer WWW:

pkg_add -r nginx

W efekcie czego będziemy mieli zainstalowane:

• py26-setuptools-0.6c11
• py26-flup-1.0.2
• pcre-8.12
• nginx-0.8.54

Jeśli w swoim projekcie będziemy korzystać z bazy danych PostgreSQL należy zainstalować psycopg2:

pkg_add -r py26-psycopg2

Zainstalowany pakiet py26-psycopg2-2.3.2 jest zależny od pakietu postgresql-client-8.4.6, który wykorzystuje bibliotekę libgssapi_krb5.so.9. Bibliotekę libgssapi_krb5.so.9 znajdziemy w pakiecie compat7x-i386 należącym do FreeBSD w wersji 8:

setenv PACKAGESITE ftp://ftp.freebsd.org/pub/FreeBSD/ports/i386/packages-8-stable/Latest/
pkg_add -r compat7x-i386

I to wszystko. Po skonfigurowaniu serwera Nginx możemy hostować projekty Django.

Aby utworzyć pytanie otwarte wystarczy w zakładce Questions utworzyć nowe pytanie z typem None, a następnie w okienku Options dodać pustą opcję i w okienku Edit option ustawić Freetext na Yes. Wielkość okienka dla pytań otwartych możemy zmienić przy pomocy parametrów Cols i Rows.

Strona ta nie traktuje o włamywaniu się do systemów komputerowych innych ludzi. Mnie to nie interesuje, więc nie wysyłaj do mnie wiadomości na ten temat.

Uwaga: Aby zamieszczone przykłady działały poprawnie pisz je do pliku tekstowego a następnie uruchamiaj interpreterem. Nie próbuj uruchamiać programów w trybie interaktywnym – nie wszystkie będą działać. (Nie pytaj mnie dlaczego. Sprawdź dokumentację lub wyślij email pod adres help@python.org).

Środowisko

Aby móc programować w Pythonie musisz mieć zainstalowany interpreter. Jest on dostępny na wielu platformach (włącznie z Macintoshem, Uniksem i Windows). Więcej informacji na ten temat znajdziesz na stronie Pythona. Powinieneś również mieć edytor tekstowy (np. emacs, notepad lub podobny).

Czym jest programowanie?

Programowanie komputera oznacza przekazywanie mu zestawu instrukcji mówiących co powinien zrobić. Program komputerowy bardzo przypomina przepis na ciasto. Przykład [1]:

Sernik na kruchym cieście
    Składniki:
    Ciasto:
    30 dag (1 1/2 szklanki) mąki
    13 dag margaryny
    5 dag (3 łyżki) cukru
    4 żółtka

    Masa serowa:
    50 dag sera twarogowego tłustego
    20 dag (niepełna szklanka) cukru
    13 dag margaryny
    4-5 jaj
    2 dag (1 łyżka) kaszy manny
    cukier waniliowy lub esencja zapachowa

    Sposób przyrządzenia:
    Margarynę posiekać nożem z mąką, a następnie połączyć z żółtkami i cukrem.
    Ciasto szybko wyrobić ręką i schłodzić w lodówce (co najmniej 30 min).
    Schłodzone ciasto rozwałkować na grubość 1/2 cm i przenieść wałkiem na blachę.
    Ciasto lekko podpiec w gorącym piekarniku (15-20 min).
    Przyrządzić masę serową: ser przepuścić przez maszynkę. Margarynę utrzeć z cukrem,
    żółtkami, kaszą manną i stopniowo dodawanym serem. Ubić sztywną pianę z białek i
    delikatnie połączyć z masą serową. Masę wyłożyć na podpieczony spód i
    piec 30-40 min w umiarkowanie gorącym piekarniku.

Oczywiście, żaden komputer tego nie zrozumie, a większość komputerów nie byłaby zdolna do zrobienia sernika nawet, jeśli zrozumiałyby ten przepis. Zatem, co musimy zrobić, aby przepis stał się bardziej zrozumiały dla komputera? Zasadniczo dwie rzeczy. Musimy (1) mówić w taki sposób, aby komputer nas zrozumiał, i (2) mówić o rzeczach, które jest on w stanie wykonać.

Pierwszy punkt oznacza, że musimy użyć języka – języka programowania zrozumiałego dla naszego interpretera, a drugi punkt oznacza, że nie możemy oczekiwać, aby komputer zrobił sernik – ale możemy oczekiwać, aby dodawał liczby i wypisywał teksty na ekranie.

Witaj…

Tradycją jest, aby w tutorialach o programowaniu zaczynać zawsze od programu wypisującego na ekranie „Witaj, świecie!”. W Pythonie jest to dość proste:

    print "Witaj, świecie!"

Zasadniczo program ten jest podobny do przedstawionego wcześniej przepisu na sernik (oczywiście jest on znacznie krótszy!). Program mówi komputerowi, co ma zrobić: wypisać na ekranie „Witaj, świecie!”. Łatwizna. A gdybyśmy chcieli, aby komputer wykonał coś więcej?

    print "Witaj, świecie!"
    print "Żegnaj, świecie!"

Niezbyt trudne i niezbyt interesujące. Chcielibyśmy zrobić coś ze składnikami, tak jak w przepisie na sernik. No dobrze. Jakie mamy składniki? Mamy ciągi znaków, jak „Witaj, świecie!”, ale również mamy liczby. Zlećmy, więc komputerowi, aby obliczył nam pole prostokąta. Musimy, więc dać mu przepis jak powinien to wykonać:

    # Pole prostokąta
    # Składniki:
    szerokosc = 20
    wysokosc = 30

    # Sposób przyrządzenia:
    pole = szerokosc*wysokosc
    print pole

Widzisz zapewne podobieństwo (choć niewielkie) do przepisu na sernik. Ale w jaki sposób działa ten program? Po pierwsze, linie rozpoczynające się # nazywane są komentarzem i są ignorowane przez komputer. Jednakże, użycie takich komentarzy może być ważne dla ludzi czytających twoje programy.

Linie takie jak foo = bar nazywane są przypisaniami. Poprzez wyrażenie szerokosc = 20 mówimy komputerowi, że szerokosc od tej chwili będzie równe 20. Co znaczy, że „szerokosc jest równe 20″? Znaczy to, że zostanie utworzona (bądź ponownie wykorzystana, jeśli już istnieje) zmienna o nazwie „szerokosc” i zostanie jej nadana wartość 20. Zatem, jeśli później użyjemy tej zmiennej komputer będzie już znał jej wartość. Dlatego

    szerokosc*wysokosc

jest w zasadzie tym samym co

    20*30

które z kolei równe jest 600. Wartość ta następnie zostaje przypisana zmiennej „pole”. Ostatnie wyrażenie programu wypisuje na ekran wartość zmiennej „pole”, więc po uruchomieniu programu zobaczysz po prostu na ekranie

    600

Uwaga: W niektórych językach już na początku programu musisz powiedzieć komputerowi jakich zmiennych będziesz używał (jakich składników użyjesz do przygotowania sernika) – w Pythonie zmienne możesz wymyślać w trakcie pisania programu.

Komunikacja z komputerem

No dobrze. Możesz już przeprowadzać zarówno proste, jak i dość zaawansowane obliczenia. Możesz, na przykład, napisać program obliczający pole koła zamiast prostokąta:

    promien = 30
    print promien*promien*3.14

Jednak program ten, podobnie jak poprzedni, jest mało interesujący – przynajmniej moim zdaniem. Jest on mało elastyczny. No bo, co będzie jeśli interesujące nas koło ma promień 31 stopni? Czy komputer może o tym wiedzieć? Sytuacja przypomina trochę przepis na sernik: „Masę serową wyłożyć na podpieczony spód i piec 30-40 min. w umiarkowanie gorącym piekarniku.” Skąd możemy wiedzieć czy po 30 minutach sernik jest już upieczony? Musimy to sprawdzić. W jaki sposób komputer dowie się o promieniu naszego koła? Musi nas o to zapytać… My zaś musimy w programie powiedzieć mu, aby zapytał się o promień:

    promien = input("Jaki jest promień?")
    print promien*promien*3.14

input jest funkcją. (Niedługo nauczysz się tworzyć własne funkcje. input jest funkcją wbudowaną w język Python.) Zwykłe napisanie

    input

nie zrobi wiele… Musisz wstawić parę nawiasów na końcu słowa input. Zatem input() powinno zadziałać – po prostu funkcja będzie czekać, aż użytkownik wpisze promień. Nasza wersja input jest zapewnie bardziej przyjazna, gdyż wcześniej wypisuje na ekran pytanie. Gdy wpiszemy coś pomiędzy nawiasy funkcji, np. pytanie „Jaki jest promień?” wtedy przekazujemy parametry do funkcji. To co wpisujemy w nawiasy funkcji nazywane jest parametrami. W tym przypadku jako parametr do funkcji przekazujemy pytanie, dlatego input wie co wypisać na ekranie zanim otrzyma odpowiedź od użytkownika.

Ale w jaki sposób odpowiedź trafia do zmiennej promien? Funkcja input, kiedy zostanie wywołana, zwraca wartość (tak jak inne funkcje). Nie musisz wykorzystywać tej wartości, jednak w naszym przypadku chcemy z niej skorzystać. Zatem poniższe dwa wyrażenia mają całkiem różne znaczenie:

    foo = input
    bar = input()

foo zawiera funkcję input dosłownie ją samą (zatem możesz użyć takiego wyrażenia foo("Ile masz lat?"); takie zjawisko nazywane jest dynamicznym wywołaniem funkcji), podczas gdy bar zawiera to, co wpisze użytkownik jako odpowiedź.

Sterowanie

Możemy już pisać programy wykonujące proste działania (arytmetyczne i drukujące) jak również pobierające dane od użytkownika. Jest to użyteczne, jednak nadal jesteśmy ograniczeni tzw. sekwencyjnym wykonywaniem programu – rozkazy w programie wykonywane są w ustalonym porządku. Przepisy na ciasta są pisane właśnie w takim sekwencyjnym lub liniowym porządku. A gdybyśmy chcieli powiedzieć komputerowi w jaki sposób powinien sprawdzić, czy sernik jest już upieczony? Jeśli jest, powinien go wyciągnąć z piekarnika, w przeciwnym razie powinien go pozostawić w piekarniku na kolejne pięć minut. W jaki sposób to zrobimy?

To czego potrzebujemy nazywa się sterowanie programem. Program może wykonać dwa działania – albo wyciągnąć sernik z piekarnika, albo pozostawić go. Możemy wybierać, a warunkiem jest, czy sernik jest już upieczony, czy nie. Technika ta nazywana jest warunkowym wykonaniem programu. Program może wyglądać tak:

    temperatura = input("Jaka jest temperatura sernika?")

    if temperatura == 30:
        print "Sernik jest już upieczony."
    else:
        print "Musisz troszkę poczekać na sernik."

Znaczenie programu powinno być oczywiste: Jeśli temperatura jest wyższa niż 30st.C, wówczas wypisz komunikat mówiący użytkownikowi, że sernik jest już upieczony, w przeciwnym razie powiedz użytkownikowi, że musi jeszcze troszkę poczekać.

Uwaga: Wcięcia w języku Python są ważne. Bloki w wykonaniu warunkowym (i pętle oraz definicje funkcji – patrz niżej) muszą mieć wcięcia (wcięcia z tą samą liczbą białych znaków; jeden <tab> liczy się jako 8 spacji) aby interpreter wiedział, w którym miejscu rozpoczynają się, a w którym kończą. Wcięcią również czynią program bardziej czytelny dla ludzi.

Wróćmy do naszych obliczeń pola. Czy widzisz, co ten program robi?

    # Program obliczający pole
    print "Witamy w programie obliczającym pole"
    print "------------------------------------"
    print

    # Wydrukuj menu:
    print "Wybierz figurę:"
    print "1  Prostokąt"
    print "2  Koło"

    # Czekaj na wybór użytkownika:
    figura = input("> ")

    # Oblicz pole:
    if figura == 1:
        wysokosc = input("Wpisz wysokość: ")
        szerokosc = input("Wpisz szerokość: ")
        pole = wysokosc*szerokosc
        print "Pole wynosi", pole
    else:
        promien = input("Wpisz promien: ")
        pole = 3.14*(promien**2)
        print "Pole wynosi", pole

Nowe rzeczy w tym przykładzie…

1. print użyte samo drukuje pustą linię
2. == sprawdza, czy dwie rzeczy są równe, w przeciwieństwie do =, które przypisuje wartość z prawej strony do zmiennej po lewej stronie. Jest to ważna różnica!
3. ** jest pythonowskim operatorem potęgowania – dlatego promień podniesiony do kwadratu jest zapisany jako promien**2
4. print może wydrukować więcej niż jedną rzecz. Po prostu oddziel te rzeczy przecinkami. (Na ekranie będą one oddzielone pojedynczą spacją.)

Program ten jest dosyć prosty – pyta o liczbę, która mówi mu, czy użytkownik chce obliczyć pole prostokąta, czy koła. Następnie, korzysta z wyrażenia if (wykonanie warunkowe), aby zdecydować, który blok wykorzystać do obliczenia pola. W zasadzie te dwa bloki są takie same jak te, które używaliśmy w poprzednich przykładach. Zauważ, że komentarze czynią kod bardziej czytelnym. Można powiedzieć, że pierwszym przykazaniem programowania jest „Będziesz pisał komentarze!”. W każdym
bądź razie – jest to pożądany nawyk.

Ćwiczenie 1
Rozszerz program o opcję obliczania pola kwadratów, tak aby użytkownik podawał długość jednego boku. Jest jedna rzecz, którą musisz wiedzieć, aby wykonać to ćwiczenie – jeśli masz więcej niż dwie możliwości wyboru, możesz zapisać to w taki sposób:

    if foo == 1:
        # Zrób coś...
    elif foo == 2:
        # Zrób coś innego...
    elif foo == 3:
        # Zrób coś zupełnie różnego...
    else:
        # Jeśli żaden z warunków nie został spełniony...

elif jest tajemniczym kodem, który oznacza „else if” . Zatem, jeśli foo równa się jeden, zrób coś; w przeciwnym razie, jeśli foo równa się dwa, zrób coś innego, itd. Możesz dodać do programu również inne opcje – jak trójkąty lub wielokąty. Wszystko zależy od ciebie.

Pętle

Sekwencyjne i warunkowe wykonania są tylko dwoma z trzech fundamentalnych elementów budujących program. Trzecim jest pętla. Proponowałem wcześniej rozwiązanie sprawdzające, czy sernik upiekł się. Jednak nie było ono dosyć wystarczające. No bo, jeśli sernik nie będzie gotowy, to jak następnym razem sprawdzimy czy już się upiekł. Skąd będziemy wiedzieć ile razy musimy to sprawdzać? Prawda jest taka, że nie będziemy wiedzieć. Powinniśmy móc zlecić komputerowi, aby sprawdzał sernik do czasu, aż będzie on upieczony. W jaki sposób to zrobić? Zgadłeś – użyjemy pętli, lub wykonania powtarzanego.

Python ma dwa rodzaje pętli: pętle while i pętle for. Pętle for są chyba najprostsze. Na przykład:

    for jedzenie in "ciasto", "jajka", "pomidory":
        print "Kocham", jedzenie

Co oznacza: dla każdego elementu w liście "ciasto", "jajka", "pomidory" wypisz tekst, że go kochasz. Block wewnątrz pętli jest wykonywany raz dla każdego elementu, i za każdym razem, bieżący element jest podstawiany do zmiennej jedzenie (w tym przypadku). Inny przykład:

    for liczba in range(1,100):
        print "Witaj, świecie!"
        print "Tylko", 100 - liczba, "pozostało..."

    print "Witaj, świecie"
    print "To był ostatni... Fju!"

Funkcja range zwraca listę liczb w podanym przedziale (włącznie z pierwszą, bez ostatniej… W tym przypadku, [1..99]). Zatem, parafrazując:

Zawartość pętli jest wykonywana dla (for) każdej liczby w (in) przedziale (range) od (włącznie) 1 do (bez) 100. (Wyjaśnienie tego, co robi ciało pętli i następne wyrażenia pozostawiam jako ćwiczenie dla ciebie.)

Jednak to nam nie rozwiązuje naszego problemu z pieczeniem. Jeśli chcemy sprawdzić sernik sto razy, wtedy to rozwiązanie byłoby na miejscu, ale my nie wiemy czy sto razy wystarczy, czy może będzie to za dużo. Po prostu chcemy sprawdzać sernik, kiedy nie jest on wystarczająco gorący (lub do czasu, kiedy stanie się wystarczająco gorący). Dlatego użyjemy while:

    # Program pieczenia sernika

    # Pobierz funkcję sleep
    from time import sleep

    print "Rozpocznij pieczenie sernika. (Wrócę za 3 minuty.)"

    # Czekaj 3 minuty (3*60 sekund)...
    sleep(180)

    print "Wróciłeeem..."

    # Jak gorący jest sernik?
    wystarczajaco_goracy = 30

    temperatura = input("Jak gorący jest sernik? ")
    while temperatura < wystarczajaco_goracy:
        print "Niewystarczająco gorący... Piecz jeszcze chwilę..."
        sleep(30)
        temperatura = input("OK. Jak gorący jest teraz? ")

    print "Wystarczająco gorący - gotowe!"

Nowe rzeczy w tym przykładzie…

1. Niektóre użyteczne funkcje przechowywane są w modułach i mogą być importowane. W tym przykładzie importujemy funkcję sleep (która zasypia na podaną liczbę sekund) z modułu time dostarczanego razem z Pythonem. (Możliwe jest również tworzenie swoich własnych modułów…)

Ćwiczenie 2
Napisz program sumujący liczby podawane przez użytkownika, do momentu aż suma tych liczb osiągnie 100. Napisz inny program sumujący sto podanych przez użytkownika liczb i wypisujący ich sumę.

Większe programy – abstrakcja

Jeśli chcesz przejrzeć zawartość książki, nie kartkujesz wszystkich stron – zaglądasz tylko do spisu treści, prawda? Spis treści pokazuje główne tematy książki. Teraz wyobraź sobie pisanie książki kucharskiej. Wiele przepisów takich jak „Sernik na kruchym cieście” i „Sernik po wiedeńsku” może zawierać podobne rzeczy, tak jak twaróg w tym przypadku. Zapewne nie chciałbyś w każdym przepisie powtarzać jak należy robić twaróg. (Ok… Nie musisz robić żadnego twarogu… Jednak bądź dla mnie wyrozumiały dla dobra przykładu ). Pewnie umieściłbyś przepis na twaróg w oddzielnym rozdziale, i po prostu odsyłałbyś do niego w innych przepisach. Zatem, zamiast za każdym razem pisać ciągle cały przepis, wystarczy, że skorzystać z nazwy rozdziału, w którym przepis ten już się znajduje. W programowaniu nazywamy to
abstrakcją.

Czy już mieliśmy z czymś takim do czynienia? Tak. Zamiast dokładnie mówić komputerowi w jaki sposób powinien odebrać odpowiedź od użytkownika (OK – rzeczywiście nie umielibyśmy tego zrobić… Ale nie umielibyśmy również zrobić twarogu, zatem… ) po prostu skorzystaliśmy z funkcji input. Właściwie możemy również tworzyć nasze własne funkcje, aby wykorzystać je w tego rodzaju abstrakcji.

Powiedzmy, że chcemy znaleźć największą liczbę całkowitą, która jest mniejsza od podanej liczby dodatniej. Na przykład, dla liczby 2.7 byłoby to 2. Takie coś nazywane jest „floor” danej liczby. (Właściwie można by skorzystać z wbudowanej w Python funkcji int, ale znów, bądź wyrozumiały dla mnie…) W jaki sposób zrobilibyśmy to? Prostym rozwiązaniem byłoby sprawdzić wszystkie możliwości począwszy od zera:

    liczba = input("Jaka jest liczba? ")

    floor = 0
    while floor < liczba:
        floor = floor+1
    floor = floor-1

    print "Floor liczby", liczba, "wynosi", floor

Zauważ, że pętla kończy się, kiedy floor już nie jest mniejsze od liczba, a my dodajemy o jeden za dużo do niego. Dlatego później musimy odjąć to jeden. A jeśli chcemy wykorzystać „floor” w złożonym matematycznym wyrażeniu? Musielibyśmy pisać całą pętlę dla każdej liczby, która potrzebuje być „sfloorowana”. Niezbyt przyjemne… Zapewne zgadłeś, co zamiast tego zrobimy – umieścimy wszystko w naszej własnej funkcji, którą nazwiemy „floor”:

    def floor(liczba):
        wynik = 0
        while wynik < liczba:
            wynik = wynik+1
        wynik = wynik-1
        return wynik

Nowe rzeczy w tym przykładzie…

1. Funkcje definiujemy słowem kluczowym def, po czym podajemy nazwę funkcji i w nawiasach jej parametry.
2. Jeśli funkcja powinna zwracać wartość, wykorzystujemy do tego słowo kluczowe return, które również automatycznie kończy funkcję.

Jeśli mamy już zdefiniowaną funkcję, możemy ją wykorzystać w ten oto sposób:

    x = 2.7
    y = floor(2.7)

Po wykonaniu naszej funkcji y powinno zawierać wartość 2. Możliwe jest również definiowanie funkcji z więcej niż jednym parametrem:

    def suma(x,y):
        return x+y

Ćwiczenie 3
Napisz funkcję wykorzystującą metodę Euklidesa znajdującą wspólny czynnik dwóch liczb. Powinna ona działać w taki sposób:

1. Masz dwie liczby, a i b, gdzie a jest większe od b
2. Powtarzaj poniższe działania do momentu, aż b będzie równe zero:
   1. przypisz do a wartość b
   2. przypisz do b resztę z dzielenia a (przed zmianą) przez b (przed zmianą)
3. Zwróć ostatnią wartość a

Wskazówki:

• Użyj a i b jako parametrów do funkcji
• Załóż, że a jest większe od b
• Reszta z podziału x przez z jest obliczana wyrażeniem x % z
• Możesz jednocześnie dwóm zmiennym nadać wartość w taki oto sposób: x, y = y, y+1. W tym przypadku x otrzymuje wartość y (wartość przed przypisaniem y+1 do y), a następnie y jest zwiększane o jeden

Więcej o funkcjach

I co z ćwiczeniem? Trudne? Nadal funkcje onieśmielają cię? Nie martw się – tematu tego jeszcze nie zamknąłem.

Ten rodzaj abstrakcji, którą używaliśmy podczas tworzenia funkcji często nazywany jest abstrakcją proceduralną, w wielu językach obok słowa function używa się również słowa procedure. Właściwie oba pojęcia są różne, jednak w Pythonie oba nazywane
są funkcjami (ponieważ są one definiowane i używane mniej więcej w ten sam sposób.)

Jaka jest różnica (w innych językach) między funkcjami a procedurami? Jak zauważyłeś w pierwszej części rozważań o funkcjach, funkcje mogą zwracać wartość. Różnica leży w procedurach, które nie zwracają takiej wartości. W wielu przypadkach, taki podział funkcji na dwa typy – te, które zwracają i te, które nie zwracają wartości – może być użyteczny.

Funkcja, która nie zwraca wartości („procedura”) wykorzystywana jest jako „podprogram”. Wywołujemy taką funkcję, a program wykonuje pewne zadanie, takie jak ubijanie piany z białek lub cokolwiek.
Możemy użyć tę funkcję w wielu miejscach bez przepisywania kodu. (Technikę tę nazywamy ponownym wykorzystaniem kodu (code reuse) – więcej o tym później.)

Użyteczność takiej funkcji (lub procedury) leży w jej efektach ubocznych – funkcja zmienia swoje środowisko (poprzez na przykład mieszanie cukru z białkiem i ubijanie go). Spójrzmy na przykład:

    def czesc(kto):
        print "Cześć,", kto

    czesc("świat")
    # Wypisze "Cześć, świat"

Wypisanie tekstu jest uważane za efekt uboczny i ponieważ jest to wszystko, co ta funkcja wykonuje jest ona uważana za tzw. procedurę. Ale… W rzeczywistości nie zmieniła ona swojego środowiska, nieprawdaż? Jak może to zrobić? Spróbujmy:

    # *Błędnie*
    wiek = 0

    def ustawWiek(a):
        wiek = a

    ustawWiek(100)
    print wiek
    # Drukuje "0"

Co tu jest źle? Problemem jest funkcja ustawWiek, która tworzy swoją własną, lokalną zmienną, również nazwaną wiek, która to zmienna widziana jest tylko wewnątrz ustawWiek. Jak możemy to ominąć? Możemy użyć zmiennych globalnych.

Uwaga: Zmienne globalne rzadko są wykorzystywane w Pythonie. Prowadzą one do złej struktury kodu, lub do tzw. kodu spaghetti. Ja użyję je jako wprowadzenie do bardziej skomplikowanych technik – ty, jeśli możesz, unikaj takich zmiennych.

Poprzez poinformowanie interpretera, że zmienna jest globalna (poprzez wyrażenie global wiek) faktycznie mówimy mu, aby użył zmienną utworzoną na zewnątrz funkcji zamiast tworzyć nową, lokalną zmienną. (Zatem, zmienna globalna jest przeciwna do lokalnej.) Nasz nowy program może tak wyglądać:

    # *Prawidłowo*, ale niezbyt ładnie
    wiek = 0

    def ustawWiek(a):
        global wiek
        wiek = a

    ustawWiek(100)
    print wiek
    # Drukuje "100"

Gdy poznasz objekty (poniżej) zobaczysz, że lepszym sposobem wykonania naszego zadania byłoby użycie objektu z właściwością wiek i metodą ustawWiek. W części o strukturach danych zauważysz również lepsze przykłady funkcji, które zmieniają swoje środowisko.

A co z prawdziwymi funkcjami? Czym jest w rzeczywistości funkcja? Matematyczne funkcje są jak „maszyny”, które otrzymują jakieś dane i obliczają z nich wynik. Za każdym razem zwracany będzie ten sam wynik jeśli funkcja otrzyma takie same dane. Przykład:

    def kwadrat(x):
        return x*x

Powyższe jest tym samym co funkcja matematyczna f(x)=x². Zachowuje się jak funkcja dzięki temu, że opiera się tylko na danych wejściowych i nie zmienia w żaden sposób swojego środowiska.

Zarysowałem dwa sposoby tworzenia funkcji: pierwszy typ jest podobny do procedury i nie zwraca wyniku; drugi jest podobny do funkcji matematycznej i nie robi nic (prawie) oprócz zwracania wyniku. Kiedy funkcja zwraca coś powinno być jasne, że to robi. Powinieneś zatem sygnalizować
to poprzez jej nazwę, np. używając tylko rzeczownika „czystej” funkcji tak jak kwadrat i trybu rozkazującego dla funkcji-procedur tak jak ustawWiek.

Więcej składników – struktury danych

Wiele już umiesz: jak wprowadzać dane i otrzymywać wyniki, jak tworzyć skomplikowane algorytmy (programy) i przeprowadzać obliczenia arytmetyczne; ale najlepsze jest jeszcze przed tobą.

Jakie składniki do tej pory używaliśmy w naszych programach? Liczby i łańcuchy znaków. Prawda? Troszkę nudne… Wprowadźmy kilka nowych składników, aby rzeczy stały się bardziej ciekawsze.

Struktury danych są składnikami, które zawierają dane. (Niespodzianka, niespodzianka….) Pojedyncza liczba w rzeczywistości nie posiada żadnej struktury, zgadza się? Załóżmy jednak, że chcemy kilka liczb połączyć w jeden składnik, który mógłby mieć jąkąś strukturę. Na przykład, chcielibyśmy mieć listę liczb. Proszę bardzo:

    [3,6,78,93]

O listach wspomniałem w części o pętlach, ale niewiele o nich powiedziałem. Zatem, w taki sposób możesz je tworzyć. Po prostu wypisz elementy listy, oddziel je przecinkami i zamknij w nawiasach kwadratowych.

Napiszmy teraz przykład, który oblicza liczby pierwsze (liczby, które dzielą się tylko przez siebie lub 1):

    # Oblicz wszystkie liczby pierwsze poniżej 1000
    # (Nie jest to najlepszy sposób wykonania tego, ale...)

    wynik = []
    kandydatki = range(3,1000)
    baza = 2
    produkt = baza

    while kandydatki:
        while produkt < 1000:
            if produkt in kandydatki:
                kandydatki.remove(produkt)
            produkt = produkt+baza
        wynik.append(baza)
        baza = kandydatki[0]
        produkt = baza
        del kandydatki[0]

    wynik.append(baza)
    print wynik

Nowe rzeczy w tym przykładzie…

1. Wbudowana funkcja range zwraca listę, która może być wykorzystywana jak inne listy. (Lista ta zawiera pierwszy indeks funkcji, ale nie ostatni.)
2. Lista może być użyta jako zmienna logiczna. Jeśli nie jest ona pusta, wówczas zwraca true – jeśli jest pusta, wówczas daje false. Dlatego, while kandydatki oznacza „kiedy lista o nazwie kandydatki nie jest pusta” lub prościej „kiedy nadal są w niej kandydatki”.
3. Możesz napisać if jakiśElement in jakiejśLiście, aby sprawdzić, czy dany element znajduje się w tej liście.
4. Możesz napisać jakaśLista.remove(jakiśElement), aby usunąć jakiśElement z jakiejśListy.
5. Możesz dołączyć listę do innej listy pisząc jakaśLista.append(innaLista). Właściwie, możesz również użyć + (skoro jakaśLista = jakaśLista+innaLista) jednak taki zapis jest mniej efektywny.
6. Możesz dostać się do wybranego elementu z listy poprzez podanie jego pozycji jako liczby (gdzie pierwszym elementem, trochę dziwnie, jest element 0) w nawiasach kwadratowych po nazwie listy. Stąd jakaśLista[3] jest czwartym elementem listy jakaśLista. (Więcej na ten temat niżej.)
7. Możesz usuwać zmienne wykorzystując słowo kluczowe del. Słowo to może być również wykorzystane do usuwania elementów z listy. Dlatego del jakaśLista[0] usuwa pierwszy element jakiejśListy. Jeśli listą byłby ciąg [1,2,3], po usunięciu pierwszego elementu otrzymalibyśmy [2,3].

Przed przystąpieniem do wyjaśnienia tajemnic indeksowania elementów listy krótko objaśnię przykład.

Jest to wersja starożytnego algorytmu zwanego „Sitem Erastotenesa”. (lub coś blisko tego). Bierze on pod uwagę zestaw (lub w tym przypadku listę) kandydujących liczb, a następnie systematycznie usuwa liczby, o których wiadomo, że nie są liczbami pierwszymi. Skąd o tym wiadomo? Ponieważ są one produktem dwóch innych liczb.

Rozpoczynamy listą kandydatek zawierającą liczby [2..999] – wiemy, że 1 jest liczbą pierwszą (właściwie, może być lub nie, różne są na ten temat opinie), i chcemy otrzymać wszystkie liczby pierwsze poniżej 1000. (Właściwie, nasza lista kandydatek zawiera liczby w przedziale [3..999], jednak 2 jest również kandydatką, ponieważ jest naszą pierwszą bazą). Mamy również listę nazwaną wynik, która przez cały czas zawiera uaktualnione wyniki. Mamy również zmienną nazwaną
baza. Podczas każdego wykonania algorytmu (rozpoczętego pobraniem kolejnej liczby z „round”), usuwamy wszystkie liczby, które są wielokrotnością liczby bazowej (która jest zawsze najmniejszą z kandydatek). Po każdym wykonaniu algorytmu, wiemy, że najmniejsza liczba, która pozostała jest liczbą pierwszą (ponieważ wszystkie liczby, które były produktami mniejszych liczb zostały usunięte – rozumiesz?). Dlatego, dodajemy ją do wyniku, ustawiamy tę liczbę jako bazę i wyrzucamy ją z listy kandydatek, aby nie powtarzać tego procesu ponownie. Kiedy lista kandydatek będzie pusta, lista wyniku będzie zawierać wszystkie liczby pierwsze. Sprytne, nie?

Rzeczy do przemyślenia: Co wyjątkowego jest podczas pierwszego wykonania tego algorytmu? Czy 2, która jest tutaj bazą, jest również usuwana w procesie „przesiewania”? Dlaczego? Dlaczego coś takiego nie dzieje się z innymi liczbami bazowymi? Czy możemy być pewni, że produkt jest
zawsze w liście kandydatek, kiedy chcemy go usunąć? Dlaczego?

Teraz – no właśnie co dalej? Ach tak, indeksowanie. I podział list. Są to sposoby, aby dostać się do indywidualnych elementów listy. Widziałeś już w akcji zwykłe indeksowanie. Jest ono dość proste. Właściwie powiedziałem ci już wszystko, co powinieneś wiedzieć o tym, z wyjątkiem jednej rzeczy: Ujemne indeksy zliczają elementy od końca listy. Zatem, jakaśLista[-1] jest ostatnim elementem jakiejśListy, jakaśLista[-2] jest elementem przedostatnim, i tak dalej.

Podział, jednakże, jest nowy dla ciebie. Jest on podobny do indeksowania z tym wyjątkiem, że otrzymujesz część listy, a nie tylko pojedynczy element. Jak można to zrobić? Np. tak:

    jedzenie = ["ciasto","ciasto","jajka","kiełbasa","ciasto"]

    print jedzenie[2:4]
    # Wydrukuje "['jajka', 'kiełbasa']"

[Więcej o tym później...]

Więcej o abstrakcji – obiekty i programowanie orientowane obiektowo

Jak sugeruje tytuł części, programowanie orientowane obiektowo jest po prostu kolejnym sposobem skupienia szczegółów. Procedury łączą proste wyrażenia w bardziej skomplikowane operacje nadając im nazwę. W OOP, w taki sposób postępujemy z obiektami. (I co, zaskoczyło cię to?) Na przykład, jeśli stworzyliśmy program piekący sernik, zamiast pisania mnóstwa procedur odpowiedzialnych za temperaturę, czas, składniki itd., mogliśmy to wszystko skupić w obiekcie-serniku. Mogliśmy również stworzyć obiekt-piekarnik i obiekt-zegar… Rzeczy takie jak temperatura mogłyby być atrybutami obiektu-sernika, podczas gdy czas mógłby być odczytywany z obiektu-zegara. Aby nasz program
robił coś, moglibyśmy nauczyć nasze obiekty kilku metod; na przykład, piekarnik mógłby wiedzieć jak piec sernik itd.

Zatem – jak to zrobimy w Pythonie? Nie możemy bezpośrednio utworzyć obiektu. Zamiast budowania piekarnika, tworzymy przepis opisujący jakie są piekarniki. Ten przepis opisuje klasę
(class) obiektu, który nazywamy piekarnikiem. Bardzo prosta klasa piekarnika może wyglądać tak:

    class Piekarnik:
        def wlozSernik(self, sernik):
            self.sernik = sernik 

        def wyjmijSernik(self):
            return self.sernik

Wygląda to dziwacznie, czyż nie?

Nowe rzeczy w tym przykładzie…

1. Klasy obiektów definiuje się słowem kluczowym class.
2. Nazwa klasy zwykle rozpoczyna się z dużej litery, zaś funkcje i zmienne (jak również metody i atrybuty) zaczynają się z małych liter.
3. Metody (tzn. funkcje i operacje, które wykonuje obiekt) definiuje się w zwykły sposób, ale wewnątrz bloku klasy.
4. Wszystkie metody obiektu powinny zawierać pierwszy parametr o nazwie self (lub coś podobnego…) Powód (mam nadzieję) powinien wyjaśnić się za chwilę.
5. Atrybuty i metody obiektu dostępne są w taki sposób: mojSernik.temperatura = 2, lub piekarnik.wyjmijSernik().

Domyślam się, że niektóre rzeczy są nadal niejasne w tym przykładzie. Na przykład, czym jest to self? I, skoro mamy ten przepis na obiekt (tzn. class), to jak właściwie stworzymy obiekt? Weźmy się najpierw za ostatni punkt. Obiekt tworzy się przez wywołanie nazwy klasy, tak jakby była funkcją:

    mojPiekarnik = Piekarnik()

mojPiekarnik zawiera teraz obiekt Piekarnik i nazywany jest instancją klasy Piekarnik. Załóżmy, że utworzyliśmy klasę Sernik; wówczas moglibyśmy napisać coś takiego:

    mojSernik = Sernik()
    mojPiekarnik.wlozSernik(mojSernik)

mojPiekarnik.sernik zawierałby teraz mojSernik. Jak to możliwe? Ponieważ, kiedy wywołujemy jedną z metod obiektu, pierwszy parametr, zwykle nazywany self, zawsze zawiera obiekt samego siebie. (Sprytne, nie?) Dlatego, linia self.sernik = sernik ustawia atrybut sernik bieżącego obiektu Piekarnika na wartość
parametru sernika. Zauważ, że są to dwie różne rzeczy, nawet jeśli w tym przykładzie obie nazywają się sernik.

Odpowiedź do ćwiczenia 3
Poniżej podaję bardzo zwięzłą wersję algorytmu:

    def euklides(a,b):
        while b:
            a,b = b,a % b
        return a

Przypisy

[1]   Kuchnia Online – Sernik na kruchym cieście

[Jeśli podoba ci się ten tutorial sprawdź moją książkę Beginning Python.]