Numpy

Biblioteka szeroko wykorzystywana do wykonywania obliczeń numerycznych.

Przykłady użycia

Rozróżnienie między standardową listą a listą oferowaną przez bibliotekę numpy:

import numpy as np

x = [1, 2, 3, 4, 5, 6]
v = np.array(x)
v

array([1, 2, 3, 4, 5, 6])

Przykład listy 2d, czyli macierzy:

M = np.array([[1,2], [3,4]])
M

array([[1, 2],
       [3, 4]])

type(v), type(M)

(numpy.ndarray, numpy.ndarray)

Sprawdzenie wymiarów listy/macierzy:

v.shape

(6,)

M.shape

(2, 2)

M.size

4

Typ danych w macierzy:

M.dtype

dtype('int32')

Generowanie liczb losowych (w formie macierzy):

np.random.rand(5,3)

array([[0.36166558, 0.5065146 , 0.8709358 ],
       [0.6892864 , 0.68585991, 0.78089246],
       [0.06865658, 0.91214024, 0.74774348],
       [0.91356967, 0.73962801, 0.51183955],
       [0.7314828 , 0.17924709, 0.50836662]])

Macierz zer:

np.zeros([5,3])

array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])

Operacje na macierzach:

M = np.array([[1,2,3], [4,5,6]])
N = np.array([[1,1,1], [2,2,2]])
print(N)
print(M)

[[1 1 1]
 [2 2 2]]
[[1 2 3]
 [4 5 6]]

Dodawanie:

M + N

array([[2, 3, 4],
       [6, 7, 8]])

Mnożenie przez skalar:

5*M

array([[ 5, 10, 15],
       [20, 25, 30]])

Mnozenie odpowiadającyh sobie kolejnych komórek macierzy:

M*N

array([[ 1,  2,  3],
       [ 8, 10, 12]])

Iloczyn macierzowy:

# dlaczego nie działa?
M.dot(N)

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-14-ee8431842421> in <module>
      1 # dlaczego nie działa?
----> 2 M.dot(N)

ValueError: shapes (2,3) and (2,3) not aligned: 3 (dim 1) != 2 (dim 0)

Transpozycja + iloczyn macierzowy:

M.dot(N.T)

array([[ 6, 12],
       [15, 30]])

Generowanie liczb z zakresu z krokiem (przydatne do wykresów):

v = np.arange(0, 10.01, 0.5)
print(v)

[ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5
  7.   7.5  8.   8.5  9.   9.5 10. ]

Generowanie (100) liczb z zakresu (przydatne do wykresów):

# Generowanie rownych odstepow
v = np.linspace(0,10,100)
v

array([ 0.        ,  0.1010101 ,  0.2020202 ,  0.3030303 ,  0.4040404 ,
        0.50505051,  0.60606061,  0.70707071,  0.80808081,  0.90909091,
        1.01010101,  1.11111111,  1.21212121,  1.31313131,  1.41414141,
        1.51515152,  1.61616162,  1.71717172,  1.81818182,  1.91919192,
        2.02020202,  2.12121212,  2.22222222,  2.32323232,  2.42424242,
        2.52525253,  2.62626263,  2.72727273,  2.82828283,  2.92929293,
        3.03030303,  3.13131313,  3.23232323,  3.33333333,  3.43434343,
        3.53535354,  3.63636364,  3.73737374,  3.83838384,  3.93939394,
        4.04040404,  4.14141414,  4.24242424,  4.34343434,  4.44444444,
        4.54545455,  4.64646465,  4.74747475,  4.84848485,  4.94949495,
        5.05050505,  5.15151515,  5.25252525,  5.35353535,  5.45454545,
        5.55555556,  5.65656566,  5.75757576,  5.85858586,  5.95959596,
        6.06060606,  6.16161616,  6.26262626,  6.36363636,  6.46464646,
        6.56565657,  6.66666667,  6.76767677,  6.86868687,  6.96969697,
        7.07070707,  7.17171717,  7.27272727,  7.37373737,  7.47474747,
        7.57575758,  7.67676768,  7.77777778,  7.87878788,  7.97979798,
        8.08080808,  8.18181818,  8.28282828,  8.38383838,  8.48484848,
        8.58585859,  8.68686869,  8.78787879,  8.88888889,  8.98989899,
        9.09090909,  9.19191919,  9.29292929,  9.39393939,  9.49494949,
        9.5959596 ,  9.6969697 ,  9.7979798 ,  9.8989899 , 10.        ])

Wbudowane funkcje przyjmują macierze jako argumenty:

