diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..ca259a7 --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,23 @@ +name: Build +on: + push: + branches: + - master # or the name of your main branch +jobs: + build: + name: Build + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + with: + fetch-depth: 0 + - uses: sonarsource/sonarqube-scan-action@master + env: + SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} + SONAR_HOST_URL: ${{ secrets.SONAR_HOST_URL }} + # If you wish to fail your job when the Quality Gate is red, uncomment the + # following lines. This would typically be used to fail a deployment. + # - uses: sonarsource/sonarqube-quality-gate-action@master + # timeout-minutes: 5 + # env: + # SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} diff --git a/Wprowadzenie.ipynb b/Wprowadzenie.ipynb new file mode 100644 index 0000000..65c48e3 --- /dev/null +++ b/Wprowadzenie.ipynb @@ -0,0 +1,1142 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "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.4" + }, + "colab": { + "name": "Wprowadzenie.ipynb", + "provenance": [], + "include_colab_link": true + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0Zczl31kakIm", + "colab_type": "text" + }, + "source": [ + "# Python\n", + "\n", + "### Celem jest poznanie podstaw `Python`\n", + "\n", + "Python to język, który w tej chwili staje się numerem 1 w świecie uczenia maszynowego. \n", + "Python może nie jest językiem mega wydajnym, ale są na to pewne sposoby. \n", + "\n", + "Zaczynamy od wypisania `Hello, world!`. " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "YFfBRH_lakIp", + "colab_type": "code", + "colab": {}, + "outputId": "de2f2f8e-8fa3-4d2a-984d-d25cc08d1d64" + }, + "source": [ + "print('Hello, world!')" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Hello, world!\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4_9eV9wBakIv", + "colab_type": "text" + }, + "source": [ + "Jak widzisz, wygląda to dość prosto :). Idziemy dalej." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lv6g0FRWakIw", + "colab_type": "text" + }, + "source": [ + "## Zmienna (ang. *variable*)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7C41iZyZakIx", + "colab_type": "code", + "colab": {}, + "outputId": "68726d28-d105-442b-b99e-573b4cc196f2" + }, + "source": [ + "my_var = 1\n", + "print(my_var)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "1\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IVjjBrtNakI0", + "colab_type": "text" + }, + "source": [ + "\n", + "O stylu pisania kodu w Python, to warto zajrzeć do [PEP8](https://www.python.org/dev/peps/pep-0008/)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Usrx5ZHNakI1", + "colab_type": "text" + }, + "source": [ + "## Typy zmiennych\n", + "\n", + "Python posiada 5 podstawowych typów zmiennych.\n", + "- Numbers (int, long, float, complex)\n", + "- String\n", + "- List\n", + "- Tuple\n", + "- Dictionary\n", + "\n", + "Typ zmiennej można sprawdzić używając `type(my_var)`,\n", + "na przykład:\n", + "```\n", + "my_var = 1\n", + "print(type(my_var))\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "T5UfUOVdakI2", + "colab_type": "text" + }, + "source": [ + "### Numbers\n", + "Najczęściej używane to `int` (integer) dla liczb całkowitych (np. -100, -5, 0, 34 itd) oraz `float` dla [liczb zmiennoprzecinkowych](https://pl.wikipedia.org/wiki/Liczba_zmiennoprzecinkowa).\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0kXwIlxrakI3", + "colab_type": "code", + "colab": {} + }, + "source": [ + "my_int = 1\n", + "my_float = 0.2" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GEpwkTHAakJC", + "colab_type": "text" + }, + "source": [ + "Pierwszy element listy ma indeks zero (ostatni to liczba elementów minus 1). Spróbujmy dostać się do pierwszego elementu." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YWKiGROUakJG", + "colab_type": "text" + }, + "source": [ + "Funkcja `.append()` umożliwa dodanie nowego elementu do listy (nowo dodany element pojawia się na samym końcu listy)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "85j6B45KakJH", + "colab_type": "code", + "colab": {}, + "outputId": "bcff39d6-8201-4982-c812-c466fde929be" + }, + "source": [ + "my_list.append(15)\n", + "my_list" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5, 6, 7, 8, 9, 15]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 7 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IvPIPYe0akJK", + "colab_type": "text" + }, + "source": [ + "Stworzenie pustej listy:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mVob4QZCakJK", + "colab_type": "code", + "colab": {} + }, + "source": [ + "empty_list = []" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0bNXdvfiakJP", + "colab_type": "text" + }, + "source": [ + "### Tuple\n", + "Krotka przypomina listę, ale ma kilka istotnych różnic. Stwórzmy najpierw pustą krotkę (ang. *tuple*)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "X6OhsQI8akJQ", + "colab_type": "code", + "colab": {} + }, + "source": [ + "empty_tuple = ()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zp-2yHlkakJS", + "colab_type": "text" + }, + "source": [ + "Teraz krotka będzie zawierać trzy cyfry (1, 2 oraz 3)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ao5Sue4RakJT", + "colab_type": "code", + "colab": {} + }, + "source": [ + "tuple_digits = (1,2,3)" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lp6JvxX4akJW", + "colab_type": "text" + }, + "source": [ + "Pierwszy element" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zFmTadIgakJW", + "colab_type": "code", + "colab": {}, + "outputId": "36dbbcfd-f0aa-422b-bc15-e07fdd99dd51" + }, + "source": [ + "tuple_digits[0]" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "1" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 11 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pW3Yg9GoakJZ", + "colab_type": "text" + }, + "source": [ + "#### Immutable\n", + "*Natomiast* zwróć uwagę, że \"*tupla*\" jest niezmienna (ang. *immutable*) w odróżnieniu od listy. Jeśli spróbujesz nadpisać np. zerowy element, to zobaczysz wyjątek." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "v37zk4z0akJa", + "colab_type": "code", + "colab": {}, + "outputId": "7d8b6128-9e8a-432c-f5a8-f54b7857dd7c" + }, + "source": [ + "tuple_digits[0] = 1" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "'tuple' object does not support item assignment", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtuple_digits\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qAMSc6aPakJd", + "colab_type": "text" + }, + "source": [ + "#### Hash\n", + "W odróżnieniu od listy, w *tuple* można znaleźć *hash*, co umożliwia kilka ciekawych rzeczy. Dlaczego o tym mówię? Klucz w słowniku musi posiadać *hash*." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "RjbsohCLakJd", + "colab_type": "code", + "colab": {}, + "outputId": "7d091d25-6155-466d-9d0a-75e2f0e204da" + }, + "source": [ + "hash(tuple_digits)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "2528502973977326415" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 13 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "E0wKZi1_akJg", + "colab_type": "text" + }, + "source": [ + "Zobacz, lista nie ma hashu. Dlatego np. nie może być kluczem w słowniku." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6149zFMOakJg", + "colab_type": "code", + "colab": {}, + "outputId": "df372dde-1814-4556-b35a-cc7f78ad7530" + }, + "source": [ + "hash([1, 2, 3])" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "unhashable type: 'list'", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhash\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lj8POjjZakJj", + "colab_type": "text" + }, + "source": [ + "Zwróć uwagę, że kluczem jest krotka." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gLGB2Y9kakJk", + "colab_type": "code", + "colab": {}, + "outputId": "8601e33d-db14-4b35-c396-5001cd0f0297" + }, + "source": [ + "my_dict = {\n", + " ('a', 1): [1, 2, 3],\n", + " ('b', 2): [4, 5, 6],\n", + "}\n", + "\n", + "my_dict[ ('a', 1) ]" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[1, 2, 3]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 15 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "12SamrquakJm", + "colab_type": "text" + }, + "source": [ + "#### unpack tupple\n", + "Możesz wyciągnąć poszczególne wartości z krotki do poszczególnych zmiennych. To jest dość często używane, kiedy funkcja zwraca więcej niż jeden wynik." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "FHMUTp59akJn", + "colab_type": "code", + "colab": {}, + "outputId": "344ba95b-1a2f-48be-f438-0458cc7a4cb0" + }, + "source": [ + "tuple_digits = (1,2,3)\n", + "one, two, three = tuple_digits\n", + "\n", + "two" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "2" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 16 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eSs2EIogakJp", + "colab_type": "text" + }, + "source": [ + "### String\n", + "Wszystkie teksty przechowujemy jako \"string\", czyli ciąg znaków. String technicznie rzecz biorąc, to lista (znaków). Zobacz:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "rQaxTqAUakJp", + "colab_type": "code", + "colab": {}, + "outputId": "f57bfd68-7444-49ef-d7c8-5c064ee4a764" + }, + "source": [ + "my_string = \"Hello world\"\n", + "my_string[0]" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'H'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 17 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VX4PYHtOakJr", + "colab_type": "text" + }, + "source": [ + "W ten sposób dostaliśmy się do pierwszej literki (czyli pierwszy element na liście).\n", + "\n", + "*Swoją drogą* podpowiem, jak można dostać się do ostatniego elementu w liście. Należy po prostu użyć indeks *-1*, dla przedostatniego należy użyć *-2*, itd." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "6vbGIFixakJs", + "colab_type": "code", + "colab": {}, + "outputId": "fdbe047d-34e2-4db2-fa46-343328fc6d8f" + }, + "source": [ + "my_string[-1]" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'d'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 18 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HxS97YmiakJu", + "colab_type": "text" + }, + "source": [ + "Jest jeszcze kilka innych przydatnych funkcji:\n", + "- `.lower()` - wszystkie literki będą małe (tzn. zamieniamy wielkie litery na małe)\n", + "- `.strip()` - usunięcie z przodu (tyłu) pustych znaków\n", + "- `.split(SEPARATOR)` - rozbicie stringa na listę elementów wg separatora\n", + "- `'SEPARATOR'.join(LISTA)` - funkcja odwrotna do split(), złączenie listy do stringa" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Innpzf0sakJu", + "colab_type": "code", + "colab": {}, + "outputId": "656fa8e7-a8e1-454d-b07b-a890e50df6cb" + }, + "source": [ + "\"HeLlO WoRlD\".lower()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'hello world'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 19 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "3u_fQJtOakJx", + "colab_type": "code", + "colab": {}, + "outputId": "9218f8a9-a7e3-4018-ac7e-4c89b2c1ad1f" + }, + "source": [ + "\" HeLlO WoRlD \".strip()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'HeLlO WoRlD'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 20 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "3-9NpZAIakJz", + "colab_type": "code", + "colab": {}, + "outputId": "c08a7291-7f54-4c17-d99c-797a68e38da9" + }, + "source": [ + "\"hello world\".split(\" \")" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['hello', 'world']" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 21 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "oggQDr3rakJ0", + "colab_type": "code", + "colab": {}, + "outputId": "0051c9a6-4146-4278-9669-3e3ce77d8824" + }, + "source": [ + "'; '.join(['hello', 'world'])" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'hello; world'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 22 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4gv5UUqDakJ2", + "colab_type": "text" + }, + "source": [ + "### Dictionary\n", + "Pojedynczy element słownika składa się z pary: klucz i wartość." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "mues1494akJ3", + "colab_type": "code", + "colab": {}, + "outputId": "078ddbea-12b7-47c7-9066-06206043984d" + }, + "source": [ + "capital_cities = {'Poland': 'Warsaw', 'Belarus': 'Minsk', 'Czech': 'Prague'}\n", + "capital_cities['Poland']" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Warsaw'" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0KQmzid5akJ5", + "colab_type": "text" + }, + "source": [ + "## If, else itd." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B0HMfuM1akJ6", + "colab_type": "text" + }, + "source": [ + "Kluczowe elementy w programowaniu to warunek i pętla, dzięki czemu wiele skomplikownaych rzeczy staje się możliwych. Poniżej jest przedstawiony kod z warunkiem `if` oraz `else`.\n", + "\n", + "W kodzie poniżej należy podać kraj, np. \"Poland\". Możesz również dodać więcej krajów do słownika `capital_cities` w komórce powyżej." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JvXy_XNKakKB", + "colab_type": "text" + }, + "source": [ + "## Pętla - for" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "MYbQvvAEakKC", + "colab_type": "code", + "colab": {}, + "outputId": "7c72f289-a397-46eb-dede-fdd9e4be5e0a" + }, + "source": [ + "output_list = []\n", + "\n", + "for x in [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]:\n", + " output_list.append(x) #append element to list\n", + " \n", + "output_list" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 27 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5uawA_LvakKE", + "colab_type": "text" + }, + "source": [ + "Ten sam kod można trochę uprościć, wystarczy zamienić wprost podaną listę na `range(10)`." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "oYt_sSqOakKF", + "colab_type": "code", + "colab": {}, + "outputId": "44abcac7-06bf-4963-e1d3-a96c6c5b88ba" + }, + "source": [ + "output_list = []\n", + "\n", + "for x in range(10):\n", + " output_list.append(x) #append element to list\n", + " \n", + "output_list" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 28 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bG8SNdM1akKH", + "colab_type": "text" + }, + "source": [ + "## Funkcja\n", + "Tworzenie własnej funkcji składa się z kilku kluczowych elementów:\n", + "1. zaczyna się od `def` (słowo kluczowe)\n", + "2. następnie podaje się nazwę funkcji (plus ewentualnie argumenty)\n", + "3. następnie po nazwie funkcji koniecznie trzeba dodać `:` \n", + "4. potem jest ciało funkcji (w Pythonie ważne są odstępy o tej samej długości)\n", + "5. na końcu jest słowo kluczowe `return` - to jest wynik, który zwraca funkcja\n", + "\n", + "Przykład:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "MDenfsJeakKI", + "colab_type": "code", + "colab": {} + }, + "source": [ + "def doubled_fun(value):\n", + " return value * 2" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kxn-wSFfakKK", + "colab_type": "text" + }, + "source": [ + "Wywołanie funkcji." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0gDVm9BHakKK", + "colab_type": "code", + "colab": {}, + "outputId": "1d8fd299-3deb-4132-e495-aad74eb6d06e" + }, + "source": [ + "doubled_fun(12)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "24" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 30 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mJz97WPXakKM", + "colab_type": "text" + }, + "source": [ + "### unpack tupple\n", + "*Zwróć uwagę*, że funkcja może zwrócić krotkę (ang. *tuple*) i wynik można przypisać do poszczególnych zmiennych. Ważne jest, aby liczba elementów w tuple oraz liczba zmiennych zgadzała się. Ten mechanizm jest bardzo wygodny, więc warto o nim wiedzieć." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Rx3ZqihGakKM", + "colab_type": "code", + "colab": {}, + "outputId": "daeab9c4-9b96-4bf2-f66e-4677281613a6" + }, + "source": [ + "def my_fun_with_tuple():\n", + " return 1, 2, 3\n", + "\n", + "a,b,c = my_fun_with_tuple()\n", + "\"a:\", a, \"b:\", \"c:\", c" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('a:', 1, 'b:', 'c:', 3)" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 31 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Phs_KHGJakKO", + "colab_type": "text" + }, + "source": [ + "### Funkcja anonimowa (lambda)\n", + "Są funkcje, które nie mają nazw - czyli funkcje anonimowe.\n", + "\n", + "Tą samą funkcjonalność (funkcji `doubled_fun`) można zapisać przy pomocy *lambdy*" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "T4rNkr9oakKP", + "colab_type": "code", + "colab": {}, + "outputId": "4cc5e9dc-19c2-41f6-d274-239d53472090" + }, + "source": [ + "(lambda value: value * 2)(12)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "24" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 33 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "j2SK_vlRakKR", + "colab_type": "text" + }, + "source": [ + "## Manipulacja listą\n", + "\n", + "Załóżmy, że naszem celem jest dodanie do listy podwojonych wartości cyfr od 0 do 9. Oczekiwany wynik to: `[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]`. Innymi słowy, chcemy każdą wartość przemnożyć razy dwa. Wykorzystajmy całą wiedzę, którą zdobyliśmy dotychczas." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "bWTofxh9akKS", + "colab_type": "code", + "colab": {}, + "outputId": "d3e98d18-d06a-45d9-fee2-385127e72a02" + }, + "source": [ + "def doubled_fun(value):\n", + " return value * 2\n", + "\n", + "output_list = []\n", + "for x in range(10):\n", + " output_list.append( doubled_fun(x) )\n", + " \n", + "output_list" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 34 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mj7vqaUDakKV", + "colab_type": "text" + }, + "source": [ + "### Mapping\n", + "Można to zrobić inaczej, wykorzystując funkcje `map`, która przechodzi przez wszystkie elementy listy i przekazuje ich wartość do funkcji, która może je zmienić.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "1lz2bR1dakKW", + "colab_type": "code", + "colab": {}, + "outputId": "e1102fc5-d36c-4397-f544-d5b8deb443a6" + }, + "source": [ + "my_list = range(10)\n", + "list(my_list)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pRplN_eJakKY", + "colab_type": "code", + "colab": {}, + "outputId": "d9737b47-0450-436f-8db1-971101bfe648" + }, + "source": [ + "def doubled_fun(value):\n", + " return value * 2\n", + " \n", + "list( map(doubled_fun, my_list) )" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 36 + } + ] + } + ] +} \ No newline at end of file diff --git a/lekcja2a.ipynb b/lekcja2a.ipynb new file mode 100644 index 0000000..9143975 --- /dev/null +++ b/lekcja2a.ipynb @@ -0,0 +1,686 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "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.4" + }, + "colab": { + "name": "lekcja2a.ipynb", + "provenance": [], + "include_colab_link": true + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fuu4-LWtkQTW", + "colab_type": "text" + }, + "source": [ + "# Biblioteki\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zeY7w4qSkQT7", + "colab_type": "text" + }, + "source": [ + "## [numpy](http://cs231n.github.io/python-numpy-tutorial/)\n", + "To biblioteka do pracy z wektorami lub macierzami. Jest bardzo szybka i dlatego będziemy jej używać." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0J2Ny5-9kQT8", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import numpy as np #domyślnie numpy jest nadawy alias \"np\"" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "ISqcK-XBkQT-", + "colab_type": "code", + "colab": {}, + "outputId": "8483e18f-9c02-407b-8f6b-2f78769cf4a5" + }, + "source": [ + "arr = np.array([1, 2, 3, 4, 5, 6]) # tablica\n", + "arr" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([1, 2, 3, 4, 5, 6])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Q5R18GD-kQUB", + "colab_type": "code", + "colab": {}, + "outputId": "09ed5d7e-50aa-4909-9552-97f9b79fc31d" + }, + "source": [ + "type(arr)" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "numpy.ndarray" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 12 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "W7_5-j2dkQUE", + "colab_type": "code", + "colab": {}, + "outputId": "32e38dd8-70ea-49eb-f3c3-6462b3f38de6" + }, + "source": [ + "np.array([1, 2, 3]) + np.array([5, 6, 7])" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([ 6, 8, 10])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "WCg7dQaDkQUH", + "colab_type": "code", + "colab": {}, + "outputId": "72ab815b-daf1-423f-e12e-521c28a97401" + }, + "source": [ + "np.mean([1, 2, 3])" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "2.0" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "EzSP_wFwkQUJ", + "colab_type": "code", + "colab": {}, + "outputId": "1bfbcc5d-c198-424b-afc5-40a5a9ea6cce" + }, + "source": [ + "np.array([1, 2, 3]).mean()" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "2.0" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 15 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7InelJ2dkQUM", + "colab_type": "code", + "colab": {}, + "outputId": "50a6fdfc-9859-4ad7-9398-efc480cd6e11" + }, + "source": [ + "print(arr == 1) #tylko pierwszy element jest True (bo jest równy 1)\n", + "print(arr == 2) #tylko drugie element jest True (bo jest równy 2)\n", + "print(arr > 2) #pierwsze dwa nie pasują (tylko 3 i wyżej są większe od 2), reszt pasuję\n", + "print(arr %2 == 0) # tylko parzyste" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "stream", + "text": [ + "[ True False False False False False]\n", + "[False True False False False False]\n", + "[False False True True True True]\n", + "[False True False True False True]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RdQDaHifkQUP", + "colab_type": "text" + }, + "source": [ + "Zostawiamy tylko parzyste elementy w tablicy. Operator \"%\" to jest [modulo](https://pl.wikipedia.org/wiki/Modulo)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "7_KOPaq_kQUP", + "colab_type": "code", + "colab": {}, + "outputId": "5e11fdb2-42da-410b-c784-59aa56836638" + }, + "source": [ + "arr[ arr % 2 == 0 ]" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "array([2, 4, 6])" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 17 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "8aNaHmMvkQUR", + "colab_type": "text" + }, + "source": [ + "Na samym dole strony są dwa linki do 2-godzinnych webinarów na temat: python/numpy + pandas. Są tam również przykłady na githubie. Zapoznaj się z tym i spróbuj to wykonać samodzielnie (przynajmniej część)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "06nvnYk9kQUS", + "colab_type": "text" + }, + "source": [ + "# Zadania domowe\n", + "\n", + "\n", + "Masz listę od 0 do 18. Twoim zadaniem jest zostawić tylko liczby, które dzielą się na 4 bez reszty (czyli 0, 4, 8, 12 i 16). Nie używaj czystego Pythona, tylko postaraj się wykorzystać nowe biblioteki. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g6QQTJizkQUa", + "colab_type": "text" + }, + "source": [ + "## [pandas](https://www.dataquest.io/blog/pandas-python-tutorial/)\n", + "To biblioteka, która będzie nam bardzo potrzebna dalej. Można zaryzykować stwierdzenie, że to bardziej rozbudowany numpy" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "WQjNCQd4kQUb", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import pandas as pd #domyślnie pandas jest nadawy alias \"pd\"" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nCPbnWA8kQUd", + "colab_type": "text" + }, + "source": [ + "`Pandas` wewnątrz używa `numpy`, dlatego składnia, np. filtrowania, jest podobna. Bardzo łatwo można także konwertować dane z `pandas` do `numpy`.\n", + "\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "idVWOeIrkQUe", + "colab_type": "code", + "colab": {}, + "outputId": "460a0c75-98bc-4108-a970-ffdd395712d7" + }, + "source": [ + "np.random.seed(2018)\n", + "rows = 15\n", + "\n", + "df = pd.DataFrame({\n", + " 'height': np.random.randint(140, 210, rows),\n", + " 'weight': np.random.randint(50, 80, rows),\n", + "})\n", + "\n", + "df" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
heightweight
014976
116156
216863
316071
414672
516573
616550
718773
816558
920057
1017159
1116270
1214658
1318267
1414077
\n", + "
" + ], + "text/plain": [ + " height weight\n", + "0 149 76\n", + "1 161 56\n", + "2 168 63\n", + "3 160 71\n", + "4 146 72\n", + "5 165 73\n", + "6 165 50\n", + "7 187 73\n", + "8 165 58\n", + "9 200 57\n", + "10 171 59\n", + "11 162 70\n", + "12 146 58\n", + "13 182 67\n", + "14 140 77" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 19 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ajPGqjNHkQUg", + "colab_type": "text" + }, + "source": [ + "Dostać się do danych w wybranej kolumnie, można na co najmniej dwa sposoby." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "P_A9ENsBkQUg", + "colab_type": "code", + "colab": {}, + "outputId": "73732b94-d163-45d5-bd33-6d185f2b4f87" + }, + "source": [ + "df.height\n", + "\n", + "#lub\n", + "\n", + "df['height']" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0 149\n", + "1 161\n", + "2 168\n", + "3 160\n", + "4 146\n", + "5 165\n", + "6 165\n", + "7 187\n", + "8 165\n", + "9 200\n", + "10 171\n", + "11 162\n", + "12 146\n", + "13 182\n", + "14 140\n", + "Name: height, dtype: int64" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 20 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2_HFLJlrkQUn", + "colab_type": "text" + }, + "source": [ + "\n", + "\n", + "## Filtrowanie\n", + "Kolejna operacja, która jest bardzo potrzebna, to filtrowanie. Załóżmy, że chcemy zostawić w tabelce ludzi, którzy mają mniej niż 145 cm lub więcej niż 195 cm." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GaJaHyYAkQUo", + "colab_type": "code", + "colab": {}, + "outputId": "8f28a07b-72a4-43ea-aec9-eb5acfa5479f" + }, + "source": [ + "df[ (df.height < 145) | (df.height > 195) ]" + ], + "execution_count": 0, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
heightweightcountratio
92005713.508772
141407711.818182
\n", + "
" + ], + "text/plain": [ + " height weight count ratio\n", + "9 200 57 1 3.508772\n", + "14 140 77 1 1.818182" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GvyAo5USkQUs", + "colab_type": "text" + }, + "source": [ + "Zwróć uwagę na składnię.\n", + "\n", + "Po pierwsze, jeśli jest więcej niż jeden filtr, należy pojedyncze wyrażenia trzymać w nawiasach (to jest koniecznie).\n", + "\n", + "Po drugie pomiędzy wyrażeniami logicznymi jest operator, w tym przypadku \"lub\" czyli pionowa kreska (ang. pipe) \"|\". \n", + "Również może być operator \"i\", wtedy należy użyć [ampersandy/etki](https://pl.wikipedia.org/wiki/Et) \"&\".\n", + "\n", + "Po trzecie, wyrażeń logicznych może być więcej niż jedno, ale powyżej trzech trudno jest to czytać i łatwo popełnić błąd." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "siw2wU4nkQUu", + "colab_type": "code", + "colab": {} + }, + "source": [ + "if 'ratio' in df: del df['ratio']" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kUigsfOlkQUw", + "colab_type": "text" + }, + "source": [ + "## Zadanie 2\n", + "\n", + "Zrób `dataframe`, który na początek zawiera dwie kolumny:\n", + "- **age** (losowe wartości od 15 do 50)\n", + "- **weight** (losowe wartości od 50 do 80)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "lru00xdzkQUw", + "colab_type": "code", + "colab": {} + }, + "source": [ + "" + ], + "execution_count": 0, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/monday_14.ipynb b/monday_14.ipynb new file mode 100644 index 0000000..80c54d6 --- /dev/null +++ b/monday_14.ipynb @@ -0,0 +1,516 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "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.4" + }, + "colab": { + "name": "monday_14.ipynb", + "provenance": [], + "include_colab_link": true + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "view-in-github", + "colab_type": "text" + }, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HrVh-dyDWqbW", + "colab_type": "text" + }, + "source": [ + "# Wizualizacja\n", + "\n", + "### Celem jest poznanie podstaw do tworzenia wizualizacji\n", + "\n", + "Wizualizacja jest bardzo ważnym tematem - chociażby dlatego, że jest to obszar, w którym człowiek potrafi wyciągnąć błyskawiczne wnioski. Pamiętasz to przysłowie - “Lepiej raz zobaczyć niż sto razy usłyszeć”? To właśnie za pomocą zrobionych wykresów można \"zobaczyć\" rozwiązanie.\n", + "\n", + "Z drugiej strony, warto zrozumieć, że wykresy są tworzone dla ludzi, maszyna ich nie potrzebuje. Innymi słowy, dla modelu wszystko wygląda jak wykres, on używa metryki sukcesu jako kierunku optymalizacji.\n", + "Temat wizualizacji jest ogromny - dlatego my tutaj zajmiemy się tylko ograniczonym wycinkiem, ale warto od czegoś zacząć." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "FRw2HgbcWqbY", + "colab_type": "code", + "colab": {} + }, + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import sklearn.datasets as d\n", + "\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from pandas.plotting import scatter_matrix\n", + "from matplotlib.ticker import NullLocator, FixedLocator, LogLocator, MultipleLocator\n", + "\n", + "%matplotlib inline" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EEWPyItPWqbb", + "colab_type": "text" + }, + "source": [ + "## Linia\n", + "Jeden z najprostszych wykresów to linia łącząca dwa lub więcej punktów. " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "vo1_w1rXWqbc", + "colab_type": "code", + "colab": {} + }, + "source": [ + "plt.plot([3, 7, 8]);" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ennR3yE6Wqbe", + "colab_type": "text" + }, + "source": [ + "Funkcja `.plot()` oczekuje na dwa parametry x i y, natomiast jeśli został podany tylko jeden (tak jak powyżej), czyli został podany w formie jednej listy, to traktuje to jako `y`, a wszystkie `x` wypełnia inkrementalnie. Możesz o tym myśleć w ten sposób, że wartości `x` to są indeksy `y`.\n", + "\n", + "#### Na przykład: `y[0]=3 => x=0, y=3`.\n", + "\n", + "Ten sam wynik, ale już jawnie podając `x`." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "dMga0M_4Wqbf", + "colab_type": "code", + "colab": {} + }, + "source": [ + "plt.plot([0, 1, 2], [3, 7, 8]);" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cIRttUyUWqbh", + "colab_type": "text" + }, + "source": [ + "Znak `;` na końcu powoduje usunięcie opisu z biblioteki `matplotlib`. Możesz usuąć `;` i zobaczyć, co się pojawi.\n", + "\n", + "Warto zwrócić uwagę, że domyślny kolor linii to niebieski. W dalszej części pokażę, jak można zmienić kolor.\n", + "\n", + "Zróbmy teraz bardziej złożony wykres. Funkcja `f(x)` będzie nam generować wartości na osi x od 0 do 10 i będzie tych punktów 100." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "QQPREk9SWqbi", + "colab_type": "code", + "colab": {} + }, + "source": [ + "#jakaś \"ładna\" funkcja\n", + "def f(x):\n", + " return np.pi*np.sin(x) + np.pi*np.cos(np.pi * x) + np.sin(x + np.pi)\n", + "\n", + "\n", + "x = np.linspace(0, 10, 100) # generuję 100 punktów między 0 i 10\n", + "y = f(x)\n", + "\n", + "plt.plot(x, y);" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DINs3ObcWqbk", + "colab_type": "text" + }, + "source": [ + "## Trochę więcej kontroli nad wykresem\n", + "\n", + "### Kolor linii" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "0QiQm3oRWqbl", + "colab_type": "code", + "colab": {} + }, + "source": [ + "for color in ['r', 'g', 'b', 'c', 'm']: \n", + " plt.plot(x, y, color=color) #parametr \"color\" lub skrócona wersja \"c\". Możesz sprawdzić, podając `c=color`.\n", + " plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AfBo6_OzWqbn", + "colab_type": "text" + }, + "source": [ + "### Rodzaj linii" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zuvK4JwSWqbo", + "colab_type": "code", + "colab": {} + }, + "source": [ + "for line_style in ['-', '-.', '--', ':', '']: #pusty string oznacza \"żaden\"\n", + " plt.plot(x, y, linestyle=line_style) #parameter \"linestyle\" lub skrócona wersja \"ls\"\n", + " plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g7MlVtpCWqbr", + "colab_type": "text" + }, + "source": [ + "### Punkty (marker w terminologii matplotlib)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "BdYqf22uWqbr", + "colab_type": "code", + "colab": {} + }, + "source": [ + "all_markers = {'.': 'point',',': 'pixel','o': 'circle','v': 'triangle_down','^': 'triangle_up','<': 'triangle_left','>': 'triangle_right','1': 'tri_down','2': 'tri_up','3': 'tri_left','4': 'tri_right','8': 'octagon','s': 'square','p': 'pentagon','*': 'star','h': 'hexagon1','H': 'hexagon2','+': 'plus','x': 'x','D': 'diamond','d': 'thin_diamond','|': 'vline','_': 'hline'}\n", + "\n", + "markers = {'.': 'point', 'o': 'circle', 's': 'square', '*': 'star','h': 'hexagon1'}\n", + "\n", + "\n", + "\n", + "for marker, marker_name in markers.items():\n", + " print(\"{0}\\t{1}\".format(marker, marker_name))\n", + " \n", + " plt.figure(figsize=(12, 7))\n", + " plt.plot(x, y, markersize=7, marker=marker)\n", + " plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GqknVWA_Wqbt", + "colab_type": "text" + }, + "source": [ + "### Kontrola nad kreskami (ang. *ticks*) na osiach.\n", + "Domyślnie wartości na osiach (x czy y) są wypisywane w sposób liniowy, ale możesz to zmienić zaczynając od tego, że możesz je schować, wprowadzić jawnie, które punkty chcesz mieć lub nawet zrobić skalę logarytmiczną.\n", + "\n", + "Więcej informacji w dokumentacji [Tick locating and formatting](http://matplotlib.org/api/ticker_api.html#matplotlib.ticker.Locator)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "L--smI6SWqbu", + "colab_type": "code", + "colab": {} + }, + "source": [ + "locators = [\n", + " NullLocator(), #brak\n", + " FixedLocator([0, 1, 8]), #zafiksowany, będzie tylko dla 0, 1 i 8\n", + " LogLocator(2, [1.]), #skala logarytmiczna\n", + " MultipleLocator(3.) #co trzeci\n", + "]\n", + "\n", + "for locator in locators:\n", + " print(str(locator))\n", + " plt.figure(figsize=(12, 7))\n", + " \n", + " ax = plt.gca()\n", + " ax.xaxis.set_major_locator(locator)\n", + " plt.plot(x, y)\n", + " plt.show()" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GEkalcKcWqbw", + "colab_type": "text" + }, + "source": [ + "### Wiele linii\n", + "\n", + "Więcej niż jedna linia na jednym wykresie." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "BsVLQZsiWqbw", + "colab_type": "code", + "colab": {} + }, + "source": [ + "z = y / 4.0\n", + "\n", + "plt.figure(figsize=(12, 7))\n", + "plt.plot(x, y, label=\"high\")\n", + "plt.plot(x, z, label=\"low\")\n", + "\n", + "#dodanie legendy\n", + "plt.legend(loc='best'); #opcja \"best\" (można też wpisać po prostu 0) oznacza, że biblioteka samodzielnie poszukuje najlepszej możliwej opcji" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bZupU3I4Wqbz", + "colab_type": "text" + }, + "source": [ + "### Komentarz/adnotacja (ang. *annotation*) \n", + "\n", + "Bardziej skomplikowanym przypadkiem jest, kiedy chcemy zaznaczyć wybrany punkt na wykresie i dodać komentarz.\n", + "\n", + "Jako dodatek na wykresie poniżej dodajemy dwie linie: poziomą i pionową.\n", + "\n", + "*Swoją drogą*, \"biznes\" (ludzie z biznesu) bardzo to lubi. Kiedy wskazujemy miejsce warte uwagi wykres nagle staje się zrozumiały. Pokazanie wyniku to ważna umiejętność - zwykle osoby techniczne mają z tym problem." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "84uAhP9rWqbz", + "colab_type": "code", + "colab": {} + }, + "source": [ + "plt.figure(figsize=(12, 7))\n", + "plt.plot(x, y, label=\"high\")\n", + "plt.plot(x, z, label=\"low\")\n", + "\n", + "plt.ylim(-6, 7)\n", + "\n", + "plt.annotate(r'$\\pi sin(x) + \\pi cos(\\pi x) + \\pi sin(x + \\pi )$',\n", + " xy=(2, 5), xycoords='data',\n", + " xytext=(+3, +5.5), textcoords='data', fontsize=15,\n", + " arrowprops=dict(arrowstyle=\"->\",connectionstyle=\"arc3,rad=.2\"),\n", + " )\n", + "\n", + "plt.plot([0, 10], [0, 0], color='grey', linestyle='-.')\n", + "plt.plot([2, 2],[0, 10], color='blue', linewidth=1, linestyle=\"--\");" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UFZ4BxFBWqb2", + "colab_type": "text" + }, + "source": [ + "## Anatomia matplotlib\n", + "\n", + "![](../images/anatomy_matplotlib.png)\n", + "\n", + "Powyżej jest obraz, który opisuje poszczególne elementy wykresu.\n", + "\n", + "### Teraz dodajmy:\n", + "1. Tytuł\n", + "2. Agendę\n", + "3. Bardziej zaawansowany podpis na osi x ( 0, $+\\pi$, $+2\\pi$, $+3\\pi$ )\n", + "4. Jawnie punkty na dwóch liniach (używając różnych markerów)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "vat00iGxWqb3", + "colab_type": "code", + "colab": {} + }, + "source": [ + "plt.figure(figsize=(12, 7))\n", + "plt.plot(x, y, label=\"high\", marker='*')\n", + "plt.plot(x, z, label=\"low\", marker='+')\n", + "\n", + "plt.ylim(-6, 7)\n", + "\n", + "plt.annotate(r'$\\pi sin(x) + \\pi cos(\\pi x) + \\pi sin(x + \\pi )$',\n", + " xy=(2, 5), xycoords='data',\n", + " xytext=(+3, +5.5), textcoords='data', fontsize=15,\n", + " arrowprops=dict(arrowstyle=\"->\",connectionstyle=\"arc3,rad=.2\"),\n", + " )\n", + "\n", + "plt.plot([0, 10], [0, 0], color='grey', linestyle='-.')\n", + "plt.plot([2, 2],[0, 10], color='blue', linewidth=1, linestyle=\"--\")\n", + "\n", + "plt.title(\"Magic Sinusoida\", fontsize=20)\n", + "plt.xticks([0, np.pi, 2*np.pi, 3*np.pi],\n", + " [r'$0$', r'$+\\pi$', r'$+2\\pi$', r'$+3\\pi$'])\n", + "\n", + "plt.yticks([-6, -5, -4, -3, -2, -1, 0, +1, +2, +3, +4, +5, +6], [r'$-6$', r'$-5$', r'$-4$', r'$-3$', r'$-2$', r'$-1$', r'$0$', r'$+1$', r'$+2$', r'$+3$', r'$+4$', r'$+5$', r'$+6$'])\n", + "\n", + "plt.legend(loc='best');" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DDKagqG1Wqb5", + "colab_type": "text" + }, + "source": [ + "## Zadanie 2.2.1\n", + "\n", + "Przykład z życia wzięty... Zadanie wymaga więcej czasu, aby je wyjaśnić, niż je zrealizować. Natomiast celem jest pokazanie mniej standardowego zastosowania, żeby przyzwyczaić się do myślenia, że nawet logi można wizualizować.\n", + "\n", + "Załóżmy że jest system, którego zadaniem jest wykonanie pewnej pracy. Załóżmy, że praca ta polega na renderowaniu plików pdf (z jakąś tam zawartością).\n", + "\n", + "Proces zajmujący się wyrenderowaniem nowego pliku będziemy nazywać `job`. Istnieje kilka `workerów`, które mogą tworzyć nowe `joby`. W tym samym czasie tylko jeden `job` (wśród wszystkich `workerów`) może renderować, reszta musi oczekiwać... Działa to w następujący sposób. `Workery` budzą się w pewnym odstępie czasowym (żeby nie przeszkadzać sobie nawzajem), uwzględniając ile czasu zajmuje średni rendering.\n", + "\n", + "Po \"obudzeniu\" `worker` tworzy nowego `joba` z czasem begin. Następnie jest sprawdzane - czy można zacząć render, jeśli nie (czyli zajęte) - to `job` idzie spać na losowy okres czasu - jak obudzi się, znowu sprawdza czy render jest wolny, i tak aż uda się wykonać zadanie.\n", + "\n", + "Tak wygląda przykładowy log, w którym są pewne zdarzenia. \n", + "Log zawiera następujące informacje.\n", + "- **begin** - czas, kiedy worker uruchomił job i zaczął sprawdzać, czy może zacząć render\n", + "- **finish** - czas, kiedy worker skończył job (włączając redner pdf)\n", + "- **start_processing** - czas, kiedy job zaczął render\n", + "- **offset_submit** - opóźnienie w sekundach, kiedy job narodził się (begin) w porównaniu do pierwszego (“joba”)\n", + "- **offset_processing** - opóźnienie w sekundach od momentu, kiedy job narodził się (begin) i faktycznie rozpoczął rendering (innymi słowy, jak długo musiał czekać na rozpoczęcie renderingu)\n", + "- **total_seconds** - ile czasu sumaryczne zajęło wykonanie joba\n", + "\n", + "\n", + "### Logi\n", + "![logs](../images/task2.2.1.png)\n", + "\n", + "\n", + "### Oczekiwany wynik\n", + "Twoim zadaniem jest zwizualizować wszystkie `joby`, żeby upewnić się, że wykonują się one w uczciwej kolejności. To oznacza, że nie ma wiszących `jobów`, bo ktoś inny ciągle zajmuje miejsce dla renderingu.\n", + "\n", + "![logs](../images/task2.2.2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "i5CAKv6jWqcZ", + "colab_type": "text" + }, + "source": [ + "## Pandas (plotting)\n", + "Pandas też może tworzyć wykresy z pudełka (używając `matplotlib` pod spodem)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "qwqcuQGoWqca", + "colab_type": "code", + "colab": {} + }, + "source": [ + "iris.boxplot(by=\"species\", figsize=(12, 6));" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "dL4rcDPvWqcb", + "colab_type": "code", + "colab": {} + }, + "source": [ + "cmaps = dict(zip(iris.species.unique(), ['red', 'blue', 'green']))\n", + "\n", + "\n", + "scatter_matrix(iris, c=iris.species.map(lambda x: cmaps[x]), s=90, figsize=(12, 10));" + ], + "execution_count": 0, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hj7qvDEvWqcd", + "colab_type": "text" + }, + "source": [ + "## Przydatne linki\n", + "1. [Anatomy of Matplotlib](https://www.youtube.com/watch?v=A2adyFMsut0)\n", + "2. [Overview of Python Visualization Tools](http://pbpython.com/visualization-tools-1.html)\n", + "3. [The Python Visualization Landscape](https://www.youtube.com/watch?v=FytuB8nFHPQ)\n", + "4. [matplotlib - 2D and 3D plotting in Python](http://nbviewer.jupyter.org/github/jrjohansson/scientific-python-lectures/blob/master/Lecture-4-Matplotlib.ipynb)\n", + "5. [Histograms and Boxplots](https://www.slideshare.net/dsaadeddin/histograms-and-boxplots)\n", + "6. [How To Think Visually Using Visual Analogies – Infographic](https://blog.adioma.com/how-to-think-visually-using-visual-analogies-infographic/)\n", + "7. [Visualizing Patterns on Repeat](https://flowingdata.com/2018/07/09/how-to-visualize-recurring-patterns/)\n", + "8. [Your Friendly Guide to Colors in Data Visualisation](https://blog.datawrapper.de/colorguide/)\n", + "9. [Create a zoomed-up inset plot in Matplotlib](http://akuederle.com/matplotlib-zoomed-up-inset)" + ] + } + ] +} \ No newline at end of file diff --git a/sonar-project.properties b/sonar-project.properties new file mode 100644 index 0000000..38ad59f --- /dev/null +++ b/sonar-project.properties @@ -0,0 +1 @@ +sonar.projectKey=test-demo-shop