W s tę p d o p r o g r a mo w a n i aprac.im.pwr.wroc.pl/~szwabin/assets/intro/lectures/1.pdf ·...

25.09.2018 1_Wprowadzenie

file:///home/szwabin/Dropbox/Zajecia/WstepDoProgramowania/Wyklady/1_Intro/1_Wprowadzenie.html 1/26

Wstęp do programowaniaWykład 1 - Wprowadzenie

Janusz Szwabiński

Plan wykładu:

Sprawy administracyjneNauka programowania - wyzwania i celeCzym jest program komputerowy?Błędy i ich usuwanieJęzyki naturalne i formalneJę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]ój 5.16, budynek C-11konsultacje: poniedziałek 11:00 - 13:00, piątek 9:00 - 11:00

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, dziedziczenieInterfejsy użytkownika w Tkinter.

http://prac.im.pwr.edu.pl/~szwabin/



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 QTD. Harrell, Rzecz o istocie informatyki. Algorytmika, WNT, Warszawa 2000N. Wirth, Algorytmy + struktury danych = programy, WNT, Warszawa 2000

Zaliczenie

listy zadań na ćwiczeniach i laboratoriachdwa testy: na 7 i ostatnim wykładzie

Nauka programowania

Cele

programowanie w konkretnym języku (tutaj - w Pythonie)rozwiązywanie problemów:

formułowanie problemówkreatywne 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 skomplikowaneukłady o nowych funkcjonalnościach, szuka alternatywnaukowca - obserwuje zachowanie układów złożonych, formułuje hipotezy i testuje prognozy

ocena = + +lab

2

ćw

4

wyk

4

http://prac.im.pwr.wroc.pl/~szwabin/

http://www.python.org/

http://www.greenteapress.com/thinkpython/

http://www.diveintopython.net/

http://gnosis.cx/TPiP/



Algorytmskończony ciąg jasno zdefiniowanych czynności, koniecznych do wykonania pewnego rodzajuzadańjego zadaniem jest przeprowadzenie systemu z pewnego stanu początkowego do pożądanegostanu końcowego

Przykład - metoda babilońska wyliczania pierwiastka (metoda Herona)

Szukamy aproksymacji :

1. Rozpocznij z dowolną dodatnią wartością początkową (im bliżej szukanego pierwiastka, tymlepiej).

2. Znajdź kolejne przybliżenie według wzoru

3. Powtarzaj krok 2 do osiągnięcia pożądanej dokładności.

In [1]:

S = 25

import math

math.sqrt(25)

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)

In [5]:

x2 = (x1+S/x1)/2

print(x2)

In [6]:

x3 = (x2+S/x2)/2

print(x3)

S−−√

x0

= ( + )xn+11

2xn

S

xn

Out[1]:

5.0

13.0

7.461538461538462

5.406026962727994



In [7]:

x4 = (x3+S/x3)/2

print(x4)

Program komputerowyProgram komputerowy to ciąg instrukcji opisujących sposób wykonania pewnych obliczeń (niekonieczniematematycznych). Szczegóły programu wyglądają różnie w różnych językach programowania, jednakniezależ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ławyjście - prezentacja danych na ekranie, ich zapis do pliku lub innego urządzeniaobliczenia - podstawowe operacje matematycznewarunkowe przetwarzanie - wykonywanie części programu tylko przy spełnieniu pewnychwarunkówpowtarzanie - powtarzanie pewnych części programu

