Język Python (2) Język Python (2) 1/36

Transkrypt

1 Język Python (2) Język Python (2) 1/36

2 Język Python (2) 2/36 Podstawy funkcji Pojęcia podstawowe Instrukcja def tworzy obiekt funkcji i przypisuje go do nazwy Instrukcja return przekazuje obiekt wynikowy do wywołującego Instrukcja global deklaruje zmienne, które mają być przypisane na poziomie modułu Argumenty są przekazywane przez przypisanie (odwołanie do obiektu) Nie trzeba deklarować argumentów, zwracanych typów i zmiennych

3 Język Python (2) 3/36 Deklarowanie funkcji Składnia def <nazwa >( arg1, arg2,... argn ) : <i n s t r u k c j e > return <wartość >

4 Język Python (2) 4/36 Definicje i wywołania >>> def r a z y ( x, y ) :... return x y... >>> r a z y ( 2, 4) 8 >>> r a z y ( Ni, 4) NiNiNiNi

5 Język Python (2) 5/36 Przykład (praktyczny) Przecinanie sekwencji def i n t e r s e c t ( seq1, seq2 ) : r e s = [ ] f o r x i n seq1 : i f x i n seq2 : r e s. append ( x ) return r e s Wywołanie >>> s 1 = " MIELONKA" >>> s2 = "WIELE" >>> i n t e r s e c t ( s1, s2 ) [ I, E, L ] >>> i n t e r s e c t ( [ 1, 2, 3 ], ( 1, 4 ) ) [ 1 ]

6 Język Python (2) 6/36 Zakresy działania w funkcjach Zakres lokalny i globalny Moduł otaczający jest zakresem globalnym Każde wywołanie funkcji ma nowy zakres lokalny Nazwy przypisane są lokalne, chyba że są zadeklarowane jako globalne Wszystkie pozostałe nazwy są nazwami globalnymi lub wbudowanymi

7 Język Python (2) 7/36 Reguła LGB Rysunek : Działanie reguły LGB

8 Język Python (2) 8/36 Przykład działania reguły LGB Fragment kodu >>> # z a k r e s g l o b a l n y >>> X = 99 >>> >>> def func (Y ) :... # z a k r e s l o k a l n y... Z = X + Y... return Z... >>> func ( 1 ) 100 nazwy globalne: X, func nazwy lokalne Y, Z

9 Język Python (2) 9/36 Przekazywanie argumentów >>> def zmien ( x, y ) :... x = 2... y [ 0 ] = mielonka... >>> X = 1 >>> L = [ 1, 2 ] >>> zmien (X, L ) >>> X, L ( 1, [ mielonka, 2 ] )

10 Język Python (2) 10/36 Przekazywanie argumentów (2) Podsumowanie Niezmienne argumenty zachowują się tak, jak w trybie odwołań poprzez wartości w języku C Zmienne argumenty zachowują się tak, jak w trybie odwołań poprzez wskaźniki w języku C

11 Język Python (2) 11/36 Zwracanie większej liczby obiektów >>> def r a z y ( x, y ) :... x = 2... y = [ 3, 4 ]... return x, y... >>> X = 1 >>> L = [ 1, 2 ] >>> X, L = r a z y (X, L ) >>> X, L ( 2, [ 3, 4 ] )

12 Język Python (2) 12/36 Specjalne tryby dopasowania argumentów Dostępne tryby dopasowywania Pozycyjne: dopasowanie od lewej do prawej Słowa kluczowe: dopasowanie za pomocą nazwy argumentu Domyślne: określanie wartości dla argumentów, które nie zostały przekazane varargs: wychwycenie niedopasowanych argumentów pozycyjnych lub słów kluczowych

13 Język Python (2) 13/36 Sposoby dopasowania argumentów funkcji Składnia Położenie Interpretacja func(value) wywołanie dopasowanie pozycyjne func(name=value) wywołanie dopasowanie na podstawie słowa kluczowego def func(name) funkcja argument normalny def funkcja domyślna wartość argumentu func(name=value) def func(*name) funkcja dopasowanie do pozostałych argumentów pozycyjnych def func(**name) funkcja dopasowanie do pozostałych słów kluczowych

