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

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

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

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ść >

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

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 ]

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

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

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

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 ] )

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

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 ] )

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

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

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 )

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

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 + 10... >>> 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 8 2 8 > # 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 ]

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

Język Python (2) 18/36 Wykorzystanie modułu >>> import f i b o >>> f i b o. f i b (1000) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 >>> 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) 1 1 2 3 5 8 13 21 34 55 89 144 233 377

Język Python (2) 19/36 Alternatywne wykorzystanie modułu >>> import f i b o as f >>> f. f i b (500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 >>> from f i b o import f i b, f i b 2 >>> f i b (500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377 >>> from f i b o import >>> f i b (500) 1 1 2 3 5 8 13 21 34 55 89 144 233 377

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

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 [ ]

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 ]

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....

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...

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)

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

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

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 ) ]

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 >>>

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

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

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 ) )

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()

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

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

Język Python (2) 36/36 W wykładzie wykorzystano materiały The Python Tutorial, http://docs.python.org/tutorial/index.html Mark Lutz, David Ascher, Python. Wprowadzenie, Helion, 2002