{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d6cabf5f-8469-4a8b-bfbc-d3a2bcf39c7e",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "<div class=\"alert alert-block\" style=\"text-align: center; background-color: lightgrey; font-weight: bold;\">\n",
    "<h1> Algorytmy i programowanie</h1>\n",
    "<h2> <i>Funkcje w Pythonie</i></h2> \n",
    "<h3></h3>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3adb3e26-d612-4353-ae12-20de0d4784ff",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Funkcje w Pythonie\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "413144d4-6135-49bb-ad04-8b47bf445e1b",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Na początek przyjrzyjmy się następującemu programowi, który wczytuje od użytkownika dwie liczby naturalne, a następnie liczy największy wspólny dzielnik tych liczb. Podczas wczytywania liczb program prosi użytkownika o podanie liczby dopóki nie poda liczby będącej liczbą naturalną."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "895cecac-73ae-4683-8f81-6627b35fa684",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj liczbę naturalną:"
       },
       "output_type": "stream",
       "value": "1024"
      },
      "1": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj liczbę naturalną:"
       },
       "output_type": "stream",
       "value": "256"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj liczbę naturalną: 1024"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj liczbę naturalną: 256"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NWD(1024,256) wynosi 256\n"
     ]
    }
   ],
   "source": [
    "tekst = input('Podaj liczbę naturalną:')\n",
    "while not tekst.isnumeric()  :\n",
    "    print(\"Nie podałeś liczby naturalnej!\")\n",
    "    tekst = input('Podaj liczbę naturalną:')\n",
    "a = int(tekst)\n",
    "\n",
    "tekst = input('Podaj liczbę naturalną:')\n",
    "while not tekst.isnumeric()  :\n",
    "    print(\"Nie podałeś liczby naturalnej!\")\n",
    "    tekst = input('Podaj liczbę naturalną:')\n",
    "b = int(tekst)\n",
    "\n",
    "r = a % b\n",
    "while r > 0 :\n",
    "    a = b\n",
    "    b = r\n",
    "    r = a % b\n",
    "print(\"NWD(\" + str(a) + \",\" + str(b) + \") wynosi\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c08e592-be7e-4aeb-8bf9-892dbd166555",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "W pierwszej kolejności zauważmy, że wczytywanie liczby $a$ i $b$ wygląda dokładnie tak samo. Zatem w programie dwa razy wykonywany jest niemal identyczny fragment kodu. W takich sytuacjach warto \"przypisać\" jakąś nazwę dla tego fragmentu kodu, a następnie jedynie powołując się na tę nazwę przywołać działanie tego fragmentu kodu. Do tego celu służą właśnie **funkcje** w języku Python."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae5a1d32-601c-4337-8364-9cc826c92645",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**Funkcję** w języku Python definiuje się w następujący sposób.\n",
    "\n",
    "`def` nazwa_funkcji(parametry) `:`<br />\n",
    "&emsp;&emsp; blok_instrukcji <br />\n",
    "&emsp;&emsp; `return` wynik\n",
    "\n",
    "Dodajmy, że używanie parametrów oraz ostatnia linijka zaczynająca się od `return` jest opcjonalna. \n",
    "\n",
    "Zobaczmy na początek bardzo prosty przykład funkcji.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "8fd97d83-423a-4439-b5c0-e7d141dad3a4",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj swoje imię:"
       },
       "output_type": "stream",
       "value": "Łukasz"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj swoje imię: Łukasz"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dzień dobry Łukasz\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def powitanie() :\n",
    "    imie = input('Podaj swoje imię:')\n",
    "    print(\"Dzień dobry\", imie)\n",
    "    print(\"\")\n",
    "\n",
    "powitanie()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d08bd4d-9376-462a-8444-916750043eb8",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Zauważmy jednak (patrz poniżej), że tak prosta definicja funkcji nie pozwala nam przekazać na zewnątrz wartości zmiennej `imie` występującej w definicji funkcji. W tym celu należy użyć instrukcji `return`, która pozwala zwrócić pewną wartość pojawiającą się podczas działania danej funkcji. W ten sposób możemy mieć dostęp do konkretenej wartości obliczanej podczas wykonywania funkcji również po zakończeniu działania tej funkcji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "59ac0680-9812-4c24-be06-086fc8db7a65",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj swoje imię:"
       },
       "output_type": "stream",
       "value": "Łukasz"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj swoje imię: Łukasz"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dzień dobry Łukasz\n",
      "\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'imie' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[6], line 7\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m      6\u001b[0m powitanie()\n\u001b[0;32m----> 7\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mimie\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'imie' is not defined"
     ]
    }
   ],
   "source": [
    "def powitanie() :\n",
    "    imie = input('Podaj swoje imię:')\n",
    "    print(\"Dzień dobry\", imie)\n",
    "    print(\"\")\n",
    "\n",
    "powitanie()\n",
    "print(imie)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "e557f8f1-6fc5-4dc7-8315-bb0aeb478133",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj swoje imię:"
       },
       "output_type": "stream",
       "value": "Łukasz"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj swoje imię: Łukasz"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dzień dobry Łukasz\n",
      "\n",
      "Podane imię to: Łukasz\n"
     ]
    }
   ],
   "source": [
    "def powitanie() :\n",
    "    imie = input('Podaj swoje imię:')\n",
    "    print(\"Dzień dobry\", imie)\n",
    "    print(\"\")\n",
    "    return imie\n",
    "\n",
    "podane_imie = powitanie()\n",
    "print(\"Podane imię to:\", podane_imie)\n",
    "\n",
    "# dwie ostatnie linie można zastąpić następującą\n",
    "# print(\"Podane imię to:\", powitanie())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b522cd1-dcdf-46f9-8738-fd1bbc313fc5",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Spójrzmy jeszcze raz na kod z początku pliku po modyfikacji."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "43e47581-6bc3-4313-ae7a-0279e07ab087",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj liczbę naturalną:"
       },
       "output_type": "stream",
       "value": "ggyghuihujk"
      },
      "1": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj liczbę naturalną:"
       },
       "output_type": "stream"
      },
      "4": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj liczbę naturalną:"
       },
       "output_type": "stream",
       "value": "48"
      },
      "5": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj liczbę naturalną:"
       },
       "output_type": "stream",
       "value": "60"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj liczbę naturalną: ggyghuihujk"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj liczbę naturalną: "
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nie podałeś liczby naturalnej!\n"
     ],
     "value": "-312"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nie podałeś liczby naturalnej!\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj liczbę naturalną: 48"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj liczbę naturalną: 60"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NWD(48, 60) wynosi 12\n"
     ]
    }
   ],
   "source": [
    "def wczytaj() :\n",
    "    tekst = input('Podaj liczbę naturalną:')\n",
    "    while not tekst.isnumeric()  :\n",
    "        print(\"Nie podałeś liczby naturalnej!\")\n",
    "        tekst = input('Podaj liczbę naturalną:')\n",
    "    return int(tekst)\n",
    "\n",
    "a = wczytaj()\n",
    "b = wczytaj()\n",
    "a_init = a\n",
    "b_init = b\n",
    "\n",
    "r = a % b\n",
    "while r > 0 :\n",
    "    a = b\n",
    "    b = r\n",
    "    r = a % b\n",
    "print(\"NWD(\" + str(a_init) + \", \" + str(b_init) + \") wynosi\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e3271ff-be3b-4f27-aba0-b5d500dc81b2",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Dla przejrzystości kodu możemy również stworzyć funkcję liczącą NWD. Taka funkcja powinna zależeć od dwóch liczb $a$ i $b$, które podawane są na wejściu. Zatem należy użyć funkcji, która posiada dwa parametry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "cbe32e19-4669-453c-b5f5-4136b9eaa958",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj liczbę naturalną:"
       },
       "output_type": "stream",
       "value": "60"
      },
      "1": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": "Podaj liczbę naturalną:"
       },
       "output_type": "stream",
       "value": "48"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj liczbę naturalną: 60"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": "Podaj liczbę naturalną: 48"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NWD(60, 48) wynosi 12\n"
     ]
    }
   ],
   "source": [
    "def wczytaj() :\n",
    "    tekst = input('Podaj liczbę naturalną:')\n",
    "    while not tekst.isnumeric()  :\n",
    "        print(\"Nie podałeś liczby naturalnej!\")\n",
    "        tekst = input('Podaj liczbę naturalną:')\n",
    "    return int(tekst)\n",
    "\n",
    "def nwd(liczba1, liczba2) :\n",
    "    r = liczba1 % liczba2\n",
    "    while r > 0 :\n",
    "        liczba1 = liczba2\n",
    "        liczba2 = r\n",
    "        r = liczba1 % liczba2\n",
    "    return(liczba2)\n",
    "\n",
    "a = wczytaj()\n",
    "b = wczytaj()\n",
    "\n",
    "print(\"NWD(\" + str(a) + \", \" + str(b) + \") wynosi\", nwd(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "94531d41-5b77-4cae-9e5e-d577525b8e6f",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Kilka uwag dotyczących funkcji w Pythonie\n",
    "\n",
    "#### Przypisywanie wartości domyślnych argumentom funkcji\n",
    "\n",
    "W Pythonie możemy również definiować funkcje o wielu argumentach, ale wywoływać je z mniejszą liczbą argumentów, a pozostałym argumentom przypisać pewną wartość domyślną. W tym celu przy definiowaniu funkcji przypisujemy wartości domyślne wybranym argumentom. Dla przykładu, przyjrzyjmy się następującemu programowi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "69b232cc-aeae-4fed-85ac-ac2183e88465",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Proszę zapłacić następującą kwotę: 105.0 PLN\n",
      "Proszę zapłacić następującą kwotę: 110.0 PLN\n"
     ]
    }
   ],
   "source": [
    "def do_zaplaty(koszt, napiwek = 10):\n",
    "    suma = koszt * (1 + 0.01 * napiwek)\n",
    "    print(\"Proszę zapłacić następującą kwotę:\", round(suma, 2), \"PLN\")\n",
    "    \n",
    "do_zaplaty(100, 5)\n",
    "do_zaplaty(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7842e143-267a-4044-9c7e-c9e07149b467",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### Widoczność zmiennych używanych wewnątrz funkcji\n",
    "\n",
    "Jak już widzieliśmy powyżej, zmienne używane wewnątrz funkcji nie są widoczne na zewnątrz. Są one zmiennymi lokalnymi, \n",
    "z których może korzystać jedynie ta funkcja. Jednak zmienne używane w programie są widoczne przez funkcje, co pokazuje poniższy kod."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6cf393a9-a213-4f0a-ae66-e56c95006d3f",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "b = 10\n",
    "\n",
    "def zwieksz(a) :\n",
    "    return a + b\n",
    "\n",
    "a = 2\n",
    "print(zwieksz(a))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "046a9c2c-a82a-40a7-8811-8659b9ad3c91",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "**Uwaga:** W celu lepszej kontroli nad przekazywaniem wartościami z wnętrza funkcji na zewnątrz i odwrotnie, warto przyjąć zasadę, że funkcja używa jedynie wartości przekazywanych przez argumenty.\n",
    "\n",
    "Zatem zamiast używać takiego kodu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "f914992c-e8e3-46b1-98e0-90de2b5d7940",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "def zwieksz(a) :\n",
    "    return a + b\n",
    "\n",
    "b = 10\n",
    "a = 2\n",
    "print(zwieksz(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc45f205",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "znacznie bezpieczniej jest korzystać z następującego rozwiązania:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "4f5bf445-8c9b-4936-8982-7eb8c2f9e5d7",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "def zwieksz(a, b) :\n",
    "    return a + b\n",
    "\n",
    "b = 10\n",
    "a = 2\n",
    "print(zwieksz(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8270c034-e622-42ab-afbd-02034d5d659e",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### Listy jako argumenty\n",
    "\n",
    "Poniższe dwa przykłady pokazują, że w Pythonie wartości argumentów są przekazywane funkcji na dwa sposoby: przez skopiowanie wartości lub przez referencję, czyli przekazanie adresu pamięci, gdzie podany argument jest zapisany. Drugie rozwiązanie powoduje zatem, że wszystkie zmiany dokonane na argumencie będą również widoczne po zakończeniu jej działania. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "51fe1366-fc3e-41d0-bb76-3f50e25ea6ee",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Przed wywołaniem funkcji: 1\n",
      "Wewnątrz funkcji: 11\n",
      "Po wywołaniu funkcji: 1\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "  x += 10\n",
    "  print(\"Wewnątrz funkcji:\", x)\n",
    "\n",
    "a = 1\n",
    "print(\"Przed wywołaniem funkcji:\", a)\n",
    "f(a)\n",
    "print(\"Po wywołaniu funkcji:\", a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "394c7baf-afa7-4a2b-a65d-178ed132361a",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Przed wywołaniem funkcji: [1, 2, 3, 4]\n",
      "Wewnątrz funkcji: [11, 2, 3, 4]\n",
      "Po wywołaniu funkcji: [11, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "def f(lista_arg):\n",
    "  lista_arg[0] += 10\n",
    "  print(\"Wewnątrz funkcji:\", lista_arg)\n",
    "\n",
    "lista = [1, 2, 3, 4]\n",
    "print(\"Przed wywołaniem funkcji:\", lista)\n",
    "f(lista)\n",
    "print(\"Po wywołaniu funkcji:\", lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "acc7f0f9",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Jak pokazują dwa powyższe przykłady, zmienne liczbowe przekazywane są do funkcji jako argumenty poprzez skopiowanie ich wartości. Natomiast listy przekazywane są do funkcji jako argument przez referencję. Zatem zmiany dokonane przez funkcję na liście będą również widoczne po jej zakończeniu."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c95be9-bc56-49a0-aa34-ef8e427bc878",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "#### Działanie instrukcji return\n",
    "\n",
    "Warto zaznaczyć, że wewnątrz funkcji może być wiele instrukcji `return`. Jednak funkcja kończy działanie wraz z pierwszym wykonaniem instrukcji `return`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6de5857e-e798-4df3-bb3b-fd840b95584f",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To zobaczymy\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 17,
     "metadata": {
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def proba() :\n",
    "    print(\"To zobaczymy\")\n",
    "    return 1\n",
    "    print(\"Tego nie zobaczymy\")\n",
    "    return 2\n",
    "\n",
    "proba()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2b17d641-241d-4119-a5c8-8ba6ad244475",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nie\n"
     ]
    }
   ],
   "source": [
    "def czy_dodatnie(liczby) :\n",
    "    for x in liczby :\n",
    "        if x < 0 :\n",
    "            return \"Nie\"\n",
    "            # print(\"Tego nie zobaczymy\")\n",
    "    return \"Tak\"\n",
    "\n",
    "lista = [1, 2, -3, 4]\n",
    "print(czy_dodatnie(lista))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76b74210-14d0-4eac-b858-8ce1c84c58ad",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Przy okazji warto wspomnieć, że funkcja może również zwracać listę."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e50da8a2-d682-463e-825d-a06f274e789f",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": ""
       },
       "output_type": "stream",
       "value": "1 2 4 7 7 -1 24"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": " 1 2 4 7 7 -1 24"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 7, 7, -1, 24]\n"
     ]
    }
   ],
   "source": [
    "def zwroc_liste() :\n",
    "    return list(map(int,input().split()))\n",
    "\n",
    "print(zwroc_liste())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c6e1d37-83e4-4dad-a82b-5279f770217c",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### Funkcje lambda\n",
    "\n",
    "W języku Python istnieje również szybki i wygodny sposób definiowania prostych jednolinijkowych funkcji. Do tego służy instrukcja `lambda`, której składnia jest następująca:\n",
    "\n",
    "`lambda` (parametry) : (jednolinijkowe wyrażenie)\n",
    "\n",
    "Na przykład, zamiasta definiować funkcję `do_zaplaty` w ten sposób:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e106482b-4cf7-4f74-a4f0-8c74269c991c",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "110.0\n",
      "105.0\n"
     ]
    }
   ],
   "source": [
    "def do_zaplaty(koszt, napiwek = 10) :\n",
    "    return round(koszt * (1 + 0.01 * napiwek), 2)\n",
    "\n",
    "print(do_zaplaty(100))\n",
    "print(do_zaplaty(100,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2382d05-5437-48ca-bae1-02fd1310ba4c",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "możemy użyć funkcji `lambda` w następujący sposób:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1d44373c-394d-459f-b2f9-35bdad0b1a51",
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "110.0\n",
      "105.0\n"
     ]
    }
   ],
   "source": [
    "do_zaplaty_lambda = lambda koszt, napiwek = 10 : round(koszt * (1 + 0.01 * napiwek), 2)\n",
    "\n",
    "print(do_zaplaty_lambda(100))\n",
    "print(do_zaplaty_lambda(100, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56bf1788-7958-4db7-afef-59bbbf125e64",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "Funkcję `lambda` można również wykorzystać w sytuacjach, kiedy chcemy wywołać funkcję. Na przykład możemy to zrobić przy wywołaniu funkcji `map`, której jednym z argumentów jest również funkcja. Jak wiemy funkcja `map` posiada dwa argumenty: funkcję oraz listę. Jej działanie polega na zastosowaniu funkcji podanej jako pierwszy argument do każdego elementu z podanej listy. \n",
    "\n",
    "Jak zatem w szybki sposób wczytać liczby podane przez użytkownika i zapisać ich kwadraty jako elementy nowej listy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8e0ff5b6-885e-45f6-aa69-4b8d2c377b31",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": ""
       },
       "output_type": "stream",
       "value": "1 2 -3 4"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": " 1 2 -3 4"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16]\n"
     ]
    }
   ],
   "source": [
    "def kwadrat(x) :\n",
    "    return int(x)**2\n",
    "\n",
    "kwadraty = list(map(kwadrat, input().split()))\n",
    "\n",
    "print(kwadraty)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c97172bc-70a3-4145-ab56-f94800df262b",
   "metadata": {
    "cocalc": {
     "outputs": {
      "0": {
       "name": "input",
       "opts": {
        "password": false,
        "prompt": ""
       },
       "output_type": "stream",
       "value": "1 2 -10 15"
      }
     }
    },
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": " 1 2 -10 15"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 100, 225]\n"
     ]
    }
   ],
   "source": [
    "kwadraty = list(map(lambda x : int(x)**2, input().split()))\n",
    "\n",
    "print(kwadraty)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b83289b9-eed8-4de0-a0af-3ae1719afe65",
   "metadata": {
    "collapsed": false
   },
   "source": [
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ad7b475-eb7e-4892-8981-d4ef03609930",
   "metadata": {
    "collapsed": false
   },
   "source": [
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66dec1cf-8b84-4fb3-8a33-9ef7fbd1bcf4",
   "metadata": {
    "collapsed": false
   },
   "source": [
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c3d90ef-d80d-4fac-a1a6-0dcaaa28e391",
   "metadata": {
    "collapsed": false
   },
   "source": [
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bb9e49d9-42a3-447d-9f40-535fc951d0f7",
   "metadata": {
    "collapsed": false
   },
   "source": [
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "argv": [
    "/usr/bin/python3",
    "-m",
    "ipykernel",
    "--HistoryManager.enabled=False",
    "--matplotlib=inline",
    "-c",
    "%config InlineBackend.figure_formats = set(['retina'])\nimport matplotlib; matplotlib.rcParams['figure.figsize'] = (12, 7)",
    "-f",
    "{connection_file}"
   ],
   "display_name": "Python 3 (system-wide)",
   "env": {
   },
   "language": "python",
   "metadata": {
    "cocalc": {
     "description": "Python 3 programming language",
     "priority": 100,
     "url": "https://www.python.org/"
    }
   },
   "name": "python3",
   "resource_dir": "/ext/jupyter/kernels/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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}