diff --git a/LaTeX/LAB-3.ipynb b/LaTeX/LAB-3.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d534db30d3b363ec1622abb3c1ac2dac8167930a --- /dev/null +++ b/LaTeX/LAB-3.ipynb @@ -0,0 +1,586 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zadanie 1\n", + "\n", + "Przetestujcie wykonywanie prostych obliczeń w języku Python" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n" + ] + } + ], + "source": [ + "a = 1\n", + "b = 2\n", + "\n", + "print (a+b)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Podaj liczbe a:5\n", + "Podaj liczbe b:5\n", + "Suma wynosi: 10 Roznica wynosi: 0 Iloczyn wynosi: 25 a iloraz: 1.0\n", + "Suma wynosi:10, roznica wynosi:0, iloczyn wynosi:25, a iloraz:1.0\n", + "Suma wynosi:10, roznica wynosi:0, iloczyn wynosi:25, a iloraz:1.0\n" + ] + } + ], + "source": [ + "a = int(input('Podaj liczbe a:'))\n", + "b = int(input('Podaj liczbe b:'))\n", + "\n", + "suma = a+b\n", + "roznica = a-b\n", + "iloczyn = a*b\n", + "iloraz = a/b\n", + "\n", + "\n", + "print('Suma wynosi:',suma,'Roznica wynosi:',roznica,'Iloczyn wynosi:',iloczyn,'a iloraz:',iloraz)\n", + "print('Suma wynosi:{}, roznica wynosi:{}, iloczyn wynosi:{}, a iloraz:{}'.format(suma,roznica,iloczyn,iloraz))\n", + "print(f'Suma wynosi:{suma}, roznica wynosi:{roznica}, iloczyn wynosi:{iloczyn}, a iloraz:{iloraz}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zadanie 2\n", + "\n", + "Instrukcja warunkowa w języku Python ma składnię\n", + "\n", + "```python\n", + "if condition:\n", + " expr1\n", + " expr2\n", + " \n", + "if condition:\n", + " expr1\n", + " expr2\n", + "else:\n", + " expr3\n", + " \n", + "if condition:\n", + " expr1\n", + " expr2\n", + "elif condition2:\n", + " expr3\n", + "else:\n", + " expr4\n", + " \n", + "```\n", + "\n", + "Napisz program, który dla podanych ocen z wykładu i laboratorium obliczy ocenę końcową z grupy kursów.\n", + "\n", + "- Ocena = (0.6W+0.4L) jeśli W >= 3.0 i L >= 3.0\n", + "- Ocena = 2.0 jeśli W == 2.0 lub L == 2.0" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3.4\n" + ] + } + ], + "source": [ + "W = 3\n", + "L = 4\n", + "\n", + "\n", + "# ...\n", + "\n", + "\n", + "if W>=3.0 and L>=3.0:\n", + " Ocena = (0.6*W+0.4*L)\n", + " \n", + "else:\n", + " Ocena = 2.0\n", + "\n", + "\n", + "# print ( ocena )\n", + "\n", + "print (Ocena)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zadanie 3\n", + "\n", + "Napisz kod, który dla danego wzrostu i wagi wyświetli BMI osoby oraz poda słowną interpretację\n", + "\n", + "\n", + "Zakresy wartości BMI:\n", + "\n", + " mniej niż 16 - wygłodzenie\n", + " 16 - 16.99 - wychudzenie\n", + " 17 - 18.49 - niedowaga\n", + " 18.5 - 24.99 - wartość prawidłowa\n", + " 25 - 29.99 - nadwaga\n", + " 30 - 34.99 - I stopień otyłości\n", + " 35 - 39.99 - II stopień otyłości\n", + " powyżej 40 - otyłość skrajna\n", + "\n", + "Dla przypomnienia\n", + "\n", + "$$ BMI = \\frac {masa}{wzrost^2} $$\n", + "\n", + "gdzie masa jest podana w kilogramach a wzrost w metrach" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Twoje BMI wynosi 27.777777777777775 co oznacza nadwaga\n" + ] + } + ], + "source": [ + "wzrost = 1.8\n", + "waga = 90\n", + "\n", + "# Wypisz \"Twoje BMI wynosi ... co oznacza .... (np. niedowagę) \"\n", + "\n", + "BMI = waga/(wzrost**2)\n", + "\n", + "if BMI<16:\n", + " \n", + " inter = 'wyglodzenie'\n", + " \n", + "elif BMI>=16 and BMI<=16.99:\n", + " \n", + " inter = 'wychudzenie'\n", + " \n", + "elif BMI>=17 and BMI<=18.49:\n", + " \n", + " inter = 'niedowaga'\n", + " \n", + "elif BMI>=18.5 and BMI<=24.99:\n", + " \n", + " inter = 'waga pradilowa'\n", + " \n", + "elif BMI>=25 and BMI<=29.99:\n", + " \n", + " inter = 'nadwaga'\n", + " \n", + "elif BMI>=30 and BMI<=34.99:\n", + " \n", + " inter = 'I stopien otylosci'\n", + " \n", + "elif BMI>=35 and BMI<=39.99:\n", + " \n", + " inter = 'II stopien otylosci'\n", + " \n", + "else:\n", + " inter = 'otylosc skrajna'\n", + " \n", + " \n", + "print('Twoje BMI wynosi ',BMI,' co oznacza ',inter)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zadanie 4\n", + "\n", + "Składnia pętli while w Pythonie:\n", + " \n", + "```python\n", + "while condition:\n", + " expr1\n", + " expr2\n", + "```\n", + "\n", + "Napisz program, który wyświetli wszystkie liczby podzielne przez 5 z zakresu od A do B\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5\n", + "10\n", + "15\n", + "20\n", + "25\n", + "30\n", + "35\n", + "40\n", + "45\n", + "50\n", + "55\n", + "60\n", + "65\n", + "70\n" + ] + } + ], + "source": [ + "A = 3\n", + "B = 72\n", + "\n", + "# ...\n", + "\n", + "while A<=B:\n", + " \n", + " if(A%5 == 0):\n", + " \n", + " print(A)\n", + " A=A+1\n", + " \n", + " else:\n", + " \n", + " A=A+1\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Zadanie 5\n", + "\n", + "Wyświetl tabelę konwersji temperatur ze stopni Celsjusza na stopnie Fahrenhaita. Wyświetl ją dla temepratur z zakresu 0C....50C z krokiem 0.5 stopnia\n", + "Tabelka powinna mieć ładne ramki ;)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "[ x**2 for x in range(3)]" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| 0.0 | 32.0 |\n", + "| 0.5 | 32.9 |\n", + "| 1.0 | 33.8 |\n", + "| 1.5 | 34.7 |\n", + "| 2.0 | 35.6 |\n", + "| 2.5 | 36.5 |\n", + "| 3.0 | 37.4 |\n", + "| 3.5 | 38.3 |\n", + "| 4.0 | 39.2 |\n", + "| 4.5 | 40.1 |\n", + "| 5.0 | 41.0 |\n", + "| 5.5 | 41.9 |\n", + "| 6.0 | 42.8 |\n", + "| 6.5 | 43.7 |\n", + "| 7.0 | 44.6 |\n", + "| 7.5 | 45.5 |\n", + "| 8.0 | 46.4 |\n", + "| 8.5 | 47.3 |\n", + "| 9.0 | 48.2 |\n", + "| 9.5 | 49.1 |\n", + "| 10.0 | 50.0 |\n", + "| 10.5 | 50.9 |\n", + "| 11.0 | 51.8 |\n", + "| 11.5 | 52.7 |\n", + "| 12.0 | 53.6 |\n", + "| 12.5 | 54.5 |\n", + "| 13.0 | 55.4 |\n", + "| 13.5 | 56.3 |\n", + "| 14.0 | 57.2 |\n", + "| 14.5 | 58.1 |\n", + "| 15.0 | 59.0 |\n", + "| 15.5 | 59.9 |\n", + "| 16.0 | 60.8 |\n", + "| 16.5 | 61.7 |\n", + "| 17.0 | 62.6 |\n", + "| 17.5 | 63.5 |\n", + "| 18.0 | 64.4 |\n", + "| 18.5 | 65.3 |\n", + "| 19.0 | 66.2 |\n", + "| 19.5 | 67.1 |\n", + "| 20.0 | 68.0 |\n", + "| 20.5 | 68.9 |\n", + "| 21.0 | 69.8 |\n", + "| 21.5 | 70.7 |\n", + "| 22.0 | 71.6 |\n", + "| 22.5 | 72.5 |\n", + "| 23.0 | 73.4 |\n", + "| 23.5 | 74.3 |\n", + "| 24.0 | 75.2 |\n", + "| 24.5 | 76.1 |\n", + "| 25.0 | 77.0 |\n", + "| 25.5 | 77.9 |\n", + "| 26.0 | 78.8 |\n", + "| 26.5 | 79.7 |\n", + "| 27.0 | 80.6 |\n", + "| 27.5 | 81.5 |\n", + "| 28.0 | 82.4 |\n", + "| 28.5 | 83.3 |\n", + "| 29.0 | 84.2 |\n", + "| 29.5 | 85.1 |\n", + "| 30.0 | 86.0 |\n", + "| 30.5 | 86.9 |\n", + "| 31.0 | 87.8 |\n", + "| 31.5 | 88.7 |\n", + "| 32.0 | 89.6 |\n", + "| 32.5 | 90.5 |\n", + "| 33.0 | 91.4 |\n", + "| 33.5 | 92.3 |\n", + "| 34.0 | 93.2 |\n", + "| 34.5 | 94.1 |\n", + "| 35.0 | 95.0 |\n", + "| 35.5 | 95.9 |\n", + "| 36.0 | 96.8 |\n", + "| 36.5 | 97.7 |\n", + "| 37.0 | 98.6 |\n", + "| 37.5 | 99.5 |\n", + "| 38.0 | 100.4 |\n", + "| 38.5 | 101.3 |\n", + "| 39.0 | 102.2 |\n", + "| 39.5 | 103.1 |\n", + "| 40.0 | 104.0 |\n", + "| 40.5 | 104.9 |\n", + "| 41.0 | 105.8 |\n", + "| 41.5 | 106.7 |\n", + "| 42.0 | 107.6 |\n", + "| 42.5 | 108.5 |\n", + "| 43.0 | 109.4 |\n", + "| 43.5 | 110.3 |\n", + "| 44.0 | 111.2 |\n", + "| 44.5 | 112.1 |\n", + "| 45.0 | 113.0 |\n", + "| 45.5 | 113.9 |\n", + "| 46.0 | 114.8 |\n", + "| 46.5 | 115.7 |\n", + "| 47.0 | 116.6 |\n", + "| 47.5 | 117.5 |\n", + "| 48.0 | 118.4 |\n", + "| 48.5 | 119.3 |\n", + "| 49.0 | 120.2 |\n", + "| 49.5 | 121.1 |\n", + "| 50.0 | 122.0 |\n", + "| 50.5 | 122.9 |\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "for i in np.arange(0,51,0.5):\n", + " \n", + " print(f'|{i:^8}|{i*9/5+32:^8}|')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "| 0.0 | 32.0 |\n", + "| 0.5 | 32.9 |\n", + "| 1.0 | 33.8 |\n", + "| 1.5 | 34.7 |\n", + "| 2.0 | 35.6 |\n", + "| 2.5 | 36.5 |\n", + "| 3.0 | 37.4 |\n", + "| 3.5 | 38.3 |\n", + "| 4.0 | 39.2 |\n", + "| 4.5 | 40.1 |\n", + "| 5.0 | 41.0 |\n", + "| 5.5 | 41.9 |\n", + "| 6.0 | 42.8 |\n", + "| 6.5 | 43.7 |\n", + "| 7.0 | 44.6 |\n", + "| 7.5 | 45.5 |\n", + "| 8.0 | 46.4 |\n", + "| 8.5 | 47.3 |\n", + "| 9.0 | 48.2 |\n", + "| 9.5 | 49.1 |\n", + "| 10.0 | 50.0 |\n", + "| 10.5 | 50.9 |\n", + "| 11.0 | 51.8 |\n", + "| 11.5 | 52.7 |\n", + "| 12.0 | 53.6 |\n", + "| 12.5 | 54.5 |\n", + "| 13.0 | 55.4 |\n", + "| 13.5 | 56.3 |\n", + "| 14.0 | 57.2 |\n", + "| 14.5 | 58.1 |\n", + "| 15.0 | 59.0 |\n", + "| 15.5 | 59.9 |\n", + "| 16.0 | 60.8 |\n", + "| 16.5 | 61.7 |\n", + "| 17.0 | 62.6 |\n", + "| 17.5 | 63.5 |\n", + "| 18.0 | 64.4 |\n", + "| 18.5 | 65.3 |\n", + "| 19.0 | 66.2 |\n", + "| 19.5 | 67.1 |\n", + "| 20.0 | 68.0 |\n", + "| 20.5 | 68.9 |\n", + "| 21.0 | 69.8 |\n", + "| 21.5 | 70.7 |\n", + "| 22.0 | 71.6 |\n", + "| 22.5 | 72.5 |\n", + "| 23.0 | 73.4 |\n", + "| 23.5 | 74.3 |\n", + "| 24.0 | 75.2 |\n", + "| 24.5 | 76.1 |\n", + "| 25.0 | 77.0 |\n", + "| 25.5 | 77.9 |\n", + "| 26.0 | 78.8 |\n", + "| 26.5 | 79.7 |\n", + "| 27.0 | 80.6 |\n", + "| 27.5 | 81.5 |\n", + "| 28.0 | 82.4 |\n", + "| 28.5 | 83.3 |\n", + "| 29.0 | 84.2 |\n", + "| 29.5 | 85.1 |\n", + "| 30.0 | 86.0 |\n", + "| 30.5 | 86.9 |\n", + "| 31.0 | 87.8 |\n", + "| 31.5 | 88.7 |\n", + "| 32.0 | 89.6 |\n", + "| 32.5 | 90.5 |\n", + "| 33.0 | 91.4 |\n", + "| 33.5 | 92.3 |\n", + "| 34.0 | 93.2 |\n", + "| 34.5 | 94.1 |\n", + "| 35.0 | 95.0 |\n", + "| 35.5 | 95.9 |\n", + "| 36.0 | 96.8 |\n", + "| 36.5 | 97.7 |\n", + "| 37.0 | 98.6 |\n", + "| 37.5 | 99.5 |\n", + "| 38.0 | 100.4 |\n", + "| 38.5 | 101.3 |\n", + "| 39.0 | 102.2 |\n", + "| 39.5 | 103.1 |\n", + "| 40.0 | 104.0 |\n", + "| 40.5 | 104.9 |\n", + "| 41.0 | 105.8 |\n", + "| 41.5 | 106.7 |\n", + "| 42.0 | 107.6 |\n", + "| 42.5 | 108.5 |\n", + "| 43.0 | 109.4 |\n", + "| 43.5 | 110.3 |\n", + "| 44.0 | 111.2 |\n", + "| 44.5 | 112.1 |\n", + "| 45.0 | 113.0 |\n", + "| 45.5 | 113.9 |\n", + "| 46.0 | 114.8 |\n", + "| 46.5 | 115.7 |\n", + "| 47.0 | 116.6 |\n", + "| 47.5 | 117.5 |\n", + "| 48.0 | 118.4 |\n", + "| 48.5 | 119.3 |\n", + "| 49.0 | 120.2 |\n", + "| 49.5 | 121.1 |\n", + "| 50.0 | 122.0 |\n" + ] + } + ], + "source": [ + "for i in range(0,501,5):\n", + " print(f'|{i/10:^8}|{i*9/50+32:^8}|')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/LaTeX/LAB-5-2022.ipynb b/LaTeX/LAB-5-2022.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..863a2c7fa85a3d6e529b5e0ba0d220923f644a19 --- /dev/null +++ b/LaTeX/LAB-5-2022.ipynb @@ -0,0 +1,883 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib widget\n", + "# jeśli wykresy nie będą działać - usuń (zakomentuj) powyższą linijkę i zrestartuj kernel notebooka\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "Użyj odpowiednich funkcji pakietu NumPy aby zdefiniować \n", + "- macierz 3x3 o zadanych wartościach (dowolnych)\n", + "- macierz jednostkową o wymiarze 3x3\n", + "\n", + "1. Oblicz \"ręcznie\" wyznaczniki wygenerowanych macierzy\n", + "2. Porównaj uzyskane wyniki z funkcją ```np.linalg.det```\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 1 3]\n", + " [4 5 6]\n", + " [7 8 9]]\n", + " \n", + "[[1 0 0]\n", + " [0 1 0]\n", + " [0 0 1]]\n", + "-6\n", + "-6.000000000000003\n" + ] + } + ], + "source": [ + "A = np.matrix(\n", + " [\n", + " [ 1,1,3 ],\n", + " [ 4,5,6 ],\n", + " [ 7,8,9 ]\n", + " ]\n", + ")\n", + "\n", + "B = np.matrix(\n", + " [\n", + " [ 1,0,0],\n", + " [ 0,1,0],\n", + " [ 0,0,1]\n", + " ]\n", + ")\n", + "\n", + "print (A)\n", + "print(\" \")\n", + "print (B)\n", + "\n", + "\n", + "\n", + "det_A=A[0,0]*A[1,1]*A[2,2]+A[0,1]*A[1,2]*A[2,0]+A[0,2]*A[1,0]*A[2,1]-A[2,0]*A[1,1]*A[0,2]-A[2,1]*A[1,2]*A[0,0]-A[2,2]*A[1,0]*A[0,1]\n", + "\n", + "print(det_A)\n", + "\n", + "\n", + "det_A2=np.linalg.det(A)\n", + "\n", + "print(det_A2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "Dany jest układ równań o postaci\n", + "\n", + "$$\n", + "\\left\\{ \\begin{array}{ll}\n", + "2x - y = -1\\\\\n", + "3x +y =16\n", + "\\end{array} \\right.\n", + "$$\n", + "\n", + " \n", + "Rozwiąż ten układ równań metodą wyznaczników." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "det wW wynosi 5.000000000000001\n", + "det wWx wynosi 15.0\n", + "det wWy wynosi 35.00000000000001\n", + " \n", + "x wynosi 2.9999999999999996\n", + "y wynosi 7.0\n" + ] + } + ], + "source": [ + "W = np.matrix(\n", + " [\n", + " [2,-1],\n", + " [3,1]\n", + " ]\n", + ")\n", + "Wx = np.matrix(\n", + " [\n", + " [-1,-1],\n", + " [16,1]\n", + " ]\n", + ")\n", + "Wy = np.matrix(\n", + " [\n", + " [2,-1],\n", + " [3,16]\n", + " ]\n", + ")\n", + "\n", + "\n", + "# policzyć wyznaczniki np. za pomocą funkcji np.linalg.det\n", + "wW = np.linalg.det(W)\n", + "wWx = np.linalg.det(Wx)\n", + "wWy = np.linalg.det(Wy)\n", + "\n", + "print('det wW wynosi',wW)\n", + "print('det wWx wynosi',wWx)\n", + "print('det wWy wynosi',wWy)\n", + "print(\" \")\n", + "\n", + "# sprawdzić przypadki szczególne\n", + "\n", + "# podać rozwiązanie\n", + "\n", + "if(wW == 0):\n", + " print('Wyznacznik glowny wynosi 0. Nie mozna wyznaczyc x i y')\n", + " \n", + "else:\n", + " x=wWx/wW\n", + " y=wWy/wW\n", + " print('x wynosi',x)\n", + " print('y wynosi',y)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Powyższy układ równań możemy zapisać \"macierzowo\" (zamiast x i y użyłem zapisu x_1 i x_2)\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + "a_{11} & a_{12} \\\\\n", + "a_{21} & a_{22}\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "x_1\\\\\n", + "x_2\n", + "\\end{bmatrix}\n", + "=\n", + "\\begin{bmatrix}\n", + "c_1 \\\\\n", + "c_2\n", + "\\end{bmatrix}\n", + "$$\n", + "To samo możemy zapisać jako\n", + "$$\n", + "AX=C\n", + "$$\n", + "\n", + "Gdybyśmy znali macierz odwrotną do A, to moglibyśmy obie strony tego równania przemnożyć lewostronnie:\n", + "$$\n", + "A^{-1}AX=A^{-1}C\n", + "$$\n", + "co dałoby nam\n", + "$$\n", + "IX=A^{-1}C\n", + "$$\n", + "czyli\n", + "$$\n", + "X=A^{-1}C\n", + "$$\n", + "\n", + "Wykorzystajcie to, że w NumPy można podnieść macierz do dowolnej potęgi i spróbujcie w ten sposób rozwiązać powyższy uład równań" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3.]\n", + " [7.]]\n", + " \n", + "[[ 1. -0.]\n", + " [-0. 1.]]\n" + ] + } + ], + "source": [ + "# wprowadź współczynniki macierzy A\n", + "A = np.matrix(\n", + " [\n", + " [2,-1],\n", + " [3,1]\n", + " ]\n", + ")\n", + "\n", + "# oblicz AA jako odwrotność A\n", + "AA = np.linalg.inv(A)\n", + "\n", + "# wprowadź współczynniki macierzy C\n", + "C = np.matrix(\n", + " [\n", + " [-1],\n", + " [16]\n", + " ]\n", + ")\n", + "\n", + "# Oblicz iloczyn odwrotności macierzy A i C\n", + "X = AA*C\n", + "print(X)\n", + "\n", + "print(\" \")\n", + "\n", + "# sprawdź , czy AA*A daje macierz jednostkową\n", + "I = AA*A\n", + "\n", + "print(I.round(2))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Porównaj uzyskane rezultaty z wynikiem działania funkcji ```np.linalg.solve```\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[3.]\n", + " [7.]]\n" + ] + } + ], + "source": [ + "print(np.linalg.solve(A,C))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "Proste wykresy funkcji możemy sobie stworzyć korzystając z następującej metody\n", + "\n", + "1. definiujemy wektor przechowujący kolejne wartości na osi OX, np. 100 wartości z zakresu 4...10\n", + "\n", + "x = np.linspace(4, 10, 100)\n", + "\n", + "2. obliczamy wartości funkcji w tych punktach\n", + "\n", + "y = 2*x+2\n", + "\n", + "3. rysujemy wykres\n", + "\n", + "plt.plot(x, y)\n", + "\n", + "\n", + "Narysuj graficzne rozwiązanie powyższego układu równań\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "307d90c69cd94604ad4664b7bfe86c16", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# przekształćmy równanie do postaci \"funkcyjnej\"\n", + "x = np.linspace(2,6,100)\n", + "y = 2*x+1\n", + "plt.plot(x,y)\n", + "\n", + "y = -3*x+16\n", + "plt.plot(x,y)\n", + "# y = \n", + "# y = \n", + "\n", + "# nasze rozwiązanie jest w okolicach punktu (3,7)\n", + "# x = np.linspace(....)\n", + "\n", + "# wykres 1\n", + "# plt.plot(...)\n", + "# wykres 2\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "Przetestuj działanie funkcji ```np.hstack``` i ```np.vstack``` aby \"skleić\" ze sobą dwie wygenerowane na początku zajęć macierze" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 1 3 1 0 0]\n", + " [4 5 6 0 1 0]\n", + " [7 8 9 0 0 1]]\n", + " \n", + "[[1 1 3]\n", + " [4 5 6]\n", + " [7 8 9]\n", + " [1 0 0]\n", + " [0 1 0]\n", + " [0 0 1]]\n" + ] + } + ], + "source": [ + "A = np.matrix(\n", + " [\n", + " [ 1,1,3 ],\n", + " [ 4,5,6 ],\n", + " [ 7,8,9 ]\n", + " ]\n", + ")\n", + "\n", + "B = np.matrix(\n", + " [\n", + " [ 1,0,0],\n", + " [ 0,1,0],\n", + " [ 0,0,1]\n", + " ]\n", + ")\n", + "\n", + "\n", + "\n", + "x = np.hstack([A,B])\n", + "\n", + "y = np.vstack([A,B])\n", + "\n", + "print(x)\n", + "print(' ')\n", + "print(y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "Jedną z metod wyznaczania macierzy odwrotnej jest metoda eliminacji Gaussa-Jordana. Polega ona na tym, że do naszej macierzy A \"doklejamy\" macierz jednostkową I\n", + "\n", + "[ A | I ]\n", + "\n", + "Teraz, stosując dozwolone operacje \n", + "- mnożenie wiersza przez stałą <> 0\n", + "- dodawanie do wiersza innego wiersza (przemnożonego przez stałą <> 0)\n", + "- zamianę wierszy miejscami\n", + "\n", + "dążymy do tego, aby uzyskać macierz postaci [ I | B ]\n", + "\n", + "Jeśli nam się to uda, to B będzie macierzą odwrotną do A.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[5 6]\n", + " [4 5]]\n" + ] + } + ], + "source": [ + "# przykład:\n", + "\n", + "A = np.matrix(\n", + " [\n", + " [ 5, 6 ],\n", + " [ 4, 5 ]\n", + " ]\n", + ")\n", + "print (A)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1. 0.]\n", + " [0. 1.]]\n" + ] + } + ], + "source": [ + "I = np.eye(2)\n", + "print (I)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[5. 6. 1. 0.]\n", + " [4. 5. 0. 1.]]\n" + ] + } + ], + "source": [ + "M = np.hstack([A, I])\n", + "print (M)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 5. 6. 1. 0. ]\n", + " [ 0. 0.2 -0.8 1. ]]\n" + ] + } + ], + "source": [ + "# odejmijmy od drugiego wiersza wiersz pierwszy przemnożony przez 4/5\n", + "M[1,:] -= 4/5*M[0,:]\n", + "print (M)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 5. 0. 25. -30. ]\n", + " [ 0. 0.2 -0.8 1. ]]\n" + ] + } + ], + "source": [ + "# od pierwszego wiersza odejmijmy wiersz drugi przemnożony przez 30\n", + "M[0,:] -= 30*M[1,:]\n", + "print (M.round(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1.00000000e+00 4.26325641e-15 5.00000000e+00 -6.00000000e+00]\n", + " [ 0.00000000e+00 1.00000000e+00 -4.00000000e+00 5.00000000e+00]]\n" + ] + } + ], + "source": [ + "# podzielmy pierwszy wiersz przez 5 i drugi przez 0.2\n", + "M[0,:] /= 5\n", + "M[1,:] /= 0.2\n", + "\n", + "print (M)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1.00000000e+00 4.26325641e-15 5.00000000e+00 -6.00000000e+00]\n", + " [ 0.00000000e+00 1.00000000e+00 -4.00000000e+00 5.00000000e+00]]\n" + ] + } + ], + "source": [ + "# czy to co jest po lewej stronie jest wystarczająco bliskie macierzy jednostkowej ?\n", + "\n", + "print (M)\n", + "#print (M.round(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# wyciągnijmy \"prawą\" stronę\n", + "B = M[:, 2:]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 5. -6.]\n", + " [-4. 5.]]\n", + "[[ 5. -6.]\n", + " [-4. 5.]]\n" + ] + } + ], + "source": [ + "# czy B == A^{-1} ?\n", + "\n", + "print (B)\n", + "print (A**-1)\n", + "\n", + "# Czy A*A^{-1} == I ?\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Stosując powyższą metodę - wyznacz macierz odwrotną do macierzy\n", + "\n", + "$$\n", + "\\begin{bmatrix}\n", + "1 & 2 & 3 \\\\\n", + "0 & 1 & 4 \\\\\n", + "5 & 6 & 0\n", + "\\end{bmatrix}\n", + "$$\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2 3]\n", + " [0 1 4]\n", + " [5 6 0]]\n" + ] + } + ], + "source": [ + "A = np.matrix(\n", + " [\n", + " [1,2,3],\n", + " [0,1,4],\n", + " [5,6,0]\n", + " ]\n", + ")\n", + "print (A)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1. 0. 0.]\n", + " [0. 1. 0.]\n", + " [0. 0. 1.]]\n" + ] + } + ], + "source": [ + "I = np.eye(3)\n", + "print(I)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1. 2. 3. 1. 0. 0.]\n", + " [0. 1. 4. 0. 1. 0.]\n", + " [5. 6. 0. 0. 0. 1.]]\n" + ] + } + ], + "source": [ + "M = np.hstack([A,I])\n", + "print(M)" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1. 2. 3. 1. 0. 0.]\n", + " [ 0. 1. 4. 0. 1. 0.]\n", + " [ 0. -4. -15. -5. 0. 1.]]\n" + ] + } + ], + "source": [ + "M[2,:] = M[2,:] - 5*M[0,:]\n", + "print(M)" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1. 2. 3. 1. 0. 0.]\n", + " [ 0. 1. 4. 0. 1. 0.]\n", + " [ 0. 0. 1. -5. 4. 1.]]\n" + ] + } + ], + "source": [ + "M[2,:] = M[2,:] + 4*M[1,:]\n", + "print(M)" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1. 2. 0. 16. -12. -3.]\n", + " [ 0. 1. 0. 20. -15. -4.]\n", + " [ 0. 0. 1. -5. 4. 1.]]\n" + ] + } + ], + "source": [ + "M[1,:] = M[1,:] - 4*M[2,:]\n", + "M[0,:] = M[0,:] - 3*M[2,:]\n", + "print(M)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1. 0. 0. -24. 18. 5.]\n", + " [ 0. 1. 0. 20. -15. -4.]\n", + " [ 0. 0. 1. -5. 4. 1.]]\n" + ] + } + ], + "source": [ + "M[0,:] = M[0,:] - 2*M[1,:]\n", + "print(M)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 1. 0. 0. -24. 18. 5.]\n", + " [ 0. 1. 0. 20. -15. -4.]\n", + " [ 0. 0. 1. -5. 4. 1.]]\n", + "[[-24. 18. 5.]\n", + " [ 20. -15. -4.]\n", + " [ -5. 4. 1.]]\n" + ] + } + ], + "source": [ + "print(M)\n", + "print(A**-1)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.1" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/LaTeX/Lab_1.ipynb b/LaTeX/Lab_1.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..ce74e07554e44b88021dd9e6f08db6ca25dbaff6 --- /dev/null +++ b/LaTeX/Lab_1.ipynb @@ -0,0 +1,308 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8c30fb3f-1ccb-4ecb-b7f3-87bd80e80a91", + "metadata": {}, + "source": [ + "# Technologie informacyjne - LAB\n", + "\n", + " prowadzący: Monika Wasilewska\n", + " Politechnika Wrocławska, Katedra Akustyki, Multimediów i Przetwarzania Sygnałów\n", + " \n", + "\n", + "Run a cell via `Shift + Return`. Learn more about [CoCalc Jupyter Notebooks](https://doc.cocalc.com/jupyter.html)." + ] + }, + { + "cell_type": "markdown", + "id": "dee25ce5-a785-42f4-be6d-9c7e526b3063", + "metadata": {}, + "source": [ + "## Zajęcia 1\n", + "\n", + "1. Zasady BHP\n", + "2. Czym będziemy zajmować się na przedmiocie\n", + "3. Warunki zaliczenia\n", + "4. Pierwsze kroki z Jupyter Notebooks\n", + "\n", + "Co przygotować w domu na następne zajęcia?\n", + "\n", + "1. Dokończyć Notebooka i mieć opanowane zadania z zajęć.\n", + "\n", + "___" + ] + }, + { + "cell_type": "markdown", + "id": "bf29bc4a-379e-4ef1-8d2b-2bd957313e92", + "metadata": {}, + "source": [ + "## Dodawnia komórek w Notebooku" + ] + }, + { + "cell_type": "markdown", + "id": "00db317d-4d22-4bc5-82b5-ca592c3c820a", + "metadata": {}, + "source": [ + "Na zajęciach będziemy korzystali z wielu narzędzi, a jednym z nich będzie `Jupyter Notebooks`. Nasze Notebooki pozwalają gromadzić w jednym miejscu notatki oraz kod pisany w jednym z języków programowania. Wobec tego mamy możliwość dodawania kolejnych komórek w których wpisywać będziemy dane. Aby zaznaczyć komórkę poniżej której chcemy dodać nowe miejsce na dane klikamy na nią myszką. Jeśli komórka jest \"aktualnie zaznaczona\" pojawi się obok niej kolorowa pionowa linia tak jak na obrazku poniżej. \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "6084207e-d24b-4470-b437-53db8819bbc6", + "metadata": {}, + "source": [ + "![alt text](aktywna_kom.jpg \"aktywna_komorka\")" + ] + }, + { + "cell_type": "markdown", + "id": "e46a8278-12f1-4acb-9adf-9e25ac765e1f", + "metadata": {}, + "source": [ + "Aby **stworzyć nową komórkę poniżej aktualnie aktywnej wybieramy ikonę `+`** z paska u góry naszego dokumentu.\n", + "\n", + "![alt text](dodawanie_kom.png \"dodawnie_komorki\")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "acbf1461-e0e8-44ae-9ac6-485a72594f95", + "metadata": {}, + "source": [ + "## Formatowanie tekstu" + ] + }, + { + "cell_type": "markdown", + "id": "707a5513-d57e-48aa-a058-fe8dcac831cf", + "metadata": {}, + "source": [ + "Aby w **komórce wpisywać odpowiedzi na pytania (ogólniej mówiąc notatki) zmieniamy typ pola na `Markdown`**. Ten typ pozwoli nam na formatowanie tekstu - np. dodanie pogrubienia, kursywy czy stworzenia listy punktów.\n", + "\n", + "![alt text](zmiana_typu.png \"zmiana_typu_komorki\")" + ] + }, + { + "cell_type": "markdown", + "id": "ac5eb7aa-4a6b-4208-9583-646685b4a21b", + "metadata": {}, + "source": [ + "### Zadanie 1\n", + "\n", + "Stwórz komórkę poniżej tej w której jest treść aktualnego zadania. Zmień jej typ na `Markdown` i wpisz formułę:\n", + "\n", + "`Mam na imię *Twoje Imię*, a mój **twój numer indeksu** to: ```numer indesku``` `\n", + "\n", + "Po wpisaniu formły wciśnij jednocześnie `shift` oraz `enter`, aby uruchomich komórkę.\n" + ] + }, + { + "cell_type": "markdown", + "id": "3b18ac49-d1f0-4bea-badf-0ae43fc32d17", + "metadata": { + "tags": [] + }, + "source": [ + "### Zadanie 2\n", + "\n", + "*Komórkę na odpowiedzi dodaj klikając na wyskości zadania 2 na pole pomiędzy kolorową linią a początkiem komórki (tak jak na rysunku 1.). Następnie naciśnij literę **B** z klawiatury.*\n", + "\n", + "1. Co się stanie jeśli tekst umieścimy pomiędzy znakami `*`?\n", + "2. Jaki wynik uzyskamy stosując dwa takie symbole (`**`) na początku i końcu wyrażenia?\n", + "3. Co spowoduje umieszczenie tekstu pomiędzy znakami ` ``` ` ?" + ] + }, + { + "cell_type": "markdown", + "id": "0a946c0e-80ed-4d28-883f-d6f21a342f0f", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "843bb0e1-7d4c-4b26-a9a9-f667c99ec096", + "metadata": {}, + "source": [ + "## Nagłówki w Markdown\n", + "Aby utworzyć nagłówek w `Markdown`, poprzedź go znakiem krzyżyka (#). Umieszczasz taką samą liczbę krzyżyków, jak rozmiar nagłówka, który chcesz wykorzystać. Na przykład dla nagłówka najwyższego poziomu użyjesz jednego znaku krzyża - `# Pierwszy poziom nagłówków`, analogicznie dla nagłówka trzeciego poziomu należy użyć trzech znaków - `### Wybrane aspekty niektórych zagadnień`.\n" + ] + }, + { + "cell_type": "markdown", + "id": "ee4c8d99-9174-465d-babb-d82315a9fbfc", + "metadata": {}, + "source": [ + "### Zadanie 3 \n", + "Stwórz nową komórkę na odpowiedź, poniżej tej w której znajduje się treść aktualnego zadania. Stwórz pięć poziomów nagłówków (każdy z nich musi być zatytułowany). Uruchom komórkę, aby zobaczyć efekt naszej pracy." + ] + }, + { + "cell_type": "markdown", + "id": "f917e6ae-64bd-4d07-b6f2-57d5f4c84ed1", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "1c2cd454-31fc-4be3-ac62-ecee527541b9", + "metadata": {}, + "source": [ + "## Edytowanie istniejących komórek \n", + "\n", + "Jak pewnie część z Was się przekonała, aby wejść do trybu edycji komórki typu `Markdown` należy dwukrotnie kliknąć na nią myszką. Aby uruchomić komórkę i przejść do kolejnej należy wcisnąć jednocześnie `shift` oraz `enter`. " + ] + }, + { + "cell_type": "markdown", + "id": "79702db9-77b2-4482-b3ef-765863767bea", + "metadata": {}, + "source": [ + "### Zadanie 4\n", + "\n", + "W komórce poniżej zmień zdanie aby było poprawne, a następnie uruchom komórkę i przedź dalej." + ] + }, + { + "cell_type": "markdown", + "id": "35782088-fa9a-4bed-9d1f-7b066c07d5aa", + "metadata": {}, + "source": [ + "**Każda zmiana energii kinetycznej ciała Ek jest równoważona przez zmianę energii potencjalnej Ep, tak że ich suma pozostaje przez cały czas zmienna**" + ] + }, + { + "cell_type": "markdown", + "id": "4448a29b-c18a-41b2-b36d-636396794fab", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "id": "6cac26cc-988c-4e50-bd0f-45d7fe3c671f", + "metadata": {}, + "source": [ + "## Dołączanie linków (hiperłącza)\n", + "Aby utworzyć łącze należy umieścić tekst, który będzie wyświetlany w nawiasach kwadratowych `[tutaj umieszaczmy tekst, który będzie wyświetalny]`, a samo łącze umieścić w nawiasach okrągłych (`tutaj wpisujemy adres łącza`)" + ] + }, + { + "cell_type": "markdown", + "id": "7a87516a-0a99-4386-b2c9-9c6994515bfa", + "metadata": {}, + "source": [ + "### Zadanie 5\n", + "W przygotowanej komórce poniżej stwórz hiperłącze do eportalu Pwr. Tekst, który ma się wyświetlać niech brzmi \"To strona na którą będę się logować na każdych zajęciach\", a adres strony to: https://eportal.pwr.edu.pl/ " + ] + }, + { + "cell_type": "markdown", + "id": "e87c3048-0885-4ef4-a988-fe83dc29a3aa", + "metadata": {}, + "source": [ + "tutaj jest miejsce na odpowiedź\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "58e0a968-c297-4112-baa5-21aff147b40e", + "metadata": {}, + "source": [ + "## Nie tylko Markdown, ale też kod!\n", + "\n", + "Tak jak zostało wspomniane wcześniej istnieją komórki o różnym przeznaczeniu. Oprócz tych które służą do zapisu notatek są również takie (a raczej przede wszystkim takie), które pozwalają nam na programowanie. Wybierając typ komórki jako `Code` możemy uruchomić fragment napisanego przez nas kodu. Na naszych zajęciach korzystać będziemy z języka Python. Kolejne zadania mają na celu pokazanie możliwości wykonywania obliczeń - samym programowaniem w tym języku będziemy zajmować się na niejednych zająciach w tym semestrze." + ] + }, + { + "cell_type": "markdown", + "id": "e8ff14f9-01a1-4150-a1ca-0294f68f3b73", + "metadata": {}, + "source": [ + "### Zadanie 6\n", + "\n", + "Stwórz poniżej dwie komórki - pierwsza niech będzie typu `Markdown`, druga `Code`. W obu wpisz to samo wyrażenie: $$3+4*5$$ i uruchom każdą z nich. Porównaj otrzymane wyjścia." + ] + }, + { + "cell_type": "markdown", + "id": "2f8f6bfb-73f4-4fa1-bec0-505bd738d494", + "metadata": {}, + "source": [ + "### Zadanie 7\n", + "\n", + "Jak zauważyliście w przypadku komórki `Markdown` wyświetlił się napis, natomiast w przypadku komórki `Code` został zwrócony wynik zapisanego wyrażenia. Oznacza to, że nasz kod został zinterpretowany i uruchomiony, a w rezultacie zobaczyliśmy wynik.\n", + "\n", + "Przejdźmy w takim razie poziom wyżej i stwórzmy prosty kalkulator! **Przypisz wartości zmiennym w poniższej komórce, a następnie użyj tych zmiennych aby obliczyć ich sumę, różnicę, iloczyn oraz iloraz.** Komórka jest już wstępnie przygotowana, uzepłnij tylko brakujące dane. Nie zmieniaj formatowania!!" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a3336d23-21c6-4cc3-9eae-f1709d6bc62b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Suma to 3, roznica to -1, iloczyn wynosi 2, iloraz jest rowny 0.5.\n" + ] + } + ], + "source": [ + "a = \n", + "b = \n", + "\n", + "suma = a+b\n", + "roznica = \n", + "iloczyn = \n", + "iloraz = \n", + "\n", + "\n", + "print(\"Suma to {}, roznica to {}, iloczyn wynosi {}, iloraz jest rowny {}.\".format(suma, roznica, iloczyn, iloraz))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b2ef1f6-2546-41b7-843e-9637059e4d8c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}