Język PYTHON ‑ narzędzie dla każdego...
90
Transcript of Język PYTHON ‑ narzędzie dla każdego...
JĘZYK PYTHON - NARZĘDZIE DLA KAŻDEGO NAUKOWCA
Marcin Lewandowski
PYTHON - WSTĘP
2
Języki kompilowane
.c
• Plik z kodem źródłowym
• KOMPILACJA
.o
• Plik z kodem binarnym
• KONSOLIDACJA
.exe
• Plik wykonywalny
3
Interpreter Pythona
.py
• Plik z kodem źródłowym
• KOMPILACJA - jednokrotna
.pyc
• Plik z binarnym kodem pośrednim
• Program wykonywalny dla maszyny wirtualnej
• Uruchamianie na różnych systemach operacyjnych/maszynach wirtualnych
4
DRY KISS
• KISS – Keep It Simple Stupid
– nie przesadzaj ze skomplikowanymi konstrukcjami
– prostota jest cnotą
• DRY – Don’t repeat yourself
– przemyśl architekturę całości i klocków z których ją zbudujesz
– pisz możliwie generyczne/uniwersalne funkcje
5
Zen of Python import this
>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
6
*** Lektura rozszerzająca ***
• Steve McConnell, Code Complete: A Practical Handbook of Software Construction, 2 wydanie, Microsoft Press, 2004
• Michael L. Scott, Programming Language Pragmatics, Morgan Kaufmann; 3 edition, 2009
• Eric S. Raymond, The Art of UNIX Programming, Addison-Wesley Professional, 2003
7
START
• Uruchomienie Python w trybie interaktywnym: > python
ActivePython 2.6.4.10 (ActiveState Software Inc.) based on
Python 2.6.4 (r264:75706, Jan 22 2010, 16:41:54) [MSC v.1500 32 bit (Intel)] on
win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
• Ewaluacja wyrażenia: >>> 3*(7+2)
27
• Wyjście z trybu interaktywnego Pythona: CTRL-Z # EOF on Windows CTRL-D # EOF on Unix
8
Uruchomienie skryptu Python
• Windows: > python skrypt.py
> skrypt.py
• Linux: % python skrypt.py
% ./skrypt.py
– Wymaga dodania pierwszej linii: #!/usr/bin/env python
– Wymaga ustawienia atrybutu ‘executable’: % chmod u+x skrypt.py
9
Wykonanie/Ewaluacja poleceo/skryptu
Wykonanie: s = ’a = 2*2; print a’
exec(s)
Ewaluacja: s = ’2*2’
a = eval(s)
print a
Wykonanie skryptu z pliku: execfile(’myscript.py’)
10
Kod Python w module
mymod.py: def fun1():
print 2*2
def fun2():
print 2+2
Załadowanie modułu i wykonanie funkcji: $ python
>>> import mymod
>>> mymod.fun1()
>>> mymod.fun2()
11
Błędy
• Błędy składni (Syntax errors) – czyli błędy „gramatyczne” i „ortograficzne” języka - Python wykona
program tylko gdy tego typu błędów nie ma. Błędy składni są sygnalizowane na etapie kompilacji kodu źródłowego.
– PYTHON nie weryfikuje statycznie zgodności typów danych – dlatego niezgodności typów będą powodowały błędy działania!
• Błędy działania (Runtime errors) – Błędy które pojawiają się na etapie wykonywania programu. – Obecnie w językach programowania tego typu błędy są nazywane
‘Wyjątkami’ (Exceptions) i istnieje specjalny mechanizm ich obsługi
• Błędy semantyczne (Semantic errors) – Program działa i nie zgłasza błędów, ale wynik jego działania jest
niepoprawny – to błąd semantyczny. Programista miał co innego na myśli niż faktycznie wykonuje program.
12
Debugging
• Debug Prints – Umieszczanie w kodzie programu funkcji print do
śledzenia jego stanu wewnętrznego w newralgicznych miejscach: a = 1
if _debug_: print ”a:”, a
b = a + 1
if _debug_: print ”b:”, b
• Log
• Exceptions/Trace
• Debugger
13
IDLE
14
IDLE debugger EX1
15
ELEMENTY JĘZYKA PYTHON
16
Słowa kluczowe
• assert, break, continue, del, except, exec, finally, import, is, pass, print, raise, return, try, yield
• and, as, in, or, not
• for, from, with
• if, else, elif, while
• class, def, global, lambda
17
Zarezerwowane
• _
jest używany w trybie interaktywnym do pamiętania rezultatu ostatniej ewaluacji (bywa używany do I18N, moduł gettext)
• _* nazwy lokalne (nie widoczne przy imporcie)
• __*__ używany do nazw systemowych i niech tak zostanie (np.: __builtins__, __doc__, __name__)
• __* prywatne nazwy w klasach
18
Raczej zarezerwowane
• dir(__builtins__)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BufferError', 'BytesWarning', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'ReferenceError', 'RuntimeError', 'RuntimeWarning', 'StandardError', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs', 'all', 'any', 'apply', 'basestring', 'bin', 'bool', 'buffer', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'cmp', 'coerce', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'execfile', 'exit', 'file', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'intern', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'long', 'map', 'max', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'raw_input', 'reduce', 'reload', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'unichr', 'unicode', 'vars', 'xrange', 'zip‘+
19
Przedefiniowanie nazw (tego bym raczej nie robił)
• Spróbuj: >>> len
<built-in function len>
>>> len('abc')
3
>>> len=2
>>> len
2
>>> len('abc')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> del len
>>> len
<built-in function len>
>>>
20
Identyfikatory
• identifier ::= (letter|"_") (letter | digit | "_")*
• letter ::= lowercase | uppercase
• lowercase ::= "a"..."z"
• uppercase ::= "A"..."Z"
• digit ::= "0"..."9"
• WieLkOśd LiTeR Ma zNaczEnie!!!
• 3.0+ UNICODE!
21
Linia kodu
• Linia tekstu zakooczona znakiem nowej linii:
– LF (0x0A) – Unix (Linux, MacOS, Solaris, …)
– CR LF (0x0D 0x0A) – Windows
• Narzędzie do zamiany CRLF na LF <PYTHON>\Tools\scripts\crlf.py
• Wcięcia linii definiują bloki wykonawcze!!!
22
Kodowanie znaków (Charset/Encoding)
• Ustalenie kodowania dla pliku:
# -*- coding: <encoding-name> -*-
– Latin-1 (ISO-8859-1) – domyślny 7-bit/char
– Latin-2 (ISO-8859-2) – polskie znaki
• UTF-8 BOM (byte-order mark)
23
Komentarze
• Znak # rozpoczyna komentarz – traktowany do kooca linii
print 2*2 # oblicz 2*2
• Oczywiście: print ‘Tutaj to nie jest # komentarz #’
24
Duck typing
• "If it looks like a duck and quacks like a duck, it must be a duck.„ def calc(a, b, c): return (a+b)*c
print calc(1, 2, 3)
print calc([1, 2, 3], [4, 5, 6], 2)
print calc('apples ', 'and oranges, ', 3)
---
9
[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6]
apples and oranges, apples and oranges, apples
and oranges,
25
Typy proste
• None – specjalny obiekt pusty: None==None is true None==False is false not(None) is true!
• Boolean – typ logiczny: True False==False bool(42) not(42==True) (True or False) and not(False) True==1 not(1.000001==1) 1.00000000000000000000000009 == 1
26
Integer
• Stałopozycyjny 32-bitowy
32
int(’32’) # int ze stringu
1/3 # sic! UWAGA!!!
int(3.14) # trunc
0xABCD # heksadecymalnie
0o1234567 # ósemkowo
0b10010001 # binarnie
27
Long
• Stałopozycyjny – dowolnie długi!
5L
12319809854761238913209182039812301
long(1)
• W Python 3.0+ usunięty/ujednolicony z Integer!
28
Float
• Zmiennopozycyjny 32-bitowy 4.
4.0
float(44)
1.0/3
complex(1+2j).real
complex(1+2j).imag
4.25e3, 4.25E+3
+ moduł decimal – patrz dokumentacja Pythona 29
Zespolony
• Complex – zespolony (2x Float): complex(1)
complex(2j)
complex(’3+j’)
complex(1,2)
1+2j
30
Operatory numeryczne
Operator Rezultat Uwagi
x + y Suma x i y
x - y Różnica x i y
x * y Iloczyn x i y
x / y Dzielenie x przez y Dzielenie całkowitoliczbowe dla Int
x // y Dzielenie x przez y Dzielenie całkowitoliczbowe
x % y Reszta z dzielenia x przez y Modulo
-x zmiana znaku x
+x Bez zmiany znaku x
31
Funkcje numeryczne
Operator Rezultat Uwagi
abs(x) Wartośd bezwzględna/moduł x Moduł dla zespolonych
int(x) Konwersja x do Integer
long(x) Konwersja x do Long
float(x) Konwersja x do Float
complex(re,im) Liczba zespolona: re + im*j
c.conjugate() Sprzężenie liczby zespolonej c
divmod(x, y) Zwraca parę: (x // y, x % y)
pow(x, y) x ** y
x do potęgi y
+ moduł math – patrz dokumentacja Pythona 32
Operatory bitowe
Operator Rezultat Uwagi
x | y x OR y
x ^ y x XOR y
x & y x AND y
x << n Przesunięcie x o n bitów w lewo
n >= 0
x >> n Przesunięcie x o n bitów w prawo
n >= 0
~x Negacja bitów x
33
Funkcje konwersji Integer/Long
Funkcja Opis
bin(i) Binarna reprezentacja liczby całkowitej i (string) bin(12) == ‘0b1100’
hex(i) Heksadecymalna reprezentacja liczby całkowitej i (string) hex(12) == ‘0xc’
int(o) long(o)
Konwersja obiektu o do liczby Integer/Long (trunc dla o typu Float)
int(s, base) long(s, base)
Konwersja łaocucha s do liczby Integer/Long w zadanej bazie
oct(i) Ósemkowa reprezentacja liczby całkowitej i (string) oct(12) == ‘014’
34
Łaocuchy znakowe
• String – łaocuchy znakowe: ’A string’
"Another string"
"Escape \" quotation"
’He’ + ’llo’ + ’!’*10
’’’Cote d’azure’’’
"""Multiline string
a newline"""
’T: %.02f P:%d’ % (20.567, 1024)
+ funkcje typu string – patrz dokumentacja Pythona
EX2
35
Listy
• List – lista: [1, 2, 3]
[’word’, 33, 123.998]
[’w’, ’o’, ’r’, ’d’]
list("word")
[[’list’], [’of’, ’lists’]]
list((’a’, 1, 2))
• Tuple – lista niemodyfikowalna: (1, 2)
(’a’, 1)
(’memento comma!’,)
tuple([’a’, 1])
range(3) # [0, 1, 2]
range(2, 4) # [2, 3]
range(0, 5, 2) # [0, 2, 4]
36
Funkcje dla list i łaocuchów znakowych
• Listy (modyfikują a!): a = [5, 6, 7, 8]
a.pop() # a = [5, 6, 7]
a.append(2) # a = [5, 6, 7, 2]
a.sort() # a = [2, 5, 6, 7]
a.reverse() # a = [7, 6, 5, 2]
• Łaocuchy znakowe: a = ’Ala ma kota’
a.split() # [’Ala’, ’ma’, ’kota’]
a.upper() # ’ALA MA KOTA’
a.title() # ’Ala Ma Kota’
import string
string.join(a.split(), ’_’) # ’Ala_ma_kota’
+ więcej funkcji – patrz dokumentacja Pythona 37
Indeksowanie sekwencji (1) Wyrażenie Wynik
seq[i:j] Elementy seq w zakresie [i … j)
seq[i:] Elementy seq w zakresie [i … końca]
seq[:j] Elementy seq w zakresie [0 … j)
seq[:-1] Elementy seq w zakresie [0 … końca-1]
seq[:] Wszystkie elementy seq (kopia)
seq[i:j:k] Elementy seq w zakresie [i … j) z krokiem k (co k-ty)
38
Indeksowanie sekwencji (2) PYTHON Wynik MATLAB
a = [5, 6, 7, 8] a = [5 6 7 8]
a[0] 5 a(1)
a[2:4] [7, 8] a(3:4)
a[-1] 8 a(end)
a[-2] 7 a(end-1)
a[2:] [7, 8] a(3:end)
a[::2] [5, 7] a(1:2:end)
a[::-1] [8, 7, 6, 5] a(end:-1:1)
len(a) 4 length(a)
[min(a), max(a)] [5, 8] [min(a) max(a)]
TAKŻE DLA: a = ‘Python rulez’*0:4+ a = (5, 6, 7, 8) a = *,1: 2-, *3, 4+, 5, ’Six’+
39
Słowniki
• Dictionary/Hash – słownik:
{}, dict()
{1:’one’, 2:’two’, 5:’five’}
{’A’:1, ’AB’:2, ‘ABC’:1234}
{’NY’: ’USA’, ’WAW’: ’Poland’}
dict(one=2, two=3)
dict(zip(('one', 'two'), (2, 3)))
dict([['two', 3], ['one', 2]])
40
Operatory/Funkcje dla kolekcji (1) Operacja Wynik
s[i] = x Element i słownika s jest zamieniany na x
s[i:j] = t ‘Plaster’ s elementów *i … j) jest zamieniany na elementy z t
del s[i:j] To samo co s[i:j] = []
s[i:j:k] = t Elementy s[i:j:k] zamieniane na elementy z t
del s[i:j:k] Usunięcie elementów s[i:j:k]
41
Operatory/Funkcje dla kolekcji (2) Operacja Wynik
s.append(x) To samo co s[len(s):len(s)] = [x]
s.extend(x) To samo co s[len(s):len(s)] = x
s.count(x) Zwraca liczbę elementów spełniających warunek: s[i] == x
s.index(x[, i[, j]]) Zwraca najmniejszy indeks k, taki że s[k] == x oraz i <= k < j
s.insert(i, x) To samo co s[i:i] = [x]
s.pop([i]) To samo co x = s[i]; del s[i]; return x
s.remove(x) To samo co del s[s.index(x)]
s.reverse() Odwraca kolejnośd elementów s (w miejscu)
s.sort([cmp[, key[, reverse]]])
Sortuje elementy s (w miejscu)
42
Operatory/Funkcje dla kolekcji (3) Operacja Wynik
x in coll True jeśli coll zawiera x
x not in coll True jeśli coll zawiera x
any(coll) True jeśli którykolwiek element coll jest True
all(coll) True jeśli wszystkie elementy coll są True
len(coll) Liczba elementów coll
max(coll[, key=function]) Element maksymalny coll
min(coll[, key=function]) Element minimalny coll
43
Zbiory
• set – zbiór (nieuporządkowany) :
set()
set([1, 2]), set([2, 1])
set((2, 1))
set(range(0,5))
set([1, 2]) | set([3, 4])
• frozenset – zbiór niemodyfikowalny
+ funkcje na zbiorach – patrz dokumentacja Pythona 44
Jak skopiowad kolekcję
>>> a = [1, 2, 3]
>>> b = a # kopia !?
>>> a[1] = 2000 # zmiana w oryginale
>>> b
[1, 2000, 3] # !@%^
45
Kopia kolekcji
a = [1, 2, 3]
b = a[:] # metoda 1
b = list(a) # metoda 2
b = []; b.extend(a) # metoda 3
b = []; # metoda 4
b = [ e for e in a ]
for n in range(len(a)): # metoda 5
b.append(a[n])
+ deepcopy – patrz dokumentacja Pythona
EX3
46
range()/xrange()
• Pętla na sekwencji: for n in range(1000000000):
print(n)
MemoryError
• Rozwiązanie – użyj xrange() for n in xrange(1000000000):
print(n)
• W Python 3.0 xrange() nieistnieje, a range() zachowuje się jak xrange()!!!
47
List comprehension (1)
• Tworzenie listy: all = []
for i in range(0, 100):
all.append(i)
• j.w. w wersji jednolinijkowej: all = [ i for i in range(0, 100) ]
list = [ expr for item in iterable ]
48
List comprehension (2)
• Tworzenie listy: odd = []
for i in range(0, 100):
if i%2:
odd.append(i)
• j.w. w wersji jednolinijkowej: odd = [ i for i in range(0, 100) if i%2]
list = [ expr for item in iterable if
cond]
49
Struktury kontrolne i pętle
• Instrukcje warunkowe – If
• Pętle – for – while
• Inne – import – return – yield – pass – assert
50
if
if warunek1:
blok1
elif warunek2:
blok2
# … Dodatkowe elif …
else:
blok3
51
True or False
• False: – None
– False
– Numeryczne zero: 0, 0L, 0.0, 0j
– Pusta sekwencja: '', (), []
– Pusta słownik: {}
– Instancja klasy z funkcjami __nonzero__() lub __len__(), które zwracają 0 lub False
• Reszta True
52
Operatory porównao
Operator Znaczenie Uwagi
< Mniejszy niż
<= Mniejszy lub równy
> Większy niż
>= Większy lub równy
== Równy
!= Nie równy <>
is Identycznośd obiektów
is not Zaprzeczenie identyczności obiektów
+ Operatory logiczne: not, and, or, 53
UWAGA na zwarcie! "short circuit"
>>> 'a' == ('a' or 'b')
True
>>> 'b' == ('a' or 'b')
False
>>> 'a' == ('a' and 'b')
False
>>> 'b' == ('a' and 'b')
True
54
For in range
>>> od1do10 = range(1, 11)
>>> for count in od1do10 : print count
1
2
…
9
10
>>> od1do10
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
55
for-continue, for-else
for n in range(2, 10, 1):
if n % 2:
print n, ”is odd”
break
else:
print ”Odd not found”
56
while, while-else
input_ok = False
while not input_ok:
s = input('Enter something: ')
if s == 'exit':
break
if len(s) < 3:
print('Too small')
continue
input_ok = True
else:
print ”Input is OK”
57
BMI (Body Mass Index) EX4
58
BMI zakresy
Zakres BMI Diagnoza
< 16.5 Poważna niedowaga
[16.5, 18.5) Niedowaga
[18.5, 25) Prawidłowa
[25, 30) Nadwaga
[30, 35) Otyłośd klasy I
[35, 40) Otyłośd klasy II
> 40 Otyłośd klasy III
59
Algorytm
1. Instrukcja dla użytkownika
2. Wprowadzenie danych: wagi i wzrostu
3. Sprawdzenie poprawności zakresów danych – Waga – 0-150kg
– Wzrost – 0-200cm
4. Obliczenie BMI wg. wzoru
5. Klasyfikacja BMI wg. Tabeli
6. Powrót do punktu 1
60
Wersja I
• Korzystając z:
– Tylko typy proste
– Instrukcje: pętli, warunki
– Operacje numeryczne
– Komenda print,
– Funkcje: raw_input(), sys.exit()
61
Wersja II
• Modyfikacja Wersji I:
– Użyj listy do definicji klasyfikatora BMI
62
Funkcje
def <name>(arg1, arg2,... argN):
<statements>
return <value> #optional
n.p.:
def sayHello(who):
print 'Hello ‘, who
# End of function
63
Funkcje przykład
def printMax(a, b):
if a > b:
print a, 'is maximum'
elif a == b:
print a, 'is equal to', b
else:
print b, 'is maximum'
>>> printMax(3, 4)
4 is maximum
>>> x = 5
>>> y = 7
>>> printMax(x, y)
7 is maximum
64
lambda
lambda arg1, arg2,... argN
:expression using arguments
f = lambda x, y, z: x + y + z
def func(x, y, z): return x + y + z
65
def/lambda/return/yeld
• def – jest wykonywalny (!) i tworzy nowy obiekt pod nazwą funkcji • lambda – tworzy i zwraca nowy obiekt funkcji • return – zwraca rezultat do kodu wywołującego • yield – podobnie jak return zwraca rezultat, ale zapamiętuje stan
wewn. funkcji i miejsce powrotu • global – deklaruje zmienne w funkcji jako globalne (domyślnie są
lokalne)
• Argumenty do funkcji są przekazywane przez przypisanie (object reference)
• Argumenty, wartości zwracane i zmienne nie są deklarowane
Python 3.0+: nonlocal – odpowiednik global dla zakresu otaczającego 66
Reguły zakresu (scoping)
• Moduł to zakres global. Zmienne zdefiniowane na poziomie modułu są dostępne z innych modułów za pomocą prefiksu nazwy modułu.
• Zakres global obejmuje tylko jeden plik!!! Można zaimportowad wszystkie nazwy z modułu do przestrzeni globalnej modułu importując jego zawartośd.
• Każde wywołanie funkcji tworzy nowy zakres lokalny (dla tej funkcji).
• Zmienne utworzone/przypisane w funkcji są lokalne, chyba, że zostały zadeklarowane jako global
• Wszystkie inne nazwy są wyszukiwane w zakresie: otaczającym (enclosing scope), globalnym, wbudowanym (__builtin__).
67
Reguła przeszukiwania LEGB
68
Przykłady
X = 88 # global X
def func():
X = 99 # local X
func()
print(X) # 88
----------------------------------
# Global scope
X = 99
def func(Y):
# Local scope
Z = X + Y # X is a global
return Z
func(1) # 100
69
Argumenty funkcji
• Argumenty typów niemodyfikowalnych (Immutable) efektywnie są przekazywane przez wartośd (np. integer, string).
• Argumenty typów modyfikowalnych efektywnie są przekazywane przez referencję (np. listy, słowniki).
70
Składnia argumentów funkcji
Składnia Strona Interpretacja
func(value) Wywołanie argument normalny pozycyjny
func(name=value) Wywołanie argument nazwany
func(*sequence) Wywołanie przekazuje elementy sekwencji jako kolejne argumenty pozycyjne
func(**dict) Wywołanie przekazuje elementy słownika (klucz/wartośd) jako kolejne argumenty nazwane
def func(name) Funkcja Argument normalny: dopasowanie po pozycji lub nazwie
def func(name=value)
Funkcja Argument domyślny, o ile nie przekazany w wywołaniu
def func(*name) Funkcja Zbiera pozostałe argumenty pozycyjne w listę
def func(**name) Funkcja Zbiera pozostałe argumenty nazwane w słownik
71
Argumenty pozycyjne/nazwane/domyślne
def func(spam, eggs, toast=0, ham=0):
print((spam, eggs, toast, ham))
> func(1, 2)
(1, 2, 0, 0)
> func(1, ham=1, eggs=0)
(1, 0, 0, 1)
> func(spam=1, eggs=0)
(1, 0, 0, 0)
> func(toast=1, eggs=2, spam=3)
(3, 2, 1, 0)
> func(1, 2, 3, 4)
(1, 2, 3, 4)
72
Argumenty typu * i **
>>> def f(*args): print(args)
...
> f()
()
> f(1)
(1,)
> f(1, 2, 3, 4)
(1, 2, 3, 4)
-----------------
> def f(**args): print(args)
...
> f()
{}
> f(a=1, b=2)
{'a': 1, 'b': 2}
73
Funkcje – dobra praktyka
• Funkcja powinna służyd do realizacji jednej dobrze określonej rzeczy i nie byd zbyt rozbudowana
• Używaj argumentów na wejściu i return na wyjściu funkcji
• Zmiennych global używaj tylko w kiedy to absolutnie konieczne
• Nie modyfikuj argumentów przekazywanych przez referencję o ile wywołujący się tego nie spodziewa
• Nie modyfikuj zmiennych w innych modułach
74
Wyjątki
try:
blok-try
except ErrorClass1:
blok-except1
except ErrorClass2:
blok-except2
except …
…
else:
blok-else
finally:
blok-finally
75
Wyjątki - przykład
try:
a = 1/0
except:
print 'except'
else:
print 'ok'
finally:
print 'finally'
76
Generacja wyjątku
# Generacja instancji wyjątku
raise <instance>
# Utworzenie instancji i generacja wyjątku
raise <class>
# Powtórna generacja ostatniego wyjątku
raise
--------------------
try:
raise IndexError
except IndexError:
print 'got exception’
77
Składnia try/except/else/finally
Składnia Interpretacja
except: Łapie wyjątki wszystkich typów
except name: Łapie tylko wyjątki danego typu
except name as value: Łapie wyjątki danego typu oraz jego instancję
except (name1, name2): Łapie wyjątki danych typów
except (name1, name2) as value: Łapie wyjątki danych typów oraz ich instancję
else: Wykonywane gdy żaden wyjątek nie został zgłoszony
finally: Wykonywane ZAWSZE na koocu bloku except
78
with/as
with expression [as variable]:
with-block
with open(r'C:\data') as file:
for line in file:
print(line)
…
+ Context Management Protocol – patrz dokumentacja Pythona
EX5
79
MODUŁY
80
Moduły po co i jak
• MODUŁ = biblioteka Pythona • PAKIET (Package) = zestaw modułów w drzewie
katalogów • Po co:
– Code reuse! – Dzielenie kodu/przestrzeni nazw – Współdzielenie serwisów/funkcji/danych
• Kroki ładowania modułu: 1. Znalezienie pliku modułu (ścieżka przeszukiwania) 2. Kompilacja modułu do byte-code (o ile konieczne) 3. Wykonanie modułu
81
import
import <module1>, <module2>
from <module> import <name1>,
<name2>
from <module> import *
82
sys.path
• Poszukiwanie pliku modułu:
1. Katalog domowy/bieżący (UWAGA na nazwy!)
2. Zmienna systemowa PYTHONPATH
3. Katalog biblioteki standardowej
4. Zawartośd plików .pth
• Powyższe tworzy ścieżkę przeszukiwania pamiętaną w sys.path
83
Typy modułów
import mod
• Plik źródłowy Python modułu: mod.py • Skompilowany byte-code modułu: mod.pyc • Katalog o nazwie mod – dla importu pakietów • Skompilowany moduł natywny – biblioteka dynamiczna systemu
operacyjnego (np. mod.dll/mod.pyd dla Windows, mod.so dla Linux)
• Moduł wbudowany w interpreter Pythona (skompilowany i statycznie zlinkowany)
• Plik ZIP – zostaje automatycznie rozpakowany w locie • Obraz modułu w pamięci – dla zamrożonych programów
wykonawczych
84
Przykład
>>> sin(2.0)
NameError: name 'sin' is not defined
>>> import math
>>> dir(math) # look what is in the ’math’
['__doc__', '__name__', '__package__',
'acos', 'acosh', 'asin',…
>>> math.sin(math.pi/2)
1.0
>>> from math import sin
>>> sin(math.pi/2)
1.0
85
Ładowanie modułów c.d.
• Przemianowanie podczas ładowania:
from math import sin as mysin
• Możliwośd przeładowania modułu:
reload(mymodule
86
Przekrywanie nazw przy imporcie
from M import func
from N import func # ooops
func() # wywoła N.func!
------------------------------------------
import M, N # ładuje całe moduły
M.func() # wołamy M.func()
N.func() # wołamy N.func()
87
‘Nieśmiałe’ ładowanie
try:
import urllib3 as urllib # 1st try
except:
try:
import urllib2 as urllib # 2nd try
except:
import urllib as urllib #
urllib.urlopen(’http://neuro.imm.dtu.dk/’)
88
Dokumentacja modułów/funkcji
"""A module ble, ble, ble ..."""
def fun_add(x, y=1):
"""
fun_add(x,y=1) takes one or two numerical arguments
and adds them together. If the second argumentn is
empty it increments input by 1
"""
return x + y
print myfunction.__doc__
>>> help(myfunction)
Generacja dokumentacji HTML dla modułu $ pydoc -w ./mymodule.py
89
Uruchamianie modułu jako skryptu
• Przydatne np. do testowania modułów
• Moduł uruchomiony jako skrypt if __name__ == '__main__':
print ‘Just self testing’
test1()
90