np.sin(v)

array([ 0.        ,  0.10083842,  0.20064886,  0.2984138 ,  0.39313661,
        0.48385164,  0.56963411,  0.64960951,  0.72296256,  0.78894546,
        0.84688556,  0.8961922 ,  0.93636273,  0.96698762,  0.98775469,
        0.99845223,  0.99897117,  0.98930624,  0.96955595,  0.93992165,
        0.90070545,  0.85230712,  0.79522006,  0.73002623,  0.65739025,
        0.57805259,  0.49282204,  0.40256749,  0.30820902,  0.21070855,
        0.11106004,  0.01027934, -0.09060615, -0.19056796, -0.28858706,
       -0.38366419, -0.47483011, -0.56115544, -0.64176014, -0.7158225 ,
       -0.7825875 , -0.84137452, -0.89158426, -0.93270486, -0.96431712,
       -0.98609877, -0.99782778, -0.99938456, -0.99075324, -0.97202182,
       -0.94338126, -0.90512352, -0.85763861, -0.80141062, -0.73701276,
       -0.66510151, -0.58640998, -0.50174037, -0.41195583, -0.31797166,
       -0.22074597, -0.12126992, -0.0205576 ,  0.0803643 ,  0.18046693,
        0.27872982,  0.37415123,  0.46575841,  0.55261747,  0.63384295,
        0.7086068 ,  0.77614685,  0.83577457,  0.8868821 ,  0.92894843,
        0.96154471,  0.98433866,  0.99709789,  0.99969234,  0.99209556,
        0.97438499,  0.94674118,  0.90944594,  0.86287948,  0.8075165 ,
        0.74392141,  0.6727425 ,  0.59470541,  0.51060568,  0.42130064,
        0.32770071,  0.23076008,  0.13146699,  0.03083368, -0.07011396,
       -0.17034683, -0.26884313, -0.36459873, -0.45663749, -0.54402111])

Przykład zwięzłego wygenerowania sinusa:

%matplotlib inline
from matplotlib import pyplot as plt
plt.plot(v, np.sin(v))
plt.show()

Czytanie (krojenie) macierzy:

M = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12], [13,14,15,16]])
M

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])

Wszystkie wiersze razy druga (trzecia) kolumna:

M[:,2]

array([ 3,  7, 11, 15])

Drugi (trzeci) wiersz razy kolumny z przedziału 1:3 :

M[2,1:3]

array([10, 11])

M[1:3,2:4]

array([[ 7,  8],
       [11, 12]])

M[::2,:]

array([[ 1,  2,  3,  4],
       [ 9, 10, 11, 12]])

M

array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])

Można nadpisywać podczas czytania:

M[::2,::2]=0
M

array([[ 0,  2,  0,  4],
       [ 5,  6,  7,  8],
       [ 0, 10,  0, 12],
       [13, 14, 15, 16]])

Sympy

Biblioteka do obliczeń symbolicznych - operujemy na wzorach, nie na liczbach.

from sympy.interactive import printing
printing.init_printing(use_latex=True)

#from __future__ import division
import sympy as sym
from sympy import *

# Definicje zmiennych
x, y, z = symbols("x y z")
k = Symbol("k", integer=True)
f = Function('f')

Ważne jest przypomnienie sobie różnicy między wyrażeniem a równaniem. Poniżej znajduje się przykład wyrażenia:

exp = ((x+y)**2 * (x+1))
exp

$\displaystyle \left(x + 1\right) \left(x + y\right)^{2}$

Rozwinięcie:

expand(exp)

$\displaystyle x^{3} + 2 x^{2} y + x^{2} + x y^{2} + 2 x y + y^{2}$

a = 1/x + (x*y - 1)/x + 1
a

$\displaystyle 1 + \frac{x y - 1}{x} + \frac{1}{x}$

Uproszczenie wyrażenia:

simplify(a)

$\displaystyle y + 1$

Przykład równiania (Eq): x - 3 = 0:

eq = Eq(x - 3, 0)
eq

$\displaystyle x - 3 = 0$

Dzięki solve, możemy rozwiązać rówananie. Dlaczego wynik jest w formie listy?

solve(eq, x)

$\displaystyle \left[ 3\right]$

Trochę trudniejsze równanie:

eq = Eq(x**3 + 3*x**2 - 13*x - 15)
eq

$\displaystyle x^{3} + 3 x^{2} - 13 x - 15 = 0$

