{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# NumPy\n",
"NumPy (czyli Numerical Python) jest podstawową biblioteką w Pythonie wykorzystywaną do obliczeń naukowych. Pakiet NumPy pozwala między innymi na wykonywanie wydajnych operacji na macierzach. NumPy może być używany jako darmowa alternatywa dla MATLABa."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Arrays\n",
"Array to tablica wartości, tego samgeo typu!. Arrays są mutowalne. "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Wektor 'a'\n",
" [1 2 3 4 5]\n",
"Macierz 'A'\n",
" [[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n",
"\n",
"\n",
"(3, 3)\n",
"2\n",
"[3 6 9]\n",
"[[2 3]\n",
" [5 6]]\n",
"[[1 4 7]\n",
" [2 5 8]\n",
" [3 6 9]]\n"
]
}
],
"source": [
"# podstawowym obiektem jest np.array()\n",
"\n",
"a = np.array([1, 2, 3, 4, 5])\n",
"A = np.array([[1, 2, 3],[4, 5, 6], [7, 8, 9]])\n",
"\n",
"print(\"Wektor 'a'\\n\",a)\n",
"print(\"Macierz 'A'\\n\",A)\n",
"print()\n",
"\n",
"print(type(a)) # Wyświetla \"\"\n",
"print(A.shape) # Wyświetla \"(3,3)\"\n",
"print(A[0,1]) # Wyświetla \"2\"\n",
"print(A[:,2]) # Wyświetla \"[3 6 9]\"\n",
"print(A[:2,1:]) # Wyświetla \"[[2 3], [5 6]]\"\n",
"print(A.T) # Transpozycja macierzy A"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0. 0. 0.]\n",
" [0. 0. 0.]]\n",
"[[1. 1. 1. 1.]\n",
" [1. 1. 1. 1.]\n",
" [1. 1. 1. 1.]]\n"
]
}
],
"source": [
"B1 = np.zeros((2,3))\n",
"B2 = np.ones((3,4))\n",
"\n",
"print(B1)\n",
"print(B2)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[3.14 3.14 3.14]\n",
" [3.14 3.14 3.14]\n",
" [3.14 3.14 3.14]]\n",
"[[1. 0. 0. 0. 0.]\n",
" [0. 1. 0. 0. 0.]\n",
" [0. 0. 1. 0. 0.]\n",
" [0. 0. 0. 1. 0.]\n",
" [0. 0. 0. 0. 1.]]\n"
]
}
],
"source": [
"B3 = np.full((3,3), 3.14)\n",
"B4 = np.eye(5)\n",
"\n",
"print(B3)\n",
"print(B4)"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0 1 2 3 4 5 6 7 8 9]\n",
"[[0 1 2 3 4]\n",
" [5 6 7 8 9]]\n",
"[0 1 2 3 4 5 6 7 8 9]\n"
]
}
],
"source": [
"B5 = np.arange(10)\n",
"\n",
"print(B5)\n",
"print(B5.reshape(2,5)) # Zmieniamy \"kształt\" macierzy\n",
"print(B5.reshape(2,5).flatten()) # \"Wypłaszczamy\" macierz do jednego wymiaru"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[[1 2]\n",
" [3 4]]\n",
"\n",
" [[5 6]\n",
" [7 8]]]\n",
"(2, 2, 2)\n"
]
}
],
"source": [
"C = np.arange(1,9).reshape(2,2,2)\n",
"\n",
"print(C)\n",
"print(C.shape) # trójwymiarowa macierz"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8 1.9 2. 2.1 2.2 2.3 2.4 2.5 2.6 2.7\n",
" 2.8 2.9 3. 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 4. 4.1 4.2 4.3 4.4 4.5\n",
" 4.6 4.7 4.8 4.9 5. 5.1 5.2 5.3 5.4 5.5 5.6 5.7 5.8 5.9 6. 6.1 6.2 6.3\n",
" 6.4 6.5 6.6 6.7 6.8 6.9 7. 7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 8. 8.1\n",
" 8.2 8.3 8.4 8.5 8.6 8.7 8.8 8.9]\n"
]
}
],
"source": [
"B6 = np.arange(1,9,0.1)\n",
"print(B6)"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 2 22 33]\n",
" [44 55 66]\n",
" [77 88 99]]\n",
"[[ 0 -18 -27]\n",
" [-36 -45 -54]\n",
" [-63 -72 -81]]\n",
"[[ 1 40 90]\n",
" [160 250 360]\n",
" [490 640 810]]\n",
"[[ 291 360 420]\n",
" [ 624 810 960]\n",
" [ 957 1260 1500]]\n",
"[[ 2 4 8]\n",
" [ 16 32 64]\n",
" [128 256 512]]\n",
"[[1. 0.1 0.1]\n",
" [0.1 0.1 0.1]\n",
" [0.1 0.1 0.1]]\n"
]
}
],
"source": [
"A = np.array([[1, 2, 3],\n",
" [4, 5, 6],\n",
" [7, 8, 9]])\n",
"\n",
"B = np.array([[1, 20, 30],\n",
" [40, 50, 60],\n",
" [70, 80, 90]])\n",
"\n",
"print(A + B)\n",
"print(A - B)\n",
"print(A*B)\n",
"print(A.dot(B))\n",
"print(2**A)\n",
"print(A/B)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[['student1' '5']\n",
" ['student2' '4']\n",
" ['student3' '3.5']]\n",
"[['student1' '5']\n",
" ['student2' '4']\n",
" ['student3' '3.5']]\n"
]
}
],
"source": [
"studenci = np.array([[\"student1\", \"5\"],\n",
" [\"student2\", \"4\"],\n",
" [\"student3\", \"3.5\"]])\n",
"\n",
"print(studenci)\n",
"print(studenci)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Argumet dtype"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1. 2. 3.]\n",
" [4. 5. 6.]\n",
" [7. 8. 9.]]\n",
"\n",
"Dtype float64\n"
]
}
],
"source": [
"\n",
"\n",
"liczby = np.array([[1,2,3],\n",
" [4,5,6],\n",
" [7,8,9]], dtype=np.float64)\n",
"print(liczby)\n",
"print(\"\\nDtype\",liczby.dtype)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[['1' '2' '3']\n",
" ['4' '5' '6']\n",
" ['7' '8' '9']]\n"
]
}
],
"source": [
"liczby = np.array([[1,2,3],\n",
" [4,5,6],\n",
" [7,8,9]], dtype=np.str)\n",
"print(liczby)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ True True False]\n",
" [ True True False]\n",
" [ True True False]]\n"
]
}
],
"source": [
"liczby = np.array([[1,2,0],\n",
" [4,5,0],\n",
" [7,8,0]], dtype=np.bool)\n",
"print(liczby)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" \n",
"[1. 2. 3.]\n"
]
}
],
"source": [
"lista = [1, 2, 3]\n",
"a = np.asarray(lista, dtype = np.float64)\n",
"print(type(lista), type(a))\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Iteracje po arrays"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0 5 10 15]\n",
"[20 25 30 35]\n",
"[40 45 50 55]\n"
]
}
],
"source": [
"macierz = np.arange(0,60,5).reshape(3,4)\n",
"\n",
"for v in macierz: # pętla po wierszach\n",
" print(v)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"5\n",
"10\n",
"15\n",
"20\n",
"25\n",
"30\n",
"35\n",
"40\n",
"45\n",
"50\n",
"55\n"
]
}
],
"source": [
"for v in np.nditer(macierz): # pętla po elementach macierzy\n",
" print(v)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Kopiowanie i sortowanie"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Kopiowanie można rozróżnić na płykie (ndarray.view() ) i głębokie (ndarray.copy()). Wycinek macierzy jest traktowany jako widok ( ndarray.view()). Zmiana elemntu w widoku powoduje zmianę elemnetu w głównej macierzy."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[15 9 2 3]\n",
" [ 2 11 16 7]\n",
" [ 5 3 9 9]]\n",
"[[ 2 3 9 15]\n",
" [ 2 7 11 16]\n",
" [ 3 5 9 9]]\n",
"[[ 2 3 9 9]\n",
" [ 2 5 9 15]\n",
" [ 3 7 11 16]]\n",
"[[15 9 2 3]\n",
" [ 2 11 16 7]\n",
" [ 5 3 9 9]]\n"
]
}
],
"source": [
"macierz = np.random.randint(1,20,size=(3,4))\n",
"print(macierz)\n",
"macierz2 = macierz.copy() # kopijujemy macierz 'macierz'\n",
"\n",
"macierz.sort() # sortowanie po wierszach\n",
"print(macierz)\n",
"macierz.sort(axis=0) # sortowanie po kolumnach\n",
"print(macierz)\n",
"print(macierz2)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 5 10 6 7]\n",
" [ 5 13 10 3]\n",
" [15 15 12 17]]\n",
"[[0 2 3 1]\n",
" [3 0 2 1]\n",
" [2 0 1 3]]\n"
]
}
],
"source": [
"macierz = np.random.randint(1,20,size=(3,4))\n",
"print(macierz)\n",
"\n",
"print(macierz.argsort()) # sortowanie po wierszach, zwracamy macierz indeksów posortowanych elementów"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Boolean array"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n"
]
}
],
"source": [
"A = np.arange(1,10).reshape(3,3)\n",
"\n",
"print(A)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[False False False]\n",
" [False False True]\n",
" [ True True True]]\n",
"[[ True True True]\n",
" [ True True False]\n",
" [False False False]]\n"
]
}
],
"source": [
"print(A > 5)\n",
"print(np.logical_not(A > 5))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[6 7 8 9]\n"
]
}
],
"source": [
"print(A[A>5])"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[4 6 8]\n"
]
}
],
"source": [
"print(A[(A>3) & (A%2==0)])"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[4 6 8]\n"
]
}
],
"source": [
"warunek = (A>3) & (A%2==0)\n",
"print(np.extract(warunek, A))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Przydatne funkcje matematyczne i nie tylko"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0.0000000e+00 1.0000000e+00 1.2246468e-16 -1.0000000e+00\n",
" -2.4492936e-16 1.0000000e+00 3.6739404e-16 -1.0000000e+00\n",
" -4.8985872e-16 1.0000000e+00]\n",
"[ 1.0000000e+00 6.1232340e-17 -1.0000000e+00 -1.8369702e-16\n",
" 1.0000000e+00 3.0616170e-16 -1.0000000e+00 -4.2862638e-16\n",
" 1.0000000e+00 5.5109106e-16]\n",
"[1.00000000e+00 2.71828183e+00 7.38905610e+00 2.00855369e+01\n",
" 5.45981500e+01 1.48413159e+02 4.03428793e+02 1.09663316e+03\n",
" 2.98095799e+03 8.10308393e+03]\n"
]
}
],
"source": [
"v = np.arange(10)\n",
"omega = np.pi/2\n",
"\n",
"print(np.sin(omega*v))\n",
"print(np.cos(omega*v))\n",
"print(np.exp(v))"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 0 1 2]\n",
" [ 3 4 5]\n",
" [ 6 -1 8]]\n",
"28\n",
"[ 9 4 15]\n",
"8\n",
"7\n",
"True\n",
"3.111111111111111\n"
]
}
],
"source": [
"A = np.arange(9).reshape(3,3)\n",
"A[2,1] = -1\n",
"n, m = A.shape\n",
"print(A)\n",
"\n",
"print(A.sum())\n",
"print(A.sum(axis=0)) # suma po kolumnach\n",
"print(A.max()) # maksymalny element\n",
"print(A.argmin()) # pozycja minimalnego elemeny w macierzy A\n",
"\n",
"x = A.argmin()//n\n",
"y = A.argmin() - n*x\n",
"\n",
"print(A[x, y] == A.min())\n",
"\n",
"print(np.mean(A))"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 0. 0.1010101 0.2020202 0.3030303 0.4040404 0.50505051\n",
" 0.60606061 0.70707071 0.80808081 0.90909091 1.01010101 1.11111111\n",
" 1.21212121 1.31313131 1.41414141 1.51515152 1.61616162 1.71717172\n",
" 1.81818182 1.91919192 2.02020202 2.12121212 2.22222222 2.32323232\n",
" 2.42424242 2.52525253 2.62626263 2.72727273 2.82828283 2.92929293\n",
" 3.03030303 3.13131313 3.23232323 3.33333333 3.43434343 3.53535354\n",
" 3.63636364 3.73737374 3.83838384 3.93939394 4.04040404 4.14141414\n",
" 4.24242424 4.34343434 4.44444444 4.54545455 4.64646465 4.74747475\n",
" 4.84848485 4.94949495 5.05050505 5.15151515 5.25252525 5.35353535\n",
" 5.45454545 5.55555556 5.65656566 5.75757576 5.85858586 5.95959596\n",
" 6.06060606 6.16161616 6.26262626 6.36363636 6.46464646 6.56565657\n",
" 6.66666667 6.76767677 6.86868687 6.96969697 7.07070707 7.17171717\n",
" 7.27272727 7.37373737 7.47474747 7.57575758 7.67676768 7.77777778\n",
" 7.87878788 7.97979798 8.08080808 8.18181818 8.28282828 8.38383838\n",
" 8.48484848 8.58585859 8.68686869 8.78787879 8.88888889 8.98989899\n",
" 9.09090909 9.19191919 9.29292929 9.39393939 9.49494949 9.5959596\n",
" 9.6969697 9.7979798 9.8989899 10. ]\n"
]
}
],
"source": [
"# równo rozmieszczone liczby\n",
"t = np.linspace(0, 10, 100)\n",
"print(t)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## hstack i vstack"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2 3 4 5 6]]\n",
"[[1 2 3]\n",
" [4 5 6]]\n"
]
}
],
"source": [
"wiersz1 = np.array([[1, 2, 3]]) # Macierz 1x3\n",
"wiersz2 = np.array([[4, 5, 6]]) # Macierz 1x3\n",
"\n",
"print(np.hstack((wiersz1, wiersz2)))\n",
"print(np.vstack((wiersz1, wiersz2)))"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 4]\n",
" [2 5]\n",
" [3 6]]\n",
"[[1]\n",
" [2]\n",
" [3]\n",
" [4]\n",
" [5]\n",
" [6]]\n"
]
}
],
"source": [
"kolumna1 = np.array([[1],[2], [3]]) # Macierz 3x1 \n",
"kolumna2 = np.array([[4], [5], [6]]) # Macierz 3x1\n",
"\n",
"print(np.hstack((kolumna1, kolumna2)))\n",
"print(np.vstack((kolumna1, kolumna2)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Funkce *np.hsplit(macierz, v)* i *np.vsplit(macierz, v)* dzięlą *macierz* horyzontalnie lub wertykalnie względem kolumny lub wiersza *v* (*v* może też być wektorem). Dodatkowo warto zapoznać się z dzaiłaniem funkcji *np.concatenate* oraz *np.split*."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### np.vectorize()\n",
"Zauważ, że funkce matematyczne np.sin(), np.exp(), ..., znajdujące się w bibliotece NumPy są zwektoryzowane, tzn. mogą przyjmować sekwencje danych (lub nawet macierze) jako argument. Aby zwektoryzować własną funkcję używamy funkcji (lub dekoratora) np.vectorize."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"1\n",
"[0 1 1]\n"
]
},
{
"ename": "TypeError",
"evalue": "unsupported operand type(s) for %: 'tuple' and 'int'",
"output_type": "error",
"traceback": [
"\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwadraty2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m9\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwadraty2\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwadraty\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mt\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m(x)\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mkwadraty\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m%\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0mkwadraty2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvectorize\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mkwadraty\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[0mt\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m9\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[1;31mTypeError\u001b[0m: unsupported operand type(s) for %: 'tuple' and 'int'"
]
}
],
"source": [
"kwadraty = lambda x: x%2\n",
"kwadraty2 = np.vectorize(kwadraty)\n",
"\n",
"t = (2, 3, 9)\n",
"\n",
"print(kwadraty(9))\n",
"print(kwadraty2(9))\n",
"print(kwadraty2(t))\n",
"print(kwadraty(t))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### numpy.random"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.869229996031621\n",
"0.6540927975708454\n"
]
}
],
"source": [
"x = np.random.random() # liczba losowa z przeciału [0,1)\n",
"print(x)\n",
"\n",
"y = np.random.random()\n",
"print(y)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.6964691855978616\n",
"0.6964691855978616\n"
]
}
],
"source": [
"# funkcja seed() inicjalizuje generator liczb losowych\n",
"# ustawiając ziarno na pewną wartość\n",
"\n",
"np.random.seed(123) \n",
"x = np.random.random() \n",
"print(x)\n",
"np.random.seed(123)\n",
"\n",
"y = np.random.random()\n",
"print(y)"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 3 3 7 18 11 2 1 18 16 10]\n",
"[[0.40101756 0.62731701 0.32415089 0.24475928]\n",
" [0.69475518 0.5939024 0.63179202 0.44025718]\n",
" [0.08372648 0.71233018 0.42786349 0.2977805 ]]\n",
"[8 0 2 5]\n",
"[7 5 6 8 9 3 0 4 1 2]\n"
]
}
],
"source": [
"v1 = np.random.randint(1,20,10)\n",
"v2 = np.random.sample((3,4)) # macierz elementów losowych z [0,1)\n",
"v3 = np.random.choice(range(10),size=4, replace=False)\n",
"\n",
"v4 = np.arange(10)\n",
"np.random.shuffle(v4)\n",
"\n",
"print(v1)\n",
"print(v2)\n",
"print(v3)\n",
"print(v4)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}