KAPITAŁ LUDZKI NARODOWA STRATEGIA SPÓJNOŚCI

UNIA EUROPEJSKA EUROPEJSKI FUNDUSZ SPOŁECZNY

Projekt Fizyka wobec wyzwań XXI w. współfinansowany jest przez Unię Europejską ze środków Europejskiego Funduszu Społecznego w ramach Programu Operacyjnego Kapitał Ludzki.

Niniejszy podręcznik został stworzony dla studentów I roku neuroinformatyki i fizyki medycznej na Wydziale Fizyki Uniwersytetu Warszawskiego.

Powstanie tego podręcznika było możliwe w znacznej części dzięki wspaniałomyślności różnych osób udostępniających wyniki swojej pracy na licencji CC BY-SA i umożliwiającym tym samym swobodne kopiowanie, tłumaczenie i łączenie materiałów z różnych źródeł. Lista autorów, podziękowania i odnośniki do oryginalnych źródeł znajdują się poniżej. Prace nad podręcznikiem są częściowo finansowane z grantu przyznanego w ramach programu „Kapitał Ludzki“.

Edycja tego podręcznika jest możliwa na stronie http://brain.fuw.edu.pl/edu/PzP. Zapraszamy do wyłapywania błędów i nanoszenia poprawek.

Instalacja Pythona

Z tego rodziału warto co najwyżej przeczytać część dotyczącą tego systemu operacyjnego, którego się samemu używa.

Opisujemy zestaw dla Windows i Linuksa, który jest używany na zajęciach na Neuroinformatyce i Fizyce Medycznej. Obecnie (rok szkolny 2009/10) korzystamy z Pythona w wersji 2.6 bo do niej są stabilne moduły numeryczne.

Proszę zwrócić uwagę aby w instalowanym zestawie znalazło się środowisko IDLE. Jest to Zintegrowane środowisko programistyczne (ang. IDE — Integrated Development Environment). Będziemy z niego korzystać na zajęciach. Jest ono domyślnie instalowane z Pythonem pod Windowsami i pod Mac OS X. Również użytkownicy Linuksa i BSD mogą zainstalować IDLE.

W następnej sekcji jest opisane jak używać IDLE. W poszukiwaniu szczegółów, zapoznaj się z dokumentacją IDLE.

Dla użytkowników Windows

Istnieją wiele sposobów instalacji Pythona pod Windows:

• gotowe dystrybucje zawierające zestaw narzędzi i pakietów dedykowanych do konkretnych zastosowań np. dla nas niezły jest Python(x,y)
• wybieranie programu podstawowego i potem doinstalowywanie potrzebnych modułów np tak: Odwiedź dział download na stronie Python.org i pobierz najnowszy instalator Pythona 2.x dla Windows. Instalacja wygląda podobnie, jak w przypadku innych programów dla Windows.

Uwaga

Nie odznaczaj żadnych opcjonalnych komponentów podczas instalacji! Część z nich może być bardzo pomocna, szczególnie IDLE.

• Pobierz i zainstaluj Active Python. Jest to instalator Pythona przygotowany przez ActiveState. Zawiera wiele użytecznych rzeczy, jak np. PythonWin, który może się przydać użytkownikom Windows.

Używanie Pythona w wierszu poleceń Windows

Jeśli chcesz używać Pythona w wierszu poleceń, musisz odpowiednio ustawić zmienną PATH.

W Windows 2000, XP, 2003 otwórz Panel Sterowania → System → Zaawansowne → Zmienne środowiskowe. W części Zmienne systemowe kliknij na zmiennej PATH, wybierz Edytuj i dodaj ;C:\Python25 na samym końcu. Oczywiście powinieneś wpisać poprawną nazwę katalogu, w którym Python jest zainstalowany.

W starszych wersjach Windows dodaj linijkę PATH=%PATH%;C:\Python25 do pliku C:\AUTOEXEC.BAT i zrestartuj system. W Windows NT użyj pliku AUTOEXEC.NT.

Dla użytkowników Linuksa i BSD

Jeśli używasz dystrybucji w rodzaju Ubuntu, Fedora, Mandriva czy {wstaw własną}, albo BSD, np. FreeBSD, prawdopodobnie Python jest już zainstalowany w Twoim systemie.

Aby to sprawdzić, otwórz okno terminala (np. konsole lub gnome-terminal) i wprowadź polecenie python -V (zwróć uwagę na wielkie V):

$ python -V
Python 2.5.4

Uwaga

$ jest znakiem zachęty konsoli. Może się różnić w zależności od ustawień systemu, więc przyjmijmy, że odtąd będę używał znaku $ na oznaczenie znaku zachęty.

Jeżeli widzisz informacje na temat wersji podobne do powyższych, oznacza to, że Python jest już zainstalowany.

Jednak jeśli dostaniesz coś w rodzaju:

$ python -V
-bash: python: nie znaleziono polecenia

to nie masz go zainstalowanego. Jest to mało prawdopodobne, ale możliwe. W takim przypadku pozostają Ci następujące możliwości instalacji Pythona w systemie:

• Zainstalować pakiet binarny używając do tego programu zarządzającego pakietami w swoim systemie (np. apt-get w Ubuntu/Debianie, yum w Fedorze, urpmi w Mandrivie, pkg_add we FreeBSD, itd.). Zauważ, że potrzebne będzie połączenie z internetem.
• Możesz też pobrać paczki binarne (np. DEB czy RPM), skopiować je na swój komputer i zainstalować.
• Możesz skompilować źródła Pythona 2.x i zainstalować je. Instrukcja kompilacji jest dołączona do źródeł. Zauważ, że aby móc używać proponowanego w tej książce IDLE (więcej w następnym rozdziale), musisz skompilować Pythona z obsługą Tcl/Tk.

Dla użytkowników Mac OS X

Python jest domyślnie zainstalowany w Mac OS X 10.3 i wyższych. Jeśli chcesz zainstalować nowszą wersję Pythona, użyj MacPorts:

• Zainstaluj MacPorts.
• By otrzymać listę pakietów wykonaj sudo port search python — w momencie pisania najnowszą dostępną wersją Pythona 2.x jest Python 2.6.1 występujący w MacPorts jako python26.
• Wykonaj sudo port install python26.

Jeśli masz starszą wersji Mac OS X, odwiedź oficjalną stronę MacPython, pobierz plik DMG dla posiadanej wersji systemu, podepnij obraz dyskietki i uruchom instalator.

Podsumowanie

W systemie Windows instalacja Pythona jest prosta i polega na pobraniu instalatora i dwukrotnym kliknięciu na nim. W systemie linuksowym najprawdopodobniej już miałeś zainstalowanego Pythona, a nawet jeśli nie, możesz go zainstalować za pomocą programu zarządzającego pakietami charakterystycznego dla Twojej dystrybucji. Również w Mac OS X Python już był zainstalowany w Twoim systemie. Od tej chwili zakładamy więc, że masz zainstalowanego Pythona.

Pierwsze kroki

W pierwszym kroku nauczymy się uruchamiać w Pythonie tradycyjny* program „Witaj świecie!". Dzięki temu nauczysz się pisać w języku Python, a także zapisywać i uruchamiać swoje pythonowe programy.

*Jest taka tradycja, że za każdym razem, kiedy uczysz się nowego języka programowania, pierwszym programem jest „Witaj świecie!” (w oryginale „Hello World”) — wszystko, co robi, to tylko wypisanie tekstu „Witaj świecie!”.

Są dwa sposoby uruchamiania programów pythonowych: użycie linii poleceń interpretera lub użycie pliku źródłowego. Zobaczmy, w jaki sposób korzystać z tych metod.

Praca z Pythonem

Python jest interpreterem poleceń. Mamy dwie możliwości wydawania owych poleceń:

• interaktywnie z linii poleceń,
• zapisując polecenia w pliku tekstowym i wykonując je jako program.

Używanie linii poleceń interpretera

Uruchom interpreter Pythona, wpisując python w powłoce (ang. shell) systemowej. Jeśli używasz Linuksa lub BSD, otwórz w tym celu program w rodzaju konsole czy terminal.

W przypadku Mac OS X otwórz Terminal (znajdziesz go w: Finder → Aplikacje → Użytki → Terminal), a jeśli używasz Windows, to uruchom (Start → Uruchom...) cmd lub (w przypadku starszych wersji Windows) command albo po prostu znajdź odpowiednią pozycję w menu.

Zauważ, że w przypadku Windows musisz zadbać o poprawnie ustawioną zmienną PATH.

Użytkownicy Windows mogą chcieć również używać IDLE. Uzyskasz do niego dostęp przez:

Start → Wszystkie programy → Python 2.x → IDLE (Python GUI). 

Teraz wpisz print 'Witaj świecie!' i wciśnij Enter. Na ekranie powinien pojawić się napis Witaj świecie!

$ python
Python 2.5.4 (r254:67916, Mar 13 2009, 18:11:09)
[GCC 4.1.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print 'Witaj świecie!'
Witaj świecie!
>>>

Uwaga:

Napis: >>> oznacza, że Python oczekuje na wprowadzenie polecenia. Z ang. nazywa się to prompt.

Zobacz, Python natychmiast zwraca wynik! To, co właśnie wprowadziłeś, to pojedyncze polecenie Pythona. Używamy print (ang. drukuj, wypisz), aby wypisać to, co mu podamy. W naszym przypadku podaliśmy tekst Witaj świecie! i został on natychmiast wyświetlony na ekranie.

Jak wyjść z interpretera?

• Jeśli używasz IDLE bądź powłoki systemowej Linuksa/BSD/Mac OS X, wciśnij po prostu Ctrl-D.
• Jeśli używasz Pythona w linii poleceń Windows, naciśnij Ctrl-Z, a następnie Enter.

Pliki źródłowe

Wróćmy wreszcie do programowania.

Jak pisać programy w Pythonie?

Od tego momentu nasza standardowa procedura zapisu i uruchamianiu programów w Pythonie będzie wyglądała następująco:

1. Otwórz swój ulubiony edytor → na naszych zajęciach IDLE :-)
2. Wprowadź/Skopiuj kod programu podany w przykładzie.
3. Zapisz plik pod nazwą podaną w komentarzu. Przyjmijmy, że programy Pythona będziemy zapisywali z rozszerzeniem .py.
4. Teraz możesz uruchomić program jedną z poniższych metod:

• w powłoce systemowej za pomocą polecenia python nazwa.py, gdzie nazwa jest nazwą pliku
• użyj klawisza F5 w edytorze IDLE
• wpisz execfile('nazwa.py') w lini poleceń interpretera, aby uruchomić program.

# Nazwa pliku: witaj.py
 
print 'Witaj świecie!'

$ python witaj.py
Witaj świecie!

Gratuluję, jeśli wynik jest podobny powyższego! Właśnie uruchomiłeś swój pierwszy program w Pythonie.

Jeśli wystąpił błąd, przepisz program tak, żeby wyglądał dokładnie tak, jak powyższy i spróbuj uruchomić go jeszcze raz. Zwróć uwagę na to, że Python rozróżnia wielkość liter, np. print znaczy co innego, niż Print (zauważ wielkie P w drugim). Upewnij się także, że nie ma żadnych spacji ani też znaków tabulacji na początku jakiejkolwiek linii (za moment dowiesz się, dlaczego jest to takie jest istotne).

Jak to działa?

Zacznijmy od przeanalizowania pierwszej linii naszego programu. Jest to tak zwany komentarz. Wszystko, co znajduje się na prawo od znaku # jest pomijane w trakcie wykonywania programu i przydaje się przede wszystkim jako notatki pozostawione dla przyszłego czytelnika programu. Python nie interpretuje komentarzy.

Program w Pythonie możesz uruchomić wpisując polecenie, nazwę interpretera i pliku, czyli tak jak w naszym poprzednim przykładzie, python witaj.py.

Uwaga o komentarzach

Komentarze są ważne, ponieważ pomagają wprowadzać szczegółowe notatki związane z programem. Powinny one wyjaśniać, co program wykonuje, albo też informować o rzeczach, które czekają na poprawienie/dokończenie/zrobienie. Mogą się one okazać bardzo przydatne dla osób, które będą czytały Twój program. Również Tobie z pewnością się przydadzą, kiedy na przykład będziesz czytał swój program sześć miesięcy po jego napisaniu.

W naszym pierwszym programie po komentarzach następuje polecenie Pythona, które wypisuje na ekran słowa Witaj świecie!. print jest instrukcją (w nowym Pythonie 3.x jest to już funkcja i używa się jej nieco inaczej, ale nie będziemy się tym teraz martwić), a dostarczone przez nas 'Witaj świecie!' jest napisem (ang. string). Wyjaśnimy tę terminologię później.

Wcięcia

Przez znaki niewidoczne rozumiemy spację, tabulator itp. Rozpoczęcie od nich linii tekstu nazywamy wcięciem linii. Znaki niewidoczne znajdujące się na początku linii są w języku Python bardzo istotne. Spacje i znaki tabulacji na początku linii są brane pod uwagę przy określaniu stopnia wcięcia danej linii, co z kolei pozwala Pythonowi grupować polecenia. Polecenia, które są tak samo wcięte tworzą blok poleceń.

Powinieneś również zapamiętać, że nieprawidłowe wcięcia pociągają za sobą czasem trudne do znalezienia błędy. Spójrz na ten przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: wciecia.py
 
i = 5
 print 'Wartość zmiennej to ', i # Błąd! Zauważ spację na początku linii
print 'Powtarzam, wartość zmiennej to ', i

Próbując uruchomić powyższy program, prawdopodobnie otrzymasz następujący błąd:

  File "wciecia.py", line 4
    print 'Wartość zmiennej to ', i # Błąd! Zauważ spację na początku linii
    ^
IndentationError: unexpected indent

Python podpowiada, że we wskazanej linii znajduje się nieoczekiwane wcięcie. Nie można dowolnie zaczynać nowych bloków poleceń. Sytuacje, w których możesz rozpoczynać nowe bloki, zostaną opisane w następnych rozdziałach.

Miłą konsekwencją stosowania wcięć jest to, że w ten sposób Python zmusza nas do pisania bardziej schludnego kodu, który jest bardziej przejrzysty dla czytelnika.

Jak używać wcięć?

Nie używaj mieszaniny tabulatorów i spacji do stosowania wcięć, ponieważ nie działa to prawidłowo na wszystkich platformach. Zdecydowanie polecam żebyś używał pojedynczego tabulatora lub czterech spacji na każdy jeden stopień wcięcia.

Wybierz jeden z powyższych sposobów stosowania wcięć i stale używaj tylko tego sposobu.

Programy wykonywalne w Pythonie (na potem)

Można spowodować, by program w Pythonie zachowywał się jak każdy inny program, tzn. żeby można było go uruchomić podając jedynie jego nazwę. Zob. TI:Wykonywalne programy w Pythonie.

Uzyskiwanie pomocy

Jeśli szybko musisz znaleźć opis funkcji lub polecenia Pythona, możesz skorzystać z wbudowanej pomocy (ang. help). Przydaje się to szczególnie podczas używania wiersza poleceń interpretera. Dla przykładu możesz wykonać help('string'), a uzyskasz pomoc odnośnie napisów.

Uwaga

Aby zakończyć pomoc, wciśnij q.

W podobny sposób możesz uzyskać informacje na temat niemal wszystkiego, co dotyczy Pythona. By dowiedzieć się więcej o samej pomocy, użyj help().