Solve znalazł wszystkie rozwiązania. Czy sympy jest w stanie rozwiązać wielomian dowolnego stopnia? Jeżeli nie, to jaki jest górny limit na stopień wielomianu, by Sympy sobie mógł poradzić?

solve(eq, x)

$\displaystyle \left[ -5, \ -1, \ 3\right]$

Trochę inny przykład. Jak należy zinterpretować wynik?

eq = Eq(  x**3 + 3*x**2 - 13*x + 15)
#eq
r = solve(eq, x)
r

$\displaystyle \left[ -1 - \frac{16}{\left(- \frac{1}{2} - \frac{\sqrt{3} i}{2}\right) \sqrt[3]{3 \sqrt{5937} + 405}} - \frac{\left(- \frac{1}{2} - \frac{\sqrt{3} i}{2}\right) \sqrt[3]{3 \sqrt{5937} + 405}}{3}, \ -1 - \frac{\left(- \frac{1}{2} + \frac{\sqrt{3} i}{2}\right) \sqrt[3]{3 \sqrt{5937} + 405}}{3} - \frac{16}{\left(- \frac{1}{2} + \frac{\sqrt{3} i}{2}\right) \sqrt[3]{3 \sqrt{5937} + 405}}, \ - \frac{\sqrt[3]{3 \sqrt{5937} + 405}}{3} - \frac{16}{\sqrt[3]{3 \sqrt{5937} + 405}} - 1\right]$

Można uwikłać w równanie dodatkową zmienną. Czy widać ją w wyniku?

eq = Eq(x**3 + 3*x**2 - 13*x + z)
solve(eq, x)

$\displaystyle \left[ - \frac{\left(- \frac{1}{2} - \frac{\sqrt{3} i}{2}\right) \sqrt[3]{\frac{27 z}{2} + \frac{\sqrt{\left(27 z + 405\right)^{2} - 442368}}{2} + \frac{405}{2}}}{3} - 1 - \frac{16}{\left(- \frac{1}{2} - \frac{\sqrt{3} i}{2}\right) \sqrt[3]{\frac{27 z}{2} + \frac{\sqrt{\left(27 z + 405\right)^{2} - 442368}}{2} + \frac{405}{2}}}, \ - \frac{\left(- \frac{1}{2} + \frac{\sqrt{3} i}{2}\right) \sqrt[3]{\frac{27 z}{2} + \frac{\sqrt{\left(27 z + 405\right)^{2} - 442368}}{2} + \frac{405}{2}}}{3} - 1 - \frac{16}{\left(- \frac{1}{2} + \frac{\sqrt{3} i}{2}\right) \sqrt[3]{\frac{27 z}{2} + \frac{\sqrt{\left(27 z + 405\right)^{2} - 442368}}{2} + \frac{405}{2}}}, \ - \frac{\sqrt[3]{\frac{27 z}{2} + \frac{\sqrt{\left(27 z + 405\right)^{2} - 442368}}{2} + \frac{405}{2}}}{3} - 1 - \frac{16}{\sqrt[3]{\frac{27 z}{2} + \frac{\sqrt{\left(27 z + 405\right)^{2} - 442368}}{2} + \frac{405}{2}}}\right]$

Przykład sumy:

s = Sum(6*k**2 - 1, (k, 1, 10))
s

$\displaystyle \sum_{k=1}^{10} \left(6 k^{2} - 1\right)$

Doit = wykonuje, tj. liczy sumę:

s.doit()

$\displaystyle 2300$

Dzięki Sympy możemy policzyć granicę:

Sympy rozpozaje pewne stałe matematyczne:

lim = Limit(1/x, x, 0, '+')
lim

$\displaystyle \lim_{x \to 0^+} \frac{1}{x}$

lim.doit()

$\displaystyle \infty$

lim = 2*Limit((1+1/x)**x, x, oo)
lim

$\displaystyle 2 \lim_{x \to \infty} \left(1 + \frac{1}{x}\right)^{x}$

lim.doit()

$\displaystyle 2 e$

Sympy policzy pochodną i więcej:

q = ((3*x**2))
q

$\displaystyle 3 x^{2}$

q.diff(x)

$\displaystyle 6 x$

eqn = Eq(Derivative(f(x),x,x) + 9*f(x), 1)
eqn

$\displaystyle 9 f{\left(x \right)} + \frac{d^{2}}{d x^{2}} f{\left(x \right)} = 1$

dsolve(eqn, f(x))

$\displaystyle f{\left(x \right)} = C_{1} \sin{\left(3 x \right)} + C_{2} \cos{\left(3 x \right)} + \frac{1}{9}$