14 Język Python (2) 14/36 Sposoby dopasowania argumentów funkcji (2) >>> def func ( a, b, c =0, d =0):... p r i n t ( ( a, b, c, d ) ) >>> >>> func ( 1, 2) ( 1, 2, 0, 0) >>> func ( 1, d=1, b=0) ( 1, 0, 0, 1) >>> func ( a=1, b=0) ( 1, 0, 0, 0) >>> func ( c =1, b=2, a=3) ( 3, 2, 1, 0) >>> func ( 1, 2, 3, 4) ( 1, 2, 3, 4) >>> func ( 1 ) Traceback ( most r e c e n t c a l l l a s t ) : F i l e "<stdin >", l i n e 1, i n <module> TypeError : func ( ) t a k e s at l e a s t 2 arguments (1 g i v e n )

15 Język Python (2) 15/36 Wyrażenia lamdba Anonimowy obiekt funkcji lambda arg1, arg2,... argn : w y r a ż e n i e Przykład >>> f = lambda x, y, z : x + y + z >>> f ( 2, 3, 4) 9

16 Język Python (2) 16/36 Wbudowana funkcja map >>> l i c z n i k i = [ 1, 2, 3, 4 ] >>> >>> def p r z y r o s t ( x ) : return x >>> map( p r z y r o s t, l i c z n i k i ) [ 1 1, 12, 13, 1 4 ] # python2 >>> map( p r z y r o s t, l i c z n i k i ) <map object at 0 x 7 f 8 f 7 0 f d e > # python3 >>> l i s t (map( p r z y r o s t, l i c z n i k i ) ) [ 1 1, 12, 13, 1 4 ] # python3 >>> l i s t (map( lambda x : x + 10, l i c z n i k i ) ) [ 1 1, 12, 13, 1 4 ]

17 Język Python (2) 17/36 Tworzenie modułu Zawartość pliku fibo.py # Moduł l i c z b F i b o n a c c i e g o def f i b ( n ) : # w y p i s z c i ą g F i b o n a c c i e g o aż do n a, b = 0, 1 while b < n : p r i n t b, a, b = b, a+b def f i b 2 ( n ) : # zwróć c i ą g F i b o n a c c i e g o aż do n wynik = [ ] a, b = 0, 1 while b < n : wynik. append ( b ) a, b = b, a+b return wynik

18 Język Python (2) 18/36 Wykorzystanie modułu >>> import f i b o >>> f i b o. f i b (1000) >>> f i b o. f i b 2 (100) [ 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 8 9 ] >>> f i b o. name fibo >>> >>> f i b = f i b o. f i b >>> f i b (500)

19 Język Python (2) 19/36 Alternatywne wykorzystanie modułu >>> import f i b o as f >>> f. f i b (500) >>> from f i b o import f i b, f i b 2 >>> f i b (500) >>> from f i b o import >>> f i b (500)

20 Język Python (2) 20/36 Ścieżka poszukiwania modułów Kolejność poszukiwania modułu 1. katalog bieżący 2. katalogi określone przez zmienną systemową PYTHONPATH 3. katalogi określone w momencie instalacji 4. katalogi umieszczone w zmiennej pythonowej sys.path

21 Język Python (2) 21/36 Moduły standardowe >>> import s y s >>> s y s. ps1 >>> >>> s y s. ps2... >>> s y s. ps1 = C> C> p r i n t ( Yuck! ) Yuck! C> >>> import s y s >>> s y s. path. append ( /ufs/guido/lib/python ) >>> import s y s >>> s y s. argv [ ]

22 Język Python (2) 22/36 Funkcja wbudowana dir() dir() wypisuje nazwy zdefiniowane w module >>> import f i b o, s y s >>> d i r ( f i b o ) [ name, fib, fib2 ] >>> d i r ( s y s ) [ name, argv, builtin_module_names, copyright, exit, maxint, modules, path, ps1, ps2, setprofile, settrace, stderr, stdin, stdout, version ]

23 Język Python (2) 23/36 Funkcja wbudowana help() help() wypisuje sposób użycia modułu >>> import s y s >>> help ( s y s ) Help on b u i l t i n module s y s : NAME s y s FILE ( b u i l t i n ) MODULE DOCS h t t p : / /www. python. org / doc / c u r r e n t / l i b /module s y s. htm DESCRIPTION This module p r o v i d e s....

24 Język Python (2) 24/36 Pakiety Sound/ i n i t. py Formats / i n i t. py wavread. py wavwrite. py a i f f r e a d. py a i f f w r i t e. py... E f f e c t s / i n i t. py echo. py s u r r o u n d. py r e v e r s e. py...

