05-python-programming-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python: programowanie\n",
    "\n",
    "W Python istnieje wiele gotowych modułów, które ułatwiają programowanie. Ich listę można odlaneźć w dokumentacji [Python Module Index](https://docs.python.org/3/py-modindex.html). Dodatkowe moduły z [Python Package Index](https://pypi.org/) można doinstalować za pomocą `pip`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zasady pisania kodu\n",
    "\n",
    "Dobre praktyki związane ze stylem pisania kodu w Python opisano w [PEP 8 - Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/):\n",
    "- stosujemy wcięcia kodu o wielkości 4 spacji\n",
    "- linie nie powinny być dłuższe niż 79 znaków\n",
    "- `variable_name`, `CONSTANT`, ...\n",
    "- kod powinien być czytelny\n",
    "\n",
    "Wiele organizacji przygotowuje własne dobre praktyki związane z programowaniem np. [Google Python Style Guide](https://google.github.io/styleguide/pyguide.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Zen of Python\n",
    "\n",
    "Zen of Python to najważniejsze zasady związane z pisaniem programów w języku Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instrukcja warunkowa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "height = 1.81\n",
    "weight = 82\n",
    "bmi = weight / height ** 2\n",
    "if bmi > 25.0:\n",
    "    print(f'czas na dietę (BMI = {bmi})')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "height = 1.81\n",
    "weight = 50\n",
    "bmi = weight / height ** 2\n",
    "if bmi > 25.0:\n",
    "    print(f'czas na dietę (BMI = {bmi})')\n",
    "# warunki są sprawdzane według kolejności, wykonywany jest pierwszy spełniony\n",
    "elif bmi > 18.5:\n",
    "    print(f'waga w normie (BMI = {bmi})')\n",
    "# jeśli żaden warunek nie został spełniony\n",
    "else:\n",
    "    print(f'dodatkowy deser (BMI = {bmi})')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -2\n",
    "\n",
    "if x >= 0:\n",
    "    sign = 1\n",
    "else:\n",
    "    sign = -1\n",
    "\n",
    "# skrócona instrukcja warunkowa\n",
    "sign = 1 if x >= 0 else -1\n",
    "\n",
    "sign"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pętla while"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 3\n",
    "while i > 0:\n",
    "    print(f'i = {i}')\n",
    "    i -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 5\n",
    "while i > 0:\n",
    "    i -= 1\n",
    "    if i == 2:\n",
    "        # wznawia pętlę\n",
    "        continue\n",
    "    print(f'i = {i}')\n",
    "else:\n",
    "    print('koniec')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 3\n",
    "while True:\n",
    "    i -= 1\n",
    "    if i==0:\n",
    "        # przerywa pętlę\n",
    "        break\n",
    "    print(f'i = {i}')\n",
    "else:\n",
    "    print('koniec')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Zaimplementuj program:\n",
    "* drukujący tabliczkę mnożenia w zakresie od 1 do 10\n",
    "* drukujący tabliczkę mnożenia w zakresie od 1 do 10 dla liczb parzystych\n",
    "* drukujący tabliczkę mnożenia w zakresie od 1 do 10 dla liczb parzystych poza 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pętla for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for c in 'Hello':\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['Anna', 'Jan', 'Katarzyna', 'Aleksandra', 'Adam']\n",
    "for name in names:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# enumerate zwraca krotkę z identyfikatorem i wartością elementu\n",
    "for name in enumerate(names, 1):\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# zip zwraca krotkę łączącą kolekcje danych na określonych pozycjach\n",
    "exam = [5.0, 4.5, 4.0, 5.0, 4.5]\n",
    "for x in zip(names, exam):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# zip jest często używane do tworzenia słowników\n",
    "print(dict(zip(names, exam)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wydrukuj liczby nieparzyste w zakresie od 0 do 100 podzielne przez 3 ale nie przez 15."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wyrażenia listowe\n",
    "\n",
    "Wyrażenia listowe to uproszczona konstrukcja tworzenia listy\n",
    "\n",
    "list = [*expression* for *item* in *iterable* if *condition* == True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lista imion zaczynających się na 'A'\n",
    "names = ['Anna', 'Jan', 'Katarzyna', 'Aleksandra', 'Adam']\n",
    "a_names = list()\n",
    "for name in names:\n",
    "    if name.startswith('A'):\n",
    "        a_names.append(name.upper())\n",
    "print(a_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "names = ['Anna', 'Jan', 'Katarzyna', 'Aleksandra', 'Adam']\n",
    "a_names = [i for i in names if i.startswith('A')]\n",
    "print(a_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# lista liczb\n",
    "[i for i in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funkcje\n",
    "\n",
    "Funkcje służą do grupowania kodu używanego więcej niż jeden raz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# funkcja z dwoma argumentami, y ma wartość domyślną\n",
    "def sub(x, y=1):\n",
    "    # w docstring można opisać działanie funkcji i jej parametry\n",
    "    \"\"\"\n",
    "    Returns the difference of two integers.\n",
    "            Parameters:\n",
    "                    x (int): Integer\n",
    "                    y (int): Another integer, default 1\n",
    "            Returns:\n",
    "                    sub (int): x - y\n",
    "    \"\"\"\n",
    "    print(\"sub\")\n",
    "    return x - y\n",
    "\n",
    "\n",
    "# wywołanie funkcji\n",
    "print(sub(2, 1))\n",
    "print(sub(y=10, x=20))\n",
    "print(sub(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(sub)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# funkcja ze zmienną liczbą argumentów pozycyjnych (krotka)\n",
    "def add(*args):\n",
    "    '''Returns the sum of integers.'''\n",
    "    total = 0\n",
    "    for a in args:\n",
    "        total += a\n",
    "    return total\n",
    "\n",
    "\n",
    "print(add(1, 2, 3, 4, 5))\n",
    "\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "print(add(*numbers)) # rozpakowanie sekwencji do argumentów pozycyjnych"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# funkcja ze zmienną liczbą nazwanych argumentów (słownik)\n",
    "def varia(**kwargs):\n",
    "    for key, val in kwargs.items():\n",
    "        print(f'{key} = {val}')\n",
    "\n",
    "\n",
    "varia(lang = 'Python', age = 30, top_ten = True)\n",
    "\n",
    "values = { 'lang': 'Python', 'age': 30, 'top_ten': True }\n",
    "varia(**values) # rozpakowanie słownika do argumentów nazwanych"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kolejność argumentów\n",
    "\n",
    "Argumenty funkcji muszą być zdefiniowane w określonej kolejności\n",
    "- argumenty pozycyjne\n",
    "- `*args`\n",
    "- argumenty nazwane\n",
    "- `**kwargs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pusta funkcja, pass oznacza pusty blok kodu\n",
    "def empty():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funkcje wbudowane\n",
    "\n",
    "Wiele typowych operacji jest już w Python zaimplementowanych."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "# assert przerywa wykonanie programu jeśli warunek nie jest spełniony\n",
    "# komórka poniżej wymaga Python 3.8 do obsłużenia f-string z =\n",
    "assert sys.version_info >= (3, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [8, 3, 6, 1, 2, 0]\n",
    "\n",
    "print(f'{len(numbers) = }')\n",
    "print(f'{max(numbers) = }')\n",
    "print(f'{min(numbers) = }')\n",
    "print(f'{sum(numbers) = }')\n",
    "\n",
    "# zwraca True jeśli jakikolwiek element spełnia bool(x) == True\n",
    "print(f'{any(numbers) = }')\n",
    "# zwraca True jeśli wszystkie elementy spełniają bool(x) == True\n",
    "print(f'{all(numbers) = }')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zmienne\n",
    "\n",
    "Zmienne w Python są referencją (odniesieniem, nazwą, tożsamością) obiektu, który przechowuje określoną wartość. Zachowanie operacji na obiektach będzie zależało od tego czy są one mutowalne czy niemutowalne."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'Python'\n",
    "b = a # operator przypisanie kopiuje tożsamość, to \"inna nazwa\" obiektu, który jest pod a\n",
    "print(id(a)) # funkcja id zwraca tożsamość obiektu (miejsce w pamięci)\n",
    "print(id(b))\n",
    "print(a == b) # porównanie wartości\n",
    "print(a is b) # porównanie tożsamości"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "print(id(a))\n",
    "print(id(b))\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "b.append(4) # zmieniamy ten sam obiekt\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [1, 2, 3] # w tym przypadku można było też napisać a[:]\n",
    "print(id(a))\n",
    "print(id(b))\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "b.append(4) # zmieniamy różne obiekty\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun_x(l):     # przekazywanie parametrów do funkcji działa tak jak operator przypisania, oznacza l = a\n",
    "    l = [3, 4, 5] # do zmiennej l przypisujemy zupełnie nową referencję\n",
    "    \n",
    "\n",
    "def fun_y(l):\n",
    "    l.append([3, 4, 5])  # wykonujemy operację na obiekcie l = a (czyli na tej samej referencji)\n",
    "    \n",
    "\n",
    "a = [1, 2, 3]\n",
    "fun_x(a)\n",
    "print(a)\n",
    "fun_y(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "a = [1, 2, [3, 4]]\n",
    "b = copy.copy(a) # a[:]\n",
    "print(id(a)) # wykonano kopię listy\n",
    "print(id(b))\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "print(id(a[2])) # skopiowano tylko referencje wewnętrznych obiektów (płytkie kopia, shallow copy)\n",
    "print(id(b[2]))\n",
    "print(a[2] == b[2])\n",
    "print(a[2] is b[2])\n",
    "b[2].append(5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "a = [1, 2, [3, 4]]\n",
    "b = copy.deepcopy(a)\n",
    "print(id(a))\n",
    "print(id(b))\n",
    "print(a == b)\n",
    "print(a is b)\n",
    "print(id(a[2])) # wykonano kopię wewnętrznych obiektów (głęboka kopia, deep copy)\n",
    "print(id(b[2]))\n",
    "print(a[2] == b[2])\n",
    "print(a[2] is b[2])\n",
    "b[2].append(5)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun_z(t):\n",
    "    t[2].append(5) # nie zmieniamy krotki, ale listę w krotce\n",
    "    # operacja t[2] = [3, 4, 5] byłaby niemożliwa, krotka jest niemutowalna\n",
    "\n",
    "\n",
    "a = (1, 2, [3, 4]) # krotka jest niemutowalna, ale lista już tak\n",
    "fun_z(a) # wywołanie funkcji nie zmieniło krotki (tożsamość listy pozostała niezmieniona)\n",
    "print(a)"
   ]
  }
 ],
 "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.13.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}