Python - Uniwersytet Śląski

Instytut Nauki o Materiałach
Uniwersytet Śląski w Katowicach
ul. 75 Pułku Piechoty 1A, 41-500 Chorzów, tel. 32 349-75-15, e-mail: [email protected]
Nazwa modułu: Matematyka stosowana
Instrukcja uzupełniająca
„Podstawy programowania w języku Python”
Przygotowanie teoretyczne
Język programowania Python wraz ze środowiskiem iPython wykorzystującym moduły Matplotlib,
NumPy, SciPy, SymPy jest cenionym narzędziem do rozwiązywania problemów matematycznofizycznych. Linki do niezbędnej dokumentacji języka Python można znaleźć pod adresami:
 www.python.org/doc  pl.python.org/docs  scipy­lectures.github.io
Instalacja i uruchomienie interpretera (powłoki) iPython
Przejdź do katalogu, w którym zostały zainstalowane programy pakietu WinPython-2.7.x.x
Uruchom interpreter poleceniem (dwukrotnym kliknięciem na):
WinPython Command Prompt
Następnie wykonaj polecenie:
ipython qtconsole
W otwartym oknie powłoki iPython wpisz:
>>> print “Witaj szkolo”
Witaj szkolo
Instrukcja print zapisuje informacje do standardowego wyjścia.
Pierwsze kroki
>>> a = 2
>>> b = 3*a
>>> type(b)
int
>>> print b
6
>>> b/a
3
>>> b**2
36
>>> sqrt(b)
2.4494897427831779
>>> b=”Witaj”
>>> type(b)
str
>>> b+ b
WitajWitaj
>>> 2*b
WitajWitaj
>>> #to jest komentarz
...
>>>
Zdefiniowano dwie zmienne a i b. Zauważmy, że nie było konieczne wcześniejsze (jak to ma
miejsce w językach np. C, C++, Fortran) zadeklarowanie typu zmiennej. Wraz ze zmianą wartości
może zmienić się typ zmiennej. Najpierw zmienna b była typy całkowitego int, a następnie
łańcuchowego str.
Podstawowe typy danych
>>> # typ całkowity (liczby całkowite)
>>> a = 3
>>> type(a)
int
>>> # typ zmiennopozycyjny (liczby rzeczywiste)
>>> a = 2.1
>>> type(a)
float
>>> # typ zespolony (liczby zespolone)
>>> a = 1.5 + 0.5j
>>> a.real
1.5
>>> a.imag
0.5
>>> type(a)
complex
>>> # typ logiczny (prawda/fałsz)
>>> 3 > 2
True
>>> 3 < 2
False
>>> test = (2 >= 4)
>>> test
False
>>> type(test)
bool
Powłoka iPython może zostać wykorzystana jako zaawansowany kalkulator. W naturalny sposób
wykonalne są działania: +, ­, *, /, **, % (odpowiednio: dodawanie, odejmowanie, mnożenie,
dzielenie, potęgowanie, modulo).
>>> 7. * 3
21.0
>>> 2**10
1024
>>> 8 % 3
2
>>> # konwersja typu
>>> float(1)
1.0
>>> # dzielenie liczb całkowitych
>>> 3 / 2
1
>>> 3 / 2.
1.5
>>> a = 3
>>> b = 2
>>> a / b
1
>>> a / float(b)
1.5
>>> # można wymusić całkowity wynik dzielenia
>>> 5 // 2
2
>>> # a co z pierwiaskiem i logarytmem?
>>> sqrt(2)
1.4142135623730951
>>> 2**(1/2.)
1.4142135623730951
>>> # wcześniej dwie ważne w matematyce liczby
>>> e
2.718281828459045
>>> pi
3.141592653589793
>>> # logarytm naturalny
>>> log(e)
1.0
>>> # logarytm o podstawie 10
>>> log10(10.)
1.0
>>> # logarytm o podstawie 2
>>> log2(2.)
1.0
Listy (lists)
To uporządkowane kolekcje dowolnych obiektów. Listę można modyfikować. Poniżej przegląd
podstawowych operacji jakie można wykonać na listach.
L = []
L = [2, 3.1]
L = list(range(1,10))
len(L)
L1 + L2
L[2]
L[2:4]
L1 = L2, L1 = L2[2:4]
del L, del L[2:4]
lista pusta
lista dwuelementowa
lista wartości od 1 do 9
długość listy L
łączenie list
trzeci element listy o indeksie 2,
wartości indeksu zaczynają się od 0
2,3 i 4 elementy listy
kopiowanie listy
usuwanie listy lub jej części
Istnieją funkcje dzięki którym można listy przekształcać. Naturalnym elementem języka Python jest
obiekt. Obiekt posiada atrybuty (właściwości) i metody (funkcje). Dostęp do atrybutu realizuje
konstrukcja obiekt.atrybut, a do metody obiekt.metoda(argumenty).
>>> L = [“a”,”a”,”a”,”b”,”b”]
>>> L. <TAB> # naciśnięcie <Tab> po kropce zwraca listę metod
append count extend index insert pop remove reverse sort
>>>
>>> # ilość powtórzeń 'a'
>>> L.count('a')
>>> print L
3
>>> # dołączenie elementu 'c' na końcu listy
>>> L.append('c')
>>> print L
['a', 'a', 'a', 'b', 'b', 'c']
>>>
>>> # dołączenie 'd' przed indeksem 2
>>> L.insert(2,'d')
>>> print L
['a', 'a', 'd', 'a', 'b', 'b', 'c']
>>>
>> # usuwanie elementów
>>> L.append(“123”)
>>> print L
['a', 'a', 'd', 'a', 'b', 'b', 'c', '123']
>>> L.pop()
'123'
>>> L.extend('123'); print L
['a', 'a', 'd', 'a', 'b', 'b', 'c', '1', '2', '3']
>>> L.pop(1)
'a'
>>> print L
['a', 'd', 'a', 'b', 'b', 'c', '1', '2', '3']
Krotki (tuples)
To uporządkowane kolekcje dowolnych obiektów. Krotek nie można modyfikować tak jak to ma
miejsce w przypadku list. Poniżej przegląd podstawowych działań na krotkach.
T = ()
T = (2,)
T = (2, 3)
T = tuple(range(1,10))
len(T)
T1 + T2
3*T, T*2
T[2]
T[2:4]
T1 = T2, T1 = T2[2:4]
del T
for x in T
x in T
x not in T
krotka pusta
krotka jednoelementowa
krotka dwuelementowa
krotka z elementami o wartościach od 1
do 9
długość krotki T
łączenie krotek
powtarzanie krotek
trzeci element krotki o indeksie 2,
wartości indeksu zaczynają się od 0
2,3 i 4 elementy krotki
kopiowanie krotki
usuwanie całej krotki
iteracja
x należy do T
x nie należy do T
Dla krotek zdefiniowano dwie metody: index i count, o znaczeniu jak w przypadku list.
Łańcuchy znaków (strings)
To uporządkowany ciąg znaków do przechowywania informacji tekstowej.
>>> s1 = “abcd”
>>> s2 = 'efgh'
>>> s1 + s2
'abcdefgh'
>>> s = 'ala ma'kota'
invalid syntax
>>> s = “ala ma'kota” # to jest poprawna konstrukcja
>>> >>> s = '''ala ma kota,
... kot ma ale''' # kontynuacja łańcucha w wielu wierszach
>>> >>> s1[0]
a
>>> s1[­1] # dostęp od końca
d
>>> s=s1+s2
>>> s[2:5]
'cde'
>>> s[0:7:2]
'aceg'
>>> s[2]='3'
'str' object does not support item assignment
>>>
>>> s='Hello world'
>>> s.replace('l','z',1)
Hezlo world
Podstawianie łańcuchów znaków
>>> 'int: %i, float %f, str %s' % (1, 3.2, 'alamakota')
'int: 1, float 3.200000, str alamakota'
>>> n = 113
>>> 'nazwa_pliku_%i' % n
'nazwa_pliku_113'
Instrukcje sterujące: if, for
, while
Zapewniają sterowanie przetwarzaniem informacji podczas wykonywania programu. Najpierw
jednak nieco o instrukcji przypisania =.
>>> a = 2
>>> x, y = 2, 3 # oznacza, że: x=2, y=3
>>> [x, y] = ["ab", "cd"] # x='ab', y='cd'
>>> x, y, z = "abc" # x='a', y='b', z='c'
>>> x=y=z=0
>>> x+=5 # x=x+5
Instrukcja warunkowa if
Należy zwrócić uwagę na wcięcia. Dany blok instrukcji ma takie samo wcięcie.
>>> if 2**2 == 4:
... print 'Oczywiście'
Oczywiście
>>> if 2**2 > 4:
... print 'Prawda'
... else:
... print 'Fałsz'
Fałsz
>>> >>> a = 5
>>> if a == 0: ... print(1)
... elif a == 2
... print(2)
... else:
... print('Za dużo')
... Za dużo
Pętla for
Iteracja po zbiorze liczb całkowitych jest realizowana instrukcją range.
>>> for i in range(4):
... print i
0
1
2
3
>>> for slowo in ('ciekawa', 'fascynująca', 'praktyczna'):
... print 'Matematyka jest %s.' % slowo
... Matematyka jest ciekawa.
Matematyka jest fascynująca.
Matematyka jest praktyczna.
Pętla while
Iteracja po zbiorze liczb całkowitych jest realizowana instrukcją range.
>>> z=1
>>> while z <= 10:
... z = z + 1
0
1
2
3
Instrukcje break i continue.
>>> a = [1, 0, 2, 4]
>>> for n in a:
... if n == 0:
... print 'Próba dzielenia przez 0. Koniec.'
... break
... print 1./n
... 1.0
Próba dzielenia przez 0. Koniec.
>>> for n in a:
... if n == 0:
... continue
... print 1./n
... 1.0
0.5
0.333333333333
Iteracyjny sposób tworzenia list
>>> [i**2 for i in range(4)]
[0, 1, 4, 9]
Funkcje
Realizują fragmenty kodu programu. Funkcji przypisuje się nazwę służącą do jej wywołania.
Funkcja może wykorzystywać, w tym modyfikować, wartości przekazywane jej w postaci
argumentów. Funkcje definiujemy instrukcją def.
>>> def test():
... print('Funkcja testowa')
... >>> test() # wywołanie funkcji
Funkcja testowa
Opcjonalnie funkcja może zwracać wartość poprzez instrukcję return.
>>> # promien jest argumentem funkcji
>>> def pole_kola(promien):
... return 3.14*promien*promien
... >>> pole_kola(2)
12.56
Argumentowi funkcji można przypisać wartość domyślną.
>>> def pole_kola(promien=1):
... return 3.14*promien*promien
... >>> pole_kola()
3.14
Wartości domyślna przypisywana jest podczas definicji funkcji, a nie jej wykonywania.
Zmienne definiowane wewnątrz funkcji to zmienne lokalne. Zmienne globalne nie mogą być
zmodyfikowane działaniem funkcji (wyjątki!).
>>> x = 5
>>> def zmien(y):
... x=y
... print 'x jest równe %i'% x
... >>> zmien(10)
x jest równe 10
>>> x
5
>>>
>>>
def zmien(y):
... global x
... x=y
... print 'x jest równe %i'% x
... >>> zmien(10)
x jest równe 10
>>> x
10
W pierwszym przykładzie zmienna x występująca w funkcji zmien jest zmienną lokalną i nie jest
tożsama ze zmienną x zdefiniowaną wcześniej. Użycie instrukcji global sprawia, że x wewnątrz
funkcji odnosi się do zmiennej zdefiniowanej poza ciałem funkcji.
Liczba argumentów funkcji może być zmienna
>>> def variable_args(*args, **kwargs):
... print 'args to:', args
... print 'kwargs to:, kwargs
... >>> variable_args(1,3,6,5.5,a=3,b=6)
args is (1, 3, 6, 5.5)
kwargs is {'a': 3, 'b': 6}
Widać, że args tworzą krotkę, a kwargs słownik (dowiedz się więcej o tym typie danych!).
Wprowadzenie do modułu SymPy i tworzenie wykresów funkcji
Moduł to kolekcja obiektów języka Python wyspecjalizowana w realizacji określonych zadań
informatycznych. Moduł należy importować. Wtedy dopiero można korzystać z jego zasobów.
Moduł SymPy służy do wykonywania obliczeń symbolicznych.
>>> from sympy import *
>>> x,y = symbols('x,y')
Zostały importowane wszystkie dostępne składniki modułu SymPy. Druga z instrukcji deklaruje
dwie zmienne symboliczne (w skrócie „zmienne”) x i y. Można teraz wykonać proste
przekształcenia:
>>> simplify(sin(x)**2 + cos(x)**2)
1
>>> expand((x+y)**3)
x**3 + 3*x**2*y + 3*x*y**2 + y**3
>>> expand(cos(x+y), trig=True)
­sin(x)*sin(y) + cos(x)*cos(y)
>>> simplify((x+x*y)/x)
y + 1
Praca z modułem SymPy będzie nieodzowna w toku kolejnych ćwiczeń laboratoryjnych. Zatem
konsekwentnie będą poznawane kolejne jego możliwości.
SymPy umożliwia tworzenie wykresów funkcji.
>>> plot(x**2)
Powstał wykres funkcji kwadratowej
y=x
2
dla
−10⩽x⩽10 . Funkcja plot pozwala rysować
wykres kilku funkcji dla tego samego przedziału zmienności x
>>> plot(x**2, x, (x,0,2))
lub dla różnych przedziałów zmienności x
>>> plot((x**2, (x,0,2)), (x, (x,0.5,1.5)))
Dziedzina wykresu funkcji jest próbkowana specjalnym algorytmem, którego działanie można
„wyłączyć” i samodzielnie określić liczbę punktów dziedziny dla których obliczane będą wartości
funkcji.
>>> plot(x**2, x, (x,0,2), adaptive=False, nb_of_points=400)
>>> plot(x**2, x, (x,0,2), adaptive=False, nb_of_points=2)
Wprowadzenie do modułu PyLab i tworzenie wykresów funkcji
PyLab to rodzaj nakładki na moduły Matplotlib (tworzenie wykresów) i NumPy (obliczenia
numeryczne). Przystosowuje on środowisko pracy tak by było jak najbardziej zbliżone do
środowiska komercyjnego programu MATLAB.
>>> %pylab
Welcome to pylab, a matplotlib­based Python environment [backend: TkAgg].
For more information, type 'help(pylab)'.
Narysujemy teraz wykresy funkcji sinus i cosinus.
>>> X = linspace(­pi, pi, 256, endpoint=True)
>>> C, S = cos(X), sin(X)
>>> plot(X, C)
>>> plot(X, S)
>>> # i powstaje odpowiedni rysunek
Metoda linspace pochodzi z modułu NumPy. Jej wykonanie zwraca tablicę zawierającą liczby
równomiernie pokrywające zadany przedział. Metoda plot korzysta z modułu Matplotlib i rysuje
wykres funkcji. Tak powstaje rysunek standardowy.
Metoda plot dopuszcza użycie większej liczby argumentów, które pozwalają na odpowiednie
zmodyfikowanie obrazu standardowego. Poniższy przykład wiele wyjaśni jeśli chodzi o szczegóły
tworzenia wykresów funkcji.
>>> figure(figsize=(8, 6), dpi=80)
>>> subplot(1, 1, 1)
>>> X = linspace(­pi, pi, 256)
>>> C, S = cos(X), sin(X)
>>> plot(X, C, color="blue", linewidth=1.0, linestyle="­")
>>> plot(X, S, color="green", linewidth=1.0, linestyle="­")
>>> xlim(­4.0, 4.0)
>>> ylim(­2.0, 2.0)
>>> xticks(np.linspace(­5, 5, 9, endpoint=True))
>>> yticks(np.linspace(­2, 2, 5, endpoint=True))
Cel ćwiczenia
Celem ćwiczenia jest poznanie podstawowych konstrukcji języka programowania Python w
zakresie niezbędnym do samodzielnego programowania prostych zadań matematycznych.
Omówione zostaną właściwości modułu SymPy służącego do matematycznych obliczeń
symbolicznych, oraz modułu PyLab. Zostaną przedstawione sposoby tworzenia wykresów funkcji.
Spis wyposażenia
Komputer z systemem operacyjnym Windows. Zainstalowany program WinPython, który można
bezpłatnie pobrać ze strony code.google.com/p/winpython.
Przebieg ćwiczenia
Wykonaj działania opisane we wstępie teoretycznym.
Wykorzystaj pętlę for do obliczenia wartości liczby π . Zastosuj wzór Wallisa:
∞
2
4n
π=
∏
2 n=1 4 n2−1
Narysuj wykres funkcji
y=−x 2+2x w przedziale x∈[−1, 3] . Wykorzystaj środowisko
PyLab.
Uwagi do sprawozdania
Przedstaw sposoby rozwiązania zadania drugiego i trzeciego.