25 Język Python (2) 25/36 Użycie pakietów Przykłady: import Sound. E f f e c t s. echo Sound. E f f e c t s. echo. e c h o f i l t e r ( input, output, d e l a y =0.7, a t t e n =4) from Sound. E f f e c t s import echo echo. e c h o f i l t e r ( input, output, d e l a y =0.7, a t t e n =4) from Sound. E f f e c t s. echo import e c h o f i l t e r e c h o f i l t e r ( input, output, d e l a y =0.7, a t t e n =4)

26 Język Python (2) 26/36 Importowanie z pakietu Zawartość pliku init.py a l l = [ "echo", "surround", "reverse" ] import Sound. E f f e c t s. echo import Sound. E f f e c t s. s u r r o u n d from Sound. E f f e c t s import

27 Język Python (2) 27/36 Słowniki Podstawy >>> eng2pol = {} >>> eng2pol [ one ] = jeden >>> eng2pol [ two ] = dwa >>> >>> p r i n t ( eng2pol ) { two : dwa, one : jeden } >>> eng2pol = { one : jeden, two : dwa, three : trzy } >>> >>> p r i n t ( eng2pol [ two ] ) dwa

28 Język Python (2) 28/36 Metody słowników Dostęp do zawartości słownika >>> eng2pol. keys ( ) [ three, two, one ] >>> eng2pol. v a l u e s ( ) [ trzy, dwa, jeden ] >>> eng2pol. i t e m s ( ) [ ( three, trzy ), ( two, dwa ), ( one, jeden ) ]

29 Język Python (2) 29/36 Metody słowników (2) Sprawdzanie zawartości słownika >>> one i n eng2pol True >>> deux i n eng2pol F a l s e >>> eng2pol [ dog ] Traceback ( most r e c e n t c a l l l a s t ) : F i l e "", l i n e 1, i n KeyError : dog >>>

30 Język Python (2) 30/36 Operacje na słownikach >>> magazyn = { jablka : 430, banany : 312, pomarancze : 525, gruszki : 217} >>> p r i n t ( magazyn ) { pomarancze : 525, jablka : 430, gruszki : 217, banany : 312} Usuwanie klucza >>> del magazyn [ gruszki ] >>> p r i n t ( magazyn ) { pomarancze : 525, jablka : 430, banany : 312} Edycja wartości >>> magazyn [ gruszki ] = 0 >>> p r i n t ( magazyn ) { pomarancze : 525, jablka : 430, gruszki : 0, banany

31 Język Python (2) 31/36 Operacje na plikach Operacja output = open( plik, w ) input = open( plik, r ) S = input.read() S = input.readline() L = input.readlines() output.write(s) output.writelines(l) output.close() S łańcuch znaków L lista łańcuchów znaków Znaczenie Tworzy plik wyjściowy Tworzy plik wejściowy Odczyt całego pliku w postaci pojedynczego łańcucha Odczyt następnego wiersza Odczyt całego pliku do listy łańcuchów Zapisanie łańcucha S do pliku Zapisanie listy łańcuchów znaków do pliku Ręczne zamknięcie pliku

32 Język Python (2) 32/36 Manipulacja plikami Wydruk komentarzy import s y s f o r l i n e i n s y s. s t d i n. r e a d l i n e s ( ) : i f l i n e [ 0 ] == # : p r i n t ( l i n e, end= ) Zliczenie wystąpień słowa Python t e x t = open ( n a z w a p l i k u ). read ( ) p r i n t ( t e x t. count ( Python ) )

33 Język Python (2) 33/36 Zwykłe metody dla łańcuchów znaków index(napis, pocz, kon) find(napis, pocz, kon) count(napis, pocz, kon) replace(zmien, na) split(rozdz) strip(znaki) upper(), lower(), capitalize()

34 Język Python (2) 34/36 Składnia wyrażeń regularnych Znaki specjalne (powtórzenie). *, +,? ^, $ {m,n} [] (...) Znaki specjalne (rozszerzenie) *?, +?,?? \d, \D \b

35 Język Python (2) 35/36 Wykorzystanie wyrażeń regularnych >>> import r e >>> m = r e. match ( r"c", "abcdef" ) >>> m >>> m = r e. s e a r c h ( r"c", "abcdef" ) >>> m < s r e. SRE Match object at 0 x7f09214a3b28> >>> m. group ( 0 ) c >>> r e. f i n d a l l ( r"c", "abcabc" ) [ c, c ] >>> r e. sub ( "c.*c", "cc", "abcabc" ) abcc

36 Język Python (2) 36/36 W wykładzie wykorzystano materiały The Python Tutorial, Mark Lutz, David Ascher, Python. Wprowadzenie, Helion, 2002