Wprowadzenie do Pythona 3 Arkusze Pracy Studenta Władysław

Transkrypt

Wprowadzenie do Pythona 3
Arkusze Pracy Studenta
Władysław Skarbek
Politechnika Warszawska
Wydział Elektroniki i Technik Informacyjnych
Etap 1
Instrukcja 1 (Instalacja systemu Python 3.1)
1. Zainstaluj system Python 3.1 w domyślnym katalogu, koniecznie z oryginalnej strony
http://www.python.org/download wybierz binarny instalator Windowsx86 MSI Installer
2. Załóż własny katalog roboczy poza katalogiem Python31, np.
D:/my-31-packages.
3. Wpisz do niego pusty plik o nazwie __init__.py. W przyszłości pami˛etaj o tej czynności dla każdego podkatalogu, w którym b˛eda˛ Twoje pliki .py (tzw. moduły), a które
chcesz używać (importować) z modułów umieszczonych w innych podkatalogach.
4. Dopisz tekst C:\Python31; do zmiennej systemowej PATH (o ile instalator tego nie
zrobił samodzielnie).
5. Poinformuj Pythona o swoim katalogu roboczym, tj.:
• Utwórz plik Twoich ścieżek z rozszerzeniem .pth,
np. plik my.pth z linia˛ D:/my-31-packages.
• Umieść ten plik w katalogu Python26/Lib/site-packages.
6. Dla sprawdzenia:
• Umieść plik ex1.py oraz plik danych example-1.txt w katalogu roboczym
D:/my-31-packages
• Z Menu Start uruchom IDLE (Python GUI). Otworzy si˛e okno interpretera Pythona.
• Otwórz plik ex1.py w oknie edytora IDLE: klawisz Ctrl-O.
• Zmodyfikuj linie odnoszace
˛ si˛e do lokalizacji pliku danych example-1.txt.
• Dopisz wywołanie funkcji testowej (przed lub po niej):
if __name__==’__main__’: test()
• Uruchom program ex1.py z okna edytora: klawisz F5.
• Porównaj swój ekran z wynikami poniżej:
a all an and application approach are areas available
be binary but
data development distributed dynamic
easy effective efficient elegant extensive
for form freely from
has high http
ideal in interpreted interpreter is it its
1
language learn level library
major make many may most
nature
object on or org oriented
platforms powerful programming python python’s
rapid
scripting simple site source standard structures syntax
the to together typing
web with www
7. Uruchamianie skryptów Pythona z materiałów wykładowych w formacie pdf b˛edzie łatwiejsze gdy zainstalujemy Foxit Reader ze strony:
http://www.foxitsoftware.com/downloads/
Ćwiczenie 1 (Pierwsze wyrażenia)
Dla poniższych wyrażeń i ich interpretacji w sekcji Wyniki:
1. Wpisz kolejne linie w oknie interpretera w środowisku IDLE. Porównaj wyniki.
2. Utwórz w nowym oknie edycyjnym IDLE plik skryptowy p1a.py zawierajacy
˛ te wyrażenia.
3. Wykonaj w IDLE skrypt p1a.py (klawisz F5). Porównaj wyniki.
4. Zmień wartości zmiennych a,b,c, wykonaj kroki 1–3 i porównaj wyniki w punktach 1
oraz 3.
1
2
3
4
a = 1; c = 10; b = 5
i f b >=5: p r i n t ( ’ b = ’ , b )
i f b<c : p r i n t ( ’ c = %d ’ % ( c ) )
i f a<b<c : p r i n t ( ’ a=%d , b=%d , c=%d ’ % ( a , b , c ) )
5
6
7
8
9
# Wyniki :
b = 5
c = 10
a =1 , b =5 , c =10
Ćwiczenie 2 (Wartości boolowskie)
Dla poniższych wyrażeń i ich interpretacji w sekcji Wyniki:
1. Wpisz kolejne linie w oknie interpretera w środowisku IDLE. Porównaj wyniki.
2. Utwórz w nowym oknie edycyjnym IDLE plik skryptowy p1b.py zawierajacy
˛ te wyrażenia.
3. Wykonaj w IDLE skrypt p1b.py (klawisz F5). Porównaj wyniki.
4. Zmień wartości zmiennych a,b,c, wykonaj kroki 1–3 i porównaj wyniki w punktach 1
oraz 3.
2
1
2
3
4
5
6
7
# −∗− c o d i n g : cp1250 −∗−
a = 1; c = 10; b = 5
e = a<b<c
f = a<b and b<c
p r i n t ( ’ e = ’ , e , end= ’ ’ )
print ( ’ , f =’ , f )
p r i n t ( ’ e równowa żne f ? : ’ , e== f )
8
9
10
11
# Wyniki :
e = True , f = T r u e
e równowa żne f ? : T r u e
Ćwiczenie 3 (Upraszczamy silni˛e)
1. Wykonaj w IDLE poniższy kod obliczajacy
˛ silni˛e.
2. Sprawdź co jest ważniejszym ograniczeniem w tym programie: czas czy pami˛eć?
3. Z poniższego kodu wybierz linie istotne dla obliczenia n! i wykonaj ten nowy program.
(a) Linia inicjacji zmiennych.
(b) Główna p˛etla.
(c) Drukowanie wyników.
1
2
3
4
5
6
7
8
9
10
11
12
from t i m e i m p o r t c l o c k
f = 1 ; n = 1000
s t a r t = clock ()
f o r i i n r a n g e ( 2 , n ) : f ∗= i
end = c l o c k ( )
p r i n t ( ’ c z a s :%d [ ms ] ’ %(1000∗( end− s t a r t ) ) )
p r i n t ( ’ c z a s : { 0 : d } [ ms ] ’ . f o r m a t ( i n t ( 1 0 0 0 ∗ ( end− s t a r t ) ) ) )
f r o m math i m p o r t l o g 1 0
p r i n t ( ’ j e s t %d c y f r d z i e s i e˛ t n y c h w z a p i s i e %d ! ’ %\
(1+ i n t ( l o g 1 0 ( f ) ) , n ) )
p r i n t ( ’%d ! = %d ’ %(n , f ) )
p r i n t ( ’ Typ n u m e r y c z n y ’ , t y p e ( f ) , ’ma p r e c y z j e˛ dowoln a˛ ! ’ )
Zadanie 1 (Funkcja silnia)
1. Napisz iteracyjna˛ funkcj˛e isilnia.
2. Napisz rekurencyjna˛ funkcj˛e rsilnia.
3. Sprawdź, która z nich działa szybciej.
Rozwiazanie:
˛
1. Iteracyjna funkcja silni, wynik i czas obliczeń:
3
1
2
3
4
5
6
7
8
9
10
11
12
##
##
##
##
##
##
##
##
##
##
##
##
2. Rekurencyjna funkcja silni, wynik i czas obliczeń:
1
2
3
4
5
6
7
8
9
10
11
##
##
##
##
##
##
##
##
##
##
##
Zadanie 2 (Ciag
˛ Fibonacciego)
1. Ciag
˛ Fibonacciego definiujemy indukcyjnie:
F0 = F1 = 1, n > 1 −→ Fn = Fn−1 + Fn−2
2. Napisz iteracyjna˛ funkcj˛e fibonacci(n), która zwraca list˛e zawierajac
˛ a˛ pierwsze n+1
elementów ciagu Fibonacciego
[F0 , F1 , . . . , Fn ]
3. Wskazówki:
(a) inicjacja listy: li = [1,1]
(b) dodawanie elementu x do listy: li.append(x).
Rozwiazanie:
˛
1
2
3
4
5
6
##
##
##
##
##
##
4
7
8
9
10
11
##
##
##
##
##
Tworzeniu wi˛ekszych programów b˛edzie łatwiejsze w bardziej rozbudowanym środowisku jakim jest system Eric rozwijany przez Detleva Offenbacha.
Instrukcja 2 (Instalacja zintegrowanego środowiska Eric5)
1. Doinstaluj ActivePython 3.1 frirmy ActiveState. Ładowanie ze strony:
http://www.activestate.com/activepython/downloads
– instalacja dopisuje i podmienia niektóre pliki oryginalnej instalacji, ale nie zmienia
pakietów z katalogu site-packages
2. Na wszelki wypadek zainstaluj pakiet oprogramowania
Microsoft Visual C++ 2008 Redistrbutable Package (x86)
Adres strony dostaniesz w Google, jeśli wkleisz powyższa˛ nazw˛e pakietu. Łacze
˛
może
być do starszej wersji pakietu, wi˛ec szukaj ikony sześciokata
˛ z wpisem a newer version
is available.
3. Zainstaluj system okienkowy PyQt 4 dla Pythona 3. ŁAcze:
˛
http://riverbankcomputing.com/software/pyqt/download
Wybierz opcj˛e PyQt-Py3.1-x86-...
4. Zainstaluj środowisko Eric5:
• wejdź na stron˛e http://www.eric-ide.python-projects.org,
• wybierz kolejno łacza:
˛
eric downloads!, eric5 IDE, download eric5
• pobierz archiwum .zip i rozpakuj je w C:\ProgramFiles\
• w oknie DOSa otwórz katalog eric... i uruchom instalator:
>python3 install.py
5. Zainstaluj pakiet sprawdzania ortografii:
• Załaduj PyEnchant ze strony
http://www.rfk.id.au/software/pyenchant/
• Ze strony OpenOffice wyszukaj łacze
˛ do lokacji słownika j˛ezyka polskiego:
http://extensions.service.openoffice.org/en/dictionaries
• Rozpakuj archiwum słownika, ale wybierz z niego tylko dwa pliki pl-PL.aff oraz
pl_PL.dic i skopiuj je do katalogu:
C:\Python31\Lib\site-packages\enchant\share\enchant\myspell
• Skonfiguruj detekcj˛e bł˛edów pisowni w środowisku Eric5:
Settings, Preferences, Spell checking
• Skonfiguruj inne opcje Erica według swoich preferencji, np.: szerokość linii, kolor
jej przepełnienia, ilość symboli wystarczajacej
˛ do uruchomienia okienka podpowiedzi, liczba cyfr w numerze linii, krój czcionki w oknie edycji, słowa kluczowe
edytora Latexa, kolory całostek Pythona, itp.
5
Etap 2
Ćwiczenie 4 (Obsługa wyjatków)
˛
1. Sprawdź działanie bloku try:...except Exception... dla operacji arytmetycznych:
1
2
3
4
5
6
7
8
9
10
a = 4; b = 0; c = 2
try :
print ( ’a / c =’ ,a / c )
print ( ’a / b =’ ,a / b )
except ZeroDivisionError :
p r i nt ( ’ Dzielenie przez zero ’ )
##
##
##
##
2. Dopasuj kod do nast˛epujacych
˛
wyników:
1
2
3
4
5
6
##
##
##
##
##
##
7
8
9
10
# Wyniki :
a =4 , a ∗a=16
D z i e l e n i e p r z e z z e r o , b=0
3. Sprawdź działanie bloku try:...except Exception... dla operacji listowych:
1
2
3
4
5
6
7
8
9
10
11
l i = [1 ,3 , −1 , −3]
try :
f o r i in range ( −2 ,7):
p r i n t ( ’ i = ’ , i , ’ , ’ , end= ’ ’ )
p r i n t ( ’ l i [%d]=%d ’ % ( i , l i [ i ] ) )
except Exception :
p r i n t ( ’ I n d e k s l i s t y poza zakresem ’ )
##
##
##
##
6
12
13
14
15
16
##
##
##
##
##
˛
wyników:
1
2
3
4
5
6
##
##
##
##
##
##
7
8
9
10
11
12
13
14
15
# Wyniki :
i =0 , l i [0]=−1
i =1 , l i [1]=3
i =2 , l i [2]=1
i =3 , l i [3]=3
i =4 , l i [4]=4
i =5 , l i [5]=5
I n d e k s poza zakresem
Ćwiczenie 5 (Interpretacja kodu tworzonego ”w locie”)
1. Sprawdź działanie polecenia eval:
1
2
3
4
5
6
7
8
s = " name=’ A l a ’ , age =15 , h e i g h t =160 "
d = e v a l ( ’ d i c t ( ’+s+ ’ ) ’ )
p r i n t ( ’ Słownik : ’ ,d )
p r i n t ( ’ Wiek : ’ , d [ ’ age ’ ] )
##
##
##
##
˛
wyników:
1
2
3
4
5
6
7
##
##
##
##
##
##
##
8
9
10
11
12
13
14
# Wyniki :
I m i e˛ : A n d r z e j
Wiek : 25
W z r o s t : 180
Mama : Maria
T a t a : Jan
7
3. Sprawdź działanie poleceń exec and eval:
1
2
3
4
d e f e x e c _ o n _ f l y ( module , f u n c , a r g s ) :
e x e c ( ’ i m p o r t ’+module+ ’ \ n ’ )
y = e v a l ( module+ ’ . ’+f u n c+ ’ ( ’+a r g s+ ’ ) ’ )
return y
5
6
7
8
9
10
11
12
module = ’ math ’
func = ’ sin ’
args = ’ 3.14 ’
p r i n t ( e x e c _ o n _ f l y ( module , f u n c , a r g s ) )
##
##
##
˛
wyników:
1
2
3
4
5
6
7
8
9
10
##
##
##
##
##
##
##
##
##
##
11
12
13
# Wyniki :
45.0
Ćwiczenie 6 (Importowanie modułów i elementów)
1. W swoim głównym katalogu skryptów Pythona X utwórz manualnie zagnieżdżone katalogi pakietowe A,B: B ⊂ A ⊂ X.
2. W pliku __init__.py pakietu A wpisz print(’pakiet A’),
3. W pliku __init__.py pakietu B wpisz print(’pakiet B’),
4. Włacz
˛ swoje implementacje funkcji isilnia, rsilnia, oraz fibonacci w module
wprawki.
5. W pliku wprawki.py wpisz dyrektyw˛e kodowania i polecenie print(’moduł W’),
6. Umieść moduł wprawki w katalogu B.
7. Sprawdź spójność polecenia importowania z wywołaniem Twojej funkcji w kombinacjach określonych w poniższej tabeli. W miejscach bł˛ednych (poprawnych) kombinacji
wpisz - (+).
8
Wywołanie
rsilnia(5)
wprawki.isilnia(10)
B.wprawki.fibonacci(5)
A.B.wprawki.fibonacci(10)
abw.fibonacci(15)
imp0
—
—
—
—
—
imp1
—
—
—
—
—
imp2
—
—
—
—
—
imp3
—
—
—
—
—
imp4
—
—
—
—
—
imp5
—
—
—
—
—
gdzie polecenie importowania indj ma postać dla j = 0, . . . , 5 :
skrót
imp0
imp1
imp2
imp3
imp4
imp5
polecenie importowania
import A
import A.B
import A.B.wprawki
import A.B.wprawki as abw
from A.B.wprawki import rsilnia
8. W poniższej tabelce wpisz teksty drukowane przez moduły __init__ dla każdego zdania
import wykonywanych:
(a) w podanej kolejności w tym samym programie,
(b) niezależnie w osobnych programach.
imp0
——–
imp0 imp1
——– ——–
wiedź dla przypadku 2:
——– ——–
——– ——–
Odpowiedź dla przypadku 1:
imp1
——–
imp2
——–
——–
——–
imp2
——–
imp3
——————-
imp3
——imp4
——————-
imp4 imp5
Odpo——– ——–
imp5
——————-
Zadanie 3 Ćwiczenie 6 można zrealizować ”manualnie” piszac
˛ dla każdego elementu tabeli
osobny kod. To zadanie opisuje automatyczne rozwiazanie
˛
tego ćwiczenia. Twoim zadaniem
jest:
1. uzupełnienie brakujacych
˛
fragmentów kodu w poniższym opisie;
2. przetestowanie otrzymanego kodu.
Rozwiazanie:
˛
1. Zdefiniuj list˛e napisów dla poleceń importowych:
1
2
i m p o r t s = [ ’ ’ , ’ i m p o r t A ’ , ’ i m p o r t A . B ’ , ’ i m p o r t A . B . wprawki ’ ,
’ i m p o r t A . B . wprawki a s abw ’ , ’ from A . B . wprawki i m p o r t r s i l n i a ’ ]
2. Zdefiniuj list˛e napisów dla wywołań funkcji:
3
4
c a l l s = [ ’ r s i l n i a ( 5 ) ’ , ’ wprawki . i s i l n i a ( 1 0 ) ’ , ’B . wprawki . f i b o n a c c i ( 5 ) ’ ,
’A . B . wprawki . f i b o n a c c i ( 1 0 ) ’ , ’ abw . f i b o n a c c i ( 1 5 ) ’ ]
3. Zdefiniuj funkcj˛e imp(i), która testuje wszystkie wywołania funkcji dla i-tego polecenia importowego. Funkcja ta ma nast˛epujac
˛ a˛ struktur˛e:
9
5
7
10
13
14
18
21
d e f imp ( i ) :
#< I n t e r p r e t a c j a i m p o r t s [ i ] >#
#< Drukowanie n a p i s u i m p o r t s [ i ] >#
for k in range ( len ( c a l l s ) ) :
#< Formowanie t r y _ b l o c k d l a w y w o ł a n i a c a l l s [ k ] >#
#< I n t e r p r e t a c j a t r y _ b l o c k >#
#< W o ł a n i e f u n k c j i imp ( i ) >#
4. Interpretacja napisu imports[i]:
7
8
##
##
5. Drukowanie napisu imports[i]:
10
11
##
##
6. Formowanie napisu try_block dla bloku try:...except Exception:...
14
15
16
##
##
##
7. Interpretacja napisu try_block:
18
19
##
##
8. Wywołaj funkcj˛e imp(i) dla wszystkich poleceń importowych:
21
22
23
24
p r i n t ( ’START : ’ , d i r ( ) )
for i in range ( len ( imports ) ) :
p r i n t ( ’− ’ ∗ 5 0 , i ) ; imp ( i )
p r i n t ( ’END: ’ , d i r ( ) )
9. Oto wyniki tego programu: Wykonaj w oknie interpretera
10
Etap 3
Ćwiczenie 7 (Definiowanie funkcji – Parametry jawne)
1. Sprawdź działanie funkcji:
1
2
3
4
5
6
7
8
9
10
11
12
d ef f ( a , b =2):
d e f g ( c ) : r e t u r n 2∗ c ∗ c+3
d = g ( a )+ g ( b )
return d
x = y = 5
p r i n t ( ’ f (%d)=%d ’ % ( x , f ( x ) ) )
z = f ( x , b=y )
p r i n t ( ’ f (%d , b=%d)=%d ’ % ( x , y , z ) )
##
##
##
##
˛
wyników:
1
2
3
4
5
6
7
##
##
##
##
##
##
##
8
9
10
11
# Wyniki :
f (7)=113
f ( 7 , b =7)=203
Ćwiczenie 8 (Definiowanie funkcji – Parametry niejawne (listy i słowniki))
1
2
3
d e f f ( ∗ a r g s ) : r e t u r n sum ( a r g s )
a = 1; b = 2; c = 3
p r i n t ( ’ f (%d ,%d ,%d ,%d)=%d ’ %(a , b , c , 4 , f ( a , b , c , 4 ) ) )
4
5
6
d e f g (∗∗ kwargs ) :
sval = 0
11
7
8
9
10
11
f o r k i n k w a r g s : s v a l += k w a r g s [ k ]
return sval
a = 1; b = 2; c = 3
s s = g ( x=a , y=b , z=c )
p r i n t ( ’ g ( x=%d , y=%d , z=%d)=%d ’ %(a , b , c , s s ) )
12
13
14
15
16
17
18
19
20
21
22
23
24
25
d e f h (∗ args , ∗ ∗ kwargs ) :
sval = 0
f o r a i n a r g s : s v a l += a
return sval
a = 1; b = 2; c = 3; d = 4
s s = h ( a , b , x=c , y=d )
p r i n t ( ’ h(%d ,%d , x=%d , y=%d)=%d ’ %(a , b , c , d , s s ) )
##
##
##
##
##
˛
wyników:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
21
22
23
24
25
# Wyniki :
f (−1,−2,−3,−4)=−2
g ( x =−1, y =−2, z =−3)+1=−5
h ( −1 , −2 , x =−3, y=−4)−1=−11
Ćwiczenie 9 (Definiowanie funkcji – Argumenty niejawne)
12
1
2
3
d e f f ( ∗ a r g s ) : r e t u r n sum ( a r g s )
l i = [1 ,2 ,3]
p r i n t ( ’ l i =%s , f ( ∗ l i )=%d ’ %( l i , f ( ∗ l i ) ) )
4
5
6
7
8
9
10
d e f g (∗∗ kwargs ) :
sval = 0
return sval
d i = d i c t ( a =1 , b =2 , c =3)
p r i n t ( ’ d i=%s , g ( ∗ ∗ d i )=%d ’ %( d i , g ( ∗ ∗ d i ) ) )
11
12
13
14
15
16
17
18
19
20
21
22
23
d e f h (∗ args , ∗ ∗ kwargs ) :
sval = 0
f o r a i n a r g s : s v a l += a
return sval
l i = [ 1 , 2 ] ; d i = d i c t ( c =3 , d =4)
p r i n t ( ’ l i =%s , d i=%s , h ( ∗ l i , ∗ ∗ d i )=%d ’ %( l i , d i , h ( ∗ l i , ∗ ∗ d i ) ) )
##
##
##
##
##
˛
wyników:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
19
20
21
22
23
# Wyniki :
l i =[ −1 , −2, −3] , f ( ∗ l i )=−6
d i ={ ’ a ’ : −1, ’ c ’ : −3, ’ b ’ : −2} , g ( ∗ ∗ d i )+1=−5
l i =[ −1 , −2] , d i ={ ’ c ’ : −3, ’ d ’ : −4} , h ( ∗ l i , ∗ ∗ d i )−1=−11
Ćwiczenie 10 (Definiowanie funkcji – Krotki wyników)
13
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def f (∗ args ) :
s2 = 0
f o r a i n a r g s : s 2 += a∗a
n = len ( args )
avg = sum ( a r g s ) / f l o a t ( n )
v a r = s 2 / f l o a t ( n ) − avg ∗ avg
r e t u r n avg , v a r
l i = [1 ,2 ,3 ,4]
a , v = f (∗ l i )
p r i n t ( ’ l i s t a =%s \ n ś r e d n i a = %f \ n w a r i a n c j a = %f ’ % ( l i , a , v ) )
##
##
##
##
##
˛
wyników:
1
2
3
4
5
6
7
8
9
10
11
12
13
##
##
##
##
##
##
##
##
##
##
##
##
##
14
15
16
17
18
19
# Wyniki :
l i s t a =[ −1 , −2, −3, −4, −5]
ś r e d n i a = −3.000000
wariancja = 2.000000
standardowe o d c h y l e n i e = 1.414214
Ćwiczenie 11 (Definiowanie funkcji – Wyrażenia typu lambda)
1
2
3
4
1
2
3
a = 1; b = 2; c = 3
f = lambda x : ( a ∗ x+b ) ∗ x+c
p r i n t ( ’ W i e l o m i a n a x x+bx+c : a=%g , b=%g , c=%g ’ % ( a , b , c ) )
f o r x i n [ − 1 . 5 , − 1 . , − . 5 , 0 . , . 5 , 1 . , 1 . 5 ] : p r i n t ( ’w(%g ) = %g ’ %(x , f ( x ) ) )
##
##
##
14
4
5
6
7
8
9
##
##
##
##
##
##
˛
wyników:
1
2
3
4
1
2
3
4
5
6
7
8
9
##
##
##
##
# Wyniki :
W i e l o m i a n a x x x+b x x+c x x+d : a =1 , b =2 , c =3 , d=4
w( − 1 . 5 ) = 0 . 6 2 5
w( −1) = 2
w( − 0 . 5 ) = 2 . 8 7 5
w(0) = 4
w( 0 . 5 ) = 6.125
w ( 1 ) = 10
w( 1 . 5 ) = 16.375
Ćwiczenie 12 (Testowanie klasy Z)
1. Dana jest klasa Z implementujaca
˛ algebr˛e liczb zespolonych o współrz˛ednych całkowitych:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Z( object ):
d ef _ _ i n i t _ _ ( sf , a , b =0):
sf .a = a; sf .b = b
d e f __add__ ( s e l f , z ) :
a = s e l f . a+z . a ; b = s e l f . b+z . b
return Z(a , b)
d e f __mul__ ( s e l f , z ) :
a = s e l f . a ∗ z . a− s e l f . b∗ z . b
b = s e l f . a ∗ z . b+ s e l f . b∗ z . a
return Z(a , b)
def __str__ ( s e l f ):
i f s e l f . a !=0 and s e l f . b ! = 0 :
r e t u r n ’ {0: d }+{1: d } j ’ . format ( s e l f . a , s e l f . b )
i f s e l f . a==0 and s e l f . b ! = 1 :
return ’ {0: d} j ’ . format ( s e l f . b )
i f s e l f . a==0 and s e l f . b==0: r e t u r n ’ 0 ’
i f s e l f . a==0 and s e l f . b==1: r e t u r n ’ j ’
i f s e l f . b==0: r e t u r n ’ { 0 : d } ’ . f o r m a t ( s e l f . a )
@staticmethod
def j ( ) : return Z(0 ,1)
15
1
2
3
4
1
2
3
4
5
6
print (Z (6)); print (Z (4)); print (Z(2 ,5)); print (Z(5 ,2))
j =Z . j ( )
a = Z ( 2 ) ; b = Z ( 3 ) ; c = a+ j ∗ b
p r i n t ( ’ a=%s , b=%s , c=a+ j b=%s ’ %(a , b , c ) )
##
##
##
##
##
##
˛
wyników:
1
2
3
4
1
2
3
4
5
6
##
##
##
##
# Wyniki :
4
5
−2+5 j
−5+2 j
a =4 , b =2 , c=a+ j b =4+2 j , d=a+b+c =10+2 j
Zadanie 4 (Rozbudowa klasy Z)
Chcemy dopuścić liczby rzeczywiste jako składowe liczb zespolonych implementowanych w
klasie C. W tym celu
1. Zmodyfikuj metod˛e __str__ by możliwe było drukowanie liczb rzeczywistych.
Wskazówka: Użyj formatowania g.
2. Rozszerz konstruktor o składowe biegunowe r,phi:
a = r cos ϕ, b = r sin ϕ
3. W przypadku składowych kartezjańskich dodaj automatyczne wyznaczanie składowych
biegunowych:
√
r = a2 + b2 , ϕ = atan2(b, a)
4. Dodaj operacj˛e odejmowania liczb zespolonych.
5. Dodaj operacj˛e dzielenia / dla liczb zespolonych.
Wskazówka: Zastosuj współrz˛edne biegunowe.
6. Przetestuj zbudowana˛ przez Ciebie klas˛e C.
Rozwiazanie:
˛
16
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
17
52
53
54
55
56
57
58
59
60
61
62
63
64
##
##
##
##
##
##
##
##
##
##
##
##
##
18
Etap 4
Ćwiczenie 13 (Sekwencyjne struktury danych)
Przykłady poniżej ilustruja˛ wspólne operacje dla sekwencji s, (w kolejności ich priorytetu):
max(s), min(s), len(s), s[i:j:k], s[i:j], s[i], s*n, n*s, s+t, x not in s, x in s.
Sprawdź prawdziwość poniższych równości wpisujac
˛ je kolejno w osobnych liniach okna interpretera:
1. Lista list:
s = [1,-1,2,-2,3,-3]
max(s)==3,min(s)==-3,len(s)==6
s[0]==1,s[2]==2,s[5]==-3
s[6]
# bład:
˛
indeks poza zakresem
s[-1]==s[5],s[-2]==s[4],s[-6]==s[0]
s[-7]
# bład:
˛
indeks poza zakresem
2. Krotka tuple:
s = (1,-1,2,-2,3,-3)
s[1:4]==(-1,2,-2),s[4:]==s[4:6],s[4:]==(3,-3)
s[:4]==s[0:4],s[:4]==(1,-1,2,-2),s[:]==s
s[1:5:2]==(s[1],s[3]),s[1:5:2]==(-1,-2)
s[1::2]==(s[1],s[3],s[5]),s[1::2]==(-1,-2,-3)
s[::2]==(s[0],s[2],s[4]),s[::2]==(1,2,3),s[::]==s
3. Słowo str:
s = ’abcdefać˛
˛ e’
s[1::2]==s[1:9:2],s[1::2]==’bdfć’
s[4:1:-1]==’edc’,s[4:1:-1]==s[4]+s[3]+s[2]
s[4:0:-1]==’edcb’,s[4:0:-1]==s[4]+s[3]+s[2]+s[1]
s[7:-1:-1]==’’,s[7::-1]==’ćafedcba’,s[8::-1]==’˛
˛
ećafedcba’
˛
s[5::-1]==s[5]+s[4]+s[3]+s[2]+s[1]+s[0]
4. Sekwencja bajtów bytes:
s = bytes(’aacće˛
˛
e’,encoding=’cp1250’)
len(s)==6,min(s)==97,max(s)==234
s[0]==97,s[1]==185,s[2]==99,s[3]==230
s*3==3*s,type(s*2)==bytes
s*2==bytes(’aacće˛
˛
eaacće˛
˛
b’c’ in s, 230 in s, 98 not in s, b’\xf3’ not in s
s+s*3==4*s,3*s+s==s*4
19
5. Tablica bajtów bytearray:
s = bytearray(6)
len(s)==6,min(s)==0,max(s)==0
s[:] = bytes(’aacće˛
˛
s*3==3*s,type(s*2)==bytearray
s*2==bytes(’aacće˛
˛
eaacće˛
˛
b’c’ in s, 230 in s, 98 not in s, b’\xf3’ not in s
s+s*3==4*s,3*s+s==s*4
Ćwiczenie 14 (Specyficzne metody w list) Listy sa˛ jedynymi modyfikowalnymi sekwencjami
Pythona. Zmiany,usuwania i dodawania elementów listy s możemy dokonywać w notacji indeksu (s[i]=x, del s[i]), przekroju (s[i:j]=t, del s[i:j], s[i:j:k]=t, del s[i:j:k])
lub w wyniku zastosowania jednej z metod:
• s.append(x): dopisuje element x na koniec listy s
• s.extend(t): dołacza
˛ na koniec elementy listy t
• s.insert(i,x): dołacza
˛ x przed s[i] (jak w \verb! del s[i:i] = [x])
• s.pop(i): usuwa referencj˛e s[i] i zwraca obiekt s[i]
• s.remove(x): usuwa pierwsze wystapienie
˛
obiektu x
• s.reverse(): odwraca list˛e w miejscu (nic nie zwraca)
• s.sort(): sortuje w miejscu (nic nie zwraca)
Ostatnie dwie metody w klasie list maja˛ charakter informacyjny:
• s.count(x): zwraca liczb˛e wystapień
˛
obiektu x na liście s
• s.index(x): zwraca indeks pierwszego wystapienia
˛
x (−1 gdy x nie wyst˛epuje w s
Sprawdź prawdziwość poniższych równości wpisujac
˛ je kolejno w osobnych liniach okna interpretera:
s = [1,2,3,4]
s[2]=-s[2];s==[1,2,-3,4];del s[:2];s==[-3,4]
t=s[:];t==s; not t is s; len(t)==2
s.append(5);t[2:2]=[5];s==[-3,4,5];t==s
s.extend([6,7]);t[3:3]=[6,7];s==[-3,4,5,6,7];t==s
s[::2] = [3,-5,-7];s==[3,4,-5,6,-7];del s[::2];s==[4,6]
t=s[:];s.insert(0,7);s==[7,4,6];t[0:0]=[7];t==s
t=s[:];s.insert(1,8);s==[7,8,4,6];t[1:1]=[8];t==s
t=s[:];s.insert(4,8);s==[7,8,4,6,8];t[4:4]=[8];t==s
s.count(6)==1,s.index(6)==3,s.count(8)==2,s.index(8)==1
s.pop(3)==6,s==[7,8,4,8],s.pop()==8,s==[7,8,4]
s.reverse();s==[4,8,7];s.sort();s==[4,7,8]
s.remove(7);s==[4,8]
20
Ćwiczenie 15 (Sortowanie polskich słów)
Sortujemy polskie słowa metoda˛ sort w klasie list wykorzystujac
˛ parametr key w celu
rejestracji funkcji kodowania koduj. Funkcja ta podaje nowe wartości porzadkowe
˛
znaków –
zgodne z polskim alfabetem. Zwarte rozwiazanie
˛
problemu stanowi klasa PL.
Dopisz do niej funkcj˛e testowa˛ klasy PL sortujac
˛ a˛ list˛e polskich słów o 40000 elementach i
sprawdzajac
˛ a˛ czas tego sortowania.
1
2
3
4
# −∗− c o d i n g : cp1250 −∗−
c l a s s PL :
p l = ’ \ nAABC
˛ ĆDEEFGHIJKLŁMN
˛
ŃOÓPQRSŚTUVWXYZŻŹ ’ +\
’ a a˛ b c ć d e e˛ f g h i j k l ł m n ń o ó p q r s ś t u v w x y z ż ź ’
5
def __init__ ( s e l f ):
s e l f . pl2code = l i s t ( range ( 2 5 6 ) )
f o r i i n r a n g e ( l e n ( PL . p l ) ) :
k = b y t e s ( PL . p l [ i ] , e n c o d i n g= ’ cp1250 ’ ) [ 0 ]
s e l f . pl2code [ k ] = i
6
7
8
9
10
11
d e f k o d u j ( s e l f , word ) :
cword = ’ ’
f o r c i n word :
cword += c h r ( s e l f . p l 2 c o d e [ b y t e s ( c , e n c o d i n g= ’ cp1250 ’ ) [ 0 ] ] )
r e t u r n cword
12
13
14
15
16
17
d e f s o r t u j ( s e l f , words ) : words . s o r t ( k e y= s e l f . k o d u j )
18
Rozwiazanie:
˛
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
##
Ćwiczenie 16 (Specyficzne metody klasy str)
Klasa napisowa str oprócz ogólnych metod przysługujacych
˛
typom sekwencyjnym posiada
specjalizowane techniki wygodne w przetwarzaniu tekstu.
• k=ord(x); x=chr(k) – jeśli x jest słowem jednoznakowym (a wi˛ec znakiem), to k jest
21
pozycja˛ tego znaku w tablicy kodów. Mamy równości:
ord(chr(k))==k, chr(ord(x))==x
• y=x.strip() – usunie białe znaki na końcu i na poczatku
˛ napisu x nie zmieniajac
˛ x;
• y=x.replace(u,v) – utworzy z x nowe słowo, w którym każde wystapienie
˛
podsłowa
u b˛edzie zastapione
˛
podsłowem v;
• words=x.split(sep) – zwraca list˛e słów, które przedzielone separatorem sep tworza˛ napis x. Jeśli pominiemy sep, to każda sekwencja białych znaków jest separatorem.
Jeśli użyjemy jednak separatora np. -, to mi˛edzy kolejnymi separatorami, np. --, otrzymamy puste słowo;
• i=x.find(y) – zwraca indeks pierwszego wystapienia
˛
słowa y w napisie x. Jeśli y nie
podsłowem x, to zwraca -1;
• x.startswith(u) – prawda, gdy x ma prefiks u;
• x.endswith(u) – prawda, gdy x ma sufiks u.
Sprawdź prawdziwość poniższych równości:
s=’ Ala ma kota. ’
s.strip()==’Ala ma kota.’,
s.split()==[’Ala’,’ma’,’kota.’]
s.replace(’ma’,’miała’)==’ Ala miała kota. ’
s.find(’kot’)==s.find(’pies’)+10, s.endswith(’. ’)
Ćwiczenie 17 (Formatowanie napisów) Sprawdź poprawność poniższych zapisów formatowania danych w Pythonie 2.6
1. Formatowanie wartości całkowitych:
i = 27
’%d %o %x’ % (i,i+1,i+2) == ’27 34 1d’
’{0:d} {1:o} {2:x}’.format(i,i+1,i+2) == ’27 34 1d’
2. Formatowanie wartości zmiennoprzecinkowych:
x=27.2727
’%10.3e,%.3f,%g’ % (x,x+1,x+2) ==\
’ 2.727e+01,28.273,29.2727’
’{0:10.3e},{1:.3f},{2:g}’.format(x,x+1,x+2) ==\
’ 2.727e+01,28.273,29.2727’
3. Formatowanie listy:
lis=[1,2,3]
’Lista %s ma %d el.’ % (lis,len(lis)) ==\
’Lista [1, 2, 3] ma 3 el.’
’Lista {0:s} ma {1:d} el.’.format(lis,len(lis)) ==\
’Lista [1, 2, 3] ma 3 el.’
22
4. Formatowanie słownikowe:
d = dict(nazwisko=’Kowalska’,wymiary=[185,75,65],\
dzieci={’Janek’:15,’Ania’:10})
ft = ’{nazwisko:s}, wzrost {wymiary[0]:d} cm,’+\
’ wiek syna {dzieci[Janek]:d} lat’
ft.format(**d) ==\
’Kowalska, wzrost 185 cm, wiek syna 15 lat’
5. Formatowanie mieszane:
dm = dict(nazwisko=’Kowalski’,wymiary=[185,75,65])
dk = dict(nazwisko=’Kowalska’,wymiary=[165,65,55])
li = [dm,dk]
ft = ’{0[nazwisko]:s}, wzrost {0[wymiary][0]:d} cm’
ft += ’; {1[nazwisko]:s}, biodra {1[wymiary][1]:d} cm’
ft.format(*li)==\
’Kowalski, wzrost 185 cm; Kowalska, biodra 65 cm’
Ćwiczenie 18 (Operatory mnogościowe)
Popularne działania i relacje mnogościowe maja˛ swoja˛ reprezentacj˛e w klasie set w postaci
docia˛żonych operatorów:
1. u = s|t – realizuje sum˛e mnogościowa˛ U ← S ∪ T
2. s |= t – realizuje sum˛e mnogościowa˛ S ← S ∪ T
3. u = s&t – realizuje iloczyn mnogościowy U ← S ∩ T
4. s &= t – realizuje iloczyn mnogościowy S ← S ∩ T
5. u = s-t – realizuje różnic˛e mnogościowa˛ U ← S − T
6. s -= t – realizuje różnic˛e mnogościowa˛ S ← S − T
7. u = s^t – realizuje różnic˛e symetryczna˛ U ← (S − T ) ∪ (T − S)
8. s ^= t – realizuje różnic˛e symetryczna˛ S ← (S − T ) ∪ (T − S)
9. s<t – sprawdza inkluzj˛e S ⊂ T
10. s<=t – sprawdza inkluzj˛e S ⊆ T
11. s>t – sprawdza inkluzj˛e S ⊃ T
12. s>=t – sprawdza inkluzj˛e S ⊇ T
13. s=t! – sprawdza nierówność S 6= T
Sprawdź słuszność poniższych relacji:
s = set([1,3,5,7]); t = set([1,2,4,6,7]); u = s|t
2 in u and 2 in t and 2 not in s
s<u and t<u and s!=t
s &= t; s==set([1,7])
u ^= s; u==set([2,3,4,5,6])
23
Ćwiczenie 19 (Metody w klasie dict)
Podsumujmy istotne metody w klasie dict, w tym różne formy konstruktora.
1. Inicjacja przez podstawienia key=value (tylko gdy klucze sa˛ napisami):
d = dict(k1=v1,k2=v2,...,kn=vn)
2. Inicjacja przez oryginalny zapis słownikowy (klucze moga˛ być dowolnego typu Hashable:
d = dict({k1:v1,k2:v2,...,kn:vn})
3. Inicjacja przez list˛e par (key,value): d = dict([(k1,v1),...,(kn,vn)])
4. Ustawianie wartości: d[k] = v
5. Usuwanie klucza: del d[k]
6. Odczyt wartości dla klucza k: v = d[k]
Rzuca wyjatek
˛ KeyError gdy klucza k nie ma w słowniku.
7. Ustawianie wartości domyślnej: vk = d.setdefault(k,v)
Jeśli k in d, to zwraca d[k] w przeciwnym razie d[k] = v i zwraca wartość domyślna˛ v.
8. Odczyt wartości z opcja˛ wartości domyślnej: vk = d.get(k,v)
Jeśli k in d, to zwraca d[k] w przeciwnym razie zwraca wartość domyślna˛ v.
9. Odczyt i usuni˛ecie: vk = d.pop(k,v)
Jeśli k in d, to zwraca d[k] i usuwa ze słownika w przeciwnym razie zwraca wartość
domyślna˛ v, a w przypadku braku tej wartości rzuca wyjatek
˛ KeyError.
10. Aktualizacja dla wielu kluczy: d.update(x)
gdzie argument x może być taki jaki możemy używać w konstruktorze dict
Sprawdź prawdziwość nast˛epujacych
˛
równości:
d1 = {’Ala’:(150,12),’Bogdan’:(170,14)}
d2 = dict(Ala=(150,12),Bogdan=(170,14))
d3 = dict([[’Ala’,(150,12)],[’Bogdan’,(170,14)]])
d1==d2; d2==d3
d1[’Ala’][0]==150; d1[’Bogdan’][1]==14
del d2[’Bogdan’]; d2.get(’Bogdan’,(180,16))==(180,16)
d3.pop(’Bogdan’,(180,16))==(170,14)
d3.update(d1); d3[’Bogdan’]==(170,14)
24
Etap 5
Zadanie 5 (Łaczenie
˛
ścieżek)
Napisz funkcj˛e jpath która łaczy
˛ ścieżk˛e bezwzgl˛edna˛ abs_path ze ścieżka˛ wzgl˛edna˛ rel_path.
Funkcja opcjonalnie sprawdza check=True istnienie połaczonej
˛
ścieżki w systemie, a wtedy
gdy ścieżka nie istnieje, to rzuca wyjatek
˛ Exception.
Wskazówka: Użyj funkcje join, normpath, exists z pakietu os.path.
Rozwiazanie:
˛
1
2
3
4
5
6
7
8
9
10
11
##
##
##
##
##
##
##
##
##
##
##
Ćwiczenie 20 (Przegladanie
˛
katalogów)
1. Sprawdź poprawność modułu fpaths.py oferujacego
˛
funkcj˛e get_image_paths:
1
2
3
# −∗− c o d i n g : cp1250 −∗−
import os
i m p o r t o s . p a t h a s op
4
5
6
def get_image_paths ( root , e x t s ) :
f i p a t h s = [ ] ; paths = [ ] ; i p a t h s = { } ; idd = 0;
7
8
9
10
11
12
13
14
15
16
17
18
19
f o r dirname , d i r s , f i l e s i n o s . w a l k ( r o o t ) :
f o r fname i n f i l e s :
name , e x t = op . s p l i t e x t ( fname )
i f ext in exts :
i = i p a t h s . g e t ( dirname , −1)
i f i <0:
i p a t h s [ dirname ] = idd
i = idd
p a t h s . append ( d i r n a m e )
i d d += 1
f i p a t h s . append ( ( i , fname ) )
return fipaths , paths
25
2. Zastosuj moduł fpaths w identyfikacji wszystkich plików dźwi˛ekowych znajdujacych
˛
si˛e
w danym drzewie katalogów.
3. Zastosuj moduł fpaths w identyfikacji wszystkich plików obrazowych i filmowych znajdujacych
˛
si˛e w danym drzewie katalogów.
Ćwiczenie 21 (Wyrażenia regularne)
1. Ważne metody w pakiecie re
Typowa praca z wyrażeniem regularnym, np. wyrażeniem r" ([^ab ]+) " opisujacym
˛
pierwsze środkowe słowo w tekście nie zawierajace
˛ liter a,b (zwróć uwag˛e na
spacj˛e w zbiorze symboli):
(a) Importujemy pakiet re
(b) Tworzymy skompilowana˛ postać wyrażenia: r = re.compile()
(c) Stosujemy wyszukiwanie dla tekstu, który chcemy analizować
m = r.search(’ala ma koty i psy’)
Otrzymujemy obiekt dopasowania m który zawiera informacj˛e o grupach symboli
spełniajacych
˛
ograniczenia.
(d) Jeśli m<>None, to znalezione słowo odczytamy z m.groups(0)
2. Zapisz i sprawdź wyrażenie regularne określajace
˛ słowa bez symboli a,b znajdujace
˛ si˛e
na poczatku
˛ napisu.
Wskazówka: Użyj symbol ^ na poczatku
˛ wyrażenia.
3. Zapisz i sprawdź wyrażenie regularne określajace
˛ słowa bez symboli a,b znajdujace
˛ si˛e
na końcu napisu.
Wskazówka: Użyj symbol $ na końcu wyrażenia.
4. Detekcja linii poczatkowej
˛
środowiska verbatim w Latexu.
(a) Linia taka postać: \begin{verbatim}
(b) Wyrażenie regularne dla takiej linii:
re4verbatim_begin = re.compile(r"(.*)(\\begin\{verbatim\})(.*)")
(c) Sprawdzamy czy \begin{verbatim} wyst˛epuje w line:
sobj = re4verbatim_begin.search(line)
if sobj<>None: in_verbatim = True
5. Zapisz i sprawdź wyrażenie regularne detekujace
˛ końcowa˛ lini˛e środowiska verbatim
o postaci:
\end{verbatim}
6. Detekcja linii z dyrektywa˛ input w Latexu.
(a) Linia taka zawiera: \input{path}
(b) Wyrażenie regularne dla tej dyrektywy:
re4input = re.compile(r"^([^%]*)(\\input\{)(.+)(\}[ \t]*)")
(c) Sprawdzamy czy \input{path} wyst˛epuje w line:
26
1
2
3
4
5
6
def extract_path ( line ):
’’’\
Sprawd ź c z y ’ l i n e ’ j e s t d y r e k t y w a˛ i n p u t { p a t h }
J e ś l i t a k , t o z w r ó ć ś c i e ż k e˛ ’ p a t h ’
’’’
i f i s _ i n _ v e r b a t i m ( l i n e ) : r e t u r n None
7
sobj = re4input . search ( l i n e )
i f s o b j==None : r e t u r n None
8
9
10
r e t u r n sobj . groups ( ) [ 2 ]
11
7. Sprawdź poprawnośc działania funkcji extract_path. Dlaczego poczatek
˛ wyrażenia
re4input ma postać ^([^%]*)?
8. Detekcja linii dyrektyw konwertera tekstowego KTL.
(a) Linia taka zawiera na poczatku
˛ jeden z sześciu napisów: %(%, %)%, %i%,%n%,
%[%, %]%
(b) Wyrażenie regularne dla dyrektyw KTL:
re4ktl = re.compile(r"(^[ \t]*%)([i\[\]n])(%.*)")
(c) Sprawdzamy czy line jest dyrektywa˛ KTL:
1
2
3
4
5
6
7
def extract_ktl_command ( l i n e ) :
’’’\
Sprawd ź c z y ’ l i n e ’ j e s t d y r e k t y w a˛ KTL p o s t a c i :
< s p a c j e z a k o ń c z o n e %><z n a k d y r e k t y w y x><% i r e s z t a znaków w l i n i i >
J e ś l i t a k , t o z w r ó ć t r ó j k e˛ ( t e k s t p r z e d x , x , t e k s t po x )
’’’
i f i s _ i n _ v e r b a t i m ( l i n e ) : r e t u r n None
8
sobj = r e 4 k t l . search ( l i n e )
i f s o b j==None : r e t u r n None
r e t u r n sobj . groups ( )
9
10
11
9. Sprawdź poprawnośc działania funkcji extract_ktl_command. Dlaczego poczatek
˛
wyrażenia re4ktl ma postać (^[ \t]*%)?
10. Przetwarzanie fragmentów tekstów:
(a) Umożliwia to funkcja sub w module re:
sub(pattern, repl, string)
gdzie pattern jest wyrażeniem regularnym, repl jest funkcja˛ podstawiajac
˛ a˛ w
napisie string, w miejsce każdej dopasowanego fragmentu przetworzony frag-
ment.
(b) repl jest funkcja˛ typu callback, która wywoływana jest automatycznie. Użytkownik może dowolnie formować postać tej funkcji, w praktyce wykonujac
˛ dowolne
operacje na dopasowanych fragmentach.
27
(c) Wymiana ograniczników – przykład formowania funkcji przetwarzania tekstu:
Dane sa˛ ograniczniki wejściowe beg_in,end_in, symbole nie wystepujace
˛ mi˛edzy ogranicznikami others oraz ograniczniki wyjściowe beg_out,end_out.
Wtedy wyrażenie regularne rex oraz funkcj˛e podmiany repl budujemy nast˛epujaco:
˛
1
2
3
4
5
6
7
import re
d e f g e t _ r e x _ r e p l ( beg_end ) :
beg_in , end_in , o t h e r s , beg_out , end_out = beg_end
s = ’ ( ’+b e g _ i n+ ’ ) ( [ ^ ’+ o t h e r s + ’ ] ∗ ) ( ’+e n d _ i n+ ’ ) ’
rex = re . compile ( s )
r e p l = lambda m: b e g _ o u t+m . g r o u p ( 2 ) + e n d _ o u t
r e t u r n rex , r e p l
(d) Typowe użycie rex,repl:
line = re.sub(rex,repl,line)
Np. wymiana w konwerterze KTL wymiana makra \v na makro \verb dokonano
dla takich ograniczników:
beg_in = r’{\small\verb!’; end_in = r’!}’
others = r’!’
beg_out = r’{\small \verb!’; end_out = r’!}’;
(e) Sprawdź poprawność działania funkcji get_rex_repl przy zamianie tekstów postaci \mak{tekst} na tekst postaci mymak{tekst}.
(f) Inne zastosowanie: zamiana oznaczonego tekstu <xxxx> na zadany tekst, np. kreski poziome ---- (operacja stosowana przy generowaniu arkuszy pracowni studenckiej, by ukryć rozwiazania
˛
przed studentami). Wtedy
1
2
3
4
5
6
7
8
import re
d e f r e p l a c e _ o n l y ( l i n e s , h i d e=F a l s e , l d e l i m = ’< ’ , r d e l i m = ’> ’ , hsym= ’ ? ’ ) :
s = ’ ( ’+ l d e l i m + ’ ) ( [ ^ ’+ r d e l i m + ’ ] ∗ ) ( ’+ r d e l i m + ’ ) ’
rex = re . compile ( s )
r e p = lambda m: m . g r o u p ( 2 ) i f n o t h i d e e l s e hsym ∗ l e n (m . g r o u p ( 2 ) )
f o r i in xrange ( len ( l i n e s ) ) :
l i n e s [ i ] = r e . s u b ( r e x , rep , l i n e s [ i ] )
return lines
(g) Sprawdź poprawność działania funkcji replace_only przy zamianie tekstów postaci $$$tekst$$$ na tekst postaci tekst jeśli hide=False lub na tekst +++++
(liczba plusów powinna być równa liczbie znaków w napisie tekst) jeśli hide=True.
28

Wprowadzenie do Pythona 3 Arkusze Pracy Studenta Władysław

Transkrypt

Podobne dokumenty

CELTS FACTFILE

1 + z2, y

Zajęcia korekcyjno – kompensacyjne