poezja wikipedia

Wstęp do programowania
Wykład 1 ­ Wprowadzenie
Janusz Szwabiński
Plan wykładu:
Sprawy administracyjne
Nauka programowania ­ wyzwania i cele
Czym jest program komputerowy?
Błędy i ich usuwanie
Języki naturalne i formalne
Języki skryptowe (interpretowane)
Dlaczego Python?
Przykłady prostych krótkich programów w Pythonie
Sprawy administracyjne
Dane kontaktowe
http://prac.im.pwr.edu.pl/~szwabin/ (http://prac.im.pwr.edu.pl/~szwabin/)
email: [email protected]
pokój 5.16, budynek C­11
konsultacje: czwartek 11:15 ­ 12:45, piątek 9:15 ­ 10:45
Treści programowe
Środowiska do programowania w Pythonie.
Podstawowe typy danych, literały, operatory i wyrażenia.
Dygresja ­ reprezentacja danych liczbowych.
Wyrażenia warunkowe i pętle.
Funkcje, skrypty i moduły.
Listy, krotki, zbiory i słowniki.
Operacje na plikach.
Programowanie obiektowe: klasy i obiekty, dziedziczenie
Interfejsy użytkownika w Tkinter.
Materiały do wykładów
prezentacje i listy zadań pod adresem http://prac.im.pwr.wroc.pl/~szwabin/
(http://prac.im.pwr.wroc.pl/~szwabin/)
strona główna Pythona (http://www.python.org)
A. B. Downey, J. Elkner, C. Meyers, Think Python. How to Think Like a Computer Scientist,
(http://www.greenteapress.com/thinkpython/ (http://www.greenteapress.com/thinkpython/))
M. Pilgrim, Dive into Python, (http://www.diveintopython.net/ (http://www.diveintopython.net/))
D. Mertz, Text Processing in Python, (http://gnosis.cx/TPiP/ (http://gnosis.cx/TPiP/))
M. Summerfield, Rapid Gui Programming with Python and QT
D. Harrell, Rzecz o istocie informatyki. Algorytmika, WNT, Warszawa 2000
N. Wirth, Algorytmy + struktury danych = programy, WNT, Warszawa 2000
Zaliczenie
listy zadań na ćwiczeniach i laboratoriach
dwa testy: na 7 i ostatnim wykładzie
lab
ocena =
ćw
+
2
wyk
+
4
4
Nauka programowania
Cele
programowanie w konkretnym języku (tutaj ­ w Pythonie)
rozwiązywanie problemów:
formułowanie problemów
kreatywne poszukiwanie rozwiązań
programowanie jako środek do osiąnięcia celu ­ przedstawienia rozwiązania
Wyzwania
Informatyk­programista łączy w sobie cechy:
matematyka ­ używa języka formalnego do opisu pomysłów (obliczeń)
inżyniera ­ wymyśla i tworzy "rzeczy", łączy istniejące komponenty w bardziej skomplikowane
układy o nowych funkcjonalnościach, szuka alternatyw
naukowca ­ obserwuje zachowanie układów złożonych, formułuje hipotezy i testuje prognozy
Algorytm
skończony ciąg jasno zdefiniowanych czynności, koniecznych do wykonania pewnego rodzaju
zadań
jego zadaniem jest przeprowadzenie systemu z pewnego stanu początkowego do pożądanego
stanu końcowego
Przykład ­ metoda babilońska wyliczania pierwiastka (metoda Herona)
Szukamy aproksymacji √S :
1. Rozpocznij z dowolną dodatnią wartością początkową x 0 (im bliżej szukanego pierwiastka, tym
lepiej).
2. Znajdź kolejne przybliżenie według wzoru
1
x n+1 =
2
S
(x n +
)
xn
3. Powtarzaj krok 2 do osiągnięcia pożądanej dokładności.
In [1]:
S = 25
import math
math.sqrt(25)
Out[1]:
5.0
In [2]:
x0 = 1
In [3]:
x1 = (x0+S/x0)/2 # Uwaga!!! Poniższy przykład działa poprawnie z Pythonem 3.X
In [4]:
print(x1)
13.0
In [5]:
x2 = (x1+S/x1)/2
print(x2)
7.461538461538462
In [6]:
x3 = (x2+S/x2)/2
print(x3)
5.406026962727994
In [7]:
x4 = (x3+S/x3)/2
print(x4)
5.015247601944898
Program komputerowy
Program komputerowy to ciąg instrukcji opisujących sposób wykonania pewnych obliczeń (niekoniecznie
matematycznych). Szczegóły programu wyglądają różnie w różnych językach programowania, jednak
niezależnie od języka można wyróżnić kilka podstawowych elementów programu:
wejście ­ pobranie danych z klawiatury, pliku, bazy danych lub innego źródła
wyjście ­ prezentacja danych na ekranie, ich zapis do pliku lub innego urządzenia
obliczenia ­ podstawowe operacje matematyczne
warunkowe przetwarzanie ­ wykonywanie części programu tylko przy spełnieniu pewnych
warunków
powtarzanie ­ powtarzanie pewnych części programu
Praktycznie każdy program zbudowany jest z tych podstawowych "klocków". Dlatego programowanie można
rozumieć jako proces rozkładania dużego, skomplikowanego zadania na coraz prostsze podzadania do
momentu, aż te podzadania można wykonać w ramach jednego z powyższych elementów.
Błędy w programach komputerowych (ang. bugs)
Błędy składniowe (ang. syntax error) – błąd w składni ciągu znaków lub słów, które powinny po
sobie następować zgodnie z zasadami języka programowania. Wykrywany przez kompilator lub
interpreter języka, łatwy do poprawienia. Bardzo częsty u początkujących programistów.
Błędy działania programu (ang. runtime error) ­ błędy, które pojawiają się w trakcie wykonywania
programu (np. próba odczytu danych z pliku, do którego nie ma dostępu lub dzielenie przez zero).
Błędy znaczeniowe (ang. semantic error) – w przypadku tych błędów program zadziała, jednak z
reguły nie jest to już program, który planowaliśmy napisać. Wykrycie błędów semantycznych
stanowi często duże wyzwanie.
Przykłady błędów
In [8]:
prit("Witaj świecie")
-------------------------------------------------------------------------NameError
Traceback (most recent ca
ll last)
<ipython-input-8-e201ead868f9> in <module>()
----> 1 prit("Witaj świecie")
NameError: name 'prit' is not defined
In [9]:
print("Witaj świecie")
Witaj świecie
In [10]:
infile = open('foo.txt')
for line in infile:
print(line)
-------------------------------------------------------------------------FileNotFoundError
Traceback (most recent ca
ll last)
<ipython-input-10-4e36f54a367f> in <module>()
----> 1 infile = open('foo.txt')
2 for line in infile:
3
print(line)
FileNotFoundError: [Errno 2] No such file or directory: 'foo.txt'
In [11]:
def suma(a,b):
print(a-b) #zwróć uwagę na błąd w działaniu!!!
suma(10,6)
4
Etymologia słowa bug
It has been just so in all of my inventions. The first step is an intuition, and comes with a
burst, then difficulties arise — this thing gives out and [it is] then that "Bugs" — as such little
faults and difficulties are called — show themselves and months of intense watching, study
and labor are requisite before commercial success or failure is certainly reached. (Thomas
Edison, 1878)
In 1946, when Hopper was released from active duty, she joined the Harvard Faculty at the
Computation Laboratory where she continued her work on the Mark II and Mark III. Operators
traced an error in the Mark II to a moth trapped in a relay, coining the term bug. This bug was
carefully removed and taped to the log book. Stemming from the first bug, today we call
errors or glitches in a program a bug.(Sharon Ann Danis, Rear Admiral Grace Murray
Hopper, 1997)
Usuwanie błędów (ang. debugging)
“Wyeliminuj wszystkie inne możliwości, a to, co ci zostanie, będzie prawdą.” (A. Conan Doyle, Znak Czterech)
jedna z najważniejszych umiejętności związanych z programowaniem
wyzwanie intelektualne
potrafi być frustrujące
przypomina naukę eksperymentalną
dla niektórych programowanie to proces nieustannego debuggowania programu do momentu, aż
program osiągnię żądaną funkcjonalność
"Zawsze jest jeszcze jeden błąd" (prawo nieskończoności Lubarskiego)
Języki naturalne i języki formalne
Języki programowania są językami formalnymi stworzonymi do opisu obliczeń!
język naturalny ­ język stosowany przez ludzi do komunikacji interpersonalnej, powstały w drodze
historycznego rozwoju określonych grup etnicznych
wieloznaczny
redundantny
alegoryczny język formalny ­ podzbiór zbioru wszystkich słów nad skończonym alfabetem, język wymyślony
przez człowieka
jednoznaczny
zwięzły
dosłowny
Od poezji do programu komputerowego
poezja ­ wieloznaczna, używa słów nie tylko ze względu na ich znaczenie, lecz również brzmienie,
utwór często ma wywołać reakcję emocjonalną
proza ­ ważniejsze od brzmienia jest znaczenie słów i struktura tekstu; łatwiejsza w analizie, jednak
ciągle może być wieloznaczna
program ­ jednoznaczny i dosłowny, do jego zrozumienia wystarczy analiza tokenów i struktury
Języki programowania
Klasyfikacja języków programowania
Języki programowania mogą być podzielone ze względu na:
paradygmat programowania (np. programowanie proceduralne, strukturalne, funkcyjne,
imperatywne, obiektowe)
generację języka programowania
sposób kontroli typów
sposób wykonywania (kompilacja, interpretacja)
poziom (języki niskiego poziomu są bardziej zbliżone pod względem budowy do działania sprzętu)
przeznaczenie
20 najpopularniejszych języków według TIOBE (http://www.tiobe.com/tiobe­index/
(http://www.tiobe.com/tiobe­index/))
"Witaj świecie" w wybranych językach programowania
C
#include<stdio.h>
int main()
{
printf("\nHello world in C!");
return 0;
}
C++
#include <iostream>
int main () {
std::cout << "Hello world in C++!" << std::endl;
}
C#
namespace HelloWorld
{
class Program
{
static void Main(string[] args)
{
System.Console.WriteLine("Hello world in C#!");
}
}
}
Fortran
program hello
print *, "Hello world in Fortran!"
end program
Java
public class HelloWorld
{
public static void main(String[] args)
{
System.out.println("Hello world in Java!");
}
}
Julia
println("Hello world in Julia!")
Pascal
program byeworld;
begin
writeln('Hello world in Pascal!');
end.
Perl
use feature 'say';
say 'Hello world in Perl!';
PHP
<?php
echo "Hello world in PHP!\n";
?>
Python (wersja 2.7.X)
print "Hello world in Python!"
Python (wersja 3.X)
print("Hello world in Python!")
Ruby
puts 'Hello world in Ruby'
Interpretowane kontra kompilowane
Języki interpretowane ­ główne cechy
zaprojektowane z myślą o interakcji z użytkownikiem (tryb interaktywny)
przenośne
osadzane w aplikacjach (np. Python w Blenderze)
często używane do jednorazowych zadań (np. administracyjnych)
niektóre nadają się do tworzenia samodzielnych aplikacji
zwięzłe
Python
darmowy i przenośny
interpretowany
duża zwięzłość
dynamiczna semantyka i elegancka składnia
automatyczne zarządzanie pamięcią (ang. garbage collection)
bogata biblioteka standardowa
struktury wysokiego poziomu (m.in. listy, słowniki, liczby zespolone)
wieloparadygmatowy (programowanie obiektowe, strukturalne, funkcyjne)
łatwo integruje się z C/C++ i Fortranem
oddana społeczność programistów
bogata dokumentacja wbudowana i do znalezienia w Internecie
dużo narzędzi do obliczeń naukowych
idealny do tworzenia skryptów i tzw. błyskawiczego rozwijania aplikacji
pełnoprawny język programowania o znacznych możliwościach
Kilka (drobnych) wad
mała wydajność
duża modularność
problemy z wcięciami kodu przy przenoszeniu źródeł między platformami
wiele wersji
brak kompatybilności między wersjami 2.x i 3.x
Dlaczego mała wydajność nie jest (z reguły) wielkim problemem?
przeciętny program większość czasu spędza na oczekiwaniu na operacje wejścia/wyjścia,
opóźnienia związane z siecią i wypełnienie pamięci podręcznej
programiści stosujący języki skryptowe okazują się prawie dwukrotnie wydajniejsi od tych
używających tradycyjnych języków programowania (krótszy kod i mniej popełnionych błędów)
sprzęt komputerowy jest tani, dlatego często lepszym wyborem z ekonomicznego punktu widzenia
jest skrócenie czasu debuggowania i długoterminowa łatwość obsługi kodu
Implementacje języka Python
CPython (https://www.python.org/) ­ standardowa implementacja w języku C; projekt Open Source
zarządzany przez Python Software Foundation (https://www.python.org/psf/)
Jython (http://www.jython.org/) ­ implementacja napisana w Javie
IronPython (http://ironpython.net/) ­ Python dla platformy .Net
CLPython (https://common­lisp.net/project/clpython/) ­ implementacja w Common Lispie
PyPy (http://pypy.org/) ­ wersja Pythona napisana w... Pythonie, a w zasadzie w statycznym
podzbiorze Pythona o nazwie Restricted Python, który następnie można skompilować do kodu
bajtowego Javy, C lub CLR.
Wersje języka Python
2.7.X ­ w pewnym sensie przeszłość Pythona
3.X ­ teraźniejszość i przyszłość języka
https://wiki.python.org/moin/Python2orPython3 (https://wiki.python.org/moin/Python2orPython3)
Instalacja Pythona
pod Windowsem ­ instalator ze strony https://www.python.org/downloads/
(https://www.python.org/downloads/)
inne platformy (Unix, Linux, Mac OS)
Python jest już najprawdopodobniej zainstalowany
pakiety binarne ­ systemowy manager oprogramowania
kompilacja ze źródeł ­ strona https://www.python.org/downloads/
(https://www.python.org/downloads/)
Historia
Pythona stworzył we wczesnych latach 90. holenderski programista Guido van Rossum:
Ponad 6 lat temu, w grudniu 1989, szukałem hobbystycznego projektu
programistycznego, który zająłby mnie w tygodniu przed świętami. Moje biuro miało
być zamknięte, ale miałem domowy komputer. Zdecydowałem się napisać
interpreter dla nowego języka skryptowego, nad którym wtedy myślałem: pochodną
ABC, która przemawiałaby do hakerów Uniksa i C. Jako roboczy tytuł wybrałem
Python, będąc wielkim fanem Latającego Cyrku Monty Pythona. (Wprowadzenie do
Programming Python, Mark Lutz, wyd. O'Reilly).
obecnie nad projektem pracuje cała grupa osób
z racji kluczowej roli, jaką odgrywa van Rossum przy podejmowaniu ważnych decyzji projektowych,
często określa się go przydomkiem Benevolent Dictator for Life (BDFL).
In [12]:
# Historia
from IPython.display import YouTubeVideo
YouTubeVideo("OgV4iBQVNyU")
Out[12]:
Monty Python - skecz o ministerstwi...
Kto używa Pythona?
Google (Youtube, aplikacje webowe)
Yahoo (aplikacje webowe).
Microsoft (IronPython: Python dla .NET)
Disney (animacje 3D)
Dropbox
Instagram
BitTorrent (poprzednie wersje)
Spotify
Reddit
BitBucket
Blender3D
In [13]:
### Kto używa Pythona?
from IPython.display import YouTubeVideo
YouTubeVideo("Z8l8WNHwTOg")
Out[13]:
The best blender demo reel lm 2013
Filozofia Pythona
In [14]:
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 i
t.
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!
Przykłady programów w Pythonie
In [15]:
%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
t = np.arange(0.0,5.2,0.2)
plt.plot(t,t,'ro',t,t**2,'bs',t,t**3,'g^')
Out[15]:
[<matplotlib.lines.Line2D at 0x7f22bf2e64a8>,
<matplotlib.lines.Line2D at 0x7f22bf2e67f0>,
<matplotlib.lines.Line2D at 0x7f22bf2f2048>]
Wykresy 3D
In [16]:
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d.axes3d import Axes3D
alpha = 0.7
phi_ext = 2 * np.pi * 0.5
def flux_qubit_potential(phi_m, phi_p):
return 2 + alpha - 2 * np.cos(phi_p)*np.cos(phi_m) - alpha * np.cos(phi_ext
- 2*phi_p)
#generujemy siatkę (meshgrid) i wyliczamy na niej wartości funkcji
phi_m = np.linspace(0, 2*np.pi, 100)
phi_p = np.linspace(0, 2*np.pi, 100)
X,Y = np.meshgrid(phi_p, phi_m)
Z = flux_qubit_potential(X, Y).T
#wykres powierzchniowy z rzutami
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(1,1,1, projection='3d')
ax.plot_surface(X, Y, Z, rstride=4, cstride=4, alpha=0.25)
cset = ax.contour(X, Y, Z, zdir='z', offset=-np.pi, cmap=plt.cm.coolwarm)
cset = ax.contour(X, Y, Z, zdir='x', offset=-np.pi, cmap=plt.cm.coolwarm)
cset = ax.contour(X, Y, Z, zdir='y', offset=3*np.pi, cmap=plt.cm.coolwarm)
ax.set_xlim3d(-np.pi, 2*np.pi);
ax.set_ylim3d(0, 3*np.pi);
ax.set_zlim3d(-np.pi, 2*np.pi);
Gra w życie według Conwaya
In [17]:
import numpy as np
from scipy.signal import convolve
# do zliczania sąsiadów każdej komórki
FILTER = np.array([[1, 1, 1],
[1, 100, 1],
[1, 1, 1]], dtype=np.uint8)
def evolve(length, generations):
"""
Uruchom grę w życie. Stan początkowy jest losowy.
Parametry
------|---length : int
rozmiar liniowy planszy
generations : int
liczba generacji, dla których rozgrywa się gra
"""
current = np.random.randint(2, size=(length, length))
next = np.empty_like(current)
current[length/2, 1:(length-1)] = 1
show_board(current)
for _ in range(generations):
advance(current, next)
current, next = next, current
show_board(current)
def advance(current, next):
"""
Wyznacz kolejną iterację gry.
Parametry
---------current : 2D array
Aktualny stan planszy
next : 2D array
Stan planszy w kolejnym kroku.
"""
assert current.shape[0] == current.shape[1], \
'Plansza powinna być kwadratowa'
next[:] = 0
count = convolve(current, FILTER, mode='same')
next[(count == 3) | (count == 102) | (count == 103)] = 1
In [18]:
from IPython.display import clear_output, display_html
import time
def show_board(board):
"""
Rysuje planszę w tabeli HTML.
Usuwa wszystko, co na wyjściu, przy pomocy `IPython.display.clear_output`
w celu zrobienia animacji.
Parametry
---------board : 2D array
Plansza.
"""
clear_output(True)
nx, ny = board.shape
table = '<table style="border-color: black; border-width: 5px;">\n'
for y in range(ny-1, -1, -1):
table += '<tr>'
for x in range(0, nx):
if board[x, y]:
table += '<td style="background: black; border-color: white;"></
td>'
else:
table += '<td style="border-color: white;"></td>'
table += '</tr>\n'
table += '</table>'
display_html(table, raw=True)
time.sleep(0.1)
In [19]:
evolve(40,100)
Wahadło pojedyncze
In [20]:
from IPython.display import Image
Image(filename='Pendulum.jpg', width=250)
Out[20]:
Równanie ruchu wahadła (przy odpowiednio dobranych l i g) ma postać:
¨
θ + sin θ = 0
Przekształcamy najpierw to równanie do układu równań różniczkowych pierwszego rzędu:
dθ
= v
dt
dv
= −sinθ
dt
Chcemy rozwiązać to równanie dla warunku początkowego θ
= 0, 3 i v = 0 :
In [21]:
import matplotlib.pyplot as plt
import scipy as sp
from scipy.integrate import odeint
#wartości początkowe
th0 = 0.3
v0 = 0.0
init = [th0,v0]
#prawa strona układu równań: f(theta,v)
def rhs(y,t):
return [y[1],-sp.sin(y[0])]
#czas ruchu
t = sp.linspace(0, 10, 250)
#rozwiązanie równania
y = odeint(rhs,init,t)
plt.plot(t,y[:,0],label="theta")
plt.plot(t,y[:,1],label='v')
plt.legend(loc="upper right")
plt.xlabel("time [s]")
Out[21]:
<matplotlib.text.Text at 0x7f22b04e2ef0>
Wahadło podwójne
In [22]:
Image(url='http://upload.wikimedia.org/wikipedia/commons/c/c9/Double-compound-pe
ndulum-dimensioned.svg')
Out[22]:
(0, 0)
ℓ
θ1
(x1,y1)
mg
θ2
ℓ
(x2,y2)
mg
Równania ruchu wahadła mają następującą postać (http://en.wikipedia.org/wiki/Double_pendulum
(http://en.wikipedia.org/wiki/Double_pendulum)):
˙
θ1 =
˙
θ2 =
2p θ −3 cos(θ1 −θ2 )p θ
6
1
2
8p θ −3 cos(θ1 −θ2 )p θ
6
2
2
= −
ṗ θ
= −
2
1
2
16−9 cos (θ1 −θ2 )
mℓ
ṗ θ
1
2
2
16−9 cos (θ1 −θ2 )
mℓ
1
2
1
2
mℓ
mℓ
2
2
.
ẋ 2 =
2
mℓ
g
ℓ
sin θ 2 ]
= [θ 1 , θ 2 , pθ , pθ ] . Wówczas:
1
2
16−9 cos (x1 −x2 )
8x4 −3 cos(x1 −x2 )x3
6
2
mℓ
ẋ 4 = −
sin θ 1 ]
2x3 −3 cos(x1 −x2 )x4
6
ẋ 3 = −
ℓ
˙ ˙
[−θ 1 θ 2 sin(θ 1 − θ 2 ) +
Wprowadźmy zmienną wektorową x
ẋ 1 =
g
˙ ˙
[θ 1 θ 2 sin(θ 1 − θ 2 ) + 3
1
2
1
2
2
16−9 cos (x1 −x2 )
mℓ
mℓ
2
2
[ẋ 1 ẋ 2 sin(x 1 − x 2 ) + 3
[−ẋ 1 ẋ 2 sin(x 1 − x 2 ) +
g
ℓ
sin x 1 ]
g
ℓ
sin x 2 ]
2
In [23]:
g = 9.82
L = 0.5
m = 0.1
def dx(x, t):
"""
prawa strona układu RRZ dla wahadła podwójnego
"""
x1, x2, x3, x4 = x[0], x[1], x[2], x[3]
dx1 = 6.0/(m*L**2) * (2 * x3 - 3 * sp.cos(x1-x2) * x4)/(16 - 9 * sp.cos(x1-x
2)**2)
dx2 = 6.0/(m*L**2) * (8 * x4 - 3 * sp.cos(x1-x2) * x3)/(16 - 9 * sp.cos(x1-x
2)**2)
dx3 = -0.5 * m * L**2 * ( dx1 * dx2 * sp.sin(x1-x2) + 3 * (g/L) *
sp.sin(x1))
dx4 = -0.5 * m * L**2 * (-dx1 * dx2 * sp.sin(x1-x2) + (g/L) * sp.sin(x2))
return [dx1, dx2, dx3, dx4]
# stan początkowy
x0 = [sp.pi/4, sp.pi/2, 0, 0]
# przedział czasu, dla którego rozwiązujemy równanie (od 0 do 10 s)
t = sp.linspace(0, 10, 250)
# rozwiązanie układu
x = odeint(dx, x0, t)
# kąty w funkcji czasu
plt.plot(t, x[:, 0], 'r', label="theta1")
plt.plot(t, x[:, 1], 'b', label="theta2")
plt.legend(loc="upper right")
plt.xlabel("time [s]")
Out[23]:
<matplotlib.text.Text at 0x7f22b0043e80>
In [24]:
# wykres w przestrzeni położeń
x1 = + L * sp.sin(x[:, 0])
y1 = - L * sp.cos(x[:, 0])
x2 = x1 + L * sp.sin(x[:, 1])
y2 = y1 - L * sp.cos(x[:, 1])
plt.plot(x1, y1, 'r', label="pendulum1")
plt.plot(x2, y2, 'b', label="pendulum2")
plt.legend(loc="upper right")
Out[24]:
<matplotlib.legend.Legend at 0x7f22abc4c748>
A teraz prosta animacja ruchu wahadła:
In [25]:
from IPython.display import clear_output, display
import time
fig, ax = plt.subplots(figsize=(4,4))
for t_idx, tt in enumerate(t[:200]):
x1 = + L * sp.sin(x[t_idx, 0])
y1 = - L * sp.cos(x[t_idx, 0])
x2 = x1 + L * sp.sin(x[t_idx, 1])
y2 = y1 - L * sp.cos(x[t_idx, 1])
ax.cla()
ax.plot([0, x1], [0, y1], 'r.-')
ax.plot([x1, x2], [y1, y2], 'b.-')
ax.set_ylim([-1.5, 0.5])
ax.set_xlim([1, -1])
display(fig)
clear_output(True)
time.sleep(0.1)
In [ ]: