L1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Język Python - Wykład 1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Sprawy organizacyjne"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Prowadzący:\n",
    "    * mgr inż. Zbigniew Kaleta, zkaleta@agh.edu.pl\n",
    "    * dr inż. Marek Gajęcki, mag@agh.edu.pl\n",
    "    * mgr inż. Agnieszka Rudnicka, agnieszka.rudnicka@iisg.agh.edu.pl\n",
    "    \n",
    "* Konsultacje: https://wiki.ki.agh.edu.pl/pages/viewpage.action?pageId=9502795\n",
    "\n",
    "* Współautorzy materiałów: \n",
    "    * dr inż. Krzysztof Dorosz, [@krzysztofdorosz](https://twitter.com/krzysztofdorosz)\n",
    "    * dr inż. Michał Korzycki, [@michalkorzycki](https://twitter.com/michalkorzycki)\n",
    "    * dr Leszek Grzanka, [@leszekgrzanka](https://twitter.com/leszekgrzanka)\n",
    "* Slajdy udostępnione w formacie Jupyter Notebook na [naszym koncie github agh-glk](https://github.com/agh-glk/python-lecture)\n",
    "* Na pewno nie unikniemy gdzieś błędu w materiałach wykładu, dlatego gorąco zachęcamy do zgłaszania poprawek na githubie (fork + pull request)\n",
    "* Wykład co tydzień przez pół semestru: 1, 8, 15, 22 i 29 marca oraz 5 kwietnia\n",
    "* Laboratoria na przemian"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Zaliczenie\n",
    "### Składowe:\n",
    "* projekt z wagą 2\n",
    "* kolokwium z wagą 1\n",
    "* obie składowe **muszą być pozytywne**\n",
    "* w przypadku negatywnej oceny z którejś składowej, przysługuje 1 (słownie: jeden) termin poprawy\n",
    "* ostateczna ocena to średnia ważona wszystkich uzyskanych ocen, przy czym nie mniej niż 3.0, jeżeli obie składowe zostały zaliczone\n",
    "\n",
    "### Terminy oddania projektu:\n",
    "* podstawowy: ostatnie zajęcia własnej grupy w semestrze\n",
    "* poprawkowy: koniec letniej sesji egzaminacyjnej\n",
    "\n",
    "### Terminy kolokwiów:\n",
    "* podstawowy: 7 czerwca\n",
    "* poprawkowy: 26 czerwca **albo** 11 września o 11:00 w sali 2.41 (albo = xor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Przedsmak Pythona"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(list):\n",
    "    if not list:\n",
    "        return []\n",
    "    else:\n",
    "        tmp = list[0]\n",
    "        less = [x for x in list     if x <  tmp]\n",
    "        more = [x for x in list[1:] if x >= tmp]\n",
    "        return fun(less) + [tmp] + fun(more)\n",
    "    \n",
    "fun([3,2,1,4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Co takiego robi powyższy kod?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Cechy rozpoznawcze Pythona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* wcięcia jako element składni\n",
    "* w pełni obiektowy\n",
    "* bardzo wysokiego poziomu\n",
    "* dynamiczna typizacja (*duck typing*)\n",
    "* język skryptowy (interpretowany), ale również kompilowany do *bytecode*'u\n",
    "* liberalny interpreter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Zalety:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * zwięzły\n",
    " * czytelny (duża ekspresja)\n",
    " * bardzo dużo zasobów: frameworków, bibliotek, tutoriali\n",
    " * bardzo popularny (3.~4. miejsce w rankingu TIOBE index, wg. GitHuba poniżej)\n",
    " ![popularność języków wg. GitHuba](https://cdn-images-1.medium.com/max/800/0*wyH0Qr8K1HIePqhR)\n",
    "za https://hackernoon.com/top-3-most-popular-programming-languages-in-2018-and-their-annual-salaries-51b4a7354e06"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Wady:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* prędkość\n",
    "* Global Interpreter Lock\n",
    "* niekompatybilne linie 2.x i 3.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import antigravity"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Przyczyny powstania - historia języka i jego twórca"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* BDFL - **Guido van Rossum**\n",
    "    * Benevolent Dictator For Life\n",
    "* Centrum Wiskunde & Informatica – Amsterdam Hollandia\n",
    "\n",
    "![caption](files/L1_img/guido1.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Pierwsza implementacja - XII 1989\n",
    "\n",
    "> \"Over six years ago, in December 1989, I was looking for a \"hobby\" programming project that would keep me occupied during the week around Christmas. My office (a government-run research lab in Amsterdam) would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new scripting language I had been thinking about lately: a descendant of ABC that would appeal to Unix/C hackers. I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus).\" Guido van Rossum\n",
    "\n",
    "Źródło: https://www.python.org/doc/essays/foreword/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Interpreter napisany w języku C, najstarszy (14.10.1990) kod interpretera dostępny tutaj:\n",
    "https://github.com/python/cpython/tree/daadddf7ae82f9e352e660d14a8a27285d992b2f\n",
    "\n",
    "* Wersja 0.9.0 - II 1991\n",
    "* Wersja 1.0 – I 1994\n",
    "* Wersja 2.0 – 16 X 2000\n",
    "    * Zbieranie nieużytków (Garbage collector)\n",
    "    * Zwykłe ciągi znaków oraz Unicode\n",
    "    * 2.2 wszystko stało się obiektem, generatory\n",
    "* Wersja 3.0 – 3 XII 2008\n",
    "    * *print* jest funkcją a nie slowem kluczowym\n",
    "    * tylko Unicode\n",
    "    * nowy operator dzielenia /\n",
    "    * nowa składnia raise/except\n",
    "* Na wykładzie korzystamy z linii 3.6.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Alternatywne implementacje Pythona"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* CPython - standardowa implementacja jest często w kontekście innych alternatywnych nazywana CPython\n",
    "\n",
    "* RPython - Restricted Python, statycznie typowany podzbiór języka Python, JIT \n",
    "\n",
    "* PyPy - interpreter Pythona napisany w ... Pythonie (dokładnie w RPythonie), it's all about speed, JIT\n",
    "\n",
    "* Jython – interpreter napisany na JVM\n",
    "\n",
    "* Stackless Python - nie używa C call stack, skierowany na wielowątkowość (microthreads)\n",
    "\n",
    "* Unladen Swallow - sponsorowany przez Googla zawieszony po 2009 roku projekt, który miał dostarczyć super wydajną wersję CPythona. Nie wyszło.\n",
    "\n",
    "* Cython - Python kompilowany do C\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## PEP 20 - Python ZEN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PEP - Python Enhancement Proposal - system dokumentów (podobna idea jak w RFC), zawierający pomysły na rozwój środowiska Python\n",
    "\n",
    "\n",
    "PEP 20 - http://www.python.org/dev/peps/pep-0020/\n",
    "\n",
    "***Long time Pythoneer Tim Peters succinctly channels the BDFL's guiding principles for Python's design into 20 aphorisms, only 19 of which have been written down.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Jak uruchomić program w Pythonie?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* nie uruchamiać - pisać wprost w interpreterze (dobre jako kalkulator lub do najprostszych testów)\n",
    "* python &lt;nazwa pliku&gt; (patrz także: *shebang*)\n",
    "* sposób mieszany: python -i &lt;nazwa pliku&gt;\n",
    "* wpisując w interpreterze *import &lt;nazwa modułu&gt;*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Przypisanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "a, b = 10, 15\n",
    "b, a = a, b\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 0.5\n",
    "\n",
    "if number > 0:\n",
    "    print(\"Dodatni\")\n",
    "    print(\"Czyli większy od zera\")\n",
    "elif number == 0:\n",
    "    print(\"Zero\")\n",
    "else:\n",
    "    print(\"Ujemny\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Dodatni\" if number > 0 \n",
    "      else (\"Zero\" if number == 0 else \"Ujemny\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "wartosc1 if warunek else wartosc2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Pętla WHILE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number = 23\n",
    "running = True\n",
    "\n",
    "while running:\n",
    "    guess = int(input('Enter an integer : '))\n",
    "    if guess == number:\n",
    "        print('Congratulations, you guessed it.')\n",
    "        running = False # this causes the while loop to stop\n",
    "        break # - but we can't use break here -> no else then \n",
    "    elif guess < number:\n",
    "        print('No, it is a little higher than that.')\n",
    "    else:\n",
    "        print('No, it is a little lower than that.')\n",
    "else:\n",
    "    print('The while loop is over.')\n",
    "# Do anything else you want to do here\n",
    "\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ewaluacja warunków"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wartością fałszywą jest:\n",
    "* False\n",
    "* None\n",
    "* 0\n",
    "* 0.0\n",
    "* pusty napis, lista, krotka, słownik...\n",
    "\n",
    "Wszystko inne jest prawdziwe*\n",
    "\n",
    "Ewaluacja wyrażenia złożonego jest przerywana jeśli końcowa wartość jest znana.\n",
    "\n",
    "Wartością całego wyrażenia jest wartość ostatniego członu, który był ewaluowany."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"a\" and 0 and [0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0 or [0] or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def xor(a,b):\n",
    "    return bool(a) != bool(b)\n",
    "\n",
    "# albo from operator import xor\n",
    "\n",
    "xor([0], [])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jakie są priorytety i wiązanie operatorów logicznych?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False and False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Pętla FOR"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Typowa pętla po liczbach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)\n",
    "else:\n",
    "    print('The for loop is over')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(8, 0, -2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W praktyce najczęściej iterujemy po elementach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in ['apple', 'orange', 'peach']:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in ('apple', 'orange', 'peach'):\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in {'apple', 'orange', 'peach'}:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "W takiej pętli nie mamy dostępu do indeksu elementu w liście, ale możemy taki uzyskać, odpowiednio mapując kolekcję za pomocą enumerate (generator):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(enumerate(['apple', 'orange', 'peach']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, e in enumerate(['apple', 'orange', 'peach']):\n",
    "    print(i, e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(enumerate(['apple', 'orange', 'peach']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importowanie"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "print(sys.version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi\n",
    "print(pi)\n",
    "print(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Liczby"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Całkowite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 4\n",
    "print(type(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(0x10)\n",
    "print(0b10)\n",
    "print(0o10)\n",
    "print(\"---\")\n",
    "print(int(\"010101\"))\n",
    "print(int(\"010101\", 2))\n",
    "print(int(\"010101\", 40))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(hex(12))\n",
    "print(oct(12))\n",
    "print(bin(12))\n",
    "\n",
    "bin(3 + 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = a\n",
    "a += 1\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![caption](files/L1_img/img041.gif)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1 + 1)\n",
    "print(1 - 1)\n",
    "print(3 * 3)\n",
    "print(4 / 2)\n",
    "print(3 / 2)\n",
    "print(3 % 2)\n",
    "print(2 ** 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int(-4/3), int(-5/3), int(4/3), int(5/3))\n",
    "print(-4//3, -5//3, 4//3, 5//3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.ceil(-4/3), math.ceil(-5/3), math.ceil(4/3), math.ceil(5/3))\n",
    "print(math.floor(-4/3), math.floor(-5/3), math.floor(4/3), math.floor(5/3))\n",
    "print(math.trunc(-4/3), math.trunc(-5/3), math.trunc(4/3), math.trunc(5/3))\n",
    "print(round(-4/3), round(-5/3), round(4/3), round(5/3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zmiennoprzecinkowe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type(1.0))\n",
    "a = 2.4\n",
    "print(2.4e9)\n",
    "print(2.4e-9)\n",
    "print(2.4E90)\n",
    "print(1 + 1e-15 == 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1.5 // 0.2)\n",
    "print(5.5 % 1.5)\n",
    "print(round(1.55555, 2))\n",
    "print(round(155.555, -1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operacje bitowe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3 << 2)\n",
    "print(bin(3), bin(12))\n",
    "print(3 | 2)\n",
    "print(bin(3), bin(2))\n",
    "print(3 & 2)\n",
    "print(3 ^ 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Funkcje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def say(message, times=1):\n",
    "    print((message + ' ') * times)\n",
    "    \n",
    "say('developers')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "say('developers', 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "say('developers', times=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "say(times=3, 'developers')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "say(times=3, message='developers')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from random import randint\n",
    "\n",
    "def print_rand(rand=randint(1,100)): #losowanie z przedziału [1;100] (domkniętego)\n",
    "    print(rand)\n",
    "\n",
    "for i in range(3):\n",
    "    print_rand()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PEP 8 - Zasady formatowania kodu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://www.python.org/dev/peps/pep-0008/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " **,,code is read much more often than it is written''** (BDFL)\n",
    " \n",
    " Po co wytyczne do formatowania kodu?\n",
    "   * spójność stylu wewnątrz modułów i projektu\n",
    "   * wytyczne to nie wyrocznia, można je pominąć, gdy:\n",
    "      * czyni to kod mniej czytelnym\n",
    "      * aby być spójnym z istniejącym kodem\n",
    "      * jest ryzyko utraty kompatybilności wstecz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* snake_case\n",
    "* 4 spacje na jedno wcięcie kodu \n",
    "* Nie używać znaków tabulacji (``\\t``)\n",
    "* Nigdy nie mieszać znaków tabulacji ze spacjami do robienia wcięć w jednym kodzie\n",
    "* Dwie puste linie pomiędzy kodem klas i funkcji (na najwyższym poziomie)\n",
    "* Jedna pusta linia pomiędzy kodem metod i funkcji zagnieżdżonych\n",
    "* Maksymalna długość linii kodu to 79 znaków\n",
    "* Nie używać ``from <module> import *`` - zatrucie przestrzeni nazw\n",
    "* starać się nie używać zmiennych ``l`` (małe L, podobne do 1), ``O`` (duże o, podobne do zero), ``I`` (duże i, podobne do 1)\n",
    "    \n",
    "* Znaki spacji przed i po wyrażeniach przypisania i porównania (z wyjątkiem listy argumentów)\n",
    "\n",
    "    Dobrze:\n",
    "        a = 5\n",
    "        b = [1, 2, 3, 4]\n",
    "        f(a=5, b=10)\n",
    "    \n",
    "    Źle:\n",
    "        a=5\n",
    "        a= 5\n",
    "        a =5\n",
    "        f(a = 5, b = 10)\n",
    "        f(a= 5, b= 10)\n",
    "\n",
    "* Bez spacji na brzegach nawiasowania i listy argumentów\n",
    "\n",
    "    Dobrze:\n",
    "        (a + 3) * (5 - b)\n",
    "        \n",
    "    Źle:\n",
    "        (a+3)*(5-b)\n",
    "        ( a + 3 ) * ( 5 - b )\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}