Praktycznie każdy program zbudowany jest z tych podstawowych "klocków". Dlatego programowanie możnarozumieć jako proces rozkładania dużego, skomplikowanego zadania na coraz prostsze podzadania domomentu, 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 posobie następować zgodnie z zasadami języka programowania. Wykrywany przez kompilator lubinterpreter 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 wykonywaniaprogramu (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 zreguły nie jest to już program, który planowaliśmy napisać. Wykrycie błędów semantycznychstanowi często duże wyzwanie.

Przykłady błędów

In [8]:

prit("Witaj świecie")

5.015247601944898

-------------------------------------------------------------------

--------

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

In [10]:

infile = open('foo.txt')

for line in infile:

print(line)

In [11]:

def suma(a,b):

print(a-b) #zwróć uwagę na błąd w działaniu!!!

suma(10,6)

Witaj świecie

-------------------------------------------------------------------

--------

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'

4



Etymologia słowa bug

It has been just so in all of my inventions. The first step is an intuition, and comes with aburst, then difficulties arise — this thing gives out and [it is] then that "Bugs" — as such littlefaults and difficulties are called — show themselves and months of intense watching, studyand labor are requisite before commercial success or failure is certainly reached. (ThomasEdison, 1878)

In 1946, when Hopper was released from active duty, she joined the Harvard Faculty at theComputation Laboratory where she continued her work on the Mark II and Mark III. Operatorstraced an error in the Mark II to a moth trapped in a relay, coining the term bug. This bug wascarefully removed and taped to the log book. Stemming from the first bug, today we callerrors or glitches in a program a bug.(Sharon Ann Danis, Rear Admiral Grace MurrayHopper, 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 programowaniemwyzwanie intelektualnepotrafi być frustrująceprzypomina 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 drodzehistorycznego rozwoju określonych grup etnicznych

wieloznacznyredundantnyalegoryczny

język formalny - podzbiór zbioru wszystkich słów nad skończonym alfabetem, język wymyślonyprzez człowieka

jednoznacznyzwięzłydosł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, jednakciągle może być wieloznacznaprogram - 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 programowaniasposób kontroli typówsposó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/))

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śneosadzane w aplikacjach (np. Python w Blenderze)często używane do jednorazowych zadań (np. administracyjnych)niektóre nadają się do tworzenia samodzielnych aplikacjizwięzłe

Pythondarmowy i przenośnyinterpretowanyduża zwięzłośćdynamiczna semantyka i elegancka składniaautomatyczne zarządzanie pamięcią (ang. garbage collection)bogata biblioteka standardowastruktury wysokiego poziomu (m.in. listy, słowniki, liczby zespolone)wieloparadygmatowy (programowanie obiektowe, strukturalne, funkcyjne)łatwo integruje się z C/C++ i Fortranemoddana społeczność programistówbogata dokumentacja wbudowana i do znalezienia w Interneciedużo narzędzi do obliczeń naukowychidealny do tworzenia skryptów i tzw. błyskawiczego rozwijania aplikacjipeł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 platformamiwiele wersjibrak 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ęcznejprogramiści stosujący języki skryptowe okazują się prawie dwukrotnie wydajniejsi od tychuż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 widzeniajest 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 Sourcezarządzany przez Python Software Foundation (https://www.python.org/psf/)Jython (http://www.jython.org/) - implementacja napisana w JavieIronPython (http://ironpython.net/) - Python dla platformy .NetCLPython (https://common-lisp.net/project/clpython/) - implementacja w Common LispiePyPy (http://pypy.org/) - wersja Pythona napisana w... Pythonie, a w zasadzie w statycznympodzbiorze Pythona o nazwie Restricted Python, który następnie można skompilować do kodubajtowego Javy, C lub CLR.

Wersje języka Python

2.7.X - w pewnym sensie przeszłość Pythona3.X - teraźniejszość i przyszłość językahttps://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 zainstalowanypakiety binarne - systemowy manager oprogramowaniakompilacja 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 projektuprogramistycznego, który zająłby mnie w tygodniu przed świętami. Moje biuro miałobyć 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łemPython, będąc wielkim fanem Latającego Cyrku Monty Pythona. (Wprowadzenie doProgramming Python, Mark Lutz, wyd. O'Reilly).

obecnie nad projektem pracuje cała grupa osóbz 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).

https://www.python.org/

https://www.python.org/psf/

http://www.jython.org/

