umz21/lab/2001_Python.ipynb
2021-03-02 08:32:40 +01:00

1673 lines
32 KiB
Plaintext
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"slideshow": {
"slide_type": "slide"
}
},
"source": [
"## Uczenie maszynowe 2019/2020 laboratoria\n",
"### 2/3 marca 2020\n",
"# 1. Python listy składane, indeksowanie, biblioteka _NumPy_"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Listy składane (*List comprehension*)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Przypuśćmy, że mamy dane zdanie i chcemy utworzyć listę, która będzie zawierać długości kolejnych wyrazów tego zdania. Możemy to zrobić w następujący sposób:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 4, 7, 3, 4, 1, 4, 3, 4, 1, 4, 7, 6, 4]\n"
]
}
],
"source": [
"zdanie = 'tracz tarł tarcicę tak takt w takt jak takt w takt tarcicę tartak tarł'\n",
"wyrazy = zdanie.split()\n",
"dlugosci_wyrazow = []\n",
"for wyraz in wyrazy:\n",
" dlugosci_wyrazow.append(len(wyraz))\n",
" \n",
"print(dlugosci_wyrazow)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Możemy to też zrobić bardziej „pythonicznie”, przy użyciu list składanych:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 4, 7, 3, 4, 1, 4, 3, 4, 1, 4, 7, 6, 4]\n"
]
}
],
"source": [
"zdanie = 'tracz tarł tarcicę tak takt w takt jak takt w takt tarcicę tartak tarł'\n",
"wyrazy = zdanie.split()\n",
"dlugosci_wyrazow = [len(wyraz) for wyraz in wyrazy]\n",
"\n",
"print(dlugosci_wyrazow)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Jeżeli chcemy, żeby był sprawdzany dodatkowy warunek, np. chcemy pomijać wyraz „takt”, to wciąż możemy użyć list składanych:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 4, 7, 3, 1, 3, 1, 7, 6, 4]\n"
]
}
],
"source": [
"zdanie = 'tracz tarł tarcicę tak takt w takt jak takt w takt tarcicę tartak tarł'\n",
"wyrazy = zdanie.split()\n",
"dlugosci_wyrazow = [len(wyraz) for wyraz in wyrazy if wyraz != 'takt']\n",
"print(dlugosci_wyrazow)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Indeksowanie"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wszystkie listy i krotki w Pythonie, w tym łańcuchy (które trakowane są jak krotki znaków), są indeksowane od 0:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a\n",
"e\n"
]
}
],
"source": [
"napis = 'abcde'\n",
"print(napis[0]) # 'a'\n",
"print(napis[4]) # 'e'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Indeksy możemy liczyć również „od końca”:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"e\n",
"d\n",
"a\n"
]
}
],
"source": [
"napis = 'abcde'\n",
"print(napis[-1]) # 'e' („ostatni”)\n",
"print(napis[-2]) # 'd' („drugi od końca”)\n",
"print(napis[-5]) # 'a' („piąty od końca”)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Łańcuchy możemy też „kroić na plasterki” (_slicing_):"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bcd\n",
"b\n",
"cd\n",
"bcd\n",
"de\n",
"abc\n",
"abcde\n"
]
}
],
"source": [
"napis = 'abcde'\n",
"print(napis[1:4]) # 'bcd' („znaki od 1. włącznie do 4. wyłącznie”)\n",
"print(napis[1:2]) # 'b' (to samo co `napis[1]`)\n",
"print(napis[-3:-1]) # 'cd' (kroić można też stosując indeksowanie od końca)\n",
"print(napis[1:-1]) # 'bcd' (możemy nawet mieszać te dwa sposoby indeksowania)\n",
"print(napis[3:]) # 'cde' (jeżeli koniec przedziału nie jest podany, to kroimy do samego końca łańcucha)\n",
"print(napis[:3]) # 'ab' (jeżeli początek przedziału nie jest podany, to kroimy od początku łańcucha)\n",
"print(napis[:]) # 'abcde' (kopia całego napisu)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Biblioteka _NumPy_"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Tablice"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Głównym obiektem w NumPy jest **jednorodna**, **wielowymiarowa** tablica. Przykładem takiej tablicy jest macierz `x`.\n",
"\n",
"Macierz $x =\n",
" \\begin{pmatrix}\n",
" 1 & 2 & 3 \\\\\n",
" 4 & 5 & 6 \\\\\n",
" 7 & 8 & 9\n",
" \\end{pmatrix}$\n",
"można zapisać jako:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2 3]\n",
" [4 5 6]\n",
" [7 8 9]]\n"
]
}
],
"source": [
"import numpy as np\n",
"\n",
"x = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Najczęsciej używane metody tablic typu `array`:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(3, 3)"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x.shape"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([12, 15, 18])"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x.sum(axis=0)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2., 5., 8.])"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x.mean(axis=1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Do tworzenia sekwencji liczbowych jako obiekty typu `array` należy wykorzystać funkcję `arange`."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.arange(10)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([5, 6, 7, 8, 9])"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.arange(5, 10)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([5. , 5.5, 6. , 6.5, 7. , 7.5, 8. , 8.5, 9. , 9.5])"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.arange(5, 10, 0.5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Kształt tablicy można zmienić za pomocą metody `reshape`:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[ 1 2 3 4 5 6 7 8 9 10 11 12]\n",
"[[ 1 2 3 4]\n",
" [ 5 6 7 8]\n",
" [ 9 10 11 12]]\n"
]
}
],
"source": [
"x = np.arange(1, 13)\n",
"print(x)\n",
"y = x.reshape(3, 4)\n",
"print(y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Funkcją podobną do `arange` jest `linspace`, która wypełnia wektor określoną liczbą elementów z przedziału o równych automatycznie obliczonych odstępach (w `arange` należy podać rozmiar kroku):"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0. 1.25 2.5 3.75 5. ]\n"
]
}
],
"source": [
"x = np.linspace(0, 5, 5)\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Dodatkowe informacje o funkcjach NumPy uzyskuje się za pomocą polecenia `help(nazwa_funkcji)`:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Help on function shape in module numpy:\n",
"\n",
"shape(a)\n",
" Return the shape of an array.\n",
" \n",
" Parameters\n",
" ----------\n",
" a : array_like\n",
" Input array.\n",
" \n",
" Returns\n",
" -------\n",
" shape : tuple of ints\n",
" The elements of the shape tuple give the lengths of the\n",
" corresponding array dimensions.\n",
" \n",
" See Also\n",
" --------\n",
" alen\n",
" ndarray.shape : Equivalent array method.\n",
" \n",
" Examples\n",
" --------\n",
" >>> np.shape(np.eye(3))\n",
" (3, 3)\n",
" >>> np.shape([[1, 2]])\n",
" (1, 2)\n",
" >>> np.shape([0])\n",
" (1,)\n",
" >>> np.shape(0)\n",
" ()\n",
" \n",
" >>> a = np.array([(1, 2), (3, 4)], dtype=[('x', 'i4'), ('y', 'i4')])\n",
" >>> np.shape(a)\n",
" (2,)\n",
" >>> a.shape\n",
" (2,)\n",
"\n"
]
}
],
"source": [
"help(np.shape)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tablice mogą składać się z danych różnych typów (ale tylko jednego typu danych równocześnie, stąd jednorodność)."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"int32\n",
"[0.1 0.2 0.3]\n",
"float64\n",
"float64\n"
]
}
],
"source": [
"x = np.array([1, 2, 3])\n",
"print(x.dtype)\n",
"x = np.array([0.1, 0.2, 0.3])\n",
"print(x)\n",
"print(x.dtype)\n",
"x = np.array([1, 2, 3], dtype='float64')\n",
"print(x.dtype)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tworzenie tablic składających się z samych zer lub jedynek umożliwiają funkcje `zeros` oraz `ones`:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[0. 0. 0. 0.]\n",
" [0. 0. 0. 0.]\n",
" [0. 0. 0. 0.]]\n"
]
}
],
"source": [
"x = np.zeros([3,4])\n",
"print(x)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1. 1. 1. 1.]\n",
" [1. 1. 1. 1.]\n",
" [1. 1. 1. 1.]]\n"
]
}
],
"source": [
"x = np.ones([3,4])\n",
"print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Podstawowe operacje arytmetyczne"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Operatory arytmetyczne na tablicach w NumPy działają **element po elemencie**."
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2. 3. 4.]\n"
]
}
],
"source": [
"import numpy as np\n",
"\n",
"a = np.array([3, 4, 5])\n",
"b = np.ones(3)\n",
"print(a - b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Za mnożenie macierzy odpowiada funkcja `dot` (nie operator `*`):"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2]\n",
" [3 4]]\n"
]
}
],
"source": [
"a = np.array([[1, 2], [3, 4]])\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[1 2]\n",
" [3 4]]\n"
]
}
],
"source": [
"b = np.array([[1, 2], [3, 4]])\n",
"print(b)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 1, 4],\n",
" [ 9, 16]])"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a * b"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 7, 10],\n",
" [15, 22]])"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.dot(a,b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Przykłady innych operacji dodawania i mnożenia:"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[5., 5.],\n",
" [5., 5.]])"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = np.zeros((2, 2), dtype='float')\n",
"a += 5\n",
"a"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[25., 25.],\n",
" [25., 25.]])"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a *= 5\n",
"a"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[50., 50.],\n",
" [50., 50.]])"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a + a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Sklejanie tablic:"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 2, 3, 4, 5, 6, 7, 8, 9])"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = np.array([1, 2, 3])\n",
"b = np.array([4, 5, 6])\n",
"c = np.array([7, 8, 9])\n",
"np.hstack([a, b, c])"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1, 2, 3],\n",
" [4, 5, 6],\n",
" [7, 8, 9]])"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.vstack([a, b, c])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Typowe funkcje matematyczne:"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([3.14159265, 4.44288294, 5.44139809, 6.28318531])"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = np.arange(1, 5)\n",
"np.sqrt(x) * np.pi"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"16"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2**4"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"16"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.power(2, 4)"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.log(np.e)"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = np.arange(5)\n",
"x.max() - x.min()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Indeksy i zakresy"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tablice jednowymiarowe zachowują sie podobnie do zwykłych list pythonowych."
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 3])"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = np.arange(10)\n",
"a[2:4]"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 2, 4, 6, 8])"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[:10:2]"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[::-1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Tablice wielowymiarowe mają po jednym indeksie na wymiar:"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0, 1, 2, 3],\n",
" [ 4, 5, 6, 7],\n",
" [ 8, 9, 10, 11]])"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = np.arange(12).reshape(3, 4)\n",
"x"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"11"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[2, 3]"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1, 5, 9])"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[:, 1]"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([4, 5, 6, 7])"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[1, :]"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 4, 5, 6, 7],\n",
" [ 8, 9, 10, 11]])"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x[1:3, :]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Warunki"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Warunki pozwalają na selekcję elementów tablicy."
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([2, 2, 2, 3, 3, 3])"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = np.array([1, 1, 1, 2, 2, 2, 3, 3, 3])\n",
"a[a > 1]"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([3, 3, 3])"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[a == 3]"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([0, 1, 2, 3, 4, 5], dtype=int64),)"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.where(a < 3)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0, 1, 2, 3, 4, 5], dtype=int64)"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.where(a < 3)[0]"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([], dtype=int64),)"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.where(a > 9)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Pętle i wypisywanie"
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "Missing parentheses in call to 'print'. Did you mean print(row)? (<ipython-input-48-5346ec1a1aa1>, line 2)",
"output_type": "error",
"traceback": [
"\u001b[1;36m File \u001b[1;32m\"<ipython-input-48-5346ec1a1aa1>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m print row\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m Missing parentheses in call to 'print'. Did you mean print(row)?\n"
]
}
],
"source": [
"for row in x:\n",
" print row"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"for element in x.flat:\n",
" print element, "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Liczby losowe"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.random.randint(0, 10, 5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.random.normal(0, 1, 5) "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.random.uniform(0, 2, 5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Macierze"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"NumPy jest pakietem wykorzystywanym do obliczeń w dziedzinie algebry liniowej, co jeszcze szczególnie przydatne w uczeniu maszynowym. \n",
"\n",
"Wektor o wymiarach $1 \\times N$ \n",
"$$\n",
" x =\n",
" \\begin{pmatrix}\n",
" x_{1} \\\\\n",
" x_{2} \\\\\n",
" \\vdots \\\\\n",
" x_{N}\n",
" \\end{pmatrix} \n",
"$$\n",
"\n",
"i jego transpozycję $x^\\top = (x_{1}, x_{2},\\ldots,x_{N})$ można wyrazić w Pythonie w następujący sposób:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"\n",
"x = np.array([[1, 2, 3]]).T\n",
"x.shape"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"xt = x.T\n",
"xt.shape"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Macierz kolumnowa** w NumPy.\n",
"$$X =\n",
" \\begin{pmatrix}\n",
" 3 \\\\\n",
" 4 \\\\\n",
" 5 \\\\\n",
" 6 \n",
" \\end{pmatrix}$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = np.array([[3,4,5,6]]).T\n",
"x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Macierz wierszowa** w NumPy.\n",
"$$ X =\n",
" \\begin{pmatrix}\n",
" 3 & 4 & 5 & 6\n",
" \\end{pmatrix}$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = np.array([[3,4,5,6]])\n",
"x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Oprócz obiektów typu `array` istnieje wyspecjalizowany obiekt `matrix`, dla którego operacje `*` (mnożenie) oraz `**-1` (odwracanie) są określone w sposób właściwy dla macierzy (w przeciwieństwie do operacji elementowych dla obiektów `array`)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"x = np.array([1,2,3,4,5,6,7,8,9]).reshape(3,3)\n",
"x"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"X = np.matrix(x)\n",
"X"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Wyznacznik macierzy**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = np.array([[3,-9],[2,5]])\n",
"np.linalg.det(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Macierz odwrotna**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"A = np.array([[-4,-2],[5,5]])\n",
"A"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"invA = np.linalg.inv(A)\n",
"invA"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"np.round(np.dot(A, invA))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(ponieważ $AA^{-1} = A^{-1}A = I$)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Wartości i wektory własne**"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"a = np.diag((1, 2, 3))\n",
"a"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"w, v = np.linalg.eig(a)\n",
"print(w) # wartości własne\n",
"print(v) # wektory własne"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Zadania"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Zadanie 1.1 (1 pkt)\n",
"\n",
"Dla danej listy `input_list` zawierającej liczby utwórz nową listę `output_list`, która będzie zawierała kwadraty liczb dodatnich z `input_list`. Użyj _list comprehension_!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Przykładowe dane\n",
"\n",
"input_list = [34.6, -203.4, 44.9, 68.3, -12.2, 44.6, 12.7]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Zadanie 1.2 (1 pkt)\n",
"\n",
"Za pomocą jednowierszowego polecenia utwórz następującą macierz jako obiekt typu `array`:\n",
"$$A = \\begin{pmatrix}\n",
"1 & 2 & \\cdots & 10 \\\\\n",
"11 & 12 & \\cdots & 20 \\\\\n",
"\\vdots & \\ddots & \\ddots & \\vdots \\\\\n",
"41 & 42 & \\cdots & 50 \n",
"\\end{pmatrix}$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Zadanie 1.3 (1 pkt)\n",
"\n",
"Dla macierzy $A$ z zadania 1.2:\n",
" * określ liczbę elementów, kolumn i wierszy,\n",
" * stwórz wektory średnich po wierszach oraz po kolumnach,\n",
" * wypisz jej trzecią kolumnę,\n",
" * wypisz jej czwarty wiersz.\n",
" \n",
"Użyj odpowiednich metod obiektu `array`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Zadanie 1.4 (1 pkt)\n",
"\n",
"Utwórz macierze\n",
"$$ A = \\begin{pmatrix}\n",
"0 & 4 & -2 \\\\\n",
"-4 & -3 & 0\n",
"\\end{pmatrix} $$\n",
"$$ B = \\begin{pmatrix}\n",
"0 & 1 \\\\\n",
"1 & -1 \\\\\n",
"2 & 3\n",
"\\end{pmatrix} $$\n",
"oraz wektor\n",
"$$ x = \\begin{pmatrix}\n",
"2 \\\\\n",
"1 \\\\\n",
"0\n",
"\\end{pmatrix} $$\n",
"\n",
"Oblicz:\n",
" * iloczyn macierzy $A$ z wektorem $x$ \n",
" * iloczyn macierzy $A \\cdot B$\n",
" * wyznacznik $\\det(A \\cdot B)$\n",
" * wynik działania $(A \\cdot B)^\\top - B^\\top \\cdot A^\\top$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Zadanie 1.5 (1 pkt)\n",
"\n",
"Czym różni się operacja `A**-1` dla obiektów typu `array` i `matrix`? Pokaż na przykładzie."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Zadanie 1.6 (1 pkt)\n",
"\n",
"Dla macierzy $X = \\left[\n",
" \\begin{array}{rrr}\n",
" 1 & 2 & 3\\\\\n",
" 1 & 3 & 6 \\\\\n",
" \\end{array}\n",
" \\right]$ oraz wektora $y = \\left[\n",
" \\begin{array}{r}\n",
" 5 \\\\\n",
" 6 \\\\\n",
" \\end{array}\n",
" \\right]$ oblicz wynikowy wektor: \n",
"$$ \\theta = (X^\\top \\, X)^{-1} \\, X^\\top \\, y^\\top \\, . $$\n",
"Wykonaj te same obliczenia raz na obiektach typu `array`, a raz na obiektach typu `matrix`.\n",
"W przypadku obiektów typu `matrix` zastosuj możliwie krótki zapis. "
]
}
],
"metadata": {
"celltoolbar": "Slideshow",
"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.8.3"
},
"livereveal": {
"start_slideshow_at": "selected",
"theme": "amu"
}
},
"nbformat": 4,
"nbformat_minor": 4
}