Jarekz: /* Liczby Fibonacciego */

2015-05-22T19:50:24Z

Liczby Fibonacciego

Jarekz: Utworzono nową stronę "===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..."

2015-05-22T19:49:45Z

Utworzono nową stronę "===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..."

Nowa strona

===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 <tt>.py</tt>, 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 [http://pl.wikipedia.org/wiki/C_(Język_programowania) 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<nowiki>:</nowiki>

<source lang = python>
#!/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'
</source>

;Rezultat<nowiki>:</nowiki>

<pre>
$ 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']

</pre>

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

====Jak to działa?====
Najpierw ''importujemy'' moduł <tt>sys</tt> używając polecenia <tt>import sys</tt>, czyli mówimy Pythonowi, że chcemy go używać. Moduł <tt>sys</tt> zawiera polecenia związane z Pythonem i jego środowiskiem, czyli ''sys''temem.

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

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 <tt>argv</tt> w module <tt>sys</tt> jest dostępna jako (<tt>sys.argv</tt>), dzięki czemu wiadomo, że ta nazwa jest częścią modułu <tt>sys</tt>. 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 <tt>argv</tt> w różnych modułach, i jednoznacznie się do niech odwoływać.

Zmienna <tt>sys.argv</tt> jest ''listą'' ciągów znaków. (Listy poznamy dokładniej w [[TI:Struktury danych#Lista|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 <tt>python uzycie_sys.py my jestesmy argumentami</tt>, uruchamiamy moduł <tt>uzycie_sys.py</tt> za pomocą aplikacji <tt>python</tt> wraz z argumentami <tt>my jestesmy argumentami</tt>. Python przechowuje dla nas treść linii komend w zmiennej <tt>sys.argv</tt>.

Pamiętaj, że nazwa uruchamianego skryptu jest zawsze na początku listy <tt>sys.argv</tt>. Dlatego w omawianym przykładzie mamy następujące przypisania:
* <tt>uzycie_sys.py</tt> jako <tt>sys.argv[0]</tt>,
* <tt>my</tt> jako <tt>sys.argv[1]</tt>,
* <tt>jestesmy</tt> jako <tt>sys.argv[2]</tt>
* <tt>argumentami</tt> jako <tt>sys.argv[3]</tt>.
Zauważ, że Python numeruje od 0, nie od 1.

<tt>sys.path</tt> 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 <tt>print os.getcwd()</tt> (oczywiście najpierw musisz zaimportować moduł <tt>os</tt>).

===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 <tt>.pyc</tt>. Pliki <tt>.pyc</tt> są niezależne od platformy. Plik <tt>.pyc</tt> 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 <tt>.pyc</tt> są zazwyczaj tworzone w tym samym folderze, co odpowiednie pliki <tt>.py</tt>. Jeżeli Python nie ma pozwolenia na zapis w tym folderze, pliki <tt>.pyc</tt> nie zostaną utworzone.

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

Tak naprawdę, powinieneś normalnie używać formy <tt>import ...</tt>,
i odwoływać się do zmiennych z innych modułów przez nazwę ich modułu.
Formy <tt>from...import...</tt> 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 <tt>import</tt> ''nazwa_modulu'' <tt>as</tt> ''inna_nazwa'' spowoduje zaimportowanie modułu, z tym, że dostęp do jego zmiennych i funkcji będzie się odbywał przez <tt>inna_nazwa.</tt> . 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 <tt>__name__</tt> zawiera nazwę modułu. Wyjątkiem jest sytuacja gdy został on uruchomiony samodzielnie, jako program. Wówczas zawiera napis <tt>'__main__'</tt>.
Dzięki temu możemy rozróżnić dwa sposoby wywołania modułu i podjąć odpowiednie decyzje.

;Przykład<nowiki>:</nowiki>

<source lang = python>
#!/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.'
</source>

;Rezultat<nowiki>:</nowiki>

<source lang='shell_example'>
$ python nazwa.py
Ten program jest uruchomiony samodzielnie.

$ python
>>> import nazwa
Zostałem zaimportowany z innego modułu.
>>>
</source>

====Jak to działa?====
Każdy moduł Pythona ma zdefiniowaną własną nazwę. Jeżeli jest nią <tt>'__main__'</tt>, 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 <tt>.py</tt>. Ten przykład powinien wszystko wyjaśnić.

Przykład<nowiki>:</nowiki>

<source lang = python>
#!/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.
</source>

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 <tt>sys.path</tt>.

<source lang = python>
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: mojmodul_demo.py

import mojmodul

mojmodul.mowczesc()
print 'Wersja', mojmodul.__version__
</source>

Rezultat<nowiki>:</nowiki>

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

====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 <tt>from...import...</tt><nowiki>:</nowiki>

<source lang = python>
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Nazwa pliku: mojmodul_demo2.py

from mojmodul import mowczesc, __version__

mowczesc()
print 'Wersja', __version__
</source>

Rezultat <tt>mojmodul_demo2.py</tt> jest taki sam jak <tt>mojmodul_demo.py</tt>.

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

Możesz także użyć:
<source lang = python>
from mojmodul import *
</source>

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

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

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

Przykład<nowiki>:</nowiki>

<source lang = python>
$ 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']
>>>
</source>

===Jak to działa?===
Na początku sprawdzamy działanie <tt>dir</tt> na zaimportowanym module <tt>sys</tt>. Widać długą listę jego atrybutów.

Następnie używamy funkcji <tt>dir</tt> 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 <tt>dir</tt> w akcji, deklarujmy nową zmienną <tt>a</tt>, przypisujemy jej wartość, a następnie sprawdzamy, że na liście pojawiła nazwa naszej nowej zmiennej. Usuwamy ją poleceniem <tt>del</tt>, czego efekt widać po kolejnym użyciu <tt>dir</tt>.

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

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

==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 <tt>__init__.py</tt>, który informuje Pythona, że ten katalog jest specjalnie przeznaczony właśnie do przechowywania modułów.

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

Oto, jak powinna wyglądać twoja struktura katalogów<nowiki>:</nowiki>

''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 [[../Biblioteka standardowa/|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ł <tt>fib3</tt> zawierający trzy funkcje zwracające <math>n</math>-tą liczbę Fibonacciego — obliczoną rekurencyjnie z definicji, w pętli, oraz ze [[wikipl:Liczby Fibonacciego#Wzór Bineta|wzoru Bineta]]. Sam moduł oraz funkcje muszą mieć ''docstringi''.

Moduł ma też zawierać bezargumentową funkcję <tt>test</tt>, 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ł <tt>fib3-czas</tt>, który wykorzystuje moduł <tt>fib3</tt> i moduł <tt>time</tt> 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
... ... ... ...

@@ Linia 280: / Linia 280: @@
 ==Zadania==
 ===Liczby Fibonacciego===
-Stwórz moduł <tt>fib3</tt> zawierający trzy funkcje zwracające <math>n</math>-tą liczbę Fibonacciego &mdash; obliczoną rekurencyjnie z definicji, w pętli, oraz ze [[wikipl:Liczby Fibonacciego#Wzór Bineta|wzoru Bineta]]. Sam moduł oraz funkcje muszą mieć ''docstringi''.
+Stwórz moduł <tt>fib3</tt> zawierający trzy funkcje zwracające <math>n</math>-tą liczbę Fibonacciego &mdash; obliczoną rekurencyjnie z definicji, w pętli, oraz ze [[wikipedia:Liczby Fibonacciego#Wzór Bineta|wzoru Bineta]]. Sam moduł oraz funkcje muszą mieć ''docstringi''.
 Moduł ma też zawierać bezargumentową funkcję <tt>test</tt>, 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.

TI/Moduły - Historia wersji

Jarekz: /* Liczby Fibonacciego */

Jarekz: Utworzono nową stronę "===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..."