JĘZYK PYTHON - NARZĘDZIE DLA KAŻDEGO NAUKOWCA

Marcin Lewandowski

[ mlew@ippt.gov.pl ]

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