http://ironpython.net/

https://common-lisp.net/project/clpython/

http://pypy.org/

https://wiki.python.org/moin/Python2orPython3

https://www.python.org/downloads/

https://www.python.org/downloads/



In [12]:

# Historia

from IPython.display import YouTubeVideo

YouTubeVideo("OgV4iBQVNyU")

Kto używa Pythona?

Google (Youtube, aplikacje webowe)Yahoo (aplikacje webowe).Microsoft (IronPython: Python dla .NET)Disney (animacje 3D)DropboxInstagramBitTorrent (poprzednie wersje)SpotifyRedditBitBucketBlender3D

Out[12]:



In [13]:

### Kto używa Pythona?

from IPython.display import YouTubeVideo

YouTubeVideo("Z8l8WNHwTOg")

Filozofia Pythona

Out[13]:



In [14]:

import this

Przykłady programów w Pythonie

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!



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

Wykresy 3D

Out[15]:

[<matplotlib.lines.Line2D at 0x7f22bf2e64a8>,

<matplotlib.lines.Line2D at 0x7f22bf2e67f0>,

<matplotlib.lines.Line2D at 0x7f22bf2f2048>]



In [16]:


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)

Równanie ruchu wahadła (przy odpowiednio dobranych i ) ma postać:

Przekształcamy najpierw to równanie do układu równań różniczkowych pierwszego rzędu:

Chcemy rozwiązać to równanie dla warunku początkowego i :

l g

+ sin θ = 0θ

= vdθ

dt

= −sinθdv

dt

θ = 0, 3 v = 0

Out[20]:



In [21]:


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

Wahadło podwójne

Out[21]:

<matplotlib.text.Text at 0x7f22b04e2ef0>



In [22]:

Image(url='http://upload.wikimedia.org/wikipedia/commons/c/c9/Double-compound-pe

ndulum-dimensioned.svg')

Równania ruchu wahadła mają następującą postać (http://en.wikipedia.org/wiki/Double_pendulum(http://en.wikipedia.org/wiki/Double_pendulum)):

Wprowadźmy zmienną wektorową . Wówczas:

=θ 16

mℓ2

2 −3 cos( − )pθ1θ1 θ2 pθ2

16−9 ( − )cos2 θ1 θ2

= .θ 26

mℓ2

8 −3 cos( − )pθ2θ1 θ2 pθ1

16−9 ( − )cos2 θ1 θ2

= − m [ sin( − ) + 3 sin ]pθ1

12

ℓ2 θ 1 θ 2 θ1 θ2g

ℓθ1

= − m [− sin( − ) + sin ]pθ2

12

ℓ2 θ 1 θ 2 θ1 θ2g

ℓθ2

x = [ , , , ]θ1 θ2 pθ1pθ2

=x16

mℓ2

2 −3 cos( − )x3 x1 x2 x4

16−9 ( − )cos2 x1 x2

=x26

mℓ2

8 −3 cos( − )x4 x1 x2 x3

16−9 ( − )cos2 x1 x2

= − m [ sin( − ) + 3 sin ]x312

ℓ2 x1x2 x1 x2g

ℓx1

= − m [− sin( − ) + sin ]x412

ℓ2 x1x2 x1 x2g

ℓx2

Out[22]:

(0, 0)

mg

(x1,y1)

mg

(x2,y2)

θ1

θ2

ℓ

ℓ

http://en.wikipedia.org/wiki/Double_pendulum



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


A teraz prosta animacja ruchu wahadła:

Out[24]:

<matplotlib.legend.Legend at 0x7f22abc4c748>



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

W s tę p d o p r o g r a mo w a n i aprac.im.pwr.wroc.pl/~szwabin/assets/intro/lectures/1.pdf ·...

Documents

Transcript of W s tę p d o p r o g r a mo w a n i aprac.im.pwr.wroc.pl/~szwabin/assets/intro/lectures/1.pdf ·...