kl_py_alapok_01.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "kl_py_alapok_01.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "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"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/klajosw/python/blob/master/kl_py_alapok_01.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VJmwTrmZPtU-",
        "colab_type": "text"
      },
      "source": [
        "<p align=\"left\"> \n",
        "    <img src=\"https://raw.githubusercontent.com/klajosw/python/master/kl_mie_python_logo_250.jpg\" \n",
        "         align=\"left\" width=\"251\" height=\"251\">\n",
        "    \n",
        "</p>\n",
        "\n",
        "\n",
        "<p> </p>\n",
        "\n",
        "\n",
        "\n",
        "# Python alapok 1\n",
        "\n",
        "<https://klajosw.blogspot.com/>\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "ook4dftq76_j"
      },
      "source": [
        "# Python alapok 1.\n",
        "\n",
        "\n",
        "## Python programozási nyelv alapok\n",
        "\n",
        "\n",
        "### Standard adatfolyamok\n",
        "\n",
        "Az operációs rendszer indításkor minden folyamathoz hozzárendel 3 szabványos adatfolyamot: \n",
        "\n",
        "- a standard bemenetet, \n",
        "- a standard kimenetet, \n",
        "- és a standard hibakimenetet. \n",
        "\n",
        "Alapértelmezés szerint a standard bemenet a billentyűzettel, a standard kimenet és hibakimenet pedig a képernyővel van\n",
        "összekötve. \n",
        "\n",
        "Ez a beállítás módosítható, pl. a standard bemenet érkezhet egy fájlból vagy egy másik programból, a standard kimenet és hibakimenet pedig íródhat fájlba vagy továbbítódhat másik programnak.\n",
        "\n",
        "\n",
        "#### Standard bemenet\n",
        "A standard bemenetről adatokat bekérni az `input` függvény segítségével lehetséges. \n",
        "\n",
        "Az eredmény sztring típusú. Ha más adattípusra van szükség, akkor konvertálni kell.\n",
        "\n",
        "\n",
        "\n",
        "#### Standard kimenet és hibakimenet\n",
        "\n",
        "A standard kimenetre és hibakimenetre kiírni a `print` függvény segítségével lehet.\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "fkLCtvEP76_q"
      },
      "source": [
        "\n",
        "### Kimenetre írás (print)  (Standard kimenet)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "IAAM1cvj76_q",
        "colab": {}
      },
      "source": [
        "## több változó kiírása vesszövel tagoltan\n",
        "print('Lajos', 57, 'BI', 40+2)\n",
        "\n",
        "## összefüzéses kiíratás\n",
        "print('Kecskeméti' + ' ' +'Lajos')\n",
        "\n",
        "## Újsor jelzés kikapcsolása\n",
        "print('a',end=' ') \n",
        "print('b',end=' ') \n",
        "print('c')\n",
        "\n",
        "## promázott kiíratás\n",
        "print('{0:.3f}'.format(1.033/33)) \n",
        "print('{0:_^13}'.format('Szia'))\n",
        "print('{name} született {born} -ben'.format(name='Lajos', born=62))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "Usu1X9DF76_v"
      },
      "source": [
        "\n",
        "### Adat, szöveg bekérés  (standard bemenet)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "CRrFsNBB76_w",
        "colab": {}
      },
      "source": [
        "szoveg=input('Adj meg egy szöveget : ')\n",
        "szam = int(input('Kérek egy számot : '))\n",
        "print(szoveg, szam)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "J5pDDB4L76_1"
      },
      "source": [
        "\n",
        "### Program tagolás behuzással (Indentation)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "eUcgYc9R76_2",
        "colab": {}
      },
      "source": [
        "# from __future__ import braces\n",
        "\n",
        "i=5\n",
        "if i < 10:\n",
        "    print(i)\n",
        "    i = i + 1  # növel 1-el\n",
        "    i += 4     # növel 4-el\n",
        "    i *= 2     # megkétszerez\n",
        "print(i)\n",
        "\n",
        "if True:\n",
        "    print('Ez egy mindíg igaz állítás')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F-q2rlqFPtVQ",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "itNNWx5OPtVR",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "---\n",
        "\n",
        "## Vezérlési szerkezetek\n",
        "\n",
        "\n",
        "Pythonban a vezérlési szerkezetek belsejét indentálással (azaz beljebb írással) kell jelölni. Emiatt garantált, hogy a program megjelenése és logikai jelentése összhangban van.\n",
        "\n",
        "\n",
        "\n",
        "#### Vezérlési szerkezetek\n",
        "\n",
        " - if elif else      // elágazás\n",
        " - for x in sorozat  // For ciklus\n",
        " - while             // while ciklus\n",
        "\n",
        "\n",
        "\n",
        "### Program elágazások, if utasítás Szintaxis:\n",
        "\n",
        "\n",
        "if FELTÉTEL1: \n",
        "\n",
        "->   UTASÍTÁS1 \n",
        "   \n",
        "elif FELTÉTEL2: \n",
        "\n",
        "->   UTASÍTÁS2 \n",
        "   \n",
        "else: \n",
        "\n",
        " -> UTASÍTÁS3\n",
        "\n",
        "\n",
        "\n",
        "#### Megjegyzések: \n",
        "\n",
        " - Több elif ág is szerepelhet. \n",
        " \n",
        " - Az elif ágak és az else ág is elhagyható. \n",
        " \n",
        " - Ha az utasítás 1 soros, akkor írható az if-fel elif-fel ill. az else-zel azonos sorba.\n",
        " \n",
        "---\n",
        " \n",
        " -  for x in lista:\n",
        "        Lista elemei kerülnek x-be \n",
        "       \n",
        "      \n",
        " - for x in tuple: \n",
        "       Tuple elemei kerülnek x-be \n",
        "       \n",
        "       \n",
        " - for x in sztring: \n",
        "       String karakterei kerülnek x-be\n",
        "       \n",
        "       \n",
        " - Szekvencia generálás listaként: \n",
        "       range() \n",
        "       range(5)  ->  [0, 1, 2, 3, 4]\n",
        "       \n",
        "   \n",
        "---\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GfYuHPDsPtVS",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "szam = 1\n",
        "szam = int(input(\"Szám? \"))   \n",
        "paros = []      # ures lista (bővitgetés miatt) \n",
        "paratlan = []   # ures lista (bővitgetés miatt) \n",
        "while ( szam != 0 ):\n",
        "    szam = int(input(\"Szám? \"))    \n",
        "    if (szam != 0):        \n",
        "        if (szam % 2 == 0):    \n",
        "            paros.append(szam)        \n",
        "        else:\n",
        "            paratlan.append(szam) \n",
        "            \n",
        "print (\"Párosak: \", paros) \n",
        "print (\"Páratlanok: \", paratlan)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Zx4qRj5xPtVV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Példa: Kérsz páleszt? \n",
        "x = int(input('Hány éves vagy? ')) \n",
        "if x >= 18: \n",
        "    print('Kérsz sört?') \n",
        "else: \n",
        "    print('Nem adhatok páleszt.')\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "67am7lPIPtVZ",
        "colab_type": "code",
        "colab": {},
        "outputId": "f709b545-f4b6-49a4-a979-870c039c6648"
      },
      "source": [
        " # Példa: Másodfokú egyenlet megoldó. \n",
        "a = float(input('a: '))\n",
        "b = float(input('b: '))\n",
        "c = float(input('c: '))\n",
        "d = b**2 - 4 * a * c \n",
        "if d > 0: \n",
        "    x1 = (-b + d**0.5) / (2 * a) \n",
        "    x2 = (-b - d**0.5) / (2 * a) \n",
        "    print(x1, x2) \n",
        "elif d == 0: \n",
        "    x1 = -b / (2 * a) \n",
        "    print(x1) \n",
        "else: print('Nincs megoldása!')\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a: 2\n",
            "b: 3\n",
            "c: 1\n",
            "-0.5 -1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KBaTOpIwPtVc",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "bsmIwj-K76_4"
      },
      "source": [
        "\n",
        "---\n",
        "\n",
        "## Ciklusok\n",
        "\n",
        "### for ciklus\n",
        "\n",
        "\n",
        "\n",
        "Megjegyzések: \n",
        "\n",
        " - A szekvencia lehet egész számok folytonos sorozata, de lehet más is \n",
        "    (pl. sztring, tuple, lista, halmaz, szótár, megnyitott fájl). \n",
        "    \n",
        "    \n",
        " - Akkor érdemes for ciklust alkalmazni, ha \n",
        "    \n",
        "          A) a szekvencia már rendelkezésre állv \n",
        "          \n",
        "          B) a ciklus kezdetekor tudjuk az iterációk számát.\n",
        "          \n",
        "          \n",
        "---    \n",
        "    "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "4Wj1elJB76_5",
        "outputId": "9cea962e-be70-4cbc-a4e1-184ea8805625",
        "colab": {}
      },
      "source": [
        "for i in range(1,5):\n",
        "    print('Számoljunk', i) \n",
        "else:\n",
        "    print('A for ciklus végetért')\n",
        "    \n",
        "print('Ez mindíg megjelenik')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Számoljunk 1\n",
            "Számoljunk 2\n",
            "Számoljunk 3\n",
            "Számoljunk 4\n",
            "A for ciklus végetért\n",
            "Ez mindíg megjelenik\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "LnuDRhhI76_7",
        "outputId": "cb8a5a77-4ecf-4dba-d73a-2a14dd1eb13a",
        "colab": {}
      },
      "source": [
        "## Kiolvasó ciklus 1.\n",
        "szamok = ['egy', 'kettő', 'három', 'négy']\n",
        "for p in szamok:\n",
        "    print(p, ' szám hossza ', len(p))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "egy  szám hossza  3\n",
            "kettő  szám hossza  5\n",
            "három  szám hossza  5\n",
            "négy  szám hossza  4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "xEoJNSCD76_9",
        "outputId": "953895ad-b890-4a38-9225-9d5cfc0a763e",
        "colab": {}
      },
      "source": [
        "## Kiolvasó ciklus 2.\n",
        "szamok = ['egy', 'kettő', 'három', 'négy']\n",
        "for i in range(len(szamok)):\n",
        "    print(i, szamok[i])\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 egy\n",
            "1 kettő\n",
            "2 három\n",
            "3 négy\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "8n_JPx8x77AA",
        "outputId": "c4426e1f-9178-4835-dc99-fb87262e82e9",
        "colab": {}
      },
      "source": [
        "# Prim keresés\n",
        "for n in range(2, 21):\n",
        "    for x in range(2, n):\n",
        "        if n % x == 0:\n",
        "            print(n, ' nem prim, felbontható', x, '*', n/x)\n",
        "            break\n",
        "    else:\n",
        "        # sigue el bucle sin encontrar un factor\n",
        "        print(n, ' Ez prim szám ')\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2  Ez prim szám \n",
            "3  Ez prim szám \n",
            "4  nem prim, felbontható 2 * 2.0\n",
            "5  Ez prim szám \n",
            "6  nem prim, felbontható 2 * 3.0\n",
            "7  Ez prim szám \n",
            "8  nem prim, felbontható 2 * 4.0\n",
            "9  nem prim, felbontható 3 * 3.0\n",
            "10  nem prim, felbontható 2 * 5.0\n",
            "11  Ez prim szám \n",
            "12  nem prim, felbontható 2 * 6.0\n",
            "13  Ez prim szám \n",
            "14  nem prim, felbontható 2 * 7.0\n",
            "15  nem prim, felbontható 3 * 5.0\n",
            "16  nem prim, felbontható 2 * 8.0\n",
            "17  Ez prim szám \n",
            "18  nem prim, felbontható 2 * 9.0\n",
            "19  Ez prim szám \n",
            "20  nem prim, felbontható 2 * 10.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "m3Tpew_077AC",
        "outputId": "d392237e-4bf7-44d4-e0c3-64ee3bc2e4dc",
        "colab": {}
      },
      "source": [
        "print('range(10)       = ', range(10))\n",
        "print('list(range(10)) =', list(range(10)))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "range(10)       =  range(0, 10)\n",
            "list(range(10)) = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "wWi_bZpG77AE"
      },
      "source": [
        "\n",
        "---\n",
        "\n",
        "### While ciklus\n",
        "\n",
        "\n",
        "Megjegyzések: \n",
        "\n",
        " - Egy jól megírt program esetén az utasítás a feltételt előbb-utóbb hamisra állítja. \n",
        "    (Ellenkező esetben végtelen ciklus keletkezik.) \n",
        "    \n",
        " - Akkor érdemes while ciklust alkalmazni, ha a ciklus elején még nem tudjuk pontosan az iterációk számát.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "-CAjKPLl77AF",
        "outputId": "53b0f6b2-b6f3-4e74-b26a-0a72ca5c7be0",
        "colab": {}
      },
      "source": [
        "number=42 \n",
        "kerdez=True\n",
        "tip=0\n",
        "while kerdez:\n",
        "    guess=int(input('Kérek egy számot (1-100 között) : '))\n",
        "    tip+=1\n",
        "    if guess == number:\n",
        "        print('Gratulálok eltaláltad. Neked ', tip, 'tipelésed volt.')\n",
        "        kerdez=False\n",
        "    elif guess < number:\n",
        "        print('Nem talált nagyobbat adjál meg.') \n",
        "    else:\n",
        "        print('Nem talált kisebbet adjál meg.') \n",
        "else:\t\t\t\t\n",
        "    print('Itt a while ciklus vége.')\n",
        "\n",
        "print('Kész vagyunk. Ha háromból eltaláltad ügyes vagy.')\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Kérek egy számot (1-100 között) : 45\n",
            "Nem talált kisebbet adjál meg.\n",
            "Kérek egy számot (1-100 között) : 25\n",
            "Nem talált nagyobbat adjál meg.\n",
            "Kérek egy számot (1-100 között) : 31\n",
            "Nem talált nagyobbat adjál meg.\n",
            "Kérek egy számot (1-100 között) : 35\n",
            "Nem talált nagyobbat adjál meg.\n",
            "Kérek egy számot (1-100 között) : 41\n",
            "Nem talált nagyobbat adjál meg.\n",
            "Kérek egy számot (1-100 között) : 43\n",
            "Nem talált kisebbet adjál meg.\n",
            "Kérek egy számot (1-100 között) : 42\n",
            "Gratulálok eltaláltad. Neked  7 tipelésed volt.\n",
            "Itt a while ciklus vége.\n",
            "Kész vagyunk. Ha háromból eltaláltad ügyes vagy.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "TyOuXgP477AH",
        "outputId": "2638d73c-bef7-4006-ab36-c539eb1ca7b5",
        "colab": {}
      },
      "source": [
        "## Fibonacci sor whilde ciklussal:\n",
        "a, b = 0, 1\n",
        "while b < 100:\n",
        "    print(b, end=' -> ')  ## Egysorvba legyen az eredmény\n",
        "    a, b = b, a+b\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 -> 1 -> 2 -> 3 -> 5 -> 8 -> 13 -> 21 -> 34 -> 55 -> 89 -> "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cNnyIP1sPtVz",
        "colab_type": "code",
        "colab": {},
        "outputId": "d5b9c0a7-9f93-4672-f216-2c2ff2e85a9f"
      },
      "source": [
        "while True: # Most nem ismert a ciklusok száma.\n",
        "    s= input(\" Kérek egy szöveget: \")\n",
        "    s= s.upper()\n",
        "    print(s)\n",
        "    if \"STOP\" in s:\n",
        "        break # A ciklus megtörése.\n",
        "print('Vége')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            " Kérek egy szöveget: 1\n",
            "1\n",
            " Kérek egy szöveget: 2\n",
            "2\n",
            " Kérek egy szöveget: 3\n",
            "3\n",
            " Kérek egy szöveget: STOP\n",
            "STOP\n",
            "Vége\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "U0bdkpXL77Ah"
      },
      "source": [
        "\n",
        "---\n",
        "\n",
        "\n",
        "### Függvények\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#### Az iteráció, rekurzió\n",
        "\n",
        "Az `iteráció` legfőbb tulajdonsága az időbeni ismétlés, egy kódrészlet időben egymás utáni többszöri végrehajtása. \n",
        "\n",
        "Egy másik típusú ismétlés a `rekurzió`, amikor ugyancsak megtörténik az időbeli ismétlés, de emellett a kódblokk fizikailag is megtöbbszöröződik.\n",
        "\n",
        "\n",
        "\n",
        "#### Különleges paraméterezés\n",
        "\n",
        "A függvény rábízhatjuk a megadott argumentumaink sokaságba foglalását, ha ezt a függvény definíciójában jelezzük neki, amihez csupán egy ` * `-ot kell az argumentum elé illeszteni. \n",
        "\n",
        "Sőt még ennél többet is tehetünk, ha telhetetlenül ` ** ` „biggyesztünk” oda, mert ekkor nevesített argumentumokat adhatunk meg, amelyekből az értelmező egy szótárt készít.\n",
        "\n",
        "\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "wKXONp0377Ai",
        "outputId": "591f297a-2a40-42ea-e22e-deb55d3b3fd1",
        "colab": {}
      },
      "source": [
        "def fib(n):         # Függvény Fibonacci sor kiszámolására\n",
        "      \"\"\"Függvény Fibonacci sor kiszámolására.\"\"\"\n",
        "      a, b = 0, 1\n",
        "      while a < n:\n",
        "          print(a, end=' ')\n",
        "          a, b = b, a+b\n",
        "    \n",
        "\n",
        "def fib2(n):         # Függvény Fibonacci sor listába írására\n",
        "    \"\"\"Függvény Fibonacci sor listába írására.\"\"\"\n",
        "    result = []\n",
        "    a, b = 0, 1\n",
        "    while a < n:\n",
        "           result.append(a)    # ver abajo\n",
        "           a, b = b, a+b\n",
        "    return result\n",
        "\n",
        "\n",
        "print(fib(2000))  ## Deffinició meghívása\n",
        "\n",
        "print(fib) ## fib typus lekérése :  <function fib at 0x00000192AEF69DC8>\n",
        "\n",
        "f = fib    ## alias létrehozása f névvel\n",
        "print( f(100) )    ## Deffinició meghívása\n",
        "\n",
        "print(fib(0))  ## Nincs eredmény  : None\n",
        "\n",
        "print('fib2(100)  = ', fib2(100))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 None\n",
            "<function fib at 0x00000192AEF69828>\n",
            "0 1 1 2 3 5 8 13 21 34 55 89 None\n",
            "None\n",
            "fib2(100)  =  [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "j8RvU8N477Aj",
        "outputId": "d62c162a-3b53-4272-818f-c6ebc25eae91",
        "colab": {}
      },
      "source": [
        "def f(a, L=[]):\n",
        "    L.append(a)\n",
        "    return L\n",
        "\n",
        "def f2(a, L=None):\n",
        "    if L is None:\n",
        "        L = []\n",
        "    L.append(a)\n",
        "    return L\n",
        "\n",
        "print(f(1))\n",
        "print(f(2))\n",
        "print(f(3))\n",
        "\n",
        "print(f2(1))\n",
        "print(f2(2))\n",
        "print(f2(3))\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1]\n",
            "[1, 2]\n",
            "[1, 2, 3]\n",
            "[1]\n",
            "[2]\n",
            "[3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "jHakcPkK77Al",
        "outputId": "72a9f127-743b-4f30-a9c1-9173ea334b30",
        "colab": {}
      },
      "source": [
        "## paraméter átadás\n",
        "def param_olvaso(valt, *argument, **lista):\n",
        "    print(\"Változó : \", valt, \" OK\")\n",
        "\n",
        "    for arg in argument:\n",
        "        print(arg)\n",
        "    print(\"-\" * 40)  ## Elválasztás kiírása\n",
        "    claves = sorted(lista.keys())\n",
        "    for c in claves:\n",
        "        print(c, \":\", lista[c])\n",
        "        \n",
        "param_olvaso(\"Lajos\", \"Egyes1.\",\n",
        "             \"kettes2.\",\n",
        "             cliente=\"Dani\",\n",
        "             vendedor=\"Tomi\",\n",
        "             join=\"Testvérek\")\n",
        "\n",
        "#--------------------------------------\n",
        "\n",
        "def concatenar(*args, sep=\"/\"):\n",
        "    return sep.join(args)\n",
        "\n",
        "print(concatenar(\"Lajos\", \"Tamás\", \"Dani\"))\n",
        "print(concatenar(\"Lajos\", \"Tamás\", \"Dani\", sep=\".\"))\n",
        "\n",
        "\n",
        "#-------------------------------------\n",
        "def lambda_incrementor(n):\n",
        "    \"\"\" Ez a függvény használja a lambda függvényt\n",
        "    a deffiniciós részében\n",
        "    érdekes lehet\"\"\"\n",
        "    return lambda x: x + n  ## névtelen függvény használata\n",
        "\n",
        "f = lambda_incrementor(42)\n",
        "print(f(0))\n",
        "print(f(5))\n",
        "\n",
        "print(lambda_incrementor.__doc__)  ## függvény dokumentációs infó megjelenítése\n",
        "\n",
        "        "
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Változó :  Lajos  OK\n",
            "Egyes1.\n",
            "kettes2.\n",
            "----------------------------------------\n",
            "cliente : Dani\n",
            "join : Testvérek\n",
            "vendedor : Tomi\n",
            "Lajos/Tamás/Dani\n",
            "Lajos.Tamás.Dani\n",
            "42\n",
            "47\n",
            " Ez a függvény használja a lambda függvényt\n",
            "    a deffiniciós részében\n",
            "    érdekes lehet\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "ZqUU1-3F77An",
        "colab": {}
      },
      "source": [
        "## modul tartalma  /// fibo.py\n",
        "\n",
        "def fib(n):    \n",
        "    a, b = 0, 1\n",
        "    while b < n:\n",
        "        print(b, end=' ')\n",
        "        a, b = b, a+b\n",
        "     print()\n",
        "    \n",
        "def fib2(n): \n",
        "    resultado = []\n",
        "    a, b = 0, 1\n",
        "    while b < n:\n",
        "        resultado.append(b)\n",
        "        a, b = b, a+b\n",
        "    return resultado\n",
        "\n",
        "## modul használat\n",
        "\n",
        "from fibo import *\n",
        "from fibo import fib, fib2\n",
        "\n",
        "imp.reload(fibo)\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    import sys\n",
        "    fib(int(sys.argv[1]))\n",
        "    \n",
        "    \n",
        "# modul használatos meghívás \n",
        "python fibo.py 50\n",
        "\n",
        "\n",
        "\n",
        "# modul info megjelenítése\n",
        "import fibo, sys\n",
        "dir(fibo)\n",
        "\n",
        "\n",
        "## modul elérési könyvtár lista bővítése\n",
        "import sys\n",
        "sys.path.append('/ufs/guido/lib/python') \n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EgboSd9tPtWC",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Generátorok\n",
        "\n",
        "Egy generátor értékeket \"generál\" amikor kérik, a helyett, hogy előre eltárolná őket.\n",
        "\n",
        "\n",
        "A generátorobjektum nem tartalmazza „készen” az elemeit, mint például a listák, karakterláncok és a többi konténer típusú objektum, s ezért nem is lehet indexelni, de bejárni igen. \n",
        "\n",
        "\n",
        "Az elemeket csak kérésre hozza létre, mindig csak egyet, s ez az a tulajdonsága, ami miatt esetenként nagyon hasznos, mert kevés memoria helyet igényel.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ynv3lre5PtWC",
        "colab_type": "code",
        "colab": {},
        "outputId": "9cf40ec2-43d4-490d-e627-9632b217140a"
      },
      "source": [
        "# A következő metódus (ez még NEM egy generátor) megduplázza a kapott iterable elemeit,\n",
        "# és eltárolja őket. Nagy méretű iterable esetén ez nagyon sok helyet foglalhat!\n",
        "\n",
        "def double_numbers(iterable):\n",
        "    double_arr = []\n",
        "    for i in iterable:\n",
        "        double_arr.append(i + i)\n",
        "    return double_arr\n",
        "\n",
        "\n",
        "# A következő kód futtatásakor az összes szám kétszeresét kiszámítanánk, és visszaadnánk\n",
        "# ezt a nagy listát a ciklus vezérléséhez.\n",
        "\n",
        "for value in double_numbers(range(1000000)):  # `test_non_generator`\n",
        "    print (value)\n",
        "    if value > 5:\n",
        "        break\n",
        "\n",
        "\n",
        "\n",
        "# Használjunk inkább egy generátort, ami \"legenerálja\" a soron következő elemet,\n",
        "# amikor azt kérik tőle\n",
        "\n",
        "def double_numbers_generator(iterable):\n",
        "    for i in iterable:\n",
        "        yield i + i\n",
        "\n",
        " \n",
        "\n",
        "# A lenti kód mindig csak a soron következő számot generálja a logikai vizsgálat előtt.\n",
        "# Így amikor az érték eléri a > 5 határt, megszakítjuk a ciklust, és a lista számainak\n",
        "# nagy részénél megspóroltuk a duplázás műveletet (ez sokkal gyorsabb így!).\n",
        "\n",
        "for value in double_numbers_generator(range(1000000)):  # `test_generator`\n",
        "    print (value)\n",
        "    if value > 5:\n",
        "        break\n",
        "\n",
        " \n",
        "\n",
        "\n",
        "# csak akkor generálja le a következő számot, amikor kérjük\n",
        "# - esetünkben a ciklus következő iterációjakor\n",
        "\n",
        "\n",
        "\n",
        "# A lista képzéshez hasonlóan generátor képzőket is használhatunk  (\"generator comprehensions\").\n",
        "values = (-x for x in [1, 2, 3, 4, 5])\n",
        "for x in values:\n",
        "    print(x)      # kimenet: -1 -2 -3 -4 -5\n",
        "\n",
        " \n",
        "\n",
        "# Egy generátor összes generált elemét listaként is elkérhetjük:\n",
        "\n",
        "values = (-x for x in [1, 2, 3, 4, 5])\n",
        "gen_to_list = list(values)\n",
        "print(gen_to_list)  # => [-1, -2, -3, -4, -5]\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "2\n",
            "4\n",
            "6\n",
            "0\n",
            "2\n",
            "4\n",
            "6\n",
            "-1\n",
            "-2\n",
            "-3\n",
            "-4\n",
            "-5\n",
            "[-1, -2, -3, -4, -5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lqX4xxN-PtWF",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "## Dekorátorok\n",
        "\n",
        "A dekorátor egy magasabb rendű függvény, aminek bemenete és kimenete is egy függvény.\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nkEaaouRPtWF",
        "colab_type": "code",
        "colab": {},
        "outputId": "9d7bfe48-1aba-43fb-a3dd-4cb8eb970e73"
      },
      "source": [
        "# A lenti egyszerű példában az add_apples dekorátor a dekorált get_fruits függvény\n",
        "# kimenetébe beszúrja az 'Apple' elemet.\n",
        "\n",
        "def add_apples(func):\n",
        "    def get_fruits():\n",
        "        fruits = func()\n",
        "        fruits.append('Apple')\n",
        "        return fruits\n",
        "    return get_fruits\n",
        " \n",
        "\n",
        "@add_apples\n",
        "def get_fruits():\n",
        "    return ['Banana', 'Mango', 'Orange']\n",
        "\n",
        "# A kimenet tartalmazza az 'Apple' elemet:\n",
        "# Banana, Mango, Orange, Apple\n",
        "print (', '.join(get_fruits()))\n",
        "\n",
        "print(' ---------------------------------') \n",
        "\n",
        "# Ebben a példában a beg dekorátorral látjuk el a say függvényt.\n",
        "# Beg meghívja say-t. Ha a say_please paraméter igaz, akkor\n",
        "# megváltoztatja az eredmény mondatot.\n",
        "\n",
        "from functools import wraps \n",
        "\n",
        "def beg(target_function):\n",
        "    @wraps(target_function) \n",
        "    def wrapper(*args, **kwargs):\n",
        "        msg, say_please = target_function(*args, **kwargs)\n",
        "        if say_please:\n",
        "            return \"{} {}\".format(msg, \"Kérem! Segítsen rajtam:(\")\n",
        "        return msg\n",
        "    return wrapper \n",
        "\n",
        "@beg\n",
        "def say(say_please=False):\n",
        "    msg = \"Kaphatok egy sört?\"\n",
        "    return msg, say_please\n",
        "\n",
        "print (say())                  # Kaphatok egy sört?\n",
        "print (say(say_please=True))   # Kaphatok egy sört?  Kérem! Segítsen rajtam:(\n"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Banana, Mango, Orange, Apple\n",
            " ---------------------------------\n",
            "Kaphatok egy sört?\n",
            "Kaphatok egy sört? Kérem! Segítsen rajtam:(\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}