$ python
Python 2.5.4 (r254:67916, Mar 13 2009, 18:11:09)
[GCC 4.1.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> help('print')

Zauważ, że musimy użyć apostrofów i zapytać o 'print', bo print jest tzw. słowem kluczowym i nie może być użyte jako argument do help.

Podsumowanie i ćwiczenia

Wykonywalne programy w Pythonie

Odnosi się to wyłącznie do użytkowników Linuksa/BSD/Mac OS X, ale użytkownicy Windows również mogą być zainteresowani znaczeniem pierwszej linii programu.

Jeśli chcemy, żeby nasz program w Pythonie zachowywał się jak normalny program, czyli żeby można go było uruchomić wpisując jedynie ścieżkę do pliku, musimy wykonać dwa kroki.

Przede wszystkim na początku pliku (a dokładnie w pierwszej linijce) musimy napisać jakiego interpretera należy system ma użyć do interpretacji tego programu. W tym celu, tak jak w przykładach w tej książce, należy zapisać ścieżkę do interpretera po znakach '#!'.

#!/usr/bin/python
<treść programu>

Po drugie, musimy nadać użytkownikom pliku tzw. prawo do wykonywania, poprzez użycie polecenia chmod.

$ chmod +x witaj.py 
$ ./witaj.py 
Witaj !

Komendy chmod używamy, aby zmienić tryb (ang. change mode) pliku przez nadanie prawa wykonywania (execute) wszystkim użytkownikom systemu. Potem wykonujemy program poprzez bezpośrednie podanie lokalizacji pliku - używamy ./ by wskazać, że program znajduje się w aktualnym katalogu.

Jak wynika z powyższego opisu, informacja dla systemu o tym jakiego typu (w jakim języku) jest program, jest tak naprawdę zawarta w jego pierwszej linijce. W takim razie, do czego służy końcówka nazwy programu, '.py'? Okazuje się, że jest to informacja dla użytkownika... można zmienić nazwę pliku na zwykłe witaj i uruchamiać go przez ./witaj, a program wciąż będzie działać, bo system wie, że musi uruchomić program z użyciem danego interpretera.

Dodanie do ścieżki

Potrafisz już uruchamiać program, jeśli znasz jego dokładne położenie. Co jednak zrobić, gdy chcesz mieć możliwość uruchomienia programu z każdej lokalizacji? Możesz to osiągnąć, umieszczając program w jednym z katalogów zawartych w zmiennej środowiskowej PATH (ścieżka dostępu).

Zawsze, gdy próbujesz uruchomić program przez podanie jego nazwy, system szuka tego programu w każdym z katalogów wymienionych w zmiennej PATH i, w przypadku sukcesu, uruchamia program. Można sprawić, by program był zewsząd dostępny, poprzez umieszczenie go w jednym z tych katalogów.

# Kopiowanie programu do katalogu obecnego w zmiennej PATH
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/home/swaroop/bin
$ cp witaj.py /home/swaroop/bin/
$ witaj
Witaj !

Możemy wyświetlić zawartość zmiennej PATH, używając komendy echo i umieszczając $ przed nazwą zmiennej. Znak $ wskazuje powłoce, że chcemy otrzymać wartość danej zmiennej. Widzimy, że katalog /home/swaroop/bin jest obecny w PATH. Zwróć uwagę, że swaroop jest nazwą użytkownika w systemie. Jaki masz katalog domowy możesz łatwo sprawdzić:

$ cd ~
$ pwd

Jeżeli nie masz jeszcze odpowiedniego prywatnego katalogu w zmiennej PATH, możesz oczywiście tę zmienną rozszerzyć o pożądany katalog. Możesz to zrobić przez wpisanie w powłoce:

export PATH=$PATH:/home/swaroop/mojkatalog

gdzie /home/swaroop/mojkatalog jest katalogiem, który chcesz dodać do zmiennej PATH.

W tym przykładzie dodajemy katalog do zmiennej PATH. Używamy $PATH, by otrzymać dotychczasową wartość i ustawiamy nową wartość przez dodanie pełnej ścieżki do pożądanego katalogu. Zwróć uwagę, że katalogi w zmiennej PATH oddzielane są dwukropkami :, więc my też jeden dodaliśmy. Komenda export oznacza, że programy uruchamiane z aktualnej powłoki powinny móc używać nowej wartości zmiennej PATH.

Możemy więc skopiować nasz program do katalogu obecnego w zmiennej PATH i kiedy gdziekolwiek po prostu wpiszemy witaj, system odnajdzie nasz program i uruchomi go, korzystając oczywiście z interpretera.

Ważną rzeczą jest zwrócenie uwagi na fakt, że dzięki temu nasz program stał się jakby częścią systemu operacyjnego.

Uwaga

Względem Pythona program, skrypt i oprogramowanie oznaczają dokładnie to samo.

Stałe i zmienne

Stałe dosłowne

Przykładem stałej dosłownej jest:

• liczba, np. 5, 1.23, 9.25e-3
• napis w rodzaju 'To jest napis' albo "To też jest napis!".

Nazywa się ją dosłowną, bo jest dosłowna, tzn. zawsze używasz jej wartości w sposób dosłowny. Przykładowo liczba 2 zawsze reprezentuje samą siebie i nic innego. Jest stałą, ponieważ jej wartości nie można zmienić. Stąd wszystkie stałe tego typu nazywa się stałymi dosłownymi.

Wpisywane przez nas liczby to stałe dosłowne. Proszę zwrócić uwagę na wyniki dzielenia 1/2 i 1.0/2

Liczby

Liczby w Pythonie dzielimy na trzy główne typy: całkowite (ang. integers), zmiennoprzecinkowe (ang. floating point albo krócej: float) i zespolone (ang. complex).

• Przykładami liczb całkowitych są 2 i 1025.
• Przykłady liczb zmiennoprzecinkowych to: 3.23 i 52.3E–4.

W przypadku liczb zmiennoprzecinkowych część znajdująca się przed znakiem E nazywana jest mantysą. Po znaku E znajduje się wykładnik. Wartość liczby to mantysa razy 10 podniesione do danego wykładnika.

52.3E–4

= 52,3·10–4

• Jednostkę urojoną zapisujemy jako j po liczbie, tak więc

–5 + 4j	= –5 + 4i
2.3 – 4.6j	= 2,3 – 4,6i
1j	= i

Napisy

Napis (ang. string) to po prostu ciąg znaków.

Apostrof (')

Napis można zapisać w programie używając apostrofów

'Możecie mnie cytować.'

Wszystkie znaki (litery, odstępy, tabulatory) są zachowane w niezmienionej postaci.

Cudzysłów (")

Napisy w cudzysłowach zapisuje się tak samo jak w apostrofach.

"Zażółcić gęślą jaźń."

Różnica jest taka, że w napisie w apostrofach można łatwo zawrzeć cudzysłów, a w napisie w cudzysłowach, apostrof. Później, w trakcie używania napisu, nie ma żadnego znaczenia to, w jaki sposób został on zapisany.

Potrójny cudzysłów lub apostrof (""" lub ''')

Za pomocą potrójnych cudzysłowów lub apostrofów możesz oznaczać napisy wielolinijkowe. Co więcej, wewnątrz nich możesz swobodnie używać zarówno cudzysłowów jak i apostrofów. Najlepiej zilustruje to przykład:

'''Litwo, ojczyzno moja,
ty jesteś jak zdrowie.
Ile cię trzeba cenić,
ten tylko się dowie,
kto cię stracił.
'''

Sekwencje specjalne

Wyobraź sobie, że chcesz zapisać napis, który zawiera apostrof ('), na przykład Nie lubię Harry'ego. Nie można zapisać 'Nie lubię Harry'ego', bo Python nie zrozumie, gdzie napis ma koniec. Musimy więc wyraźnie zaznaczyć, że ten konkretny apostrof pomiędzy y a e nie oznacza końca napisu. Tutaj z pomocą przychodzą nam właśnie sekwencje specjalne. Za ich pomocą możemy zapisać ów apostrof jako \', z ukośnikiem wstecznym. Zatem nasz napis, poprawnie zapisany, wygląda tak: 'Nie lubię Harry\'ego'.

W tym konkretnym wypadku lepiej jednak jest użyć cudzysłowów do zaznaczenia granic napisu: "Nie lubię Harry'ego". Po to właśnie istnieje możliwość używania zarówno cudzysłowów jak i apostrofów.

A co w przypadku napisów wielolinijkowych? Można użyć potrójnych cudzysłowów, jak pokazaliśmy wyżej. Można także użyć znaków ucieczki, aby zapisać znak specjalny — znak nowej linii. Robimy to w następujący sposób: To jest pierwszy wiersz\nTo jest drugi wiersz.

Oprócz \n istnieje więcej znaków specjalnych, ale w miarę często używa się tylko jeszcze jednego, czyli znaku tabulacji \t. Znak tabulacji zachowuje się trochę jak 8 lub 4 spacje.

Możemy także zrobić rzecz odwrotną, a mianowicie zapisać napis niezawierający znaków nowej linii w wielu wierszach w programie:

"To jest pierwsze zdanie. \
A to drugie."

Powyższy przykład jest równoważny napisowi "To jest pierwsze zdanie. A to drugie.". Zauważ, że umieściliśmy spację przed ukośnikiem wstecznym — w przeciwnym wypadku A występowałoby w napisie bezpośrednio po kropce.

Napisy surowe

Jeżeli musisz stworzyć napis, który nie zawiera żadnych sekwencji specjalnych, a zawiera fragmenty ze wstecznymi ukośnikami, przydatną opcją są napisy surowe (ang. raw). Tworzymy je, poprzedzając napis literą r lub R. Przykład: r"Nowe linie zapisujemy za pomocą \n.".

Napisy Unikodowe

Unikod (ang. Unicode) jest zestandaryzowanym sposobem zapisu tekstu w różnych językach. Jeśli chcesz zapisać tekst np. w języku polskim, prawdopodobnie wiesz, że najlepiej jest użyć edytora z obsługą unikodu. Python również daje Ci możliwość użycia Unikodu: wystarczy przy zapisie napisu jako przedrostek dodać u lub U, na przykład: u"Ten tekst zapisaliśmy w Unikodzie.". Niezależnie od tego, z jakiego kodowania korzysta dany komputer, nie będzie on miał problemu z poprawnym odczytaniem tekstu zapisanego w unikodzie, więc używaj unikodowego zapisu napisów dla tekstów, które zawierają np. polskie znaki, a mogą być odczytywane przez różne komputery.

W systemie linuks możemy zadeklarować chęć korzystania ze znaków w kodowaniu UTF. Do tego służy nam linijka # -*- coding: utf-8 -*- na początku kodu, która informuje interpreter, że w kodzie mogą się pojawić znaki niestandardowe (teksty zostaną zakodowane w systemie UTF-8). W systemie Windows musimy dopisywać literkę u przed ciągiem znaków zawierających polskie litery. W Linuksie owe u nie przeszkadza, więc chcąc mieć przenośny kod powinniśmy to u dopisywać.

Napisy są niezmienne (ang. immutable)

Oznacza to, że jeżeli już raz utworzyłeś napis, nie możesz go zmienić.

Automatyczne łączenie napisów zapisanych obok siebie

Jeżeli umieścimy dwa napisy obok siebie, Python automatycznie je połączy. Spójrz na przykład: 'Jak ' 'Cię zwą?' zostanie automatycznie przekonwertowane do 'Jak Cię zwą?'.

Zmienne

Używanie tylko stałych dosłownych może szybko stać się nudne — potrzebujemy sposobu przechowywania informacji i manipulowania nimi. Do tego właśnie służą zmienne. Są dokładnie tym, co mówi nam ich nazwa, czyli mogą ulegać zmianom, a to oznacza, że możesz w nich przechowywać cokolwiek. Zmienne to nic innego, tylko fragmenty pamięci Twojego komputera, w których przechowywana jest jakaś informacja. W przeciwieństwie do stałych, musisz mieć możliwość dostępu do tych danych, tak więc zmiennym nadajemy nazwy. Najpierw tylko zobaczmy, jakie nazwy możesz nadać zmiennym.

Nazewnictwo identyfikatorów

Zmienne są przykładami identyfikatorów. Identyfikatory to nazwy, które nadajemy czemuś do zidentyfikowania tego. Tworząc identyfikatory w Pythonie, musisz trzymać się kilku zasad:

• Pierwszym znakiem identyfikatora musi być mała lub wielka litera alfabetu łacińskiego (więc polskie znaki są niedopuszczalne) albo podkreślnik (_).
• Pozostałe znaki mogą zawierać małe lub wielkie litery alfabetu łacińskiego, podkreślniki oraz cyfry (0-9).
• Wielkość znaków w identyfikatorze jest ważna. Stąd mojanazwa i mojaNazwa to zupełnie co innego. Zwróć uwagę na wielkie N w drugim przykładzie.
• Przykłady poprawnych identyfikatorów to: i, __moja_nazwa, nazwa_23, a1b2_c3.
• Przykłady niepoprawnych identyfikatorów to: 2nazwy, nazwa ze spacjami, moja-nazwa.

Aby nadać zmiennej jakąś wartość trzeba wartość przypisać do zmiennej. Robi się to przy pomocy operatora = (operatora przypisania). Zwróć uwagę, że jest to zupełnie inny sens znaku „=” niż w matematyce.

Przykład użycia zmiennych i stałych dosłownych

Teraz zobaczymy, jak w programach używać zmiennych razem ze stałymi dosłownymi.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: zmienne.py
i = 5
print i
i = i + 1
print i
s = '''To jest napis wielolinijkowy.
To jest drugi wiersz.'''
print s

$ python zmienne.py
5
6
To jest napis wielolinijkowy.
To jest drugi wiersz.

Jak to działa?

Najpierw przypisujemy stałą dosłowną 5 do zmiennej i za pomocą operatora przypisania (=). Linia ta nazywa się poleceniem, ponieważ zleca ona Pythonowi wykonanie czegoś: w tym przypadku łączymy nazwę zmiennej i z wartością 5.

Następnie, również za pomocą polecenia, wypisujemy wartość zmiennej i na ekran, używając print.

Później dodajemy 1 do wartości przechowywanej w zmiennej i i zapisujemy nowo obliczoną wartość z powrotem do zmiennej i. Potem wypisujemy wartość zmiennej i i, jak się spodziewaliśmy, dostajemy 6.

Analogicznie postępujemy ze zmienną s, której przydzielamy wartość dosłowną napisu i wypisujemy ją.

W czasie wykonywania programu możemy podawać mu dane. Jedną z funkcji służących do wprowadzania danych przez użytkownika w czasie wykonywania programu jest raw_input(). Z funkcji tej można skorzystać np. tak: a = raw_input(napis, który program ma wyświetlić). Takie wywołanie funkcji powoduje wyświetlenie w konsoli podanego w argumencie napisu. Następnie funkcja czeka, aż użytkownik napisze coś i zakończy wprowadzanie danych naciśnięciem Enter. Wprowadzony przez użytkownika napis przypisywany jest do zmiennej a.

Typy danych

Zmienne przechowują wartości różnego rodzaju: są to typy danych. Podstawowe typy danych już poznaliśmy, są to liczby i napisy. W następnych rozdziałach dowiemy się, jak tworzyć nasze własne typy danych za pomocą klas.

Obiekty

Od teraz zapamiętaj, że Python traktuje wszystkie rzeczy użyte w programie jako obiekty. Rozumiemy to w ogólnym sensie. Zamiast mówić "to coś", mówimy "ten obiekt".

Operatory

Większość poleceń, jak będziesz w przyszłości pisał, będzie zawierała wyrażenia (ang. expressions). Prostym przykładem wyrażenia może być 2 + 3. Wyrażenie możemy podzielić na operatory i operandy.

Operatory to funkcjonalności, które coś robią i są reprezentowane przez symbole, jak +, albo przez specjalne słowa kluczowe. Operatory, jak sama nazwa wskazuje, muszą na czymś operować — tym czymś są operandy. W naszym przypadku operandami są 2 i 3. Spójrz na tabelę przedstawiającą operatory i ich użycie.

Zanim jednak to zrobisz, pozwól, że przypomnę Ci, że możesz obliczyć wartość wyrażenia, bezpośrednio używając linii poleceń interpretera. Spójrz na przykład:

>>> 2 + 3
5
>>> 3 * 5
15
>>>

Tabela operatorów

Uwaga: nie musisz od razu przyswajać sobie całej poniższej tabeli. Jest ona duża, ale po to, żeby wszystkie informacje na ten temat były zebrane w jednym miejscu. Można będzie do niej wracać w razie potrzeby, w trakcie późniejszej nauki.

Nie ma obowiązku przyswojenia całej tabeli operatorów naraz — jej zawartość jest po kolei omawiana w następnych rozdziałach: operacje algebraiczne za moment, operacje logiczne i przyrównania w rozdziale o wykonaniu warunkowym, a operacje bitowe w rozdziale o operacjach bitowych.

Kolejność wykonywania

Jeśli mamy wyrażenie typu 2 + 3 * 4, co jest wykonywane najpierw: dodawanie czy mnożenie? Znając reguły matematyczne, możemy stwierdzić, ze mnożenie powinno być wykonane w pierwszej kolejności, co oznacza, że operator mnożenia ma wyższy priorytet (ang. precedence) od operatora dodawania. O kolejności wykonywania operacji decyduje tabela priorytetów operatorów.

Jeśli chcesz zmienić kolejność wykonywania działań, również musisz użyć nawiasów. Aby dodawanie zostało wykonane przed mnożeniem, należy napisać na przykład (2 + 3) * 4.

Czasem używa się nawiasów, mimo że nie powoduje to zmiany kolejności wykonywania. Przykładowo można napisać 2 + (3 * 4), żeby podkreślić, że mnożenie jest wykonywane wcześniej. Nie należy z tym przesadzać.

Poniższa tabela daje nam spojrzenie na priorytety operatorów w Pythonie, od najwyższego (wykonywanego najpierw) do najniższego (wykonywany w ostatniej kolejności). W praktyce wygląda to tak, że w wyrażeniu najpierw wykonane zostaną operacje położone wyżej w tabeli, a dopiero potem te z niższych wierszy.

Poniższa tabela jest dość obszerna (pochodzi z dokumentacji Pythona), aby dać pełne spojrzenie na to zagadnienie. Priorytety operatorów są dobrane tak, by były zgodne z przyzwyczajeniami wziętymi z matematyki, a także by można były popularne wyrażenia zapisać bez nawiasów. O tym, czy należy użyć nawiasów w sytuacji gdy nie są konieczne, decyduje czytelność. Jeśli program jest bardziej zrozumiały z nawiasami, to należy ich użyć.

Operatory, z którymi się jeszcze nie zapoznaliśmy, zostaną wyjaśnione w następnych rozdziałach.

Operatory mające taki sam priorytet znajdują się w jednym wierszu powyższej tabeli. Przykładowo, + i – mają taki sam priorytet.

  delta < 0 or a*x1**2 + b*x1 + c == 0 and a*x2**2 + b*x2 + c == 0 and x1 <= x2

(
   ( delta < 0 )
   or
   (
     ((a*x1**2 + b*x1 + c) == 0 )
     and
     ((a*x2**2 + b*x2 + c) == 0 )
     and
     (x1 <= x2)
   )
)

Łączność operatorów

Operatory są zazwyczaj łączone od lewej do prawej, co oznacza, że operacje z tym samym pierwszeństwem są wykonywane od lewej do prawej. Przykładowo 2 - 3 - 4 jest wykonywane jak (2 - 3) - 4, czyli daje wynik −5.

Wyjątkiem w stosunku do łączności lewostronnej jest operator potęgowania, który jest łączony od prawej do lewej, np. 3**3**3 daje , a nie . Czyli potęgowanie w Pythonie zachowuje się tak jak normalnie w matematyce.

x1 < 0 < x2
# lub równoważnie
x1 < 0 and 0 < x2

Przypisanie do wielu zmiennych jest traktowane jak przypisanie do wszystkich tych zmiennych tej samej wartości. Np. a = b = c to to samo co a = c i b = c.

Wyrażenia

Wyrażenia są kombinacjami zmiennych, stałych i łączących je operatorów. Przykładem może być wzór na obliczanie pola lub obwodu jakiejś figury geometrycznej.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: wyrazenia.py
 
dlugosc = 5
szerokosc = 2
pole = dlugosc * szerokosc
print 'Pole wynosi', pole
print 'Obwód wynosi', 2 * (dlugosc + szerokosc)

Spodziewany wynik

$ python wyrazenia.py
Pole wynosi 10
Obwód wynosi 14

Jak to działa?

Długość i szerokość prostokąta są przechowywane w zmiennych o tych samych nazwach. Użyjemy tych zmiennych, aby za pomocą wyrażeń obliczyć pole i obwód tego prostokąta. Przechowujemy wynik wyrażenia dlugosc * szerokosc w zmiennej pole, aby wypisać jej wartość za pomocą polecenia print. W przypadku obwodu bezpośrednio używamy wyrażenia 2 * (dlugosc + szerokosc) w poleceniu print.

Zwróć uwagę na to, że Python jest napisany tak, by ułatwić życie programiście. Mimo, że nie umieściliśmy spacji pomiędzy 'Pole wynosi', a zmienną pole, Python wstawił ją tam za nas. Oddzielenie wypisywanych wartości spacjami to najpowszechniejsza potrzeba programisty, więc tak się dzieje, jeśli poda on pare rzeczy do wypisania.

Wykonanie warunkowe

Wprowadzenie

W programach, które widzieliśmy dotychczas, zawsze występowały ciągi wyrażeń, które Python wiernie odtwarzał w podanej kolejności. Co zrobić, gdy chcemy zmienić tę kolejność? Na przykład chcemy, żeby program podejmował decyzje i robił różne rzeczy, zależnie od sytuacji, jak na przykład wypisywał „Dzień dobry” albo „Dobry wieczór” zależnie od pory dnia.

Uzyskuje się to kontrolując przepływ programu za pomocą wyrażeń, które powodują przeskok i wykonanie instrukcji w innej kolejności niż ta, w której są napisane. Najważniejsze z takich wyrażeń to if (wykonanie warunkowe, przedstawione poniżej) oraz for i while (wykonanie w pętli, przedstawione w następnym rozdziale).

Konstrukcja if

Składnia

Konstrukcja if jest używana do wyboru jednego z dwóch bloków w zależności od pewnego warunku. Poniżej przedstawiamy składnię tej konstrukcji najpierw w dwóch szczególnych, ale często występujących przypadkac, a na końcu w pełnej wersji. Proszę zwrócić uwagę na dwukropki i wcięcia. Fragment kodu o wyróżniony jednakowym wcięciem nazywamy blokiem.

• Przypadek I: wykonanie warunkowe bloku kodu:

if warunek:
    blok kodu,
    który ma być wykonany
    jeśli warunek jest prawdziwy

• Przypadek II: wykonanie warunkowe jednego z dwóch bloków kodu:

if warunek:
    blok kodu,
    który ma być wykonany
    jeśli warunek jest prawdziwy
else:
    blok kodu,
    który ma być wykonany
    jeśli warunek jest fałszywy

• Przypadek ogólny: kaskada warunków

if warunek1:
    blok kodu,
    który ma być wykonany
    jeśli warunek1 jest prawdziwy
elif warunek2:
    blok kodu,
    który ma być wykonany
    jeśli warunek2 jest prawdziwy
else:
    blok kodu,
    który ma być wykonany
    jeśli każdy z powyższych warunków jest fałszywy

Przykład 1

Chcemy napisać program realizujący następujący algorytm:

1. ustal zmienną temperatura na pewną wartość np. 11
2. Jeśli temperatura jest dodatnia wypisz komunikat: "jest ciepło!"

Algorytm ten można w pythonie zaimplementować następująco:

#!/usr/bin/python
# -*- coding: utf-8 -*-
temperatura = 11
 
if temperatura > 0:
   print "jest ciepło!"

Python wykonuje wyrażenie będące warunkiem (temperatura > 0). Ponieważ warunek jest prawdziwy, uruchamiamy blok operacji bezpośrednio pod if.

Przykład 2

Zmodyfikujmy nieco nasz algorytm:

1. ustal zmienną temperatura na pewną wartość np. 11
2. Jeśli temperatura jest dodatnia wypisz komunikat: "jest ciepło!"
3. W przeciwnym razie wypisz komunikat: "uwaga, przymrozek!"

Algorytm ten można zaimplementować w następujący sposób:

#!/usr/bin/python
# -*- coding: utf-8 -*-
temperatura = 11
 
if temperatura > 0:
   print "jest ciepło!"
else:
   print "uwaga, przymrozek!"

Program został wzbogacony o nowy blok poprzedzony instrukcją else. Jeśli zmienilibyśmy wartość przypisaną do zmiennej temperatura i warunek był fałszywy, wykonałby się właśnie ten blok (pod else).

Sekcja else jest opcjonalna — jeśli jej nie ma, a warunek jest fałszywy, to cała konstrukcja if nie powoduje wykonania żadnych instrukcji (poza wykonaniem warunku).

Zadanie

Proszę napisać program realizujący algorytm:

1. poproś użytkownika po podanie temperatury
2. przypisz podaną przez użytkownika wartość do zmiennej temperatura
3. Jeśli temperatura jest powyżej 30 wypisz komunikat: "upał"
4. jeśli jest powyżej 15 dodatnia wypisz komunikat: "jest ciepło!"
5. W przeciwnym razie wypisz komunikat: "uwaga, chłodno!"

Uwaga 1: proszę przeanalizować sekwencję warunków

Uwaga: W tym i kolejnym zadaniu przydać się może funkcja raw_input. Dla przypomnieinia: ta funkcja wczytuje jedną linijkę „z klawiatury“ Wywołujemy funkcję raw_input przekazując jej jako argument napis, który zostaje wypisany na ekran jako zachęta dla użytkownika. Po tym jak użytkownik wpisze coś i naciśnie Enter, funkcja raw_input zwraca to, co zostało wpisane, jako napis. Przetwarzamy go na liczbę całkowitą za pomocą int, a następnie zapisujemy w zmiennej. Podsumowując:

licba_wprowadzona =  int(raw_input('Podaj liczbę: ' ) )

Zadanie: Zagadka

Algorytm zagadki jest następujący:

1. przypisz do zmiennej liczba wartość 23
2. pobierz od użytkownika liczbę całkowitą i przypisz ja do zmiennej strzal
3. Jeśli wartości zmiennych liczba i strzal są równe to wypisz gratulacje
4. jeśli wartość zmiennej liczba jest większa niż wartość zmiennej strzal to wypisz informację "Nie, szukana liczba jest większa od podanej"
5. jeśli wartość zmiennej liczba jest mniejsza niż wartość zmiennej strzal to wypisz informację "Nie, szukana liczba jest mniejsza od podanej"

Zwróćmy uwagę na fakt, że jeżeli pierwszy i drugi warunek nie jest spełniony (jest fałszywy) to warunek ostatni jest jedyną możliwością i nie musimy go już sprawdzać.

Proszę zaimplementować powyższy algorytm.

Możliwe rozwiązanie (ukryte):

Wartości logiczne

Jak wiadomo, logika rządzi się swoimi prawami. Pozwalają one na ścisłe wyliczanie wartości logicznej zdań — czyli po prostu określenie, czy zdanie złożone z prostszych zdań jest prawdziwe czy też fałszywe. Ponieważ występują tylko dwie wartości i można dla nich pisać równania, to zasady logiki nazywamy algebrą dwuwartościową, lub częściej algebrą Boole'a, od nazwiska osoby która pierwsza sformalizowała ten rachunek.

Dwie wartości, prawdę i fałsz, oznaczamy często jako 1 i 0. W Pythonie jako wartość oznaczającą prawdę można użyć liczby 1 albo specjalnego obiektu True, natomiast fałsz — liczby 0 lub obiektu False. Te specjalne obiekty nazywane są po angielsku booleans, co należy rozumieć jako wartości Boole'a. Nie są niezbędne i zostały wprowadzone po to, by podkreślić kiedy używamy algebry dwuwartościowej, a kiedy zwykłej.

Operacje logiczne

Koniunkcja

Jeśli mamy dwa zdania a oraz b, ich koniunkcją nazywamy wyrażenie, które jest prawdziwe gdy obywa zdania są prawdziwe. W matematyce oznacza się to przez . W Pythonie operatorem koniunkcji jest and.

Możemy wypisać działanie operatora na każdą możliwą parę wartości logicznych:

wartości zdań		wartość ich koniunkcji
a	b	a and b
True	True	True
True	False	False
False	True	False
False	False	False

Koniunkcję nazywa się często iloczynem logicznym, bo jeśli oznaczymy prawdę i fałsz przez 1 i 0, to zwykłe mnożenie tych dwóch liczb daje taki sam wynik jak koniunkcja.

Alternatywa

Jeśli mamy dwa zdania a oraz b, ich alternatywą nazywamy wyrażenie, które jest prawdziwe gdy przynajmniej jedno z tych zdań jest prawdziwe. W matematyce oznacza się to przez . W Pythonie operatorem alternatywy jest or.

Ponownie, najłatwiej przedstawić działanie operatora w tabelce ze wszystkimi możliwymi parami wartości logicznych:

wartości zdań		wartość ich alternatywy
a	b	a or b
True	True	True
True	False	True
False	True	True
False	False	False

Alternatywę nazywa się często sumą logiczną, bo jeśli ponownie oznaczymy prawdę i fałsz przez 1 i 0, to zwykłe dodawanie tych dwóch liczb daje taki sam wynik jak koniunkcja, za wyjątkiem 1 + 1. W wypadku sumy logicznej dwóch zdań prawdziwych wynik i tak jest 1, bo w algebrze Boole'a po prostu nie ma większej liczby.

Zaprzeczenie

Jeśli mamy zdanie a, jego zaprzeczeniem nazywamy wyrażenie, które jest prawdziwe tylko gdy to zdanie jest fałszywe.

Tutaj tabelka możliwości jest krótsza, bo mamy tylko jedno zdanie:

wartość zdania	wartość jego zaprzeczenia
a	not a
True	False
False	True

Wartość logiczna wyrażeń w Pythonie

Kiedy używamy operatorów przyrównania (==, !=, <=, >=, <, >), w wyniku otrzymujemy jedną z dwóch wartości logicznych True / False. Większość innych wyrażeń nie jest prawdziwa lub fałszywa w sensie matematycznym. Na przykład napis "Hello, World" nie ma wartości logicznej w sensie matematycznym. Niemniej w Pythonie, jak też w wielu innych językach programowania, wszystkie obiekty mają wartość logiczną określaną zgodnie z pewnymi ustalonymi regułami. Pozwala to wykorzystać dowolne wyrażenie jako warunek w poleceniu sterujących wykonaniem programu, jak if czy while, bo każde wyrażenie zwraca jakiś obiekt.

W przypadku obiektów które nie są po prostu True ani False, to czy dany obiekt zostanie zinterpretowany jako prawdziwy, czy też jako fałszywy, rządzi się paroma prostymi regułami:

1. w przypadku liczb, liczba 0 jest fałszywa, wszystkie pozostałe są prawdziwe
2. w przypadku sekwencji (np. napisów) i innych kolekcji, tylko te puste, o długości 0, są fałszywe
3. pozostałe obiekty są prawdziwe (o ile ich twórca nie podjął specjalnych działań by mogły mieć różne wartości logiczne)

TO DO: http://Link?

Jeśli chcemy sprawdzić wartość logiczną, możemy konwersję na wartość logiczną wykonać explicite. Robimy to za pomocą wyrażenia bool(coś).

$ python
>>> bool("Hello, World")
True
>>> bool("")
False
 
>>> bool(1)
True
>>> bool(120)
True
>>> bool(-120)
True
>>> bool(0.5)
True
 
>>> bool(0)
False
>>> bool(0.0)
False
 
>>> bool(True)
True
>>> bool(False)
False

Obliczanie wartości wyrażeń logicznych w Pythonie

Jeśli napiszemy wyrażenie zawierające operatory and lub or, często możemy określić wartość logiczną całego wyrażenia bez znajomości wartości logicznej drugiego operandu. Pozwala to na pominięcie części obliczeń, tzw. wykonanie warunkowe (ang. short-circuiting). Mówiąc bardziej konkretnie,

• w przypadku operatora and, jeśli pierwszy wyraz jest fałszywy, to drugi nie jest obliczany bo wiadomo, że całe wyrażenie jest fałszywe,
• w przypadku operatora or, jeśli pierwszy wyraz jest prawdziwy, to drugi nie jest obliczany, bo wiadomo, że całe wyrażenie jest prawdziwe.

W przedstawionych powyżej tabelkach przedstawiającej działanie operatorów and lub or na wartości logiczne True i False argumentami były wszystkie możliwe kombinacje tych dwóch wartości. Później zostały przedstawione reguły pozwalająca na nadanie wartości logicznej każdemu wyrażeniu. W przypadku gdy jako argumentu w koniunkcji lub alternatywie użyje się obiektu, który nie jest wartością logiczną True albo False, to wynik wyrażenia logicznego też może nie być wartością logiczną.

Tabelki działania operatorów pozostają w mocy, ale aby uwzględnić działanie na nie-booleans i wykonanie warunkowe, do wykonywania operatorów logicznych używa się następujących reguł:

x and y — jeżeli x jest fałszem, zwraca x, w przeciwnym wypadku zwraca y

x or y — jeżeli x jest prawdą, zwraca x, w przeciwnym wypadku zwraca y

Wyniki działania tych reguł dla wartości True i False dają to co powinny. Natomiast w innych przypadkach pozwalają na budowanie pseudo-zdań logicznych. Np. jeśli prosimy użytkownika o wpisanie pewnego napisu, ale w przypadku gdy wpisał napis pusty chcemy użyć wartości domyślnej, możemy wykorzystać alternatywę:

print (napis or "(podałeś pusty napis)")
# napis o długości 0 jest fałszywy,
#     w takim wypadku zostanie użyty drugi operand

Przedstawione powyżej reguły obliczania koniunkcji i alternatywy są równoważne następującemu przepisowi:

1. Zaczynamy od obliczenia wartości lewego operandu.
2. Jeśli wartość logiczna lewego operandu nie pozwala na rozstrzygnięcie wartości logicznej całego wyrażenia, obliczamy wartość prawego operandu.
3. Jako wynik zwracamy ostatni obliczony operand, czyli ten który rozstrzyga o wartości logicznej całego wyrażenia.

Pętle

Pętla while

Wyrażenie

while warunek: 
    blok

służy do konstrukcji bloku poleceń pętli wykonywanej warunkowo. Jak w przypadku każdego bloku w Pythonie, do bloku po while zaliczają się te linijki, które są wyrównane do tej samej kolumny (mają takie samo wcięcie). Python najpierw sprawdza czy warunek jest spełniony, i jeśli tak, to wykonuje wszystkie wyrażenia zawarte w bloku. Następnie ponownie sprawdza warunek, i jeśli nadal jest spełniony, to ponownie wykonuje wszystkie wyrażenia zawarte w bloku. Pętla jest wykonywana tak długo, jak długo warunek jest prawdziwy.

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
liczba = 23
dzialaj = True
while dzialaj:
    strzal = int(raw_input('Wpisz liczbę całkowitą: '))
    if strzal == liczba:
        print 'Gratulacje, zgadłeś ją!'
        print '(Ale nic nie wygrałeś.)'
        dzialaj = False  # To sprawia, że warunek przestaje być
	                 # spełniony
    elif strzal < liczba:
        print 'Nie, szukana liczba jest większa od podanej.'
    else:
        print 'Nie, szukana liczba jest mniejsza od podanej.'
print 'Koniec programu.'

$ python while.py
Wpisz liczbę całkowitą: 50
Nie, ta liczba jest mniejsza od szukanej. 
Wpisz liczbę całkowitą: 22
Nie, ta liczba jest większa od szukanej.
Wpisz liczbę całkowitą: 23
Gratulacje, zgadłeś ją!
(Ale nic nie wygrałeś.)
 
Koniec programu.

Wyrażenia break i continue

Standardowe wykonanie pętli — warunek spełniony, wykonujemy cały blok, warunek spełniony, wykonujemy cały blok, ..., warunek niespełniony, koniec — nie zawsze jest pożądane. Pętlę można zarówno po prostu przerwać, jak też pominąć pozostałą do wykonania resztę bloku i rozpocząć następny obieg pętli.

Wyrażenie break

Wyrażenia break używamy, aby wyrwać się z pętli, czyli zakończyć jej wykonywanie natychmiast. Przykład powyżej można w sposób równoważny, ale krótszy i czytelniejszy, zapisać z użyciem break.

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
liczba = 23
while True:
    strzal = int(raw_input('Wpisz liczbę całkowitą: '))
    if strzal == liczba:
        print 'Gratulacje, zgadłeś ją!\n(Ale nic nie wygrałeś.)'
	break
    elif strzal < liczba:
        print 'Nie, szukana liczba jest większa od podanej.'
    else:
        print 'Nie, szukana liczba jest mniejsza od podanej.'
 
print '\nKoniec programu.'

Wyrażenie continue

Wyrażenia continue używamy, aby nakazać Pythonowi ominąć pozostałe wyrażenia w bloku pętli i kontynuować od następnej iteracji tej pętli.

Jeszcze raz ten sam program, tym razem z wykorzystaniem continue:

#!/usr/bin/python
# -*- coding: utf-8 -*-
# nazwa pliku: zgadywanka.py
liczba = 23
while True:
    strzal = int(raw_input('Wpisz liczbę całkowitą: '))
    if strzal > liczba:
        print 'Nie, ta liczba jest większa od szukanej.'
        continue
    if strzal < liczba:
        print 'Nie, ta liczba jest mniejsza od szukanej.'
        continue
    print 'Gratulacje, w końcu ją zgadłeś!'
    print '(Ale znowu nic nie wygrałeś.)'
    break
print '\nKoniec programu.'

Wyrażenia break i continue są uniwersalne — mogą zostać użyte zarówno w pętli while jak i w pętli for, opisanej poniżej.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: continue.py
 
while True:
    s = raw_input('Wpisz coś: ')
    if s == 'quit':
        break
    if len(s) < 3:
        print 'Za krótkie.'
        continue
    print 'Wpis jest wystarczającej długości.'
    print 'Liczba słów wpisu:', len(s.split()), '.'

$ python continue.py
Wpisz coś: a
Za krótkie.
Wpisz coś: 12
Za krótkie.
Wpisz coś: abc cde
Wpis jest wystarczającej długości.
Liczba słów wpisu: 2.
Wpisz coś: quit

Sekwencje i pętla for

Przedstawiona powyżej pętla while jest pierwowzorem pętli — na dodatek wygląda i działa niemalże tak samo w różnych językach programowania. Niemniej, na co dzień, używa się raczej innej pętli, bardziej zwięzłej i wygodniejszej w użyciu.

 for zmienna in sekwencja:
     blok

Pętla for służy do wykonania tego samego bloku operacji dla każdego elementu z sekwencji. Oznacza to, że liczba wykonań bloku jest równa długości sekwencji. Zmienna przyjmuje po kolei wartości wszystkich elementów sekwencji. Jednokrotne wykonanie bloku pętli dla aktualnej wartości zmiennej nazywamy iteracją. W żargonie mówimy, że pętla for iteruje po sekwencji obiektów.

Najprostszym przykładem jest wykonanie tej samej operacji dla sekwencji liczb. W pythonie najprostszym przykładem sekwencji jest lista liczb. Można ją wytworzyć wpisując "ręcznie" liczby rozdzielone przecinkami w nawiasie kwadratowym. W powłoce pythona proszę wypróbować następujący kod:

a = [2, 3, 4, 5]
print 'sekwencja a:', a

Wygodniejszym sposobem wygenerowania potrzebnej sekwencji liczb jest funkcja range(a,b). Proszę wypróbować:

a = range(2,6)
print 'sekwencja a:', a

# cała sekwencja na raz
print 'sekwencja:', [2, 3, 4, 5]
 
# sekwencja element po elemencie
for i in [2, 3, 4, 5]:
    print 'element sekwencji:', i

$ python for.py
sekwencja: [2, 3, 4, 5]
element sekwencji: 2
element sekwencji: 3
element sekwencji: 4
element sekwencji: 5

Wiele różnych typów sekwencji

Cechą wspólną wielu różnych kolekcji obiektów jest możliwość ponumerowania w określony sposób elementów i iteracji po nich, czyli dostępu do każdego z nich po kolei. Dzięki temu możemy np. iterować po sekwencji znaków, albo po sekwencji linii w pliku, albo po sekwencji liczb.

Najprostszy przykład sekwencji to lista wpisana bezpośrednio w tekście programu.

Drugi przykład, to ciąg znaków. Naturalnie myślimy o napisie jako o sekwencji znaków/liter.

Trzeci przykład, to funkcja range(a, b) generująca sekwencję liczb od a do b.

Sekwencje uzyskujemy też jako wynik wywołania wielu innych funkcji.

Funkcje range i xrange

Sekwencję liczb generujemy używając wbudowanej funkcji range. Podajemy dwie liczby, a funkcja range zwraca nam sekwencję liczb począwszy od pierwszej, a kończąc przed drugą z nich. Na przykład range(2,6) tworzy sekwencję [2,3,4,5]. Pierwszy argument range jest opcjonalny, jeśli go się nie poda, to sekwencja zaczyna się od 0. Na przykład wywołanie range(N) zwraca sekwencję N elementów: od 0 do N−1.

Domyślnie, range wytwarza sekwencję liczb zwiększających się co 1. Trzeci, opcjonalny argument range jest wartością o jaką będą zwiększane kolejne liczby w sekwencji. Na przykład range(1,5,2) zwróci [1,3].

Funkcja range tworzy od razu całą wymaganą listę. Jeśli lista jest długa, jest to niepotrzebny narzut, bo możemy przerwać wykonywanie pętli przedwcześnie, nie używając wszystkich elementów. Dlatego w wyrażeniu for należy używać zamiennika xrange, który zachowuje się tak samo, ale generuje swoje elementy w miarę potrzeby w trakcie wykonywania pętli.

range(0, 2*100, 2)

Funkcja split

Metoda split dzieli ciąg znaków na słowa — tj. zwraca listę ciągów znaków dzieląc w miejscach gdzie występują spacje.

# Plik slowa.py
for slowo in 'ala ma kota'.split():
    print slowo

$ python slowa.py
ala
ma
kota

Podsumowanie

Pętla for...in działa dla każdej sekwencji. Tutaj mieliśmy sekwencje liczb, znaków lub napisów, ale tak naprawdę możemy użyć dowolnego rodzaju sekwencji z dowolnym rodzajem obiektów! Przyjrzymy się temu w następnych rozdziałach.

Blok else po pętli

Blok else jest wywoływany gdy warunek pętli while przyjmuje wartość False lub gdy pętla for for przebiegnie całą sekwencję. To może się wydarzyć nawet za pierwszym razem, jeśli warunek jest od początku fałszywy albo sekwencja pusta. Jeżeli istnieje sekcja else dla pętli while, jest ona zawsze uruchamiana, z wyjątkiem sytuacji, gdy wyjdziesz z pętli poleceniem break.

Przykład:

Chcemy sprawdzić co jest mniejsze: liczba 10 czy piąta w kolejności liczba podzielna przez 3?

# Co jest mniejsze: 10 czy piąta w kolejności liczba podzielna przez 3?
# plik wyścig.py
 
podzielnych = 0
i = 1
while i < 10:
    if i % 3 == 0:
         print i, "jest podzielna przez 3"
         podzielnych += 1
         if podzielnych == 5:
              print "piąta liczba podzielna przez 3 jest mniejsza"
              break
    i += 1
else:
    print "doszliśmy do 10"
    print "10 jest mniejsze"

Rezultat:

$ python wyścig.py
3 jest podzielna przez 3
6 jest podzielna przez 3
9 jest podzielna przez 3
doszliśmy do 10
10 jest mniejsze

Zauważ, że gdy wyjdziesz z pętli for albo while używając break, blok else nie zostanie wywołany.

Pętle i litery z polskimi znakami diakrytycznymi

Zobaczmy jeszcze jeden przykład, wydawałoby się niemalże trywialny, na wykorzystanie pętli while...

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: break.py
 
while True:
    s = raw_input('Wpisz coś: ')
    if s == 'quit':
        break
    else:
	print 'Długość tego ciągu znaków to:', len(s)
print 'Koniec programu.'

$ python break.py
Wpisz coś: Programming is fun
Długość tego ciągu znaków to: 18
Wpisz coś: When the work is done
Długość tego ciągu znaków to: 21
Wpisz coś: if you wanna make your work also fun:
Długość tego ciągu znaków to: 37
Wpisz coś:     use Python!
Długość tego ciągu znaków to: 15
Wpisz coś: quit
Koniec programu.

I czy jest w tym coś podchwytliwego? Spróbujmy jeszcze raz:

$ python break.py
Wpisz coś: pyton
Długość tego ciągu znaków to: 5
Wpisz coś: wąż
Długość tego ciągu znaków to: 5
#                       dlaczego akurat 5 a nie 3?

Jaką długość ma napis zawierający polskie litery?

Jeśli zapytasz o długość ciągu znaków zawierającego polskie znaki diakrytyczne („ą”, „ć”, „ę”, „ł”, „ń”, „ó”, „ś”, „ź”, „ż” oraz „Ą”, i inne wielkie), uzyskana odpowiedź może różnić się od oczekiwań!

$ python
>>> print len('aaa')
3
>>> print len('ąęó')
6                       #wynik może być różny w zależności od systemu: zazwyczaj 6 lub 3 lub 12

Aby wyjaśnić co się tutaj dzieje, trzeba by zacząć od podstaw, czyli stron kodowych i standardu Unicode. Temat jest ciekawy, ale by wyjaśnić powyższy wynik, wystarczy powiedzieć, że ciąg znaków 'ąęó' jest rozumiany przez Pythona jako ciąg znaków z bardzo ograniczonego zestawu ASCII. Jeśli używasz w miarę współczesnego systemu operacyjnego, to taka sekwencja znaków zostaje podana Pythonowi jako ciąg znaków ze znacznie szerszego zestawu Unicode. Znaki ASCII są zapisywanie po jednym na bajt, a że znaków Unicode jest znacznie więcej, to potrzeba na nie więcej miejsca. Ile dokładnie miejsca potrzeba na polskie znaki diakrytyczne zależy od systemu, ale najczęściej są to dwa bajty na każdy. Ostatecznie Python otrzymuje ciąg bajtów, które usiłuje interpretować jako jednobajtowe znaki ASCII. Rezultat jest taki, że otrzymujemy ilość bajtów zajmowanych przez ciąg znaków, a nie długość tego ciągu.

Nie tylko zliczanie znaków działa źle, pętla for też się gubi:

$ python
>>> for znak in 'ąęó':
...     print znak
...
�                # znak oznaczający 'zepsuty' znak
�
�
�
�
�

Aby zaradzić temu zamieszaniu (np. bo nie chcemy żeby program dawał inny wynik w zależności od systemu na którym jest wykonywany) mamy proste wyjście. Musimy poinformować Pythona, że dany ciąg znaków jest ciągiem znaków Unicode. W tym celu ciąg przed otwierającym cudzysłowem wstawiamy literkę 'u':

$ python
>>> print len(u'aaa')
3
>>> print len(u'ąęó')
3                     # zgodnie z oczekiwaniem
>>> for znak in u'ąęó':
...      print znak
...
ą
ę
ó

Niestety takie rozwiązanie jest pracochłonne dla programisty, a na dodatek łatwo o pomyłkę, gdy gdzieś zapomnimy przedrostka. Nowe wersje Pythona (3.0 i późniejsze) rozwiązują ten problem prościej — ciągi znaków to domyślnie Unicode i nie ma w ogóle przedrostka 'u'.

Podsumowanie

Zobaczyliśmy, jak używać trzech wyrażeń kontroli przepływu — if, while oraz for, razem z powiazanymi z nimi poleceniami break i continue. Są one jednymi z najczęściej używanych części Pythona i w związku z tym obeznanie się z nimi jest niezbędne.

W następnym rozdziale dowiemy się jak tworzyć funkcje i nimi operować.

Ćwiczenia

  1   2   3   4   5   6   7   8   9  10
  2   4   6   8  10  12  14  16  18  20
  3   6   9  12  15  18  21  24  27  30
  4   8  12  16  20  24  28  32  36  40
  5  10  15  20  25  30  35  40  45  50
  6  12  18  24  30  36  42  48  54  60
  7  14  21  28  35  42  49  56  63  70
  8  16  24  32  40  48  56  64  72  80
  9  18  27  36  45  54  63  72  81  90
 10  20  30  40  50  60  70  80  90 100

a = raw_input('Podaj liczbę: ')
 
if a > 0:
    print 'dodatnia'
elif a == 0:
    print 'zero'
elif a < 0:
    print 'ujemna'

Funkcje

Wprowadzenie

Funkcje to fragmenty programu, które można używać wielokrotnie. Możemy nadać nazwę jakiejś grupie instrukcji i uruchamiać ją używając tej nazwy w dowolnym miejscu programu tyle razy ile chcemy. Operację taką nazywamy wywołaniem funkcji. Tak naprawdę używaliśmy już wielu wbudowanych funkcji takich jak len czy range. Funkcje są prawdopodobnie najważniejszym składnikiem budującym każdy program (w dowolnym języku programowania), musimy więc poznać je dokładniej.

Funkcje definiujemy w programie używając słowa kluczowego def. Po tym słowie następuje nazwa funkcji oraz para nawiasów, które mogą zawierać nazwy zmiennych (parametrów funkcji), a linia kończy się dwukropkiem. Parametry służą do przekazywania funkcji różnych wartości tzw. wejściowych i uzyskiwania zależnych od nich wyników. Potem następuje blok linii programu, które tworzą funkcję. Poniżej jest przedstawiony przykład definicji i wywołania funkcji.

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: function1.py
 
# początek definicji funkcji
def przywitajSie():
    print 'Sie ma!' # instrukcje tworzące funkcję
# koniec definicji funkcji
 
przywitajSie() # wywołanie (użycie) funkcji
przywitajSie() # ponowne wywołanie funkcji

Sie ma!
Sie ma!

Parametry funkcji

Jak wiemy, funkcja może mieć parametry wywołania. Są to wartości, które dostarczamy funkcji, i których możemy użyć wewnątrz funkcji. Parametry zachowują się tak samo jak zmienne z tą różnicą, że ich wartości są nadawane w momencie wywołania funkcji.

Parametry wpisuje się w nawiasach podczas definiowania funkcji oddzielając je przecinkami. Kiedy wywołujemy funkcję, ich wartości podajemy w taki sam sposób. Uwaga: nazwy, które podaliśmy podczas definiowania funkcji nazywamy parametrami, ale wartości podane przy wywołaniu funkcji nazywamy argumentami.

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_param.py
 
def printMax(a, b):
    if a > b:
        print a, 'jest większe'
    elif a == b:
        print a, 'jest równe', b
    else:
        print b, 'jest większe'
 
printMax(3, 4) # bezpośrednio podane wartości
 
x = 5
y = 7
 
printMax(x, y) # zmienne podane jako argumenty

4 jest większe
7 jest większe

Zmienne lokalne

Jeśli wewnątrz funkcji zadeklarujemy zmienne, nie mają one żadnego związku ze zmiennymi poza funkcją, nawet jeśli mają takie same nazwy. Mówimy, że nazwy zmiennych wewnątrz funkcji są lokalne dla tej funkcji. Obszar, w którym możemy danej zmiennej używać nazywamy zasięgiem zmiennej. Każda zmienna zdefiniowana w funkcji ma zasięg poczynając od miejsca, w którym po raz pierwszy przypiszemy jej wartość, aż do końca funkcji.

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_local.py
 
x = 50
 
def func(x):
    print 'x wynosi', x
    x = 2
    print 'Zmieniono lokalne x na', x
 
func(x)
print 'x ciągle wynosi', x

x wynosi 50
Zmieniono lokalne x na 2
x ciągle wynosi 50

Dostęp do zmiennych globalnych

Wewnątrz funkcji, odczytywać zmienne zdefiniowane na wyższym poziomie można bez problemu. Jeśli natomiast chcemy przypisywać wartość do takiej zmiennej, zdefiniowanej poza zakresem danej funkcji, to trzeba tą zmienną określić jako globalną. Służy do tego deklaracja global. Bez użycia tej deklaracji nie jest możliwe przypisanie wartości zmiennej zdefiniowanej na zewnątrz funkcji — jedyny efekt takiego przypisania to utworzenie lokalnej zmiennej o tej nazwie, która zasłania zmienną globalną.

Należy powiedzieć precyzyjnie, co tutaj znaczy słowo globalna. W Pythonie zmienną globalną nazywa się zmienną zdefiniowaną bezpośrednio w jakimś module, a nie wewnątrz funkcji czy klasy w tym module. Takie znaczenie jest zupełnie inne niż np. w C, gdzie zmienna globalna o danej nazwie w całym programie może być tylko jedna.

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_global.py
 
x = 50
 
def func():
    global x
 
    print 'x wynosi', x
    x = 2
    print 'Zmieniono zewnętrzny x na', x
 
func()
print 'x wynosi teraz', x

x wynosi 50
Zmieniono zewnętrzny x na 2
x wynosi teraz 2

Można określić więcej niż jedną zmienną globalną w tej samej deklaracji global, na przykład: global x, y, z.

Wyskakując na moment do rozdziału o modułach, należy wspomnieć, że do do zmiennych zdefiniowanych „gdzie indziej“ można się odwoływać podając nazwę modułu który je zawiera. Na przykład zmienna argv zdefiniowana w module sys jest z poza tego modułu dostępna jako sys.argv. Dlatego atrybut global służy do dostępu do zmiennych zdefiniowanych na poziomie modułu, ale tylko z wewnątrz tego modułu.

Domyślne wartości argumentów

W przypadku pewnych funkcji nie zawsze chcemy podawać argumenty odpowiadające wszystkim parametrom określonych w definicji funkcji. Parametry mogą być „opcjonalne“. Nie musimy wtedy ich podawać w wyłaniu funkcji, i jeśli tego nie zrobimy zostaną użyte wartości domyślne. Wartości domyślne definiujemy dopisując w definicji funkcji po nazwie parametru znak = i wartość domyślną.

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_default.py
 
def napisz(wiadomosc, razy=1):
    print wiadomosc * razy
 
napisz('Dzień')
napisz('dobry', 5)

Dzień
dobrydobrydobrydobrydobry

Zaawansowane sposoby przekazywania argumentów

Argumenty nazwane

Jeśli chcemy skorzystać z funkcji o dużej liczbie parametrów, wygodne może być jawne użycie nazw parametrów. Działa to tak, że w wywołaniu funkcji podajemy zarówno nazwę parametru, jak i, tak jak poprzednio, właściwy argument. Podanie wartości danego parametru poprzez taki nazwany argument (po angielsku argumenty takie nazywa się keyword arguments), powoduje, że jego wartość w wywołaniu funkcji jest ustalona i zostaje on wyłączony z normalnego przypisywania argumentów do parametrów według kolejności.

Rozpoznawanie argumentów po nazwie, a nie kolejności, ma dwie zalety:

1. użycie funkcji jest prostsze, bo nie musimy się martwić o kolejność argumentów
2. możemy podać wartości tylko tych argumentów, których chcemy (pod warunkiem, że parametry które pomieliśmy mają określone wartości domyślne).

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_key.py
 
def func(a, b=5, c=10):
    print 'a wynosi', a, 'oraz b wynosi', b, 'oraz c wynosi', c
 
func(3, 7)
func(25, c=24)
func(c=50, a=100)

a wynosi 3 oraz b wynosi 7 oraz c wynosi 10
a wynosi 25 oraz b wynosi 5 oraz c wynosi 24
a wynosi 100 oraz b wynosi 5 oraz c wynosi 50

Użycie argumentu nazwanego nazwą która nie odpowiada żadnemu parametrowi jest błędem.

Zmienna liczba parametrów

Czasami wygodnie byłoby zdefiniować funkcję, która przyjmowałaby dowolną liczbę parametrów, tak jak polecenie print. Można to uzyskać dodając na końcu listy parametrów zmienną, do której zostanie wpisana lista „nadmiarowych“ argumentów. Ten specjalny parametr jest oznaczony przez gwiazdkę przed jego nazwą.

>>> def powypisuj(rozdzielacz, pierwsze, *reszta)
...    """Wypisuje podane słowa używając pierwszego argumentu
...       jako rozdzielacza."""
...    print pierwsze
...    for slowo in reszta:
...    	   print rozdzielacz, slowo,
...
...
>>> powypisuj('-x-', 'ala', 'ma', 'kota')
ala-x-ma-x-kota
>>> powypisuj('-x-', 'ala')
ala
>>> powypisuj('-x-')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: powypisuj() takes at least 2 arguments (1 given)

W jaki sposób argumenty zostają przyporządkowane?

Argumenty nazwane nie mogą występować tylko na końcu listy argumentów, lub patrząc od drugiej strony, argumenty nienazwane muszą znajdować się na początku. Podane argumenty są przyporządkowywane parametrom w ten sposób, że najpierw argumenty bez zadanej nazwy parametru zostają przydzielone do odpowiednich parametrów w kolejności, a potem argumenty nazwane zostają przydzielone do odpowiednich parametrów według nazwy. Tak więc, jeśli argumentów jest więcej niż parametrów „bez gwiazki“, to trafią one do zmiennej „z gwiazdką“.

Błędem jest jeśli jakiemuś parametrowi zostaną przyporządkowane dwa argumenty &mdash na przykład jeden zwykły, a drugi nazwany.

Zmienna liczba argumentów nazwanych

Istnieje jeszcze jeden sposób przekazywania zmiennej liczby parametrów, w formie słownika. Ponieważ słowniki będą omówione dopiero w rozdziale o strukturach danych, to reszta tego podrozdziału może być niezrozumiała. Jeśli tak, to nie przejmuj się i najpierw poczytaj o słownikach.

Funkcja może mieć jeszcze jeden specjalny parametr — poprzedzony dwoma gwiazkami, zwyczajowo nazywający się **kwargs. W wywołaniu takiej funkcji można użyć argumentów nazwanych, których nazwy nie odpowiadają żadnym parametrom funkcji. Te argumenty zostają wstawione do słownika, który zostaje przekazany jako parametr kwargs do funkcji. W tym słowniku, nazwy argumentów są kluczami, a ich wartości wartościami przypisanymi do tych kluczy.

>>> def f(*args, **kwargs):
...     print 'args =', args
...     print 'kwargs =', kwargs
...
>>> f(1, 2, 3, a=4, b=5, c=6)
args = (1, 2, 3)
kwargs = {'a': 4, 'b': 5, 'c': 6}

Polecenie return

Dotychczas rozważane funkcje wykonywały pewne polecenia ale nie oczekiwaliśmy od nich aby zwracały jakieś wartości (tzn. nie potrzebowaliśmy aby wartości wyliczone albo obiekty wytworzone w funkcji były dostępne w miejscu, z którego wywołaliśmy funkcję).

Polecenie return jest używane do powrotu z funkcji czyli natychmiastowego przerwania jej wykonania i zwrócenia wartości.

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_return.py
 
def maksimum(x, y):
    if x > y:
        return x
    else:
        return y
 
print maksimum(2, 3)

3

Uwaga

instrukcja return bez podanej wartości jest równoważna instrukcji return None. None jest obiektem języka Python reprezentującym brak wartości. Jest on używany na przykład do zaznaczenia, że jakaś zmienna nie ma wartości.

Każda funkcja domyślnie zawiera instrukcję return None na końcu. Można to zaobserwować wywołując print jakasFunkcja(), gdzie funkcja jakasFunkcja nie używa instrukcji return, na przykład:

>>> def jakasFunkcja():
...     pass
...
>>> print jakasFunkcja()
None

Instrukcja pass jest w języku Python używana do oznaczenia pustego bloku instrukcji.

Uwaga:
Istnieje wbudowana funkcja max, która wyszukuje większą z liczb. Jeśli tylko to możliwe należy używać funkcji wbudowanych, a nie pisać własne.

Opisy wbudowane w funkcje

W Pythonie istnieje wygodna możliwość uzupełniania programu o objaśnienia–dokumentację. W ogólności programista może umieszczać swoje uwagi jako komentarze (wykorzystując znak #), które są po prostu ignorowane w trakcie wykonywania programu, lub jako napisy wstawione na początku definicji funkcji (wykorzystując znaki normalnie używane do ograniczania napisów, czyli ' i "). Ta druga forma ma tę przewagę, że mimo iż w trakcie normalnego wykonywania programu jest pomijana podobnie jak zwykłe komentarze, to te napisy zostają także zachowane od specjalnej zmiennej i można je obejrzeć. W trybie interaktywnej pracy z Pythonem służy do tego funkcja help.

Linie tekstu z dokumentacją nazywają się po angielsku documentation strings, co skraca się do docstrings. Przez docstring rozumie się tylko taki napis umiejscowiony na początku funkcji (lub klasy czy modułu, mechanizm jest ten sam) stanowiący dokumentację.

#!/usr/bin/python
# -*- coding: utf-8 -*-
# Nazwa pliku: func_doc.py
 
def printMax(x, y):
    '''Konwertuje obydwa obiekty na int i wypisuje większą z dwóch liczb.
 
    Niepowodzenie konwersji powoduje rzucenie wyjątku ValueError.
    '''
    x = int(x) # konwersja do liczby całkowitej (integer), jeśli możliwa
    y = int(y)
 
    if x > y:
        print x, 'jest większa'
    else:
        print y, 'jest większa'
 
printMax(3, 5)
print(printMax.__doc__)

5 jest większa
Konwertuje obydwa obiekty na int i wypisuje większą z dwóch liczb.
 
    Niepowodzenie konwersji powoduje rzucenie wyjątku ValueError.

Używanie DocString

Napis w pierwszym logicznym wierszu funkcji staje się docstring-iem dla tej funkcji. Dodajmy, że DocStrings również stosują się do modułów i klas, o których będzie mowa później.

Konwencją stosowaną dla dokumentacji jest napis w kilku wierszach. Pierwszy wiersz zaczyna się wielką literą i kończy kropką. Następny wiersz jest pusty, a w trzecim wierszu rozpoczynamy dokładniejsze objaśnienia. Jest bardzo wskazane, aby stosować się do tej konwencji opisując napisane przez siebie funkcje.

Możemy odczytać dosctring jakiejś funkcji (na przyklad printMax) używając jej atrybutu (czyli nazwy należącej do funkcji) __doc__ (zauważ użycie po dwóch znaków podkreślenia). Atrybuty są częścią obiektów, którymi są też funkcje. O obiektach będzie mowa w następnych rozdziałach.

Używając pomocy help() w Pythonie robimy użytek z docstringow. Funkcja help() pobiera z funkcji jej atrybut __doc__ i wypisuje go. Możesz to wypróbować na powyższej funkcji — napisz w swoim programie help(printMax). Pamiętaj, żeby nacisnąć klawisz q, żeby zakończyć pomoc help.

Automatyczne narzędzia programistyczne pobierają dokumentację z twoich programów właśnie w taki sposób. Dlatego dobrze jest używać docstrings do każdej napisanej funkcji. Komenda pydoc, dostępna w dystrybucji języka Python działa podobnie do funkcji help() używając docstrings.

Co powinna zawierać dokumentacja funkcji

Nawet krótka dokumentacja funkcji może być bardzo pomocna. Co powinno się w niej znaleźć?

1. Jednolinijkowy opis działania wykonywanego przez funkcję: „Mnoży wektorowo argumenty i zwraca ślad wyniku.”
2. Nie ma potrzeby pisać, czym jest opisywany obiekt (w tym przypadku funkcją), ani duplikować listy parametrów, bo użytkownik i tak to wie z opisu wygenerowanego automatycznie: „To jest funkcja która ma parametry a, b, c.”
3. Dobrze jest napisać co funkcja zwraca, jeśli coś zwraca.
4. Jeśli funkcja ma być wykorzystywana przez innych jako funkcja biblioteczna, to opis musi być znacznie dłuższy — powinien zawierać głębsze wyjaśnienie tego co funkcja robi, jeśli to jest istotne jakie ma ograniczenia i warunki działania.
5. W przypadku funcji złożonych obliczeniowo, dobrze jest napisać jak czas wykonywania funkcji rośnie wraz ze wzrostem rozmiaru argumentów wejściowych.
6. Dobrze jest podać przykład użycia funkcji i oczekiwanego wyniku. Zob. http://docs.python.org/library/doctest.html .

Docstrings to ważne narzędzie, którego warto używać, bo dzięki dokumentacji program jest łatwiejszy do zrozumienia.

Ćwiczenia

Moduły

Wprowadzenie

Dowiedziałeś się, jak używać wielokrotnie fragmentu kodu programu dzieląc go na funkcje. A w jaki sposób można używać funkcji zdefiniowanych w innym miejscu? Jak pewnie zgadłeś, odpowiedzią są moduły.

Są różne metody pisania modułów, ale najprościej jest stworzyć plik z rozszerzeniem .py, który będzie zawierał funkcje i zmienne.

Moduły do Pythona można pisać nie tylko w Pythonie. Można, na przykład, napisać moduł do wydajnych obliczeń numerycznych w bardziej wydajnym języku C i po skompilowaniu używać go w swoim pythonowym kodzie.

Aby użyć zawartości modułu, należy go zaimportować. Dotyczy to również modułów ze standardowej biblioteki Pythona, od czego właśnie zaczniemy.

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: uzycie_sys.py
 
import sys
 
print 'Polecenia linii komend to:'
for i in sys.argv:
    print i
 
print '\n\nPYTHONPATH to:',sys.path,'\n'

Rezultat:

$ python uzycie_sys.py my jestesmy argumentami
Polecenia linii komend to:
uzycie_sys.py
my
jestesmy
argumentami


PYTHONPATH to: ['/home/Swaroop', '/usr/lib/python25.zip', '/usr/lib/python2.5', 
'/usr/lib/python2.5/plat-linux2', '/usr/lib/python2.5/lib-tk', '/usr/lib/python2
.5/lib-dynload', '/usr/local/lib/python2.5/site-packages', '/usr/lib/python2.5/s
ite-packages', '/usr/lib/python2.5/site-packages/Numeric', '/usr/lib/python2.5/s
ite-packages/PIL', '/usr/lib/python2.5/site-packages/gst-0.10', '/var/lib/python
-support/python2.5', '/usr/lib/python2.5/site-packages/gtk-2.0', '/var/lib/pytho
n-support/python2.5/gtk-2.0']

PYTHONPATH to lista katalogów, w których Python poszukuje modułów. W IDLE listę taką można obejrzeć klikając: File->Path Browser.

Jak to działa?

Najpierw importujemy moduł sys używając polecenia import sys, czyli mówimy Pythonowi, że chcemy go używać. Moduł sys zawiera polecenia związane z Pythonem i jego środowiskiem, czyli systemem.

Podczas wykonywania polecenia import sys Python szuka pliku lub katalogu o odpowiedniej nazwie (m.in. zaczynającej się od sys). Aby operacja się powiodła, moduł musi być w jednym z katalogów wymienionych w zmiennej sys.path.

Po znalezieniu modułu treść jego głównego bloku zostaje wykonana, a funkcjonalność dostarczana przez moduł staje się dostępna w programie. Opisana inicjalizacja modułu następuje tylko raz, podczas jego pierwszego importu w danym programie.

Do zmiennych i funkcji zdefiniowanych w module dostajemy się korzystając z notacji z kropką. Na przykład, zmienna argv w module sys jest dostępna jako (sys.argv), dzięki czemu wiadomo, że ta nazwa jest częścią modułu sys. Zaletą tej notacji jest możliwość zdefiniowania zmiennych o tej samej nazwie w różnych modułach bez utraty jednoznaczności. Możemy mieć wiele zmiennych argv w różnych modułach, i jednoznacznie się do niech odwoływać.

Zmienna sys.argv jest listą ciągów znaków. (Listy poznamy dokładniej w następnym rozdziale.) Dokładniej mówiąc, zawiera listę argumentów, z którymi program został wywołany, czyli nazwę pliku zawierającego program oraz to, co użytkownik programu wpisał po nazwie w wywołaniu z wiersza poleceń.

Gdy wpisujemy python uzycie_sys.py my jestesmy argumentami, uruchamiamy moduł uzycie_sys.py za pomocą aplikacji python wraz z argumentami my jestesmy argumentami. Python przechowuje dla nas treść linii komend w zmiennej sys.argv.

Pamiętaj, że nazwa uruchamianego skryptu jest zawsze na początku listy sys.argv. Dlatego w omawianym przykładzie mamy następujące przypisania:

• uzycie_sys.py jako sys.argv[0],
• my jako sys.argv[1],
• jestesmy jako sys.argv[2]
• argumentami jako sys.argv[3].

Zauważ, że Python numeruje od 0, nie od 1.

sys.path zawiera listę katalogów, z których są importowane moduły. Zobacz, że pierwsza pozycja to folder, w którym został uruchomiony program. Folder, w którym został uruchomiony program zostaje automatycznie wstawiony na początek listy, natomiast pozostałe jej elementy są takie same niezależnie od miejsca wywołania. Oznacza to, że możesz łatwo importować moduły znajdujące się w katalogu bieżącym. Inne moduły są dostępne tylko w wypadku gdy znajdują się w którymś z katalogów wymienionych w ścieżce.

Przy okazji, możesz w każdej chwili podejrzeć katalog, w którym jesteś wpisując w Pythonie print os.getcwd() (oczywiście najpierw musisz zaimportować moduł os).

Pliki pośrednie .pyc

Importowanie modułu to dosyć czasochłonna operacja, więc Python używa pewnych sztuczek, aby ją przyspieszyć. Jedną z nich jest tworzenie plików skompilowanych do kodu bajtowego — pewnej formy pośredniej z rozszerzeniem .pyc. Pliki .pyc są niezależne od platformy. Plik .pyc jest przydatny, gdy masz zamiar zaimportować dany moduł po raz kolejny, używając innego programu - o wiele szybciej, gdyż część pracy potrzebnej do zaimportowania została już wykonana.

Uwaga

Pliki .pyc są zazwyczaj tworzone w tym samym folderze, co odpowiednie pliki .py. Jeżeli Python nie ma pozwolenia na zapis w tym folderze, pliki .pyc nie zostaną utworzone.

Konstrukcja from ... import ...

Jeżeli chcesz bezpośrednio zaimportować zmienną argv do swojego programu (aby nie pisać ciągle sys.), możesz użyć wyrażenia from sys import argv. Jeżeli chcesz zaimportować wszystko, co znajduje się w module sys, możesz użyć wyrażenia from sys import *. To działa z każdym modułem.

Tak naprawdę, powinieneś normalnie używać formy import ..., i odwoływać się do zmiennych z innych modułów przez nazwę ich modułu. Formy from...import... powinieneś używać wtedy, gdy dana nazwa będzie używana bardzo często i kłopotliwe byłoby używanie pełnej ścieżki. Formy z gwiazdką nie powinieneś używać w programach, bo powoduje zaśmiecenie przestrzeni nazw. Niemniej jest ona użyteczna w trybie interaktywnym, gdzie naprawdę nie chcemy pisać długich nazw.

Konstrukcja import ... as ...

Istnieje też możliwość zaimportowania modułu pod inną nazwę. Konstrukcja import nazwa_modulu as inna_nazwa spowoduje zaimportowanie modułu, z tym, że dostęp do jego zmiennych i funkcji będzie się odbywał przez inna_nazwa. . Może to być przydatne jeśli chcemy sobie oszczędzić pisania (na ogół inna_nazwa wybierana jest jako znacznie krótsza niż oryginalna nazwa_modulu)

Samoidentyfikacja modułu

Każdy moduł posiada zmienną zawierającą jego nazwę (zazwyczaj). Najczęściej używa się tej zmiennej wtedy, gdy chcemy się dowiedzieć, czy moduł został zaimportowany, czy uruchomiony jako program. Jak już wcześniej wspomniano, gdy moduł zostaje zaimportowany po raz pierwszy, jego kod zostaje wykonany. W przypadku definicji funkcji i klas ich wykonanie oznacza po prostu zdefiniowanie tych funkcji i klas. Polecenia zapisane w treści funkcji nie zostają wykonane w momencie definicji funkcji, lecz dopiero później, w momencie wywołania funkcji. Podobnie jest dla klas, czyli definicja klasy nie powoduje stworzenia obiektu. Natomiast wyrażenia znajdujące się poza definicjami funkcji i klasy zostają wykonane od razu. Często chcemy, by zostałe one wykonane tylko wtedy, gdy uruchamiamy moduł jako program.

Zmienna __name__ zawiera nazwę modułu. Wyjątkiem jest sytuacja gdy został on uruchomiony samodzielnie, jako program. Wówczas zawiera napis '__main__'. Dzięki temu możemy rozróżnić dwa sposoby wywołania modułu i podjąć odpowiednie decyzje.

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: nazwa.py
 
if __name__ == '__main__':
    print 'Ten program jest uruchomiony samodzielnie.'
else:
    print 'Zostałem zaimportowany z innego modułu.'

Rezultat:

$ python nazwa.py
Ten program jest uruchomiony samodzielnie.
 
$ python
>>> import nazwa
Zostałem zaimportowany z innego modułu.
>>>

Jak to działa?

Każdy moduł Pythona ma zdefiniowaną własną nazwę. Jeżeli jest nią '__main__', oznacza to, że moduł działa samodzielnie, a wtedy możemy podjąć odpowiednie działania.

Tworzenie własnych modułów

Tworzenie własnych modułów jest proste, robisz to cały czas! A to dlatego, że każdy program w Pythonie jest także modułem. Ty musisz tylko zadbać, żeby miał rozszerzenie .py. Ten przykład powinien wszystko wyjaśnić.

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: mojmodul.py
 
def mowczesc():
    print 'Cześć, tu mówi mojmodul.'
 
__version__ = '0.1'
 
# Koniec modułu mojmodul.py.

Oto przykładowy moduł. Jak widać, nie ma tu nic szczególnie różniącego go od zwykłego programu w Pythonie. Następnie zobaczymy, jak go użyć w innych naszych programach.

Pamiętaj, że moduł powinien być umieszczony w tym samym katalogu co program, który z niego korzysta, lub też w jednym z katalogów wpisanych w sys.path.

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: mojmodul_demo.py
 
import mojmodul
 
mojmodul.mowczesc()
print 'Wersja', mojmodul.__version__

Rezultat:

$ python mojmodul_demo.py
Cześć, tu mówi mojmodul.
Wersja 0.1

Jak to działa?

Zauważ, że używamy tego samego zapisu z kropkami przy uzyskiwaniu dostępu do elementów modułu. Python robi dobry użytek z tej samej notacji nadając temu swoisty „pythonowy” styl, dzięki czemu nie musimy wciąż poznawać coraz to nowych metod pracy.

Oto wersja z użyciem from...import...:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: mojmodul_demo2.py
 
from mojmodul import mowczesc, __version__
 
mowczesc()
print 'Wersja', __version__

Rezultat mojmodul_demo2.py jest taki sam jak mojmodul_demo.py.

Ta forma jest przykładem bardzo złego stylu. Zauważ, że jeżeli nazwa __version__ już istniała wcześniej w module, który importuje mojmodul, powstanie konflikt nazw. Na dodatek jest to bardzo prawdopodobne, ponieważ zmienna o nazwie __version__ jest standardowo używana po przechowywania wersji modułu. W momencie kiedy plik mojmodul_demo zostanie wydłużony, łatwo o pomyłkę, bo normalnie __version__ to wersja bieżącego modułu, a tutaj to wersja modułu mojmodul. Stąd zawsze lepiej użyć wyrażenia import w taki sposób, by ograniczyć liczbę importowanych nazw.

Możesz także użyć:

from mojmodul import *

To spowoduje zaimportowanie prawie wszystkich nazw, jak na przykład mowczesc, ale ominie __version__, gdyż zaczyna się ona od podwójnego podkreślenia. Ta wersja jest jeszcze brzydsza.

Funkcja dir

Możesz użyć wbudowanej funkcji dir, aby wypisać nazwy zdefiniowane w pewnym obiekcie. Na przykład w module takie nazwy wskazują na funkcje, klasy i zmienne w nim zadeklarowane.

Gdy dir() zostaje wywołane z argumentem, to działa na nim. W wypadku wywołania dir() bez argumentu, działa ono na przestrzeni nazw, z której została wywołana.

Przykład:

$ python
 
>>> import sys # Zdobądź listę atrybutów, w tym wypadku dla modułu sys.
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__package__', '__s
tderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_g
etframe', 'api_version', 'argv', 'builtin_module_names', 'byteorder', 'call_trac
ing', 'callstats', 'copyright', 'displayhook', 'dont_write_bytecode', 'exc_clear
', 'exc_info', 'exc_type', 'excepthook', 'exec_prefix', 'executable', 'exit', 'f
lags', 'float_info', 'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'get
sizeof', 'gettrace', 'hexversion', 'maxint', 'maxsize', 'maxunicode', 'meta_path
', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix',
 'ps1', 'ps2', 'py3kwarning', 'pydebug', 'setcheckinterval', 'setdlopenflags', '
setprofile', 'setrecursionlimit', 'settrace', 'stderr', 'stdin', 'stdout', 'subv
ersion', 'version', 'version_info', 'warnoptions']
>>> dir() # Zdobądź listę atrybutów dla aktualnego modułu.
['__builtins__', '__doc__', '__name__', '__package__', 'sys']
>>> a = 5 # Stwórz nową zmienną "a".
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'a', 'sys']
>>> del a # Usuń nazwę.
>>> dir()
['__builtins__', '__doc__', '__name__', '__package__', 'sys']
>>>

Jak to działa?

Na początku sprawdzamy działanie dir na zaimportowanym module sys. Widać długą listę jego atrybutów.

Następnie używamy funkcji dir bez parametrów. Domyślnie zwraca ona listę atrybutów aktualnego modułu. Zauważ, że lista zaimportowanych modułów jest też częścią wyniku.

W celu ujrzenia dir w akcji, deklarujmy nową zmienną a, przypisujemy jej wartość, a następnie sprawdzamy, że na liście pojawiła nazwa naszej nowej zmiennej. Usuwamy ją poleceniem del, czego efekt widać po kolejnym użyciu dir.

Uwaga do del — to polecenie usuwa zmienną/nazwę (w tym wypadku del a), w efekcie później nie da się odnieść do tej nazwy, tak jakby nigdy wcześniej nie istniała.

Pamiętaj, że funkcja dir() działa z każdym obiektem. Na przykład możesz napisać dir(max), aby poznać atrybuty funkcji max, albo dir(str), aby poznać atrybuty klasy str.

Paczki

Właśnie zacząłeś dogłębnie poznawać hierarchię elementów twoich programów. Zmienne zazwyczaj znajdują się w funkcjach. Funkcje oraz zmienne globalne — w modułach. A co gdy chcesz zarządzać modułami? W tym miejscu na scenę wkraczają paczki.

Paczki to katalogi z modułami oraz ze specjalnym plikiem __init__.py, który informuje Pythona, że ten katalog jest specjalnie przeznaczony właśnie do przechowywania modułów.

Powiedzmy, że chcesz stworzyć paczkę o nazwie swiat zawierającą paczki azja, afryka itd., zaś w nich na przykład indie czy madagaskar.

Oto, jak powinna wyglądać twoja struktura katalogów:

 jakiś katalog wymieniony w sys.path
 └── swiat/
     ├── __init__.py
     ├── azja/
     │   ├── __init__.py
     │   ├── indie.py
     │   └── chiny.py
     └── afryka/
         ├── __init__.py
         └── madagaskar.py

Paczki są wygodnym sposobem segregacji modułów. Zobaczysz wiele przykładów ich użycia w bibliotece standardowej.

Podsumowanie

Tak jak funkcje są częściami programu wielokrotnego użytku, tak moduły to programy wielokrotnego użytku. Paczki są odrębną hierarchią organizacji modułów. Standardowa biblioteka Pythona jest przykładem zestawu paczek i modułów.

Zobaczyliśmy jak użyć tych modułów i utworzyć swoje własne.

Następnie poznamy pewne interesujące koncepty zwane strukturami danych.

Zadania

Liczby Fibonacciego

Stwórz moduł fib3 zawierający trzy funkcje zwracające n-tą liczbę Fibonacciego — obliczoną rekurencyjnie z definicji, w pętli, oraz ze wzoru Bineta. Sam moduł oraz funkcje muszą mieć docstringi.

Moduł ma też zawierać bezargumentową funkcję test, której zadaniem jest sprawdzenie poprawności działania wszystkich trzech funkcji i wypisanie odpowiedniego komunikatu. Test powinien być wykonany dla pewnych ustalonych wartości, w szczególności tych granicznych, czyli 0, 1, 2 i innych. Przydatna może być ich lista na http://pl.wikisource.org/wiki/Ciąg_Fibonacciego.

Następnie napisz moduł fib3-czas, który wykorzystuje moduł fib3 i moduł time aby porównać szybkość wykonywania wszystkich trzech algorytmów. Wynik powienien zostać wypisany w postaci tabelki

 n    T1/ms    T2/ms    T3/ms
 1     0.5     0.3      0.7
 2     0.5     0.5      1.0
 ...   ...     ...      ...

Struktury danych — sekwencje

Wprowadzenie

Struktury danych to typy danych posiadających pewną wewnętrzną organizację/strukturę. Struktury danych tworzymy łącząc w określony sposób prostsze typy danych. Przykładem może być książka telefoniczna, gdzie odpowiednio organizując i łącząc proste typy: napis (zawierający nazwisko) i int (zawierający numer telefonu) tworzymy nowy typ danych określający jak jest zbudowany pojedynczy wpisy do książki telefonicznej.

W Pythonie istnieją cztery podstawowe struktury danych — lista, krotka, słownik i zbiór. Tak naprawdę są to klasy — odpowiednio list, tuple, dict, set. Jeśli chcesz wiedzieć więcej o klasach i obiektach, to zajrzyj do rozdziału Programowanie zorientowane obiektowo. Niemniej, aby poprawnie używać obiektów, wystarczy wiedzieć, że obiekty pewnej klasy mają wspólne zachowanie zdefiniowane przez tę klasę. Oznacza to między innymi, że obiekty mają pewien zbiór metod, czyli funkcji które można uruchamiać pisząć obiekt.metoda().

Lista

Lista to struktura, która zawiera uporządkowaną sekwencję obiektów. Tych obiektów może być zero, wtedy lista jest pusta, lub dowolnie dużo. Ten sam obiekt może występować na liście wielokrotnie. Dwie najważniejsze operacje, jakie można wykonać na liście, to:

1. sekwencyjne działania na obiektach od zerowego do ostatniego. Dzięki temu można użyć listy do iterowania pętli. Wyrażenie for element in lista: rozpoczyna pętlę, w której dostępny jest kolejno każdy element listy.
2. wydobycie z listy obiektu o danym indeksie. Używamy to tego operatora indeksowania []

Łatwo sobie to wyobrazić za pomocą listy zakupów, na której masz zapisane rzeczy do kupienia. Jedyna różnica jest taka, że na liście zakupów zazwyczaj rzeczy wpisuje się jedną pod drugą, zaś w Pythonie listę zapisuje się rozdzieląc przecinkami obiekty.

Najprostszym sposobem uzyskania listy jest właśnie zapisanie w treści programu ciągu „rzeczy“ rozdzielonych przecinkami, wszystko objęte nawiasami kwadratowymi. Innym sposobem jest wywołanie funkcji, która zwróci listę.

Do listy można dodawać elementy i je z niej usuwać. Te operacje zmieniają listę, więc mówimy, że lista jest zmiennym typem danych.

Przykład użycia listy

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: lista.py
 
# To moja lista zakupów:
lista = ['jabłko', 'mango', 'marchew', 'kiwi']
 
print 'Mam', len(lista), 'rzeczy do kupienia.'
 
print 'Te rzeczy to:',
for i in lista:
    print i,
 
print '\nMuszę jeszcze kupić ryż.'
lista.append('ryż')
print 'Teraz moja lista to:', lista
 
print 'Posortuję moją listę.'
lista.sort()
print 'Posortowana lista to:', lista
 
print 'Pierwsza rzecz, jaką muszę kupić, to', lista[0]
rzecz = lista[0]
del lista[0]
print 'Kupiłem', rzecz
print 'Moja lista teraz to:', lista

Rezultat:

Mam 4 rzeczy do kupienia.
Te rzeczy to: jabłko mango marchew kiwi
 
Muszę jeszcze kupić ryż.
Teraz moja lista to: ['jabłko', 'mango', 'marchew', 'kiwi', 'ryż']
Posortuję moją listę.
Posortowana lista to: ['jabłko', 'kiwi', 'mango', 'marchew', 'ryż']
Pierwsza rzecz, jaką muszę kupić, to jabłko
Kupiłem jabłko
Moja lista teraz to: ['kiwi', 'mango', 'marchew', 'ryż']

Jak to działa?

Zmienna lista jest listą zakupów kogoś wybierającego się do sklepu. Przechowujemy tam jedynie słowa oznaczające przedmioty do kupienia, ale tak naprawdę lista może zawierać dowolne obiekty, np. liczby czy inne listy.

Użyliśmy też pętli for...in... do przejścia po wszystkich elementach listy. W tym momencie można zauważyć, że lista jest przykładem sekwencji. Ale sekwencje poznasz trochę później.

Zauważ, że na końcu polecenia print użyliśmy przecinka. Powoduje to, że Python zakończy wypisywanie spacją, a nie przejściem do nowej linii.

Następnie dodaliśmy obiekt do listy metodą append, po czym sprawdziliśmy, czy to podziałało, po prostu każąc wypisać nową zawartość listy na ekran.

Po tym wszystkim posortowaliśmy listę za pomocą metody sort. Ważne jest to, że wynik powstaje przez przestawianie obiektów wewnątrz tej samej listy. Innymi słowy, żaden nowy obiekt nie zostaje stworzony, zmienia się tylko kolejność elementów na liście, co nazywamy sortowaniem w miejscu.

Zamiast sortowania w miejscu, można by stworzyć nową listę zawierającą te same elementy w innej kolejności. Do wykonania takiej operacji można wykorzystać funkcję sorted:

posortowana = sorted(lista)

Z tego przykładu widać, że lista jest typem zmiennym, czyli obiekty tej klasy można modyfikować. W przypadku innych typów, jak krotka (tuple) czy napis (str), dysponujemy tylko tym drugim sposobem sortowania. Mówimy, że są to typy niezmienne, przez co rozumiemy, że obiekt tej klasy, raz stworzony, nie może być zmieniony.

Gdy kupiliśmy już jakąś rzecz z listy, chcemy tę pozycję usunąć. Używamy do tego polecenia del — tutaj chcemy wyrzucić pierwszy (czyli w Pythonie zerowy) element, więc piszemy del lista[0].

Przydatne metody klasy lista

Poniżej prezentujemy metody dla obiektów klasy list. Niech nasza przykładowa lista nazywa się L:

L.append(x)

Dodaje element x na koniec listy L. Taki sam efekt daje wyrażenie: L[len(L):] = [x].

L.extend(L2)

Wydłuża listę L dodając na jej końcu wszystkie elementy listy L2. Taki sam efekt daje wyrażenie: L[len(L):] = L2.

L.insert(i, x)

Wstawia element x do listy L na pozycji i. Dotychczasowe elementy listy L o indeksach od i do ostatniego mają teraz indeksy zwiększone o 1. Na przykład L.insert(0, x) wstawia element x na początek listy L natomiast L.insert(len(L), x) dodaje element na koniec listy.

L.remove(x)

Usuwa z listy L pierwszy napotkany element o wartości x. Uwaga: Jeśli takiego elementu nie ma funkcja generuje błąd!

L.pop(i)

Usuwa z listy L element o indeksie i i zwraca jego wartość. Jeśli nie podamy argumetu i to domyślnie funkcja zostanie zastosowana do ostatniego elementu listy.

L.index(x)

Zwraca pierwszy napotkany na liście L element o wartości x. Uwaga: Jeśli takiego elementu nie ma funkcja generuje błąd!

L.count(x)

Zwraca liczbę wystąpień elementu o wartości x na liście L.

L.sort()

Sortuje elementy listy L w miejscu.

L.reverse()

Odwraca kolejność elementów na liście L w miejscu.

>>> L = [66.25, 333, 333, 1, 1234.5]
>>> print L.count(333), L.count(66.25), L.count('x')
2 1 0
>>> L.insert(2, -1)
>>> L.append(333)
>>> L
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> L.index(333)
1
>>> L.remove(333)
>>> L
[66.25, -1, 333, 1, 1234.5, 333]
>>> L.reverse()
>>> L
[333, 1234.5, 1, 333, -1, 66.25]
>>> L.sort()
>>> L
[-1, 1, 66.25, 333, 333, 1234.5]

Zadanie: wariancja i odchylenie standardowe średniej

Napisz program, który wczytuje wyniki pomiaru pewnej wielkości, czyli po prostu listę liczb. Niech użytkownik wpisuje liczby podając po jednej w każdej linijce „standardowego wejścia” — czyli na przykład wpisując je z klawiatury. Pusta linijka niech oznacza koniec danych.

Po wczytaniu wszystkich liczb, wypisz je w kolejności rosnącej, wraz z odchyleniem każdej liczby od średniej. Następnie wypisz nieobciążoną estymatę wariancji i odchylenia standardowego średniej całej sekwencji.

Przykład:

Wpisz liczby:
1
3
2.5
 
Dzięki.
Posortowane:
1     -1.167
2.5    0.333
3      0.833
wariancja=1.083
odchylenie=0.601

Wskazówka:

wariancja

oraz

odchylenie standardowe

oraz

odchylenie standardowe średniej

Zadanie: outliers

Przez outliers rozumie się punkty odstające od reszty danych. W przypadku pomiarów takie punkty mogą na przykład pochodzić z błędnie przeprowadzonych pomiarów — jeśli mierzymy temperaturę termoparą i wszystkie pomiary temperatury dały ok. 30 mV, a tylko jeden 0 mV, to może w tym jednym pomiarze termopara odłączyła się od woltomierza? Niemniej zwyczajny statystyczny rozrzut wyników też może skutkować pomiarami leżącymi daleko od średniej, tyle że z małym prawdopodobieństwem.

W przypadku rozkładu Gaussa 99,7% wyników (średnio) pada w przedziale [μ−3σ, μ+3σ], gdzie μ to średnia, a σ to odchylenie standardowe. Napisz program, który tak jak w poprzednim przykładzie wczyta listę liczb, a następnie wypisze te z nich, które leżą poza przedziałem 3σ. Dla każdej z wypisywanych liczb wypisz też jej kolejność na liście. Na końcu napisz jaki procent liczb znalazł się poza przedziałem 3σ.

Zadanie: outliers 2

W poprzednim przykładzie liczby były wprowadzane przez użytkownika programu. Wprowadzanie liczb szybko robi się męczące. Na szczęście można użyć generatora liczb losowych, żeby „wprowadzić” liczby.

Generator liczb pseudolosowych zazwyczaj zwraca po prostu liczby z pewnego przedziału — np. pomiędzy 0 a 1 — zgodnie z rozkładem płaskim. Innymi słowy, wylosowanie liczby z dowolnego miejsca w całym przedziale jest tak samo prawdopodobne. Takim generatorem jest funkcja random.random.

W naszym przykładzie chcemy mieć liczby które przypominają wyniki pomiarów — czyli mają raczej rozkład normalny niż płaski. Jeśli dysponujemy generatorem liczb losowych płaskich, to bez problemu można „przerobić” go na generator liczb z dowolnego rozkładu jeśli tylko znamy dystrybuantę tego rozkładu. Na szczęście ten krok został już za nas wykonany i możemy po prostu skorzystać z funkcji random.normalvariate.

Funkcja normalvariate(mu, sigma) z modułu random ma dwa parametry — środek rozkładu i jego szerokość. Zwraca pojedynczą liczbę wylosowaną zgodnie z rozkładem normalnym.

Zmodyfikuj program z poprzedniego przykładu tak, by zamiast wczytywać liczby, generował je automatycznie. Od użytkownika pobierz tylko liczbę liczb n, i pożądane parametry μ, σ, a następnie posłuż się funkcją random.normalvariate by wygenerować n liczb z rozkładu normalnego.

Przykład:

>>> python outliers2.py
N= 100                        # 100 wpisane przez użytkownika
μ= 3                          # 3 wpisane przez użytkownika
σ= 1                          # 1 wpisane przez użytkownika
liczby:
2.93313883,  4.27443167,  3.02747082,  3.74820712,  1.67385955,
3.91314826,  2.85697077,  3.72747457,  0.83560025,  2.60574017,
...
3.90344627,  2.07056563,  2.01952891,  2.81624163,  -0.469027334
outliers:
100: -0.469027334
poza 3σ: 1%

Pamiętaj, że oczekiwana częstość występowania liczb spoza przedziału 3σ to tylko 3‰.

Krotka

Krotka to niemodyfikowalna lista.

Podobnie jak listy, krotki można wygodnie tworzyć, wykorzystując specjalną notację: krotkę definiuje się przez wypisanie jej elementów oddzielonych przecinkami. Często, dla czytelności, warto zamknąć definicję krotki w nawias.

Krotki używa się w sytuacji, gdy chcemy przechowywać niezmienną sekwencję obiektów.

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: krotka.py
 
zoo = ('pyton', 'słoń', 'pingwin') # Pamiętaj, że nawiasy są opcjonalne.
print 'Liczba zwierząt w zoo:', len(zoo)
 
nowe_zoo = ('małpa', 'wielbłąd', zoo)
print 'Liczba klatek w nowym zoo:', len(nowe_zoo)
print 'Wszystkie zwierzęta w nowym zoo to:', nowe_zoo
print 'Zwierzęta sprowadzone ze starego zoo to:', nowe_zoo[2]
print 'Ostatnim zwierzęciem sprowadzonym ze starego zoo jest', nowe_zoo[2][2]
print 'Liczba zwierząt w nowym zoo:',len(nowe_zoo)-1+len(nowe_zoo[2])

Rezultat:

Liczba zwierząt w zoo: 3
Liczba klatek w nowym zoo: 3
Wszystkie zwierzęta w nowym zoo to: ('małpa', 'wielbłąd', ('pyton', 'słoń', 'pingwin'))
Zwierzęta sprowadzone ze starego zoo to: ('pyton', 'słoń', 'pingwin')
Ostatnim zwierzęciem sprowadzonym ze starego zoo jest pingwin
Liczba zwierząt w nowym zoo: 5

Jak to działa?

Zmienna zoo odnosi się do krotki złożonej ze zwierząt. Jak widać, dzięki funkcji len możemy sprawdzić długość krotki. To dodatkowo pokazuje, że krotka jest sekwencją.

Z powodu zamknięcia starego zoo, przenosimy zwierzęta do nowego. Dlatego też krotka nowe_zoo zawiera kilka zwierząt, które były już tam wcześniej, a także zwierzęta przeniesione ze starego zoo. Wracając do rzeczywistości, zauważ, że krotka w krotce nie traci swojej tożsamości.

Możemy odnieść się do pojedynczego elementu krotki poprzez podanie pozycji tego elementu w nawiasach kwadratowych, zupełnie jak przy listach. Nazywamy to operatorem indeksowania. Uzyskujemy trzeci element w krotce nowe_zoo przez wpisanie nowe_zoo[2] oraz trzeci element w trzecim elemencie tej krotki dzięki nowe_zoo[2][2].

Notacja „krotkowa”

Nawiasy

Pomimo, że są opcjonalne, warto często użyć nawiasów, by podkreślić, że tworzy się krotkę. Np.

a = (1, 2, 3)
# zamiast
a = 1, 2, 3

Z tych dwóch równoważnych wersji, pierwsza wydaje się czytelniejsza.

Odmienna sytuacja występuje w przypadku wypisywania zmiennych. Wyrażenia print 1,2,3 oraz print (1,2,3) mają różne znaczenia. Za pierwszym razem uzyskamy trzy cyfry oddzielone przecinkami, a za drugim krotkę (czyli te same trzy liczby oddzielone przecinkami, ale jeszcze dodatkowo otoczone nawiasami).

Krotka pusta lub z 1 elementem

pusta = ()

Krotka jednoelementowa to już większy problem. Jeśli napiszesz wyrażenie zawierające pojedynczą zmienną w nawiasach okrągłych, to (teoretycznie), można by to rozumieć jako

1. krotkę jednoelementową
2. jedno-elementowe wyrażenie wzięte w nawias

Z tych dwóch możliwości twórcy języka wybrali tą drugą. Dlatego aby stworzyć krotkę, należy użyć przecinka po pierwszym (i jedynym) jej elemencie.

samotnik = (2, )

Sekwencje

Listy, krotki i napisy określamy mianem sekwencji. Kolejność elementów w sekwencji jest ustalona i elementy te są ponumerowane. Jest to cecha wspólna wszystkich sekwencji. Numer elementu w sekwencji jest nazywany indeksem. Podstawową operacją dla sekwencji jest pobranie wartości elementu o zadanym indeksie. Ponadto możemy sprawdzić czy dany obiekt jest elementem danej sekwencji (operatory in i not in).

Wymienione wcześniej trzy typy sekwencji — lista, krotka i ciąg znaków, mogą być dodatkowo pocięte, dzięki czemu uzyskujemy wycinek, czyli pod-sekwencję zawierającą część obiektów z oryginalnej sekwencji.

Wybieranie elementów przez indeksowanie lub wycinanie pokażemy dokładniej na przykładzie napisu. Napisy są również przykładem sekwencji elementów (liter).

Indeksy

Indeksując napis odwołujemy się do wybranego znaku. Znaki mogą być liczone od początku napisu (pierwszy ma numer 0) lub od jego końca (ostatni ma numer –1).

Na powyższym rysunku czerwone indeksy są liczone od początku napisu, a niebieskie od jego końca.

Teraz przykłady:

Nie ma indeksu −0, bo w Pythonie −0 == 0, więc −0 również wskazuje na początek napisu.

Numery wskazujące na miejsca poza końcem napisu lub przed jego początkiem są błędne, Python zwróci informację o błędzie, tzw. IndexError.

Przykład — indeksy dla napisu "string"

Indeksy dodatnie

>>> tekst[0]
's'
>>> tekst[1]
't'
>>> tekst[2]
'r'
>>> tekst[3]
'i'
>>> tekst[4]
'n'
>>> tekst[5]
'g'

Indeksy ujemne

>>> tekst = "string"
>>> tekst[-1]
'g'
>>> tekst[-2]
'n'
>>> tekst[-3]
'i'
>>> tekst[-5]
't'
>>> tekst[-4]
'r'
>>> tekst[-5]
't'
>>> tekst[-6]
's'

Wycinki

Pobranie wycinka sekwencji polega na wybraniu jej fragmentu — podsekwencji. Miejsca początku i końca zakresu z którego pobieramy wycinek liczone są podobnie jak przypadku indeksowania. Istotna różnica jest taka, że wskazujemy podsekwencję, a nie pojedynczy element — i to w sposób szczególny. Przedział który wskazujemy jako [a:b], jest zamknięty od strony a, a otwarty od strony b.

Lewy i prawy kraniec wycinka podajemy oddzielając indeksy dwukropkiem :. Każdą z tych wartości można pominąć, w skrajnym przypadku zostawiając tylko dwukropek. Jeśli dany indeks pominiemy, zostaną użyte wartości domyślne:

• domyślne położenie początku wycinka to początek sekwencji
• domyślne położenie końca wycinka to koniec całej sekwencji

Taka konwencja ma pewne zalety, w szczególności dla dowolnego indeksu a prawdą jest, że

sekwencja[:a] + sekwencja[a:] == sekwencja

Konstruując wycinek możemy pobierać co n-ty element napisu. Robi się to podając wartość kroku n po kolejnym dwukropku. Domyślnie n ma wartość 1.

Teraz przykłady:

Numery wskazujące na miejsca poza rozmiarem napisu nie są błędne, Python wybierze tylko istniejące znaki.

Przykład drugi:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: sekwencja.py
 
lista = ['jabłko', 'mango', 'marchew', 'kiwi']
imie = 'Juliusz'
 
# Indeksowanie
print 'Rzecz 0 to', lista[0]
print 'Rzecz 1 to', lista[1]
print 'Rzecz 2 to', lista[2]
print 'Rzecz 3 to', lista[3]
print 'Rzecz -1 to', lista[-1]
print 'Rzecz -2 to', lista[-2]
print 'Litera 0 to', imie[0]
 
# Cięcie listy.
print 'Rzeczy od 1 do 3 to', lista[1:3]
print 'Rzeczy od 2 do końca to', lista[2:]
print 'Rzeczy od 1 do -1 to', lista[1:-1]
print 'Rzeczy od początku do końca to', lista[:]
 
# Cięcie ciągu znaków.
print 'Litery od 1 do 3 to', imie[1:3]
print 'Litery od 2 do końca to', imie[2:]
print 'Litery od 1 do -1 to', imie[1:-1]
print 'Litery od początku do końca to', imie[:]

Rezultat:

Rzecz 0 to jabłko
Rzecz 1 to mango
Rzecz 2 to marchew
Rzecz 3 to kiwi
Rzecz -1 to kiwi
Rzecz -2 to marchew
Litera 0 to J
Rzeczy od 1 do 3 to ['mango', 'marchew']
Rzeczy od 2 do końca to ['marchew', 'kiwi']
Rzeczy od 1 do -1 to ['mango', 'marchew']
Rzeczy od początku do końca to ['jabłko', 'mango', 'marchew', 'kiwi']
Litery od 1 do 3 to ul
Litery od 2 do końca to liusz
Litery od 1 do -1 to ulius
Litery od początku do końca to Juliusz

Jak to działa?

Najpierw używamy indeksów do pobrania wartości poszczególnych elementów sekwencji. Nawiasy kwadratowe są operatorem indeksowania — gdy przy sekwencji podasz liczbę w nawiasach kwadratowych to uzyskasz element z danej pozycji. Pamiętaj, że w Pythonie, podobnie jak w C i wielu innych językach programowania, sekwencje czy tablice numeruje się od 0, dlatego lista[0] to pierwszy element, a lista[3] to czwarty.

Indeks może też być ujemny, wtedy liczenie zaczyna się od końca sekwencji. Dlatego lista[-1] to ostatni element, a lista[-2] to przedostatni.

Operacja pobierania wycinka jest wykonywana przez podanie obiektu do pocięcia, a następnie dwóch liczb w nawiasie kwadratowym, przedzielonych dwukropkiem.

Pierwsza liczba (przed dwukropkiem) w operacji pobrania wycinka oznacza pozycję startową, zaś druga (za dwukropkiem) wyznacza dokąd cięcie ma zostać wykonane. Jeżeli nie ma pierwszej liczby, to Python zacznie wycinać od początku. Gdy nie ma drugiej, to wytnie aż do końca. Zauważ, że cięcie zaczyna się równo z pozycją startową, ale kończy się przed pozycją końcową. To znaczy, że pozycja startowa jest zawarta w wyciętym fragmencie, ale pozycja końcowa już nie jest.

W związku z tym, lista[1:3] zwraca elementy 1 i 2, ale nie zwraca już trzeciego, zaś lista[:] (tzw. pełny wycinek) zwraca kopię sekwencji.

Możesz także podać trzeci argument, którym jest krok cięcia (domyślnie 1).

>>> lista = ['jabłko', 'mango', 'marchew', 'kiwi']
>>> lista[::1]
['jabłko', 'mango', 'marchew', 'kiwi']
>>> lista[::2]
['jabłko', 'marchew']
>>> lista[::3]
['jabłko', 'kiwi']
>>> lista[::-1]
['kiwi', 'marchew', 'mango', 'jabłko']

Jak widzisz, gdy krok wynosi 2, uzyskujemy elementy numer 0, 2, ..., zaś gdy wynosi 3, uzyskujemy elementy numer 0, 3, ... itd.

Wypróbuj różne kombinacje używając interpretera w trybie interaktywnym. Najlepsze jest to, że możesz dokładnie to samo robić na każdym typie sekwencji, czy to lista, czy krotka, czy ciąg znaków!

 napis = "dane_użytkownika =     {tajne hasło} login=użytkownik    "

Odniesienia

Gdy tworzysz obiekt i przypisujesz go do zmiennej, zmienna jedynie odnosi się do tego obiektu, a nie reprezentuje go. Nazywamy to związywaniem (ang. binding) nazwy z obiektem. Tak więc, nazwa zmiennej jedynie wskazuje miejsce w pamięci komputera, w którym znajdują się określone dane. Pociąga to za sobą pewne konsekwencje, które ilustruje poniższy przykład.

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: odniesienie.py
 
print 'Proste Przypisywanie'
lista = ['jabłko', 'mango', 'marchew', 'kiwi']
mojalista = lista # mojalista to tylko inna nazwa dla tej samej zmiennej!
 
del lista[0] # Kupiłem pierwszą rzecz, więc ją usuwam z listy.
 
print 'Lista zakupów:', lista
print 'Moja lista:', mojalista
# Obydwie listy będą zawierać dokładnie to samo, czyli trzy pozycje.
# W żadnej z nich nie pojawi się "jabłko", bo dotyczą tego samego obiektu.
 
print 'Kopiowanie za pomocą pełnego wycinka'
mojalista = lista[:] # Stwórz kopię za pomocą pełnego wycinka...
del mojalista[0] # Usuń pierwszą rzecz...
 
print 'Lista zakupów:', lista
print 'Moja lista:', mojalista
# Teraz te listy będą się różniły.

Rezultat:

Proste Przypisywanie
Lista zakupów: ['mango', 'marchew', 'kiwi']
Moja lista: ['mango', 'marchew', 'kiwi']
Kopiowanie za pomocą pełnego wycinka
Lista zakupów: ['mango', 'marchew', 'kiwi']
Moja lista: ['marchew', 'kiwi']

Pamiętaj, że jak chcesz zrobić kopię jakiejś złożonej zmiennej (nie prostej, jak ciąg znaków), to musisz przypisać mu pełny wycinek. Jeżeli zamiast tego po prostu przypiszesz zmiennej inną nazwę, obydwie nazwy będą się odnosić do tego samego obiektu.

Uwaga dla programujących w Perl

Pamiętaj, że przypisanie listy do zmiennej nie tworzy kopii! Zawsze do skopiowania sekwencji potrzebne jest pobranie pełnego wycinka.

Więcej o ciągach znaków

Już wcześniej omówiliśmy dogłębnie ciągi znaków, więc co jeszcze można dodać? Cóż... Czy wiedziałeś, że to też są obiekty i również mają swoje metody, jak na przykład sprawdzanie, czy w danym tekście jest określone słowo?

Wszystkie ciągi znaków, jakie używasz, mają przypisaną klasę str. Poniżej zaprezentowane jest użycie kilku ciekawych metod tej klasy. Więcej informacji znajdziesz wywołując help(str).

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: str_metody.py
 
imie = 'Aleksander' # To obiekt klasy str.
 
if imie.startswith('Ale'):
    print 'Tak, to imię zaczyna się od "Ale"'
 
if 'a' in imie:
    print 'Tak, to imię zawiera literę "a"'
 
if imie.find('san') != -1:
    print 'Tak, w tym imieniu jest ciąg "san"'
 
separator = ' do '
mojalista = ['Brazylii', 'Rosji', 'Indii', 'Chin']
print 'Wielka podróż z', separator.join(mojalista)

Rezultat:

$ python str_metody.py
Tak, to imię zaczyna się od "Ale"
Tak, to imię zawiera literę "a"
Tak, w tym imieniu jest ciąg "san"
Wielka podróż z Brazylii do Rosji do Indii do Chin

Jak to działa?

Tu widzimy wiele metod w akcji. Metoda startswith sprawdza, czy tekst się zaczyna od podanego ciągu znaków. Operator in sprawdza, czy dany ciąg znaków znajduje się w tym tekście.

Metoda find sprawdza pozycję podanego ciągu znaków w tekście. Zwraca ona -1, gdy nic nie znajdzie. Klasa str ma też ciekawą metodę join, która łączy elementy sekwencji w jeden długi ciąg znaków, używając podanego ciągu jako separatora.

Struktury danych — słowniki i zbiory

W poprzednim rozdziale przedstawione były struktury danych zawierające elementy w pewnym określonym porządku — listy, krotki, napisy. W przypadku struktur danych takich jak słowniki czy zbiory elementy nie mają określonej kolejności. Nie znaczy to, że nie można wykonać operacji dla każdego elementu zbioru jak dla zwykłej sekwencji, tylko że kolejność elementów w zbiorze nie jest dobrze określona.

Słownik

O słowniku wygodnie jest myśleć jako o nieposortowanym zbiorze par klucz:wartość, przy czym klucz musi być unikalny. W słowniku kojarzymy klucze (nazwy) z wartościami (szczegółami). Przykładem słownika jest książka adresowa, w której możesz znaleźć czyjś adres lub telefon znając dane tej osoby.

Kluczem może być tylko obiekt niezmienny (na przykład napis czy krotka), ale wartości mogą być dowolne (napisy, krotki, listy, słowniki, liczby, ...). Tutaj niezmienność krotek znajduje swoje zastosowanie.

Do tworzenia słowników służy następująca notacja:

s = {klucz1 : wartość1, klucz2 : wartość2}

Między kluczem a wartością jest dwukropek, zaś między parami są przecinki. Wszystko jest zamknięte w nawiasach klamrowych.

Pamiętaj, że klucze w słowniku nie są w żaden sposób posegregowane. Jeżeli chcesz mieć je poukładane w jakimś szczególnym porządku, musisz ich listę samemu posortować.

Słowniki to po angielsku dictionary, zaś klasa nazywa się krótko dict.

Przykład:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: slownik.py
 
# "ka" to skrót od "k"siążka "a"dresowa
 
ka = { 'Jan'   : 'jasiek@jasiowo.pl',
       'Tomek' : 'tomek@cba.gov',
       'Ela'   : 'ela@zzzz.com',
       'Kasia' : 'katarzyna@hopla.us'
    }
 
print "Adres Kasi:", ka['Kasia']
 
# Usuwanie pary klucz-wartość.
del ka['Kasia']
 
print u'\nKontaktów w książce adresowej jest {0}.\n'.format(len(ka))
# iterowanie przez pary słownika
for imie, adres in ka.items():
    print '{0} ma adres {1}'.format(imie, adres)
 
# Dodawanie pary klucz-wartość.
ka['Wojtek'] = 'wojtas@kumple.pl'
 
if 'Wojtek' in ka:
    print "\nAdres Wojtka:", ka['Wojtek']
 
# pobranie listy kluczy w słowniku
l = ka.keys()
print l
 
# sprawdzenie czy klucz jest w słowniku
jest =  'Tomek' in ka
print jest

Rezultat:

Adres Kasi: katarzyna@hopla.us
 
Kontaktów w książce adresowej jest 3.
 
Jan ma adres jasiek@jasiowo.pl
Ela ma adres ela@zzzz.com
Tomek ma adres tomek@cba.gov
 
Adres Wojtka: wojtas@kumple.pl
['Jan', 'Wojtek', 'Ela', 'Tomek']
True

Jak to działa?

Tworzymy słownik ka używając omówionej już wcześniej notacji. Następnie docieramy do jednej z wartości używając nazwiska jako klucza. Operację pobrania elementu zapisujemy podobnie jak w przypadku indeksowania sekwencji. Niemniej pary w słowniku nie są uporządkowane i jako „indeksu” do słownika można użyć tylko jeden z kluczy.

Możemy usuwać wpisy ze słownika za pomocą polecenia del — po prostu określamy słownik i klucz, który razem z odpowiednią wartością ma zostać usunięty. Samej wartości nie musimy wcale znać przy tej operacji.

Następnie używamy metody items, która zwraca nam pary w postaci krotek, z których każda składa się z dwóch elementów — pierwszy to klucz, a drugi to wartość. Dzięki for...in... przypisujemy te pary do zmiennych, odpowiednio imie i adres, po czym wypisujemy je w bloku for. Do formatowania napisu wykorzystujemy tu metodę format. Jej argumentem jest krotka. Za numery w nawiasach klamrowych metoda format podstawia element krotki o tym indeksie. Możemy dodać nową parę klucz-wartość po prostu używając operatora indeksowania do oznaczenia klucza i przypisania mu wartości, tak jak zrobiliśmy to dla Wojtka w powyższym przykładzie.

Możemy sprawdzić czy dany klucz istnieje w słowniku za pomocą operatora in.

Jeśli chcesz poznać wszystkie metody dostępne dla klasy słowników, wpisz help(dict) albo zajrzyj do pomocy na sieci.

Słowniki i krotki w przekazywaniu argumentów w wywołaniu funkcji

Tak jak zostało to wcześniej wspomniane, słowniki służą do przekazywania nadmiarowych argumentów nazwanych do funkcji. Jako klucze słownika zostają użyte nazwy (nieistniejących) parametrów w postaci napisów. Klucze wskazują z kolei na wartości argumentów.

def wypisz(separator,*wyrazy, **dodatkowe_informacje):
    print separator # ten argument MUSI wystąpić w wywołaniu funkcji
    print wyrazy    # krotka zawierająca dodatkowe, NIENAZWANE argumenty 
    print dodatkowe_informacje # słownik zawierający dodatkowe NAZWANE argumenty
 
    for w in wyrazy:
        print w, separator,
    print 
    for klucz,wartosc in dodatkowe_informacje.items():
        print klucz, wartosc 
 
 
wypisz(';', 'Być','albo' ,'nie być', sztuka='Hamlet', autor='Szekspir')

;
('By\xc4\x87', 'albo', 'nie by\xc4\x87')
{'sztuka': 'Hamlet', 'autor': 'Szekspir'}
Być ; albo ; nie być ;
sztuka Hamlet
autor Szekspir

Dodatkowe zadania i przykłady

Zob. też bardziej zaawansowane przykłady w rozdziale o wyjątkach.

Bardziej ambitne zadanie wymagające inteligentnego użycia słowników: anagramy.

Zbiór

Zbiory to nieuporządkowane zestawy prostych obiektów. Używamy ich, gdy istotny jest tylko fakt występowania elementu, a nie jego położenie albo liczba powtórzeń.

Zbiory możesz testować pod kątem występowania danego elementu, sprawdzać czy to jest podzbiór innego zbioru, szukać części wspólnej zbiorów i tak dalej.

Przykład:

>>> kraje = set(['Brazylia', 'Rosja', 'Indie'])
>>> kraje.__contains__('Indie')
True
>>> kraje.__contains__('USA')
False
>>> kraje2 = kraje.copy()
>>> kraje2.add('Chiny')   
>>> kraje2.issuperset(kraje) 
True
>>> kraje.issubset(kraje2)
True
>>> kraje.remove('Rosja')
>>> kraje.intersection(kraje2)
set(['Brazylia', 'Indie'])

Lista operatorów działających na zbiory jest przedstawiona w tabeli operatorów w drugim rozdziale.

Te same operacje co powyżej można zwięźlej zapisać korzystając z operatorów zamiast metod.

>>> kraje = set(['Brazylia', 'Rosja', 'Indie'])
>>> 'Indie' in kraje
True
>>> 'USA' in kraje
False
>>> kraje2 = kraje | set(['Chiny'])
>>> kraje2 > kraje
True
>>> kraje < kraje2
True
>>> kraje.remove('Rosja')
>>> kraje & kraje2
set(['Brazylia', 'Indie'])

Jak to działa?

Ten przykład nie wymaga omawiania, gdyż użyte w nim są jedynie proste techniki matematyczne uczone w szkole. Dla porządku dodamy znaczenie używanych tu słów z języka angielskiego: set — zbiór, superset — nadzbiór, subset — podzbiór, intersection — część wspólna zbiorów.

Podsumowanie

Przestudiowaliśmy dokładnie różne wbudowane struktury danych Pythona. Będą one niezbędne przy pisaniu programów bardziej złożonych programów.

Numpy

Pakiet Numpy

Moduł Numpy jest podstawowym zestawem narzędzi dla języka Python umożliwiającym zaawansowane obliczenia matematyczne, w szczególności do zastosowań naukowych (tzw. obliczenia numeryczne, jak mnożenie i dodawanie macierzy, diagonalizacja czy odwrócenie, całkowanie, rozwiązywanie równań, itd.). Daje on nam do dyspozycji specjalizowane typy danych, operacje i funkcje, których nie ma w typowej instalacji Pythona. Natomiast moduł Scipy pozwala na dostęp do bardziej złożonych i różnorodnych algorytmów wykorzystujących bazę zdefiniowaną w Numpy.

Przedstawimy tutaj tylko wstęp do Numpy. Wynika to z faktu, że opisanie licznych funkcji dostępnych w bibliotece Numpy jest ogromną pracą, która zupełnie nie ma sensu — równie dobrze można zajrzeć bezpośrednio do źródła, http://docs.scipy.org/doc/numpy/reference/.

Najważniejszym obiektem, na którym bazuje pakiet Numpy i szereg pakietów z niego korzystających jest klasa ndarray wprowadzająca obiekty array. Obiekty array możemy traktować jako uniwersalne pojemniki na dane w postaci macierzy (czyli wektorów lub tablic). W porównaniu ze standardowymi typami sekwencji Pythonowych (lista, krotka) jest kilka różnic w operowaniu tymi obiektami:

1. obiekty przechowywane w macierzy array muszą być wszystkie tego samego typu;
2. obiekty array zachowują swój rozmiar; przy zmianie rozmiaru takiego obiektu powstaje nowy obiekt, a obiekt sprzed zmiany zostaje usunięty;
3. obiekty array wyposażone są w bogaty zestaw funkcji operujących na wszystkich przechowywanych w obiekcie danych, specjalnie optymalizowanych do przetwarzania dużych ilości danych. Jak to działa zostanie zaprezentowane poniżej.

Tworzenie

Najprostszym sposobem stworzenia macierzy Numpy jest wywołanie funkcji array z argumentem w postaci listy liczb. Jeśli zamiast listy liczb użyjemy listy zawierającej inne listy (tzw. listy zagnieżdżone), to otrzymamy macierz wielowymiarową. Na przykład jeśli listy są podwójnie zagnieżdzone, to otrzymujemy macierz dwuwymiarową (tablicę).

# przykład wykorzystania Numpy
>>> import numpy
>>> A = numpy.array([1, 3, 7, 2, 8])
array([1, 3, 7, 2, 8])
>>> B = numpy.array([[1, 2, 3], [4, 5, 6]])
>>> B
array([[1, 2, 3],
       [4, 5, 6]])
>>> B.transpose()
array([[1, 4],
       [2, 5],
       [3, 6]])

Innym sposobem tworzenia macierzy jest funkcja numpy.arange, która działa analogicznie do range, tyle tylko, że zwraca macierz zamiast listy. Argumenty są takie same:

1. indeks początkowy [opcjonalnie, domyślnie 0]
2. indeks następny po końcowym
3. krok [opcjonalnie, domyślnie 1]

>>> numpy.arange(1000000)
array([     0,      1,      2, ..., 999997, 999998, 999999])

Jak było już wspomniane, w przypadku macierzy array typowe operacje matematyczne możemy przeprowadzić dla wszystkich elementów macierzy przy użyciu jednego operatora lub funkcji. Zachowanie takie jest odmienne niż w przypadku list czy innych sekwencji Pythona. Jeśli chcielibyśmy na przykład pomnożyć wszystkie elementy listy L przez liczbę a, musimy użyć pętli:

L = [1, 3, 5, 2, 3, 1]
for i in L:
    L[i]=L[i]*a

Natomiast mnożenie wszystkich elementów macierzy M przez liczbę a wygląda tak:

M = numpy.array([1, 3, 5, 2, 3, 1])
M = M*a

Operacje wykonywane od razu na całych macierzach mają wiele zalet. Kod programu jest prostszy i krótszy, przez co mniej podatny na błędy. Poza tym nie musimy przejmować się konkretną realizacją danej operacji — robi to za nas funkcja pakietu Numpy, która jest specjalnie optymalizowana, żeby działała jak najszybciej.

Inne

zob.numpy.mgrid, numpy.ogrid, numpy.linspace, numpy.zeros, numpy.ones, numpy.r_.

Wydobywanie danych

Pojedyncze liczby

Dostęp do elementów (i pod-macierzy) jest możliwy poprzez wykorzystanie notacji indeksowej (macierz[i]) jak i wycinkowej (macierz[i:j]).

Dostęp do pojedynczego elementu:

>>> A = array([[1, 2, 3],[4,5,6]])
>>> A
array([[1, 2, 3],
       [4, 5, 6]])
>>> A[0][2]    # podobnie jak w Pythonie,numeracja od 0
3
>>> A[0, 2]
3

Indeksy dotyczące poszczególnych wymiarów można oddzielić przecinkami.

Macierz A jest tablicą dwuwymiarową, i sposób numerowania zawartych w niej obiektów jest następujący: pierwszy indeks przebiega pierwszy wymiar (wybiera wiersz), drugi indeks przebiega drugi wymiar (wybiera kolumnę).

Pod-macierze

Dostęp do pod-macierzy:

>>> A[1]             # wiersz 1
array([4, 5, 6])
>>> A[1, :]          # wiersz 1, wszystkie kolumny
array([4, 5, 6])
>>> A[:, 1]          # wszystkie wiersze, kolumna 1
array([2, 5])

Jak widać, ograniczenie się do pojedynczego punktu w danym wymiarze, powoduje degenerację tego wymiaru. Uzyskuje się macierz, w której liczba wymiarów jest mniejsza o jeden.

>>> A[:, 1:]
array([[2, 3],
       [5, 6]])

W pierwszym wymiarze (wiersze) bierzemy wszystko, natomiast w drugim od 1 do końca. Efektywnie wycinamy kolumnę 0.

Indeksowanie macierzy macierzami

Do wybrania elementów z macierzy można tez użyć innej macierzy. Może to być

• macierz liczb — wówczas są one traktowane jako indeksy. Wybieramy te elementy, które uzyskalibyśmy indeksując każdym z indeksów z osobna
• macierz wartości logicznych (boolean) rozmiaru macierzy z danymi. Wybieramy te elementy, którym odpowiada True w macierzy indeksującej.

Uwaga: W wyniku dostajemy macierz jedno wierszową.

Przykład

>>> print A
[[1 2 3]
 [4 5 6]]
>>> print A > 2
[[False False  True]
 [ True  True  True]]
>>> print A[A > 2]
[3 4 5 6]
>>> print A[A % 2 == 0]
[2 4 6]

Więcej: http://docs.scipy.org/doc/numpy/user/basics.indexing.html

Porównanie liczb w Numpy i liczb w Pythonie

Przejście od Pythona do Numpy oznacza odejście od obiektowości. Oczywiście takie stwierdzenie można natychmiast skontrować:

    numpy.random.random((10,10)).var()

jest typowym przykładem notacji obiektowej, i generalnie ma cechy obiektowości (ukrywanie detali implementacji, polimorfizm). Odejście od obiektowości występuje tylko na poziomie indywidualnych elementów — liczb.

W Pythonie, tak jak w zasadniczej większości języków programowania, operacje na liczbach są ostatecznie wykonywane przez procesor, w identyczny sposób niezależnie od języka programowania. A procesor, jak wiadomo, umie wykonywać tylko proste operacje. Przez to liczby, które się mu podaje by wykonać na nich działania, są w ściśle określonym formacie, niezależnym od języka programowania. Tak więc obiekt w Pythonie, np. liczba zmiennoprzecinkowa, zawiera pewne meta-informacje o tym obiekcie (jak reference-count, czyli liczba użytkowników obiektu, i typ, czyli przypisanie do klasy) oraz właściwe dane, w formacie oczekiwanym przez procesor.

Rysunki powyżej przedstawiają schematycznie zmienną w Pythonie (typu float) i pojedynczy element macierzy numpy.ndarray. W przypadku architektury 32-bitowej, liczba float ma 4 bajty (32 bity), a cały obiekt 12 bajtów, czyli 96 bitów).

Odejście od obiektowości w Numpy oznacza zatracenie obiektowości indywidualnych elementów macierzy, natomiast sam obiekt numpy.ndarray bardzo silnie wykorzystuje notację i właściwości podejścia obiektowego. Indywidualne elementy macierzy muszą być tego samego typu — oznacza to ten sam rozmiar w bajtach oraz identyczną interpretację i zachowanie każdego elementu.

Można powiedzieć, że numpy.ndarray rezygnuje z części możliwości na rzecz wydajności, przed wszystkim różnorodności typów przedstawionej jak na rysunku poniżej.

„Eksport” danych z Numpy do Pythona

Każda liczba w Pythonie jest indywidualnym obiektem. Liczby w Numpy takie nie są. Niemniej, kiedy wybierzemy jeden element z macierzy (np. używając []), to otrzymujemy liczbę-obiekt. Numpy automatycznie tworzy nowe obiekty do przechowywania liczb które mają być użyte poza Numpy.

Specjalne wartości liczbowe

Pakiet Numpy wprowadza też szczególne wartości dla przechowywania nietypowych wyników obliczeń. Należą tutaj takie wartości jak:

• inf opisująca wartość nieskończoną. Są dostępne również jej następujące warianty: PINF odpowiada wartości +∞, natomiast NINF wartości −∞. Do sprawdzenia czy badana zmienna x zawiera „normalną” czy nieskończoną wartość używamy funkcji isfinite(x) pakietu Numpy. Zwraca ona False w przypadku napotkania wartości nieskończonej w zmiennej x.
• NaN opisującą nie-liczbę (przechowywaną w zmiennej liczbowej, NaN to skrót od angielskiego not a number), wartość, która nie reprezentuje żadnej liczby. Wartość taka pojawia się w przypadku próby wykonania pewnych niedozwolonych operacji matematycznych lub sygnalizuje wystąpienie wyniku takiej operacji. Warto tutaj zauważyć, że porównanie numpy.NaN == numpy.NaN daje wynik False. Aby sprawdzić czy mamy do czynienia z taką wartością używamy funkcji isnan pakietu Numpy.

Jakkolwiek wartości te nie są dostępne w standardowym Pythonie, są one zestandaryzowane i opisane w normie IEEE-754; zapisane w pliku binarnym będą poprawnie interpretowane przez inne programy stosujące się do tej normy.

Dlaczego warto używać Numpy?

Pierwsza przyczyna, zazwyczaj najmniej istotna, to wydajność. Jeśli mamy pomnożyć 100 elementów, to szybkość operacji na pojedynczym elemencie nie ma znaczenia. Podobnie jest z rozmiarem pojedynczego elementu. Jeśli elementów jest 10⁶, to również wtedy narzut nie ma większego znaczenia. Policzmy: 1000000 razy 12 bajtów, to 12 MB. Typowy komputer ma obecnie 1-4 GB pamięci, czyli używamy od 1,2% do 0,27% dostępnej pamięci — jaki problem? Dopiero gdy miejsce zajmowane przez dane jest tego samego rzędu co całość dostępnej pamięci, to czy pojedyncza komórka zajmuje 8 czy 16 bajtów, zaczyna mieć znaczenie.

Druga przyczyna, istotna ze względu na przyjemność pracy, to notacja obiektowa i infixowa. Ta pierwsza to oczywiście „notacja z kropką” — dostęp do metod i atrybutów na obiekcie. Jej użycie, zwłaszcza w połączeniu z dopełnieniem TAB-em upraszcza pisanie. Przykład notacji obiektowej:

a.transpose().min()
# zamiast
numpy.min(numpy.transpose(a))

Ta druga (infixowa) to stara dobra „notacja matematyczna” — umiejscowienie operatorów dwuargumentowych pomiędzy obiektami na które działają. Przykład notacji infixowej:

a + b*c
# zamiast
numpy.add(a, numpy.multiply(b, c))

Oczywiście notacja obiektowa i infixowa jest używane wszędzie w Pythonie, ale warto wspomnieć, że Numpy od niej nie odchodzi. Niemniej Numpy odchodzi od Pythonowej interpretacji niektórych działań. W Pythonie takie operacje jak mnożenie list wywodzą się z działań na ciągach znaków. W obliczeniach numerycznych podstawą są działania na elementach, tak więc w Numpy wszystkie operatory domyślnie działają na indywidualnych parach elementów.

Trzecia przyczyna, chyba najważniejsza, to biblioteka funkcji numerycznych. Odejście od obiektowości danych pozwala na eksport wartości i komunikację z bibliotekami napisanymi w zupełnie innych językach programowania. Na przykład Scipy może korzystać z biblioteki LAPACK (Linear Algebra PACKage, napisanej w Fortranie 77). To że funkcje napisane w różnych językach mogą wymieniać się danymi w pamięci bez skomplikowanego tłumaczenia danych, wynika z faktu, że tak jak to w poprzednim podrozdziale było opisane, ostatecznie wszystkie liczby są w formacie akceptowanym przez procesor.

Możliwość użycia kodu napisanego w C czy Fortranie pozwala na wykorzystanie starych, zoptymalizowanych, sprawdzonych rozwiązań.

Podsumowanie

Normalnie programista Pythona takie detale, jak ile bitów ma zajmować zmienna, pozostawia całkowicie w gestii interpretera. Niemniej w przypadku obliczeń numerycznych często potrzebna jest silniejsza kontrola. Numpy daje możliwość dokładnej kontroli formatu danych, czyli odejście od pomocniczości powszechnej w Pythonie, pozwalając jednocześnie na gładkie łączenie obliczeń na macierzach z Numpy i normalnych obiektach pythonowych.

Zadanka

Zob. zadania z operacji na macierzach.

Matplotlib

Wprowadzenie do pakietu Pylab/Matplotlib na przykładach

Pakiet Pylab/Matplotlib bazuje na pakiecie numerycznym Numpy i korzysta z obiektów w nim zawartych. Pokażemy, jak z jego pomocą rysować różnorodne wykresy prezentujące graficznie przetwarzane dane i wyniki obliczeń. Zamiast wyliczać zawartość pakietu pokażemy ich użyteczność na przykładach. Zaczniemy od prostych i będziemy po drodze omawiać zastosowane w nich konstrukcje.

Wykres funkcji y = f(x)

Prześledźmy działanie poniższego programu:

import pylab
x = [1,2,3]
y = [4,6,5]
pylab.plot(x,y)
pylab.show()

Rezultat

Jak to działa?

Aby skorzystać z pakietu graficznego Pylab importujemy go do naszego programu poleceniem import.

Wytwarzamy dwie listy x i y zawierające ciągi liczb 1, 2, 3 oraz 4, 6, 5.

Funkcja plot rysuje wykres i umieszcza na nim punkty o współrzędnych zawartych w listach przekazanych jej jako argumenty. Pierwszy argument zawiera współrzędne x-owe kolejnych punktów, a drugi argument współrzędne y-owe kolejnych punktów wykresu. Ponieważ listy mają po trzy elementy, tak więc wykres zawierać będzie trzy punkty o współrzędnych (1, 4), (2, 6) oraz (3, 5). Domyślnie punkty na wykresie łączone są ze sobą niebieską linią ciągłą.

Po wywołaniu funkcji plot wykres nie pokazuje się jeszcze na ekranie. Aby go pokazać, używamy funkcji show. Wykres pojawia się na ekranie w osobnym oknie, a Python czeka z wykonywaniem kolejnych instrukcji do momentu zamknięcia okna z wykresem.

W okienku wykresu mamy kilka guzików (po lewej stronie na dole). Służą one do manipulowania wyglądem rysunku. Guzikiem z krzyżykiem możemy zmniejszać/zwiększać skalę na osiach (wciskając prawy guzik myszy i przesuwając kursor po obrazku) oraz przesuwać cały wykres (wciskając lewy guzik myszy i przesuwając kursor po obrazku). Guzik z okienkiem i strzałkami pozwala także zmieniać rozmiar i położenie osi wykresu wewnątrz okna wybierając właściwe wartości. Guzik z domkiem przywraca wyjściowe ustawienia rysunku.

Rysujemy wykres funkcji sinus

import pylab as p
x = p.arange(0.0, 2.0, 0.01)
y = p.sin(2.0*p.pi*x)
p.plot(x,y)
p.show()

Rezultat

Jak to działa?

Pobieramy do użycia pakiet Pylab pod nazwą p.

Funkcja arange jest podobna do standardowej funkcji range wytwarzającej określone sekwencje liczb w postaci listy. Funkcja arange zamiast listy wytwarza macierz zawierającą ciąg liczb zmiennoprzecinkowych zaczynający się od pierwszego podanego argumentu funkcji arange (u nas 0.0), a kończący się przed drugim argumentem (tradycyjnie, ciąg wynikowy nie zawiera wartości podanej jako drugi argument, u nas 2.0). Różnica między elementami wytworzonego ciągu domyślnie wynosi 1, ale jeśli podamy funkcji arange trzeci argument, to definiuje on nową różnicę ciągu, u nas wynosi on 0.01.

Tak więc zmienna x jest macierzą-wektorem zawierającą ciąg liczb od 0 do 1,99 co 0,01 (czyli 0, 0,01, 0,02, ..., 1,98, 1,99).

Funkcja sin służy do obliczania wartości funkcji sinus dla argumentu podanego w radianach. A co u nas jest argumentem tej funkcji? Wyrażenie będące argumentem zawiera mnożenie liczby 2.0 przez pi (pochodzące z pakietu Pylab), a następnie mnożenie wyniku przez macierz x. Zmienna pi zawiera wartość matematycznej stałej π ≈ 3,1415926. Mnożenie liczby i macierzy, jak wiemy z poprzedniego punktu, daje w wyniku macierz. Oznacza to, że argumentem funkcji sin jest nie liczba, ale macierz! Taka możliwość jest przewidziana przez twórców pakietu Numpy; wynikiem wywołania funkcji jest wtedy również macierz. Jest ona tej samej długości co macierz będąca argumentem wywołania funkcji.

Tak więc zmienna y zawiera ciąg wartości funkcji sinus policzonych dla wartości zawartych w zmiennej x pomnożonych każda przez 2π (czyli sin(2π·0), sin(2π·0,01), sin(2π·0,02), ..., sin(2π·1,98), sin(2π·1,99)).

Funkcja plot(x,y) narysuje zestaw punktów o współrzędnych (0, sin(2π·0)), (0,01, sin(2π·0,01)), (0,02, sin(2π·0,02)), ..., (1,98, sin(2π·1,98)), (1,99, sin(2π·1,99)) połączonych niebieską linią.

Ulepszamy wykres

import pylab as p
x = p.arange(0.0, 2.0, 0.01)
y = p.sin(2.0*p.pi*x)
p.plot(x,y,'r:',linewidth=6)
 
p.xlabel('Czas')
p.ylabel('Pozycja')
p.title('Nasz pierwszy wykres')
p.grid(True)
p.show()

Rezultat

Jak to działa?

W porównaniu z poprzednim przykładem pojawiło się na wykresie kilka drobnych zmian i „ozdobników”.

W funkcji plot pojawiły się dwa nowe parametry:

1. 'r:' — ten parametr steruje wyglądem rysowanej linii wykresu. Pierwsza litera tego napisu określa kolor linii (na przykład r: czerwony, b: niebieski, g: zielony, y: żółty, k: czarny). Drugi znak napisu określa wygląd samej linii (np. -: ciągła, :: kropkowana, o: okrągłe punkty bez linii, +: krzyżyki bez linii, itd.).
2. linewidth=6 — ten parametr zmienia grubość rysowanej linii.

Dodaliśmy też wywołania funkcji xlabel i ylabel. Ich argumentami są napisy, które pojawią się jako opisy osi, odpowiednio poziomej i pionowej. Wywołanie funkcji title wypisuje przekazany jej napis jako tytuł całego wykresu.

Funkcja grid dorysowuje siatkę prostokątną na wykresie w wybranych punktach opisujących wartości na osiach wykresu. Punkty, w których wybierane są wartości opisane na osiach (ang. tick) są wybierane automatycznie (oczywiście jeśli chcemy, możemy zmieniać ich położenie i opisy odpowiednią funkcją, powiemy o tym później).

Kilka wykresów we wspólnych osiach

Pierwsza wersja:

import pylab as p
x = p.arange(0.0, 2.0, 0.01)
y1 = p.sin(2.0*p.pi*x)
y2 = p.cos(2.0*p.pi*x)
p.plot(x,y1,'r:',x,y2,'g')
p.legend(('dane y1','dane y2'))
p.xlabel('Czas')
p.ylabel('Pozycja')
p.title('Wykres ')
p.grid(True)
p.show()

Rezultat:

Jak to działa?

W jednym układzie współrzędnych możemy narysować wiele wykresów. Robimy to podając w jednym poleceniu p.plot kolejno zestawy parametrów opisujące poszczególne linie: współrzędne x, współrzędne y, sposób wykreślania linii. Aby łatwo identyfikować linie można dodać legendę poleceniem legend(). Sposób kontrolowania wyglądu i położenia legendy: help(p.legend) (oczywiście po zaimportowaniu modułu: import pylab as p )

Druga wersja:

import pylab as p
x = p.arange(0.0, 2.0, 0.01)
y1 = p.sin(2.0*p.pi*x)
y2 = p.cos(2.0*p.pi*x)
y = y1*y2
l1, = p.plot(x,y,'b')
l2,l3 = p.plot(x,y1,'r:',x,y2,'g')
p.legend((l2,l3,l1),('dane y1','dane y2','y1*y2'))
p.xlabel('Czas')
p.ylabel('Pozycja')
p.title('Wykres ')
p.grid(True)
p.show()

Rezultat:

Jak to działa?

Wykresy możemy dodawać do współrzędnych kolejnymi poleceniami p.plot. Funkcja p.plot zwraca listę linii. Notacja l1, = p.plot(x,y,'b') wydobywa z listy pierwszą linię (Gdyby po l1 nie było przecinka to l1 byłoby listą zawierającą jeden obiekt klasy linia ).

Dzięki nazwaniu poszczególnych obiektów linii możemy kontrolować ich kolejność (i obecność) na legendzie.

Histogram (diagram liczebności)

import pylab as p
 
zliczenia = p.array([0, 1, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 5, 7])
 
p.hist(zliczenia)
p.show()

Rezultat:

Jak to działa ?

Do zmiennej zliczenia przypisujemy macierz z ręcznie podanymi wartościami. Zakres zmienności badanych zliczeń (odkładany na osi X) dzielimy na przedziały (ang. bin) o jednakowej „szerokości”; domyślnie będzie ich 10. Funkcja p.hist() zlicza wystąpienia wartości w binach i rysuje histogram. Funkcja ta zwraca krotkę (array ze zliczeniami, array z binami, lista zawierająca prostokąty, które histogram rysuje, tzw. obiekty Patch).
Pełna lista parametrów tej funkcji jest następująca:

      hist(x, bins=10, range=None, normed=False, cumulative=False,
          bottom=None, histtype='bar', align='mid',
          orientation='vertical', rwidth=None, log=False, **kwargs)

Poniżej opisujemy znaczenie najistotniejszych parametrów.

• Możemy kontrolować albo ilość binów jeśli bins jest liczbą, albo położenie binów (może być nierównomierne) jeśli bins jest sekwencją.
• range kontroluje zakres przeliczanych danych. Domyślnie jest to (x.min(), x.max()). Jeśli podamy inne wartości to dane mniejsze od dolnego zakresu i większe od górnego zakresu nie zostaną uwzględnione.
• normed kontroluje czy zliczenia w binach mają być unormowane do jedności — może to być przydatne do wykreślania np. rozkładów gęstości prawdopodobieństwa.
• Jeżeli parametr cumulative ma wartość True to kolejne biny mają do swojej własnej ilości zliczeń dodawaną sumę zliczeń wszystkich dotychczasowych (dla mniejszych wartości x) binów. W ten sposób możemy na przykład narysować dystrybuantę rozkładu prawdopodobieństwa.

Pozostałe argumenty kontrolują wygląd i układ rysunku. Ich znaczenie można poznać z dokumentacji help(p.hist)

Bardziej zaawansowany przykład:

Wyjaśnienie działania znajduje się w komentarzach do programu:

import pylab as p
import numpy 
 
mi, sigma = 100, 15
x = mi + sigma * numpy.random.randn(10000)
# numpy.random.randn zwraca array z liczbami pseudolosowymi
# pochodzącymi z rozkładu normalnego o średniej 0 i wariancji 1
# przemnożenie przez odchylenie standandardowe sigma i dodanie śreniej mi
# transformuje rozkład do rozkładu normalnego o średniej mi i wariancji sigma**2
 
 
n, bins, patches = p.hist(x, 50, normed=True, facecolor='green', alpha=0.75)
# Tu w jawny sposób odbieramy zwracane przez p.hist obiekty
# Zmieniamy też:
#   - ilość binów na 50
#   - normujemy histogram do jedności
#   - ustalamy kolor prostokątów na zielony
#   - ustawiamy przezroczystość prostokątów na 0.75
 
bincenters = 0.5*(bins[1:]+bins[:-1])
# wytwarzamy array z centrami binów korzystając z granic binów
# zwróconych przez p.hist w macierzy bins
 
y = p.normpdf( bincenters, mi, sigma)
# obliczamy wartości w normalnym rozkładzie gęstości prawdopodobieństwa
# o średniej mi i wariancji sigma**2 dla wartości bincenters
 
l = p.plot(bincenters, y, 'r--', linewidth=1)
# do histogramu dorysowujemy linię 
 
p.show()

Rezultat:

Wykres biegunowy

import pylab as p
 
p.figure()
teta = p.arange(0,3*p.pi,0.001)
r = teta
p.polar(teta, r, color='red')
 
p.figure()
r = p.arange(0,1,0.001)
teta = -2*2*p.pi*r
p.polar(teta, r, color='#ee8d18', lw=3)
 
p.show()

Rezultat:

Prosta animacja

import pylab as p
p.ion()
a=1.0
teta = p.arange(0,2*p.pi,0.1)
r = a*p.cos(3*teta)
linia, = p.polar(teta, r, color='red')
for fi in p.arange(0,p.pi,0.01):
    r = a*p.cos(3*teta+fi)
    linia.set_ydata(r)
    p.draw()

Jak to działa

Uwaga: ta metoda animowania nie działa w Windows.

Pod linuksem ten typ animacji działa i można go zrozumieć w następujący sposób. Funkcja p.ion() przełącza system graficzny w tryb interaktywny. Wywołanie funkcji p.polar wytwarza obiekt linia dany równaniem r(θ) = acos(3θ). Następnie w każdej iteracji pętli obliczamy nowy zestaw punktów definiujących linię dla aktualnej wartości fi, zgodnie z równaniem r(θ) = acos(3θ + φ). Wyliczone wartości r podstawiamy do obiektu linia. Funkcja p.draw() powoduje wyczyszczenie poprzedniej wersji rysunku i odrysowanie aktualnej reprezentacji obiektu linia.

Wizualizacja zawartości macierzy dwuwymiarowej

import pylab as p
 
X = p.array([[1,  3,   2],
             [2,  2.4, 3],
             [2,  3,   1],
             [1,  1,   2],
             [3,  2,   2]])
 
p.figure()
p.imshow(X)
 
p.figure()
p.pcolor(X)
 
p.figure()
p.imshow(X, interpolation='nearest')
p.colorbar()
 
p.show()

Rezultat:

Powierzchnia dwuwymiarowa w przestrzeni trójwymiarowej

Do rysowania prostych wykresów w przestrzeni trójwymiarowej można użyć dodatku do modułu matplotlib mpl_toolkits.mplot3d. Poniższy przykład demonstruje jego użycie.

from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
import pylab as p
import numpy as np
 
fig = p.figure() # wytwarzamy obiekt typu figura 
ax = Axes3D(fig) # wytwarzamy obiekt osie 3D
X = np.arange(-15, 15, 0.3) # wektor opisujący oś X
Y = np.arange(-15, 15, 0.3) # wektor opisujący oś Y
X, Y = np.meshgrid(X, Y)    # zamieniamy wektory osi w siatkę, której węzły są 
#zadane przez odpowiadające sobie elementy w macierzach X i Y      
# dla każdego węzła obliczamy jego odległość od początku układu współrzędnych               
R = np.sqrt(X**2 + Y**2)
# dla każdego węzła obliczamy wartość funkcji Z
Z = np.sin(R)/R
# generujemy rysunek powierzchni  
# parametry <tt>rstride=2, cstride=2</tt> służą do próbkowania siatki (tu bierzemy co drugi węzeł),
# parametr <tt>cmap=cm.jet</tt> definiuje jaką mapę kolorów zastosować
ax.plot_surface(X, Y, Z, rstride=2, cstride=2,cmap=cm.jet)
# pokazujemy gotowy rysunek
p.show()

Rezultat:

Jak to działa?

Wiele wykresów w jednym oknie

import pylab as p
 
p.subplot(1,2,1)
p.plot([1,2,3],[2,7,8])
 
p.subplot(1,2,2)
p.plot([1,2,3],[4,7,2])
 
p.show()

Rezultat:

import pylab as p
''' Ruch jednostajnie przyspieszony:
demonstracja subplotów i całkowania metodą Eulera'''
dt=0.1 # definiujemy krok czasu
       # -- mniejszy krok czasu większa dokładność całkowania
t=p.arange(0,10,dt) # wytwarzamy oś czasu
# definiujemy parametry początkowe dla rozważanego ruchu
x0=1        
v0=0.5
a0=0.5
# analityczne całkowanie ruchu ze stałym przyspieszeniem
# daje następujące wyrażenia:
 
a=a0*p.ones(len(t),)        # przyspieszenie
v=v0 + a*t                  # prędkość
x=x0 + v0*t + a*t**2/2.0    # położenie
# rysujemy wykresy
# przyspieszenia, prędkości i położenia od czasu
# uzyskane przez całkowanie analityczne
p.subplot(3,1,1)
p.plot(t,a)
p.subplot(3,1,2)
p.plot(t,v)
p.subplot(3,1,3)
p.plot(t,x)
 
 
# obliczamy numerycznie wartości prędkości w kolejnych chwilach czasu
v_num = p.zeros(len(t),)
v_num[0]=v0
for i in range(1,len(t)):
    v_num[i]=v_num[i-1]+a0*dt
# obliczamy numerycznie wartości położenia w kolejnych chwilach czasu
x_num = p.zeros(len(t),)
x_num[0]=x0
for i in range(1,len(t)):
    x_num[i]=x_num[i-1]+v_num[i-1]*dt
 
# do wykresów uzyskanych analitycznie dorysowujemy wyniki numeryczne
p.subplot(3,1,2)
p.plot(t,v_num,'r')
p.subplot(3,1,3)
p.plot(t,x_num,'r') 
p.show()

Wejście i wyjście

Wprowadzenie

Twój program, jeśli ma robić coś użytecznego, zazwyczaj musi komunikować się z użytkownikiem. Na przykład, na podstawie wprowadzonych przez użytkownika danych program wykonuje pewne obliczenia i następnie wypisuje wynik, przekazując go tym samym użytkownikowi. Ten moment kiedy informacja zostaje wprodzona do programu, lub kiedy program zapisuje wyniki swojego działania gdzieś indziej niż w swojej pamięci, nazywamy operacjami wejścia/wyjścia.

W najprostszym wypadku komunikację z otoczeniem można wykonać przy użyciu funkcji raw_input i wyrażenia print, które odpowiednio wczytują linijkę i wypisują linijkę tekstu.

W bardziej zaawansowanej wersji komunikacji z otoczeniem, program odczytuje i zapisuje informację w plikach na dysku. Pozwala to na przechowywanie danych w sposób trwały — pliku w przeciwieństwie do napisów na ekranie przeżywają wyłączenie i włączenie komputera. Tworzenie plików, odczytywanie i zmiana ich zawartości to podstawowe narzędzie, które zostanie przedstawione w tym rozdziale.

Wprowadzanie danych przez użytkownika

Przykład:

#!/usr/bin/python
# -*- coding:utf-8 -*-
# user_input.py
 
def reversed(text):
    return text[::-1]
 
def palindrom(text):
    return text == reversed(text)
 
napis = input('Wprowadź napis: ')
if palindrom(napis):
    print("Tak, to palindrom")
else:
    print("Nie, to zwykłe słowo")

Wynik:

$ python user_input.py
Wprowadź napis: abrakadabra
Nie, to zwykłe słowo
 
$ python user_input.py
Wprowadź napis: kajak
Tak, to palindrom
 
$ python user_input.py
Wprowadź napis: 1234321
Tak, to palindrom

Jak to działa?

Funkcja reversed zwraca swój argument w odwrotnej kolejności wykorzystując zaawansowane indeksowanie. Poprzednio była mowa o indeksowaniu z dwoma argumentami [a:b] — czyli braniu podsekwencji od pozycji a do pozycji b.