{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Algoritmusok Python nyelven\n", "\n", "## 2. Előadás, Függvények, egyszerű adattípusok, adatszerkezetek.\n", "\n", "### 2020. február 20." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Technikai információk\n", "\n", "### Diák elérhetősége:\n", "[damasdigabor.web.elte.hu/teaching](https://damasdigabor.web.elte.hu/teaching)\n", "\n", "Óra kezdés: 14:00" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Python\n", " - Indentálás, nem kell pontosvessző\n", " - Dinamikus típusok\n", " - Értékadásnál először a jobb oldal kiértékelődik, majd a bal oldalon lévő nevet hozzárendeljük az eredményhez." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Apróságok\n", " - A `#`-al kezdődő sorok kommentek, nem befolyásolják a programot. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "2+2\n", "# 2+3\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import this" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### break és continue\n", "\n", "- `break`: ha korábban ki akarunk lépni egy ciklusból\n", "- `continue`: ha korábban szeretnénk a következő ciklus futásra lépni" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(10):\n", " if i % 2 == 0:\n", " continue\n", " print(i)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "for i in range(10):\n", " if i > 4:\n", " break\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Függvények" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def foo():\n", " print(\"én egy nagyon okos függvény vagyok\")\n", " \n", "foo()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Függvény argumentumok, paraméterek \n", "\n", "1. pozíció szerinti (positional)\n", "2. kulcsszavas (named or keyword arguments)\n", "\n", "Először a pozíció szerintieket kell írni aztán a kulcsszavasokat" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def foo(arg1, arg2, arg3):\n", " print(\"arg1 \", arg1)\n", " print(\"arg2 \", arg2)\n", " print(\"arg3 \", arg3)\n", " \n", "foo(1, 2, \"asdfs\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "foo(1, arg3=2, arg2=29)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "arg3=4" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Visszatérési érték, a `return` parancs\n", "\n", "- Egy függvénynek több visszatérési értéke is lehet\n", " - Ilyenkor az értékek egy tuple-be kerülnek.\n", "- ha a függvény futása úgy ér véget, hogy nem ér el `return` parancsot, a visszatérési érték automatikusan `None` lesz.\n", "- Egy üres `return` parancs is `None`-nal tér vissza. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def foo(n):\n", " if n < 0:\n", " return \"negative\"\n", " if 0 <= n < 10:\n", " return \"positive\", n\n", " # return None\n", " # return\n", "\n", "print(foo(-2))\n", "print(foo(3), type(foo(3)))\n", "print(foo(12))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Mit is jelent, hogy egy függvényt meghívunk valamilyen argumentumokkal?\n", " - Létrejön egy lokális változó a paraméter névvel és az argumentumra fog mutatni. \n", " - Tényleg az átadott objektumra fog mutatni és nem csak egy másolatra!\n", " - Alapvetően az át nem adott objektumokat viszont nem látja!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l=[\"matek\"]\n", "def add_matek(k):\n", " k.append(\"matek\")\n", "\n", "print(l)\n", "add_matek(l)\n", "print(l)\n", "add_matek(l)\n", "print(l)\n", "#print(k)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s=\"matek\"\n", "def add_matek(k):\n", " k=k+\"matek\"\n", "\n", "print(s)\n", "add_matek(s)\n", "print(s)\n", "add_matek(s)\n", "print(s)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s=\"matek\"\n", "def add_matek():\n", " s=s+\"matek\"\n", "\n", "print(s)\n", "add_matek(s)\n", "print(s)\n", "add_matek(s)\n", "print(s)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "## Alapértelmezett argumentum (Default arguments)\n", "\n", "- Az argumentumoknak lehet alapértelmezett értéke. Ha nem érkezik egy ilyen paraméterhez argumentum akkor az alapértelmezett argumentumot kapja meg a függvény\n", "- Először kell megadni azokat az argumentumokat, amiknek nincs alapértelmezett értéke." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "scrolled": true }, "outputs": [], "source": [ "def foo(arg1, arg2, arg3=3):\n", " print(\"arg1 \", arg1)\n", " print(\"arg2 \", arg2)\n", " print(\"arg3 \", arg3)\n", "foo(1, 2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "foo(2, arg2=1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "foo(arg1=1, arg3=33, arg2=222)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Tetszőleges kihagyható közülük. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def foo(arg1, arg2=2, arg3=3):\n", " print(\"arg1 \", arg1)\n", " print(\"arg2 \", arg2)\n", " print(\"arg3 \", arg3)\n", " \n", "foo(11, 33)\n", "print(\"\")\n", "foo(11, arg3=33)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Emiatt rengeteg argumentumod lehet úgy is, hogy ez nem nehezíti meg a függvény használatát. Sok könyvtárban találunk olyan függvényeket, amiknek rengeteg argumentumunk van." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Például a következő függvényt a `pandas` könyvtárban találjuk:\n", "\n", "~~~python\n", " pandas.read_csv(filepath_or_buffer, sep=', ', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None, decimal=b'.', lineterminator=None, quotechar='\"', quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=False, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, skip_footer=0, doublequote=True, delim_whitespace=False, as_recarray=False, compact_ints=False, use_unsigned=False, low_memory=True, buffer_lines=None, memory_map=False, float_precision=None)\n", " ~~~" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Dinamikus tipusok\n", "\n", "- nem kell deklarálni a változókat\n", "- az értékadás tetszőleges objektumra működik" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "i = 2\n", "type(i), id(i)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "i = \"foo\"\n", "type(i), id(i)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Erősen típusos nyelv\n", "\n", "- a legtöbb implicit konverzió nem megengedett.\n", "- numerikus típusok között lehet konvertálni:" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "i = 2\n", "f = 1.2\n", "s = i + f\n", "print(type(i), type(f))\n", "print(type(i + f))\n", "print(s,type(s))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- konverzió stringek és numerikus típusok között nem megengedett" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# print(\"Nekem \" + 3.1415 + \" az IQ-m\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "Viszont explicit konverzióval működik:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(\"Nekem \" + str(3.1415) + \" az IQ-m\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Beépített típusok és operátorok.\n", " - Boolean (Igazság)\n", " - Numerikus (Szám)\n", " - String (Szöveg)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### boolean operátorok\n", "\n", "- három boolean operátor van: `and`, `or` and `not`" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "x = 2\n", "\n", "x < 2 or x >= 2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x > 0 and x < 10" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "not x < 0" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### boolean típus\n", "\n", "- két boolean érték: `True` és `False` (nagybetűvel kell kezdeni!!!)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = True\n", "type(x)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "True and False" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "True or False" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "not True" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "True and True and False" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Numerikus típusok\n", "\n", "- három numerikus típus: `int`, `float` and `complex`\n", "- a kezdeti értéktől függ az objektum típusa" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "i = 2\n", "f = 1.2\n", "c = 1+2j\n", "\n", "type(i), type(f), type(c)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- implicit konverzió működik köztük aritmetikai műveletek esetén\n", "- az eredmény típusa mindig a legkevesebb információ veszteséggel járó típus" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "c2 = i + c\n", "print(c2, type(c2))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Tartomány\n", "\n", "- Az egészek tetszőleges méretűek lehetnek, csak a számítógép hardver oldala szab határt.\n", "- Python 2-ben más a helyzet!\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "2**100000" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "type(2**63 + 1)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "## float\n", "\n", "- floatok általában a C double típusán alapszanak, így a precizitásuk véges\n", "- komplex számok pedig két floatot használnak.\n", "- pontos információt a `sys.float_info` parancs segítségével kapunk" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "import sys\n", "sys.float_info" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "sys.int_info" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Aritmetikai operátorok\n", "\n", "- összadás, kivonás, szorzás a szokásos módon működik" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "i = 2\n", "f = 4.2\n", "c = 4.1-3j\n", "\n", "s1 = i + f\n", "s2 = f - c\n", "s3 = i * c\n", "print(s1, type(s1))\n", "print(s2, type(s2))\n", "print(s3, type(s3))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Osztás vs benfoglalás\n", "- `/` törtet is adhat\n", "- `//` a hányados egész részét adja vissza\n", "- Python 2-ben más!\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "3 / 2" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "-3.0 // 2, 3 // 2 " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "4 / 0.8, 4.0 / 0.8, 4 // 0.8, 4.0 // 0.8 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Mi a megoldás a ilyesmi problémák elkerülésére?" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Összehasnolító operátorok" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = 23\n", "x < 24, x >= 22" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Össze is lehet őket láncolni" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "23 < x < 100" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "23 <= x < 100" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Egyéb operátorok\n", "\n", "#### Maradék" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "5 % 3" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "#### Hatványozás" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "2 ** 3" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "2 ** 0.5" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "#### Abszolút érték" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "abs(-2 - 1j), abs(1+1j)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "-" } }, "source": [ "#### Kerekítés" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "round(2.3456), round(2.3456, 2), round(3.4999999999999)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "#### Explicit konverzió" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "float(2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# 0 felé kerekít\n", "int(-2.7), int(2.7)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### A `math` és `cmath` modulok még sok mást tartalmaznak\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "math.log(16), math.log(16, 2), math.exp(2), math.exp(math.log(10))" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Mutable vs. immutable típusok\n", "\n", "- mutable típusba tartozó objektumok helyben változtathatóak\n", "- immutable objektumok egész életükben egyetlen értékkel rendelkeznek\n", "- minden numerikus típusok immutable " ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [], "source": [ "x = 2\n", "old_id = id(x)\n", "x += 1\n", "print(id(x) == old_id)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(-10, 260):\n", " x = i\n", " y = i + 1 - 1\n", " if x is not y:\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Mutable? bool értékek\n", "\n", "Egyedi immutable objektumok, csak egy példány van belőlük." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "x = True\n", "y = False\n", "print(x is y)\n", "x = False\n", "print(x is y)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Mutable? listák" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l1 = [0, 1]\n", "old_id = id(l1)\n", "l1.append(2)\n", "old_id == id(l1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A listák helyben megváltoztathatóak" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Sorozat típusok\n", "\n", "- minden lista/sorozat szerű típus támogatja a következő függvényeket\n", "\n", "| operation | behaviour |\n", "| :----- | :----- |\n", "| `x in s` | \tTrue ha s egyenlő x valamelyik elemével, különben False|\n", "| `x not in s` | \tFlase ha s egyenlő x valamelyik elemével, különben True |\n", "| `s + t` | \ts és t összefűzése |\n", "| `s * n or n * s` | \tekvivalens azzal, hogy összeadjuk s-nek n darab példányát |\n", "| `s[i]` | \ts-nek az i. eleme, 0-tól kezdve |\n", "| `s[i:j]` | \t s-nek az i-től j-ig tartó szelete |\n", "| `s[i:j:k]` | \t s-nek az i-től j-ig tartó szelete k lépésközzel |\n", "| `len(s)` | \ts hossza |\n", "| `min(s)` | \t s legkisebb eleme |\n", "| `max(s)` | \t s legnagyobb eleme |\n", "| `s.index(x[, i[, j]])` | \ts első előfordulásának indexe x-ben (az i. indextől a j.-ig tartó részen) |\n", "| `s.count(x)` | \ts x-beli megjelenéseinek száma |\n", "\n", "[Table source](https://docs.python.org/3/library/stdtypes.html#common-sequence-operations)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### list\n", "\n", "- mutable sorozat típus " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [1, 2, 2, 3]\n", "l" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l[1]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# l[4] # raises IndexError" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l[-1], l[len(l)-1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### append, insert, del" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [1, 2, 3]\n", "l.append(3)\n", "l" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [1, 2, 3]\n", "l.insert(1, 5)\n", "l" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l= [1, 2, 5, 1]\n", "del l[2]\n", "l" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Indexelés, range-k" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = []\n", "for i in range(20):\n", " l.append(2*i + 1)\n", "l[2:5]\n", "l[10:]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l[-4:]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i in range(10):\n", " print(l[i:i+3])" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l[2:10:3] " ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Vajon mi az eredmény?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l[::-1]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "A lista mutable, elemek megváltoztathatóak:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = []\n", "old_id = id(l)\n", "\n", "for element in range(1, 3):\n", " l.append(element)\n", " print(id(l) == old_id)\n", "l" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l[1] = 12" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [1, 2]\n", "l.extend([3, 4, 5])\n", "len(l), l" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Az = operáció egy referenciát állít be\n", "\n", "- nem jön létre új objektum" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l2 = l\n", "print(l is l2)\n", "\n", "l2.append(42)\n", "l" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### az elemeknek nem kell azonos típusunak lennie " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [1, -1, \"foo\", 2, \"bar\"]\n", "l" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### listákon végigmehetünk for ciklussal" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for element in l:\n", " print(element)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### enumerate\n", "\n", "ha szükségünk van az indexre is, a beépített `enumerate` függvény index-elem párokon fut végig" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for i, element in enumerate(l):\n", " print(i, element)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Lista rendezés\n", "\n", "- rendezni lehet a beépített `sorted` függvény segítségével" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [3, -1, 2, 11]\n", "\n", "for e in sorted(l):\n", " print(e)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "A `key` argumentummal megadhatjuk, hogy mi szerint rendezzünk" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "shopping_list = [\n", " [\"apple\", 5],\n", " [\"pear\", 2],\n", " [\"milk\", 1],\n", " [\"bread\", 3],\n", "]\n", "\n", "for product in sorted(shopping_list, key=lambda x: -x[1]):\n", " print(product)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Helyben is lehet rendezni a .sort() metódussal." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l=[3, -1, 2, 11]\n", "l.sort()\n", "l" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### A * operátor\n", " A `*` operátor segítségével \"kibonthatunk\" egy listát. A `*l` kifejezés felsorolja az `l` lista elemeit de már nem egy lista objektum. Ez tipikusan akkor hasznos, ha egy függvény sok paramétert vár. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l=[\"alma\",\"körte\",\"piskóta\"]\n", "print(l)\n", "print(*l)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def osszeg(x,y,z):\n", " return x+y+z\n", "osszeg(*[10,20,30])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### tuple\n", "\n", "- a tuple egy immutable sorozat" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t = () # empty tuple\n", "print(type(t), len(t))\n", "\n", "t = ([1, 2, 3], \"foo\")\n", "type(t), len(t)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "indexelés azonos a listákkal" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t[1], t[-1]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "a tuple immutable referenciákat tartalmaz, de, a benne lévő objektum lehet mutable" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "t = ([1, 2, 3], \"foo\")\n", "#t[0]= \"bar\" # this raises a TypeError" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "for e in t:\n", " print(id(e))\n", " \n", "print(\"\\nChanging an element of t[0]\\n\")\n", "t[0][1] = 11\n", "\n", "for e in t:\n", " print(id(e))\n", "\n", "print(\"\\n\", t)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### dictionary\n", "\n", "- beépített szótár típus (map)\n", "- kulcsokat képez le értékekre" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d = {} # üres szótár, ekvivalens: d = dict()\n", "d[\"apple\"] = 12\n", "d[\"plum\"] = 2\n", "d" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "másik megadás" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d = {\"apple\": 12, \"plum\": 2}\n", "d" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### kulcs törlése" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "del d[\"apple\"]\n", "d" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### dictionary bejárása\n", "\n", "- a kulcsok és az értékek külön és együtt is bejárhatóak \n", "- kulcsok iterálása" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d = {\"apple\": 12, \"plum\": 2}\n", "for key in d.keys():\n", " print(key, d[key])" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "értékek iterálása" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for value in d.values():\n", " print(value)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "közös iterálás" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for key, value in d.items():\n", " print(key, value)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Mi történik a háttérben?\n", "\n", "- a háttérben egy *hash table* jön létre\n", " - ennek az a lényege, hogy minden objektumhoz hozzárendelünk egy hash értéket, ami egyenlő objektumoknál azonos és az objektumok helyett a hash értéket hasonlítjuk össze. Így gyorsabb lesz a rendszer. \n", " - ezért a kulcsok nem lehetnek és nem tartalmazhatnak mutable objektumokat \n", " - de lehetnek különböző tipusú kulcsok" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d = {}\n", "d[1] = \"a\" # numeric types are immutable\n", "d[3+2j] = \"b\"\n", "d[\"c\"] = 1.0\n", "d" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- a tuple típus immutable" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "d[(\"apple\", 1)] = -2\n", "d" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- de a list mutable" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# d[[\"apple\", 1]] = 12 # raises TypeError" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "skip" } }, "source": [ "### Q. Lehetnek-e ezek dictionary kulcsok?" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "skip" } }, "outputs": [], "source": [ "key1 = (2, (3, 4))\n", "key2 = (2, [], (3, 4))\n", "\n", "d = {}\n", "d[key1] = 1\n", "d[key2] = 2\n", "d" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Függvények újra. `args` és `kwargs`\n", "\n", "- mind a pozíciós és a kulcsszavas argumentumok is összegyűjthetőek a `*` és `**` operátorokkal\n", "- a pozíciós argumentumok tuplebe kerülnek" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def arbitrary_positional_f(*args):\n", " print(type(args))\n", " for arg in args:\n", " print(arg)\n", " \n", "arbitrary_positional_f(1, 2, -1)\n", "# arbitrary_positional_f(1, 2, arg=-1) # raises TypeError" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- kulcsszavas argumentumok egy dictionarybe kerülnek" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def arbitrary_keyword_f(**kwargs):\n", " print(type(kwargs))\n", " for argname, value in kwargs.items():\n", " print(argname, value)\n", " \n", "arbitrary_keyword_f(arg1=1, arg2=12)\n", "# arbitrary_keyword_f(12, arg=12) # TypeError" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- általában mindkettőt begyűjtjük " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def arbitrary_arg_f(*args, **kwargs):\n", " if args:\n", " print(\"Positional arguments\")\n", " for arg in args:\n", " print(arg)\n", " else:\n", " print(\"No positional arguments\")\n", " if kwargs:\n", " print(\"Keyword arguments\")\n", " for argname, value in kwargs.items():\n", " print(argname, value)\n", " else:\n", " print(\"No keyword arguments\")\n", " \n", "arbitrary_arg_f()\n", "arbitrary_arg_f(12, -2, param1=\"foo\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "# set\n", "\n", "- egyedi, hash-elhető elemek (így ebben sem nem lehet mutable)\n", "- alapvető halmazműveletek használhatóak" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s = set()\n", "s.add(2)\n", "s.add(3)\n", "s.add(2)\n", "s" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s = {2, 3, 2} # d = {'a': 2}\n", "type(s), s" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### deleting elements" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s.add(2)\n", "s.remove(2)\n", "# s.remove(2) # raises KeyError, since we already removed this element\n", "s.discard(2) # removes if present, does not raise exception" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "## frozenset\n", "\n", "- immutable párja a `set`-nek" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "fs = frozenset([1, 2])\n", "# fs.add(2) # raises AttributeError" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "fs = frozenset([1, 2])\n", "s = {1, 2}\n", "\n", "d = dict()\n", "d[fs] = 1\n", "# d[s] = 2 # raises TypeError\n", "d" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "## set operációk\n", "\n", " - két féle jelölés van rájuk\n", " 1. függvények\n", " 2. operátorok" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s1 = {1, 2, 3, 4, 5}\n", "s2 = {2, 5, 6, 7}\n", "\n", "s1 & s2 # s1.intersection(s2) vagy s2.intersection(s1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s1 | s2 # s1.union(s2) vagy s2.union(s1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s1 - s2, s2 - s1 # s1.difference(s2), s2.difference(s1)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- ezek az operációk egy új `set`-tel térnek vissza. " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s3 = s1 & s2\n", "type(s3), id(s3) == id(s1), id(s3) == id(s2)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### `issubset` és `issuperset`" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s1 < s2, s1.issubset(s2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "{1, 2} < s1" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "s1.issuperset({1, 6})" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "## hasznos tulajdonságok \n", "\n", "- egy set létrehozásával megszüntethetjük a duplikációkat egy listában" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [1, 2, 3, -1, 1, 2, 1, 0]\n", "uniq = set(l)\n", "uniq" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- set-ek és dictionary-k O(1) időben keresnek. (gyorsak)\n", "- listák O(n) időben keresnek." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import random\n", "\n", "letters = \"abcdef\"\n", "word_len = [1, 2, 3, 4, 5]\n", "N = 10000\n", "samples = []\n", "\n", "for i in range(N):\n", " word = []\n", " for j in range(random.choice(word_len)):\n", " word.append(random.choice(letters))\n", " samples.append(\"\".join(word))\n", " \n", "samples = list(samples)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "word = []\n", "for j in range(random.choice(word_len)):\n", " word.append(random.choice(letters))\n", "word = \"\".join(word)\n", "print(word)\n", "word in samples" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### list lookup" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%%timeit\n", "\n", "word = []\n", "for j in range(random.choice(word_len)):\n", " word.append(random.choice(letters))\n", "word = \"\".join(word)\n", "word in samples" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### set lookup" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "samples_set = set(samples)\n", "len(samples_set), len(samples)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "%%timeit\n", "\n", "word = []\n", "for j in range(random.choice(word_len)):\n", " word.append(random.choice(letters))\n", "word = \"\".join(word)\n", "word in samples_set" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Függvények 3" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "### Mutable alapértelmezett argumentumok\n", "\n", "- csak óvatosan!!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def insert_value(value, l=[]):\n", " l.append(value)\n", " print(l)\n", " \n", "l1 = []\n", "insert_value(12, l1)\n", "l2 = []\n", "insert_value(14, l2)" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "insert_value(-1)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "insert_value(-3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- legjobb ha messzire elkerüljük" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Egy lehetséges megoldás:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def insert_value(value, l=None):\n", " if l is None:\n", " l = []\n", " l.append(value)\n", " return l\n", "\n", "l = insert_value(2)\n", "l" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "insert_value(12)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Lambda kifejezések\n", "\n", "- névtelen függvények\n", "- lehet paramétere\n", "- nem fér hozzá semmihez" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "l = [-1, 0, -10, 2, 3]" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Rendezzünk például abszolút érték szerint. A beépített `sorted` függvény nem elég:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for e in sorted(l):\n", " print(e)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "De megadhatjuk, hogy milyen `key` kulcsot használjon:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "for e in sorted(l, key=lambda x: abs(x)):\n", " print(e)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Bármilyen függvényt használhatunk" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "-" } }, "outputs": [], "source": [ "for e in sorted(l, key=abs):\n", " print(e)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Stringek\n", "\n", "- A stringek **immutable** sorozatok, melyek Unicode karaterekből állnak" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "single = 'ab\\'c'\n", "double = \"ab\\\"c\"\n", "multiline = \"\"\"\n", "sdfajfklasj;\n", "sdfsdfs\n", "sdfsdf\n", "\"\"\"\n", "single == double" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- mivel immutable, nem lehet megváltoztatni!!" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s = \"abc\"\n", "\n", "# s[1] = \"c\" # TypeError" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "- minden string operáció új függvényt hoz létre" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "print(id(s))\n", "s += \"def\"\n", "id(s), s" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- a stringekre is elérhető a legtöbb függvény, amit a listák tudnak.\n", " - pl: indexelés" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s = \"abcdefghijkl\"\n", "s[::2]" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s = \"ábc\"\n", "print(type(s))\n", "\n", "with open(\"file.txt\", \"w\") as f:\n", " f.write(s)\n", " f.write(\"\\n\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "with open(\"file.txt\") as f:\n", " text = f.read().strip()\n", " \n", "print(text)\n", "type(text)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## String operációk\n", "\n", "- rengeteg függvény elérhető" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "\"abC\".upper(), \"ABC\".lower(), \"abc\".title()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s = \"\\tabc \\n\"\n", "print(\"\" + s + \"\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "s.strip()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s.rstrip()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s.lstrip()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\"abca\".strip(\"a\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "Mivel minden függvény visszatér egy új stringgel, egymás után fűzhetőek." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\" abcd abc\".strip().rstrip(\"c\").lstrip(\"ab\")" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Eldöntendő kérédsek" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\"abc\".startswith(\"ab\"), \"abc\".endswith(\"cd\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\"abc\".istitle(), \"Abc\".istitle()" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "\" \\t\\n\".isspace()" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\"989\".isdigit(), \"1.5\".isdigit()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### split és join" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s = \"the quick brown fox jumps over the lazy dog\"\n", "words = s.split()\n", "words" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "s = \"R.E.M.\"\n", "s.split(\".\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "\"-\".join(words)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "### Példa: Egy wikipedia oldal szó frekvenciája" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ " # Ez csak akkor működik, ha a wikipedia csomag már telepítve van. Később részletesebben lesz szó arról,\n", " # hogy hogyan lehet telepíteni. Alapvetően a pip install wikipedia parancsot\n", " # kell kiadni windowson az anaconda promptban, linuxon pedig a terminálban. \n", " \n", " import wikipedia\n", " article = wikipedia.page(\"Hungary\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "text=article.content" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "text" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "words = text.split()\n", "len(words), len(set(words))" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "word_freq = {}\n", "for word in words:\n", " if word not in word_freq:\n", " word_freq[word] = 1\n", " else:\n", " word_freq[word] += 1" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "slideshow": { "slide_type": "subslide" } }, "outputs": [], "source": [ "for word, freq in sorted(word_freq.items(), key=lambda x: -x[1])[:40]:\n", " print(word, freq)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import random\n", "def make_maze(w = 16, h = 8):\n", " vis = [[0] * w + [1] for _ in range(h)] + [[1] * (w + 1)]\n", " ver = [[\"| \"] * w + ['|'] for _ in range(h)] + [[]]\n", " hor = [[\"+--\"] * w + ['+'] for _ in range(h + 1)]\n", " \n", " def walk(x, y):\n", " vis[y][x] = 1\n", " \n", " d = [(x - 1, y), (x, y + 1), (x + 1, y), (x, y - 1)]\n", " random.shuffle(d)\n", " for (xx, yy) in d:\n", " if vis[yy][xx]: continue\n", " if xx == x: hor[max(y, yy)][x] = \"+ \"\n", " if yy == y: ver[y][max(x, xx)] = \" \"\n", " walk(xx, yy)\n", " \n", " walk(random.randrange(w), random.randrange(h))\n", " \n", " s = \"\"\n", " for (a, b) in zip(hor, ver):\n", " s += ''.join(a + ['\\n'] + b + ['\\n'])\n", " return s " ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n", "print(make_maze())" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.4" } }, "nbformat": 4, "nbformat_minor": 2 }