{ "nbformat": 4, "nbformat_minor": 0, "metadata": { "anaconda-cloud": {}, "colab": { "name": "kl_py_kezdolepes.ipynb", "provenance": [], "collapsed_sections": [ "zzHhy0KGaYim", "ihWv2d17aYi-", "Nli69a3MaYjn", "Fn89WIvxaYlS" ], "include_colab_link": true }, "hide_input": false, "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" }, "latex_envs": { "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 0 }, "name": "python-bevezeto.ipynb" }, "cells": [ { "cell_type": "markdown", "metadata": { "id": "view-in-github", "colab_type": "text" }, "source": [ "\"Open" ] }, { "cell_type": "markdown", "metadata": { "id": "LrTbC1wkP4yd", "colab_type": "text" }, "source": [ "

\n", " \n", " \n", "

\n", "\n", "\n", "

\n", "\n", "\n", "\n", "# Python kezdő lépések, változók\n", "\n", "\n", "\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "qiBM-GUpaYhq" }, "source": [ "# Kezdő lépések Pythonban, ismerkedés a változókkal\n", "\n", "\n", "Ebben a notebookban rövid példákon keresztül megismerkedünk a Python nyelv szintaxisával, \n", "és néhány alapvető adattípussal és adatstruktúrával. \n", "\n", "Később ezeket és az ezekből származtatott adatstruktúrákat fogjuk lépten-nyomon használni.\n", "\n", "\n", "\n", "### Sikeres nyelv: \n", " \n", " pl: Uber, Paypal, Google, MS Azure, Facebook, Instagram, NASA, Netflix, Dropbox, Reddit stb.\n", "\n", " \n", " \n", " \n", "### Alap jellemzők\n", "\n", "\n", " - Guido van Rossum Holland programozó találta ki 1989 karácsonyán\n", " - A nevét nem a hüllőről kapta, hanem a brit komédiasorozatról, a Monty Pythonról\n", " - Nem gyors, de könnyen bevethető, sok beépülő modul segít bennünket\n", " - A szkriptfileokat .py végződéssel szokás ellátni \n", " - Bytekódot generál és ezt futtatja \n", " - Futtatás közben el is menti .pyc végződésű filenévvel \n", " - Automatikusan generálja \n", " - Alapból interaktív interpreter \n", " - Változók értékeit kiírja ha hivatkozunk rá \n", " - Az értelmező szkriptfileokat futtat, és sorrol sorra halad...\n", " - Szöveg elemzés, ML (machine learning), azaz a gépi tanulás és a big data berobbanásával lehet vele nagyot alkotni\n", " \n", "\n", "\n", "---\n", "\n", "

\n", " \n", " \n", "

\n", "

\n", " \n", " \n", "

\n", "

\n", " \n", " \n", "

\n" ] }, { "cell_type": "markdown", "metadata": { "id": "QZxJDkFpP4yh", "colab_type": "text" }, "source": [ "\n", "## Programozási alapfogalmak \n", "\n", "\n", "• Algoritmus: Valamely feladat megoldására alkalmas véges hosszú lépéssorozat. \n", "\n", "• Adatszerkezet: Adatelemek tárolására és hatékony használatára szolgáló séma (példa: lista). \n", "\n", "• Programozási nyelv: Szigorú szabályokra épülő nyelv, melynek segítségével az ember képes a számítógép felé kommunikálni az utasításait. \n", "\n", "• Programozás: Algoritmusok és adatszerkezetek megtervezése illetve megvalósításuk valamilyen programozási nyelven.\n", "\n", "---\n", "\n", "### Objektum tipusok, jelelmzők\n", "\n", "\n", "\n", "#### Iterálható objektum:\n", "Olyan objektum, amelyből más objektumokat tudunk kinyerni. A kiolvasott objektumokat a továbbiakban elemnek fogjuk nevezni. Az elemeket az objektumon történő iterálással, más kifejezéssel az objektum bejárásával egymásután sorban elérhetjük.\n", "\n", "Pl.: listák, bájt-tömbök, karakterláncok, sokaságok, szótárak, generátorobjektumok.\n", "\n", "\n", "#### Indexelhető objektum:\n", "Az ilyen objektum elemeit a természetes számok sorozatának 0-val induló és eggyel növekedő tagjaival párosíthatjuk, s az ezekre történő hivatkozással (indexeléssel) az elemeket el is érhetjük. Ha egy objektum indexelhető, akkor iterálható is, de egy iterálható objektum nem feltétlen indexelhető, az indexelhetőség egy erősebb megszorítás. \n", "\n", "Pl.: listák, karakterláncok (string), sokaságok (tuple-k), bájt-tömbök (bytes) stb. \n", "\n", "\n", "#### Nem indexelhető objektum: \n", "\n", "Pl.: készletek(set), szótárak(dir), egész számok stb.\n", "\n", "\n", "\n", "#### Leképező (mapping) szótár típusú objektum:\n", "Ezen objektum elemeit kulcs-érték párok alkotják. Egy elemhez tartozó értéket a kulcs indexszerű megadásával érhetünk el. Kulcs nagyon sokféle objektum lehet, például számok, karakterláncok stb., és ezek keverten is alkalmazhatók. Ezek az objektumok a kulcsok szerint iterálhatók.\n", "\n", "Példa: szótár(dir).\n", "\n", "---\n", "\n", "### Progrmanyelvi jellemzők\n", "\n", "\n", "• A program blokkokat a sorok behúzásával jelöljük. \n", "A fordított perjel (\\) segítségével egy hosszú sor kétfelé törhető.\n", "\n", "\n", "• A for és while szerkezetekhez tartozhat egy else ág is, amely akkor hajtódik végre, ha a ciklustörzsből nem történt kilépés a break utasítással. \n", "\n", "\n", "• enumerate (magyarul \"felsorol\"): Az iterálható bejárható objektum elemeit szolgáltatja egymásután, és minden elemhez ad egy sorszámot is, a sorszámozás 0-val kezdődik. Ha az objektum indexelhető, akkor a sorszám megegyezik az indexszel.\n", "\n", "\n", "\n", "• len(bejárható): A bejárható objektum elemszámát adja meg. \n", "\n", "• range(n): 0-tól n-1 -ig szolgáltatja az egész számokat egymásután. A range(m,n,l) kifejezésben az egész számok sorozata m-től indul, n-1-ig tart, és l a növekményük. A range(m,n) esetén a lépésköz 1 lesz. \n", "\n", "\n", "• True, False: Az igaz és a hamis értékek.\n", " \n", " ---\n" ] }, { "cell_type": "code", "metadata": { "id": "GzPMb365P4yi", "colab_type": "code", "colab": {}, "outputId": "eb18f217-4930-448d-9d28-8aa22cd54739" }, "source": [ "## Automatikus összefűzés (nincs külön operátor) \n", "print ('Kicsi' \" Dani \" \"\"\"játszik\"\"\" ) ## Kicsi Dani játszik // közvetlen összefüzés\n", "\n", "print ('Nagyobb', \" Dani \", 2020, \"\"\"-ban is \\\n", "játszik\"\"\" ) ## Nagyobb Dani 2020 -ban is játszik // vesszőnél space is megjelenik + töbsorba tördelés a \\ jel\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Kicsi Dani játszik\n", "Nagyobb Dani 2020 -ban is játszik\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "mJqp8_DyP4ym", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "## A Jupyter Notebook környezet\n", "\n", "\n", "AJupyterNotebook egy WEB böngésző alapú interaktívm unkakörnyezet. \n", "\n", "Elsődlegesen a Pythonnyelvhez fejlesztették ki, de más programozási nyelvekkel is használható. \n", "\n", "Egy notebook cellákból áll, a cellák lehetnek szöveges (Markdown) vagy kód típusúak. \n", "\n", "A kódcellákat le lehet futtatni, akár többször is egymás után. A futtatás eredménye megjelenik az adott kódcella utáni kimenetben.\n", "\n", "\n", "\n", "### A notebook használata kétféle üzemmódban történik:\n", "\n", "\n", "#### Parancsmódban \n", "tudjuk elvégezni a cellaszintű műveleteket (pl. új cella beszúrása, cella törlése, cellák mozgatása, lépegetés a cellák között stb). \n", "\n", "##### Néhány hasznos billentyűparancs: \n", " – b: Új kódcella beszúrása az aktuális cella után. \n", " – m: Az aktuális cella típusának átállítása szövegesre. \n", " – dd: Az aktuális cella törlése. \n", " – Enter: Átlépés szerkesztőmódba (az aktuális cella tartalmának szerkesztése). \n", " \n", "#### Szerkesztómódban \n", "tudjuk szerkeszteni a cellák tartalmát. \n", "\n", "\n", "##### Néhány hasznos billentyűparancs: \n", " – Ctrl+Enter: Az aktuális cella futtatása. \n", " – Esc: Visszalépés parancsmódba. \n", " \n", " \n", " A billentyűparancsokról a Help / Keyboard Shortcuts menü ad részletesebb leírást.\n", " \n", "--- \n", "\n", "\n", "### Változó névadásnál figelyni kell arra, hogy:\n", "\n", " - az értelmező nagybetű, kisbetű érzékenyen különbözteti meg őket\n", " - vannak nyelvi azonosítók, ezek fentartott szavak amelyekt ne használjunk változó elnevezéskor\n", " \n", " \n", " \n", " \n", "### Karakterkészlet / Pszeudó-komment a file elején (alapértelmezet az utf-8)\n", " \n", "\n", "` #-*- coding: ISO-8859-1 -*\n", " \n", "` #-*- coding: ISO-8859-2 -*\n", " \n", "` #-*- coding: UTF-8 -*\n", " \n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "MP1jVkMsP4yn", "colab_type": "code", "colab": {}, "outputId": "8dde141e-501b-472c-bd89-7cc01d6bef3c" }, "source": [ "## Csak konzol alkalmazásnál így töröljük le a képernyőt\n", "import os\n", "os.system('cls') # For Windows\n", "# os.system('clear') # For Linux/OS X" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0" ] }, "metadata": { "tags": [] }, "execution_count": 41 } ] }, { "cell_type": "markdown", "metadata": { "id": "--BPLYh0P4yq", "colab_type": "text" }, "source": [ "---\n", "\n", "\n", "## A Python adattípusai\n", "\n", "### Számok: \n", " Integer \n", " i=5\n", " \n", " long \n", " i=5L \n", " \n", " Float(lebegőpontos) \n", " f=5.0\n", " \n", " Komplex szám \n", " 5+4j \n", " \n", "\n", "### Logikai / boolean: \n", " b=True, \n", " b=False \n", " (nagy kezdőbetű!) True, False \n", " \n", "\n", "### Szöveg /string\n", "\n", "String \n", " szoveg='Péda szöveg'\n", "\n", "\n", "Bytes \n", " b'akarmi' → (sztring) \n", " bytes('talicska') → (sztring) \n", " \n", " \n", "Bytearray: ua. mint bytes, csak módosítható \n", " bytearray([66, 67, 68]) → bytearray(b'BCD') \n", " \n", "\n", "List (lista) \n", " l=[ 0, 15, 'beton', i ] (indexelhető, módosítható) \n", "\n", "Tuple (sokaság) \n", " t=( 0, 15, 'beton', i ) (indexelhető, nem lehet módosítani) \n", "\n", "Dictionary (asszoc. tömb) \n", " d= {'beton': 5, 'teherauto': 'KAMAZ'}\n", " \n", " Set (halmaz. készlet) \n", " s={5, 9.9, 'beton'} \n", " Halmazműveletekre (intersect, union, stb.) \n", " 1 elem csak 1x lehet tag! \n", " s.add(4) → {4, 5, 9.9, 'beton'} \n", "\n", " \n", "Frozenset \n", " mint az előbbi, csak nem módósítható\n", " \n", " \n", "---\n", "\n", " \n", "\n", "## Az adattípusok dinamikusan (deklarálás nélkül) egyből használhatóak: \n", "\n", "type(1) \n", "\n", "type(1.2) \n", "\n", "type(1.) \n", "\n", "type(\"Hello\") # string: ’ vagy ” vagy \"\"\" ill '''\n", "\n", "type(None) \n", "\n", "type(int) \n", "\n", "\n", "\n", "### Változók típusának konvertálása: \n", "\n", "Mint minden magasszintű programnyelvben itt is van castolásra lehetőségünk. A castolás\n", "gyakorlatilag a változó eredeti típusát képes megváltoztatni az általunk kiválasztott változó típusra. \n", "\n", "\n", "str(17) \n", "\n", "int(\"17\") \n", "\n", "float(\"2.5\") \n", "\n", "float(\"1\")\n", "\n", "### Változó rendszer azonosítója\n", "\n", "id(azonosito)\n", "\n", "\n", "\n", "### Megjegyzések (Comment-ek)\n", "A scriptnyelvek többségéhez hasonlóan a Python kommenteket a  #  karakter definiálja. A  #  karaktertől kezdődően az interpreter a sor végéig kommentként értelmezi a szöveget.\n", "\n", "Egy megjegyzés lehet sor elején, vagy követhet szóközt, tabulátor karaktert, de ha egy karakterlánc (string) belsejébe teszed, az nem lesz megjegyzés (lásd a példában!). A kettőskereszt karakter egy karakterláncon belül csak egy kettőskeresztet jelent.\n", "\n", "A komment csak a programozónak szól emlékeztetőül, vagy más programozók megértését segíti. Noha gyakran elmarad, a kódok rendszeres dokumentálása megjegyzésekkel később (amikor már a kód részleteit a feledés homálya borítja) nagyon kifizetődő lehet.\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "id": "khM6WudhP4yr", "colab_type": "code", "colab": {}, "outputId": "c7e7bf01-ada0-40b7-cbe0-7ae26c461e50" }, "source": [ "nem_megjegyzes =' # ez itt nem # megjegyzés csak egy sima kettőskereszt karakter # '\n", "print(nem_megjegyzes)\n", "\n", "\n", "# tipusok\n", "\n", "type(1) \n", "type(1.2) \n", "type(1.) \n", "type(\"Hello\") # string: ’ vagy ” \n", "type(None) \n", "type(int)\n", "\n", "\n", "\n", "# Változók típusának konvertálása\n", "\n", "# str( 17) \n", "int(\"17\") \n", "float(\"2.5\") \n", "float(\"1\")\n", "\n", "# Többszörös érték adás\n", "\n", "var1 = var2 = var3 = 1\n", "var=0\n", "print(var1,' ',var2,' ',var3)\n", "print('var1 = ', id(var1),'var2 = ', id(var2), 'var3 = ', id(var3), 'var = ', id(var))\n", "print('---------')\n", "var2 = 'lajos'\n", "print('var1 = ', id(var1),'var2 = ', id(var2), 'var3 = ', id(var3), 'var = ', id(var))\n", "print('---------')\n", "\n", "\n", "# egyszerre tőbb váltiozó érték beállítása\n", "\n", "var1, var2, var3 = 1, 2.5, \"john\"\n", "print(var1,' ',var2,' ',var3)\n", "\n", "\n", "\n", "\n", "# String műveletek\n", "\n", "str = 'Hello World!' # A string\n", "\n", "print(str) # megjelenítése teljes stringnek\n", "print(str[0]) # megjelenítése első karaktere\n", "print(str[2:5]) # megjelenítése harmadiktól az ötödikig\n", "print(str[2:]) # megjelenítése a szöveg harmadik karakterétől\n", "print(str[:2])\n", "print(str * 2) # megjelenítése kétszer a szövegnek\n", "print(str + \"TEST\") # megjelenítése összefüzéses string" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ " # ez itt nem # megjegyzés csak egy sima kettőskereszt karakter # \n", "1 1 1\n", "var1 = 140704464413072 var2 = 140704464413072 var3 = 140704464413072 var = 140704464413040\n", "---------\n", "var1 = 140704464413072 var2 = 3062343383344 var3 = 140704464413072 var = 140704464413040\n", "---------\n", "1 2.5 john\n", "Hello World!\n", "H\n", "llo\n", "llo World!\n", "He\n", "Hello World!Hello World!\n", "Hello World!TEST\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "GqlMEEd-P4yu", "colab_type": "code", "colab": {}, "outputId": "21f56349-e175-4e7c-a8b3-d7328116b8b3" }, "source": [ "i=303 \n", "print (str(i), \" - \" , 'i' )\n", "print ('i', \" - \", str(i))\n", "\n", "import unicodedata\n", "text = \"àéêöhello\"\n", "\n", "text = unicodedata.normalize('NFD', text)\n", "print ('t1', text)\n", "text = text.encode('ascii', 'ignore') # szöveg ascii-ra kódolása\n", "print ('t2', text)\n", "text = text.decode(\"utf-8\") # szöveg utf-8-ra kódolása\n", "print ('t3', text)\n", "\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "303 - i\n", "i - 303\n", "t1 àéêöhello\n", "t2 b'aeeohello'\n", "t3 aeeohello\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "858x3UclaYht", "colab": {}, "outputId": "09471927-8513-4c6f-a0ed-e84b041aaba4" }, "source": [ "# ez az első megjegyzés\n", "SPAM = 1 # ez a második megjegyzés tehetek további #### jeleket de ezeknek már nincs hatása\n", " # ... és ez a harmadik.\n", "STRING = \"# Ez nem megjegyzés, mert idézőjelekben van.\" # csak innen kezdődik amegjegyzés\n", "print(STRING)\n", "def fuggveny() :\n", " \"\"\" ez így megjegyzésként hat \n", " és ez több sorban is folytatódhat, \n", " de mindig csak a függvény elején álhat\"\"\"\n", " pass" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "# Ez nem megjegyzés, mert idézőjelekben van.\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "4aqgMVTBaYhw" }, "source": [ "\n", "---\n", "\n", "\n", "\n", "## A Python használata számológépként\n", "\n", "\n", "\n", "A notebookot lehet úgy használni, mint egy sima számológépet (interaktív mod): be lehet írni egy kifejezést, és az kiszámolja az értékét. \n", "\n", "A kifejezések nyelvtana a szokásos: a +, -, * és / műveletek ugyanúgy működnek, mint a legtöbb nyelvben (például Fortran vagy C). \n", "\n", "A zárójeleket értelemszerűen az elvégzendő műveletek csoportosítására, a műveleti sorrend meghatározására használjuk.\n", "\n", "\n", "\n", "\n", "### Szintaktikai lehetőségek\n", "\n", "egy sor egy utasítás,\n", "vagy egysorba több utasítás, pontosveszzővel elválasztva\n", "vagy több sorba de arészeket \\ karakterrel 'ragasszuk össze'\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "id": "rZvp4nSlP4y1", "colab_type": "code", "colab": {}, "outputId": "75f1fad7-8a7d-4662-d959-5b5d17d4e868" }, "source": [ "i=5 \n", "print(i) \n", "i=i + 1 \n", "print(i)\n", "print('-----------Elválasztás-----------')\n", "i=5 ; print(i) ; i=i + 1 ;print(i)\n", "print('-----------Elválasztás-----------')\n", "i = \\\n", "5\n", "print \\\n", "(i)\n", "i= \\\n", "i \\\n", "+1\n", "print(i)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "5\n", "6\n", "-----------Elválasztás-----------\n", "5\n", "6\n", "-----------Elválasztás-----------\n", "5\n", "6\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "WMcfL2DpP4y4", "colab_type": "text" }, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": { "id": "710cM3nxP4y5", "colab_type": "text" }, "source": [ "### Program tagolás (strukturálás) behuzással (Indentation) történik" ] }, { "cell_type": "code", "metadata": { "id": "N7PqQsSsP4y6", "colab_type": "code", "colab": {}, "outputId": "ea07164b-aa25-4588-ecce-4a05732d7c54" }, "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": [ { "output_type": "stream", "text": [ "5\n", "20\n", "Ez egy mindíg igaz állítás\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "nB_G6Ia6P4y-", "colab_type": "text" }, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": { "id": "cBLPmuuTP4y_", "colab_type": "text" }, "source": [ "### Program műveletek\n", "\n", "\n", "\n", "\n", "##### A legfontosabb általunk használt operátorok:\n", "(Megnevezés szintaktika megjegyzés)\n", "\n", "Összeadás + Két nem karakter típusú változó összeadása\n", "\n", "Konketenáció + Két sztring összefűzése \n", "\n", "Szorzás * Két nem karakter típusú változó összeszorzása\n", "\n", "Exponenciális ** Az első operandus az alap, a második a kitevő.\n", "\n", "Értékadás = Egy tetszőleges változónak inicializálása\n", "\n", "Egyenlőség reláció == Egyenlőség feltétel megadása, IF elágazás esetén használhatjuk, figyelve, hogy a két operandus azonos típusú\n", "legyen\n", "\n", "Tagadás reláció != Tagadás feltétel megadása, IF elágazás esetén használhatjuk, figyelve, hogy a két operandus azonos típusú legyen\n", "\n", "Tagadás reláció <> Tagadás feltétel megadása, IF elágazás esetén használhatjuk, figyelve, hogy a két operandus azonos típusú legyen\n", "\n", "Kisebb reláció < Kisebb feltétel megadása, IF elágazás esetén használhatjuk, figyelve, hogy a két operandus azonos típusú legyen\n", "\n", "Nagyobb reláció > Nagyobb feltétel megadása, IF elágazás esetén használhatjuk, figyelve, hogy a két operandus azonos típusú legyen\n", "\n", "Kisebb egyenlő <= Feltétel megadása, IF elágazás esetén használhatjuk, figyelve, hogy a két operandus azonos típusú legyen\n", "\n", "Nagyobb egyenlő >= Feltétel megadása, IF elágazás esetén használhatjuk, figyelve, hogy a két operandus azonos típusú legyen\n", "\n", "Logikai És and Két operandus közti és kapcsolatot teremti meg\n", "\n", "Logikai Vagy or Két operandus közti vagy kapcsolatot teremti meg\n", "\n", "Bitenkénti És & Két változó bitjei közötti és művelet\n", "\n", "Bitenkénti Vagy | Két változó bitjei közötti vagy művelet\n", "\n", "Bitenkénti kizáró vagy ^ Két változó bitjei közötti XOR művelet\n", "\n", "Bitenkénti Negáció ~\n", "\n", "Bináris balra shiftelés <<\n", "\n", "Bináris jobbra shiftelés >>\n", "\n", "\n", "in, not in : A két operátorral megkérdezhetjük, hogy egy objektumot egy másik tartalmaz-e. Ezek a konténertípusú objektumok esetén rendkívül hasznosak. Az eredmény bool típusú lesz.\n", "\n", " \n", "is, is not : Ezen operátorokkal az objektumok azonosságát tesztelhetjük. Az eredmény bool típusú lesz.\n", "\n", " \n", "\n", "not, or, and : A Boole-algebra operátorai is jól használhatók állítások megfogalmazására. A programozásban a kétértékű Boole-algebra használatos, amelyben csak két érték van, a hamis és az igaz, és ezek egymás ellentettjei.\n", "\n", "\n", "Nagyon fontos jellemzője a logikai kifejezések használatának, hogy az értelmező az utoljára kiszámított részkifejezés értékét adja eredményként, ami nem feltétlen bool típusú.\n", "\n", "|ESET1|ESET2|ESET3|ESET4|\n", "|---|---|---|---|\n", "|T = T and T | F = F and F | F = F and T | F = T and F |\n", "|T = T or T | F = F or F | T = F or T | T = T or F |\n", "\n", "\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "H3WPOrVMaYhx", "outputId": "5b4f11b5-6245-4437-ee55-d4892b9b2ef5", "scrolled": true, "colab": {} }, "source": [ "2 + 2" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "4" ] }, "metadata": { "tags": [] }, "execution_count": 5 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "A9K9-neuaYh0", "outputId": "a0b244db-46dd-4096-91b1-bc7bbaa7ffa2", "colab": {} }, "source": [ "50 - 5*6" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "20" ] }, "metadata": { "tags": [] }, "execution_count": 3 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Pu3zIOFEaYh2", "outputId": "8c88cd52-8972-4c94-8eae-a355bb6306e0", "colab": {} }, "source": [ "(50 - 5*6) / 4" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "5.0" ] }, "metadata": { "tags": [] }, "execution_count": 4 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "zTn2W5sYaYh4", "outputId": "b9bd2bcd-c1b0-4536-eb5b-50c2ebfe05c8", "colab": {} }, "source": [ "8 / 5 # az osztás egész számok esetén is lebegőpontos eredményt ad. " ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "1.6" ] }, "metadata": { "tags": [] }, "execution_count": 5 } ] }, { "cell_type": "markdown", "metadata": { "id": "fd-AXnB2P4zK", "colab_type": "text" }, "source": [ "---\n", "\n", "### feltételes értákadás \n", "\n", "`obj = kif1 if tesztkif else kif2` \n", "\n", " Az értelmező először a tesztkif kifejezést értékeli ki, és ha az igaz, akkor a kif1 kiértékelésének az eredményét írja be az obj nevű változóba, ha hamis akkor a kif2 eredményét.\n", " \n", "---" ] }, { "cell_type": "code", "metadata": { "id": "m5TFI45pP4zM", "colab_type": "code", "colab": {}, "outputId": "87a78ab7-f8f6-4e39-8839-500dc0b8e69b" }, "source": [ "miez = 2 or 4 ## Ha az első tag nem null akkor annak értékét veszi fel\n", "print('2 or 4 -> ',miez) \n", "\n", "miez = 0 and 5 ## Ha az első tag null akkor annak értékét veszi fel (null lesz)\n", "print('3 and 5 -> ',miez)\n", "\n", "miez= \"Van\" if miez else \"Nincs\" ## feltételes értékadás (az előzők is erre jók)\n", "print('if else -> ',miez)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "2 or 4 -> 2\n", "3 and 5 -> 0\n", "if else -> Nincs\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "F2z5K3bKP4zP", "colab_type": "code", "colab": {}, "outputId": "0177a799-d9bc-4146-a98f-52f5b57976f3" }, "source": [ "a = 'Lajos'\n", "print('L betű van az a változóban :','L' in a)\n", "print('X betű van az a változóban :','X' in a)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "L betű van az a változóban : True\n", "X betű van az a változóban : False\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "lqruWh4gaYh7" }, "source": [ "\n", "---\n", "\n", "az egész számok (pl. 2, 4, 20) alkotják az **int** típust, \n", "\n", "a valós számok (pl 5.0, 1.6) pedig a **float** típust. \n", "\n", "\n", "---\n", "\n", "\n", "`Pythonban` 3-ban az osztás (/) mindig lebegőpontos értékeket ad vissza. \n", "\n", "lefelé kerekítő egészosztás elvégzéséhez, amellyel egész értéket kapunk, a // operátor használható; \n", "\n", "az osztás maradékához a %-t használhatjuk\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "3ViM_h6saYh7", "outputId": "4180c75a-44a8-4d5d-fbe3-65e15086eb01", "colab": {} }, "source": [ "17 / 3 # hagyományos osztás lebegőpontos eredménnyel" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "5.666666666666667" ] }, "metadata": { "tags": [] }, "execution_count": 6 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "oMeMYUgAaYh9", "outputId": "e645fb58-298c-4abc-daf7-c93fe88d9e45", "colab": {} }, "source": [ "17 // 3 # az egészosztással megszabadulunk a törtrésztől" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "5" ] }, "metadata": { "tags": [] }, "execution_count": 7 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "XijW9RAVaYh_", "outputId": "0a0810ff-d21b-4311-e133-df70fa38b1b7", "colab": {} }, "source": [ "17 % 3 # a % operátor az osztás maradékával tér vissza" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "2" ] }, "metadata": { "tags": [] }, "execution_count": 8 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "fe_JO4HgaYiB", "outputId": "8c88b95e-0dc8-4491-c06f-a52308d4c4be", "colab": {} }, "source": [ "5 * 3 + 2 # eredmény * osztó + maradék" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "17" ] }, "metadata": { "tags": [] }, "execution_count": 9 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "iD1gNulDaYiD" }, "source": [ "---\n", "\n", "A `Pythonban` a ** operátor használható a hatvány kiszámítására:\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "hqVnBl2vaYiD", "outputId": "45e9fbd4-f5c0-49fb-9c8b-3187f7cba0cc", "colab": {} }, "source": [ "5 ** 2 # 5 négyzete" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "25" ] }, "metadata": { "tags": [] }, "execution_count": 10 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "w_FnyJfMaYiF", "outputId": "5d97bcfd-3036-4ff0-acfc-1c05277b365c", "colab": {} }, "source": [ "2 ** 7 # 2 7-dik hatványa" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "128" ] }, "metadata": { "tags": [] }, "execution_count": 11 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "odGB1Vy4aYiH" }, "source": [ "\n", "---\n", "\n", "A `Python` a lebegőpontos számokat bizonyos tekintetben előnyben részesíti az egész számokhoz képest. Azok a műveletek, amelyeknél keverednek a típusok, az egészeket lebegőpontossá alakítják:\n", "\n", "---\n", "\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "EqOqIsNsaYiI", "outputId": "3fcca6d3-bd75-4165-8099-78b495af873b", "colab": {} }, "source": [ "3 * 3.75 / 1.5" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "7.5" ] }, "metadata": { "tags": [] }, "execution_count": 12 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "BY8PxlASaYiK", "outputId": "7044c3c8-78ae-4d52-f07a-b606c6e7b1c3", "colab": {} }, "source": [ "7.0 / 2" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "3.5" ] }, "metadata": { "tags": [] }, "execution_count": 13 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "o5KeAvubaYiM" }, "source": [ "\n", "---\n", "\n", "Előfordul néha, hogy egyes függvények `int` típusú változót, várnak és ezt egy `float` típusúból kell előállítanunk. A típusok közti konverziót az int() és float() függvények segítségével tehetjük meg.\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "wvXTesTMaYiN", "outputId": "65ddb2f7-9e44-4f07-ce47-ebd9957f2649", "colab": {} }, "source": [ "int(3.1415)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "3" ] }, "metadata": { "tags": [] }, "execution_count": 14 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "fTMOpUA5aYiO", "outputId": "b0493dd6-bccd-4633-85d0-a490f77111fb", "colab": {} }, "source": [ "float(42)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "42.0" ] }, "metadata": { "tags": [] }, "execution_count": 15 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "iaktkHVjaYiQ" }, "source": [ "\n", "---\n", "\n", "A `Python` komplex számokat is tud kezelni – a képzetes részt a j vagy J jellel képezhetjük. A komplex számot (valós+képzetes j) formában írhatjuk:\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "u3bYopdvaYiR", "outputId": "580a608d-df7e-4873-ccba-2db5c35f5cf9", "colab": {} }, "source": [ "1j * 1J" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "(-1+0j)" ] }, "metadata": { "tags": [] }, "execution_count": 16 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "J0LpfMA2aYiT", "outputId": "3b2e5c7a-0803-42e3-dfcb-8b28cf4261bc", "colab": {} }, "source": [ "3+1j*3" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "(3+3j)" ] }, "metadata": { "tags": [] }, "execution_count": 17 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "bCPJ-xifaYiU", "outputId": "ba32e69c-e04b-4376-ccc2-73fa18b73683", "colab": {} }, "source": [ "(3+1j)*3" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "(9+3j)" ] }, "metadata": { "tags": [] }, "execution_count": 18 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "VPN5-R_EaYiZ", "outputId": "3ab126a3-33c9-4c77-a53a-f802916fc7d7", "colab": {} }, "source": [ "(1+2j)/(1+1j)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "(1.5+0.5j)" ] }, "metadata": { "tags": [] }, "execution_count": 19 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "FxnXZvAZaYid" }, "source": [ "A komplex számokat gyakran két lebegőpontos számmal ábrázolják: a képzetes és a valós résszel. A `z` komplex számnak ezeket a részeit talán kicsit szokatlan módon (a változó után írt `.` és a megfelelő szó ) a `z.real` és `z.imag` utasításokkal olvashatjuk vissza." ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "NK1plMBbaYie", "outputId": "60048aff-3d2d-49e9-ac21-61a36caffe95", "colab": {} }, "source": [ "(1.5+0.5j).real" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "1.5" ] }, "metadata": { "tags": [] }, "execution_count": 20 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "RaOmun4eaYif", "outputId": "7cc6aa9b-dd92-4cbb-89c1-c54333a11d85", "colab": {} }, "source": [ "(1.5+0.5j).imag" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "0.5" ] }, "metadata": { "tags": [] }, "execution_count": 21 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Pq3kbLejaYih" }, "source": [ "\n", "---\n", "\n", "A lebegőpontos és egész típusú konverziós függvények (`float()` és `int()`) nem működnek komplex számokra.\n", "\n", "A komplex-valós átalakításnak több lehetséges módja is van: ahhoz, \n", "hogy egy komplex számból valósat csinálj, használd az abs(z) utasítást, \n", "hogy megkapd a nagyságát, vagy a fennt már megismert `z.real` és `z.imag` utasítást, \n", "ha a valós része vagy a képzetes része kell. \n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Z1yasd4laYii", "outputId": "1c081bf2-b4dd-4cb3-9314-9ec91fc4182e", "colab": {} }, "source": [ "float(3.0+4.0j) # ez nem működik // can't convert complex to float" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "TypeError", "evalue": "can't convert complex to float", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfloat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3.0\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m4.0j\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# ez nem működik\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[1;31mTypeError\u001b[0m: can't convert complex to float" ] } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "tIcEH5nmaYik", "colab": {}, "outputId": "960d242a-2e5a-4bfa-925d-445d508fb312" }, "source": [ "abs(3.0+4.0j) # sqrt(a.real**2 + a.imag**2)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "5.0" ] }, "metadata": { "tags": [] }, "execution_count": 11 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "IYLDmLeYaYim" }, "source": [ "---\n", "\n", "#### A programjainkban különböző előtagokkal kell jeleznünk, hogy melyik szám rendszerben adjuk meg a számokat:\n", "\n", "decimális: nincs előtag\n", "\n", "bináris: 0b\n", "\n", "hexadecimális: 0x\n", "\n", "oktális: 0o\n", "\n", " \n", "\n", "ord(), amely az argumentumként megadott karakter Unikód táblázat szerinti kódpontját adja vissza,\n", "\n", "chr(), amely a megadott kódpontnak megfelelő karaktert jeleníti meg, ha van ilyen.\n", "\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "id": "xn1M7arLP40M", "colab_type": "code", "colab": {}, "outputId": "f3c7aa5c-60d0-4f04-8107-fa1b4ee297c1" }, "source": [ "print(bin(19))\n", "\n", "print(bin(0x13))\n", "\n", "print(hex(19 + 0b10011 + 0o23))\n", "\n", "print(hex( ord('A')))\n", "\n", "print(chr(65))" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "0b10011\n", "0b10011\n", "0x39\n", "0x41\n", "A\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "zzHhy0KGaYim" }, "source": [ "---\n", "\n", "## Változók\n", "\n", "Programozási feladatok során rendszerint változókban tároljuk a hasznos információkat. \n", "A megírt programok nem konkrét számértékekre hanem, változókra hivatkoznak, ez teszi lehetővé, hogy különböző bemeneti adatokra ugyanazt az algoritmust ha kell, többször is lefuttathassuk. \n", "A változók neveit rendszerint az angol ABC betűiből és esetleg néhány egyéb karakterből szokás összeállítani. \n", "\n", "Például: \n", "\n", "```python\n", "szelesseg # ebben csak betűk vannak\n", "a_folyoso_hossza # ebben a változó névben szerepel a _ karakter is\n", "```\n", "\n", "A változók alapértelmezetten lokálisak, tehát csak egy class-on, fuggvényen belül használhatók, ahhoz, hogy a\n", "modulon belül más class is használhassa az adott változót ’’global’’ kiterjesztéssel kell ellátnunk.\n", "\n", "`global global_valtozo` \n", "\n", "A változók neveit célszerű úgy megválasztani hogy később könnyen kitalálható legyen, mit is jelölünk vele. \n", "A legtöbb programozási nyelvhez hasonlóan az egyenlőségjellel (=) lehet értéket adni egy változónak. \n", "Az értékadás után az értelmező újabb utasításra vár, látszólag nem történik semmi:\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "iSmbowR4aYin", "colab": {} }, "source": [ "szelesseg = 20\n", "magassag = 5*9" ], "execution_count": 0, "outputs": [] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "FHBrVEN0aYip" }, "source": [ "A háttérben viszont létrejöttek a `szelesseg` és `magassag` változók, amikkel most már hasznos dolgokat tudunk művelni. Számítsuk ki például a két változó szorzatát:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "LY0gCWspaYip", "outputId": "c11a51a8-b9f1-49f7-ec64-b809522bc07f", "colab": {} }, "source": [ "szelesseg * magassag" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "900" ] }, "metadata": { "tags": [] }, "execution_count": 24 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "kyXGbbzKaYir" }, "source": [ "Ha egy változó nincs definiálva (nincs érték rendelve hozzá), és használni próbáljuk, akkor hibaüzenetet kapunk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "PCRchvfXaYit", "outputId": "7d01fe8d-3296-4dc4-80ad-e4921e327e34", "colab": {} }, "source": [ "n # Az n változót még nem definiáltuk" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "NameError", "evalue": "name 'n' is not defined", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mn\u001b[0m \u001b[0;31m# Az n változót még nem definiáltuk\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'n' is not defined" ] } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "HlmBuFQ2aYiw" }, "source": [ "Interaktív módban az utoljára kiírt kifejezés értéke a _ (alsóvonás) változóban van. Így ha a Pythont asztali számológépként használod, akkor egyszerűbb folytatni a számolásokat, például:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "j88ipWxcaYiw", "colab": {} }, "source": [ "ado = 12.5 / 100" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "QjaFG3PyaYi0", "colab": {} }, "source": [ "ar = 100.50" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "GwBo5tp4aYi2", "outputId": "b4b6e6eb-bea2-49a9-880f-729e836a98f5", "colab": {} }, "source": [ "ar * ado" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "12.5625" ] }, "metadata": { "tags": [] }, "execution_count": 28 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "eO__hzYLaYi3", "outputId": "c17d5648-4cd3-4759-d010-65e7f24a0061", "colab": {} }, "source": [ "ar + _" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "113.0625" ] }, "metadata": { "tags": [] }, "execution_count": 29 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "qSvfd0RAaYi6", "outputId": "e84b3e19-965c-49eb-ca62-f3fe3766f621", "colab": {} }, "source": [ "round(_, 2) #kerekítés 2 tizedes jegyre" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "113.06" ] }, "metadata": { "tags": [] }, "execution_count": 30 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "4xzsX28MaYi7" }, "source": [ "\n", "---\n", "\n", "Ezt a _ változót csak olvasható változóként kezelhetjük. Ne adjunk értéket neki, mert ha adunk, akkor létrehozunk egy független helyi változót azonos névvel, amely meggátolja a beépített változó elérését, amely mágikus módon viselkedik. \n", "\n", "(Ha egy globális változó nevével létrehozunk egy helyi változót, akkor az értelmező a helyit használja.)\n", "\n", "\n", "A notebookban az előző eredményen kívül jóval korábbi eredményekre is hivatkozhatunk. Például 1. parancs kimenetére a következőképpen:\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "1XEk2Gj6aYi8", "outputId": "a255af36-7b72-4cbe-cd5b-dc8868ac4ec9", "colab": {} }, "source": [ "Out[1]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "' ez így megjegyzésként hat \\nés ez több sorban is folytatódhat'" ] }, "metadata": { "tags": [] }, "execution_count": 13 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "o0FGUpE1aYi-" }, "source": [ "---\n", "\n", "### None\n", "\n", "A szó jelentése semmi vagy egyik sem. A Pythonban a None értéknek helykitöltő szerepe van. \n", "\n", "Ezzel jelölhetjük pl. a hiányzó vagy érvénytelen eredményt vagy az alapértelmezett beállítást.\n", "\n", "A None érték típusa.`\n", "type(None)\n", "\n", "NoneType\n", "\n", "Ha a cella utolsó kifejezése None érték¶, akkor nincs kimenet.\n", "1 + 1\n", "None\n", "\n", "\n", "--" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ihWv2d17aYi-" }, "source": [ "\n", "---\n", "\n", "## Logikai Bool-változók és feltételes végrehajtás\n", "\n", "\n", "Ahhoz, hogy a program reagálni tudjon bemenetekre, vagy egy már kiszámolt részeredménytől függhessen további működése, szükség van feltételek vizsgálatára. \n", "\n", "Gondoljunk például a másodfokú egyenlet megoldóképletére! Attól függően, hogy a diszkrimináns pozitív vagy negatív, léteznek, ill. nem léteznek valós gyökök, így értelemszerűen egy ilyen programnak \"döntenie\" kell. \n", "\n", "A döntés egy feltétel vizsgálatán alapul (pl. poz. vagy neg. diszkrimináns), ami lehet igaz, vagy hamis, angolul *True*, ill. *False*. Az igaz és hamis értéket tárolni képes változó típusa: **boolean** (Bool-változó). (Emlékezzünk vissza az **int** ill. **float** típusokra).\n", "\n", "---\n" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "WbiP4MFNaYi-" }, "source": [ "Két objektum azonosságáról dupla egyenlőségjellel, azaz a == operátor segítségével tájékozódhatunk. " ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "uBbWOGAkaYi_", "outputId": "1e070581-07db-4627-e3fc-13b36ee95be7", "colab": {} }, "source": [ "1 == 1 # 1 megeggyezik 1-el ?" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 32 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "D-SItTvjaYjA", "outputId": "e733711b-1f7c-460d-b162-9a95c2897f52", "colab": {} }, "source": [ "1 == 2 # 1 megeggyezik 2-vel ?" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 33 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Nzh9J4RpaYjC" }, "source": [ "Ha arról akarunk meggyőződni hogy két objektum nem ugyanaz, akkor ezt a != operátor segítségével tehetjük meg:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "WNbqohQkaYjD", "outputId": "5ffcde5c-c5d5-499d-b97b-e102f59b733a", "colab": {} }, "source": [ "1!=2 #1 nem 2 ?" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 34 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "gVZneYeQaYjE" }, "source": [ "Természetszerűen számok esetén a <,> operátorok segítségével dönthetjük el, hogy melyik szám a nagyobb:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "cUaeK9V9aYjE", "outputId": "764bc2d6-7492-46d3-df60-6e390ab242a5", "colab": {} }, "source": [ "1>2" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 35 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "YjJL5o1saYjG", "outputId": "2e6b5115-5871-43cc-f5a0-0df10a1a73e3", "colab": {} }, "source": [ "1<2" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 36 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "NnAN-wX0aYjL", "outputId": "75efff27-16dc-484c-bdc6-524cc74b0797", "colab": {} }, "source": [ "1j+3>2 # complex számokra nem értelmezzük a <> jeleket!!" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "TypeError", "evalue": "unorderable types: complex() > int()", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1j\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;31m# complex számokra nem értelmezzük a <> jeleket!!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: unorderable types: complex() > int()" ] } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "azLqJflYaYjP" }, "source": [ "Egy igaz/hamis értéket változóban is tárolhatunk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "j8-gLmEsaYjQ", "colab": {} }, "source": [ "igazvagyhamis= 2*2==5" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "HaPq3DjDaYjS", "outputId": "a9003563-8015-4569-9c16-413af971c979", "colab": {} }, "source": [ "igazvagyhamis" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 39 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "3tp1tC0saYjU" }, "source": [ "Az **is** és **is not** relációk összehasonlítják, hogy két dolog valóban azonos-e. Minden összehasonlító relációnak azonos precedenciája van, mely magasabb, mint a számokkal végzett műveleteké." ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "O5VhhrPfaYjV", "outputId": "3a85e386-efaf-4963-ddc7-7a207cd98c60", "colab": {} }, "source": [ "1==1.0 # A számegyenesen történő összehasonlítás" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 40 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "AQTAdkZhaYjY", "outputId": "b077de89-78a4-4afe-8260-a89756eeb8e8", "colab": {} }, "source": [ "1 is 1.0 # Objektum típusa és értéke szerint történő összehasonlítás: int vs float" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 41 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "7lxSPWwgaYjZ" }, "source": [ "Egy objektumról az **isinstance** parancs segítségével tudjuk eldönteni, hogy milyen típusú:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "uhGX3EXLaYjZ", "outputId": "1473c720-cb5d-44bf-ef1d-a23d2e564559", "colab": {} }, "source": [ "isinstance(1,int) # Vajon az '1' az int típusú ?" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 42 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "O7SqZ0BSaYjb", "outputId": "b5ed7cc8-a17a-4af2-ac50-4d26b8fffb70", "colab": {} }, "source": [ "isinstance(2,float) # Vajon a '2' float típusú ?" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 43 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "r_wlrBPOaYjc" }, "source": [ "Relációkat láncolhatunk is, például: az a < b == c megvizsgálja, hogy az a kisebb-e mint b, és ezen felül b egyenlő-e c-vel." ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "MbrZYTOtaYjd", "outputId": "4d124ad2-5464-4de9-ed73-0c11452b111c", "colab": {} }, "source": [ "b=2\n", "1 < 2 == b" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 44 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "dbMIHGqraYje", "outputId": "ef755215-2ec6-403c-98e5-d8a1e59099b0", "colab": {} }, "source": [ "b=3\n", "1 < 2 == b" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 45 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "gXBA6d5NaYjg" }, "source": [ "A relációkat összefűzhetjük **and** és **or** logikai műveletekkel is. Reláció erdményét (vagy bármely logikai műveletét) ellentettjére változtathatjuk a **not** művelettel." ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "LWJyyJ7_aYjg", "outputId": "a53277a2-c45b-422b-ee90-6f44b1a6e740", "colab": {} }, "source": [ "not 2*2==5" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 46 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "oK1AjvzdaYji" }, "source": [ "Az **and**, **or** és **not** fügvények, ha zárójelezést nem alkalmazunk, akkor a relációjelek után kerülnek kiértékelésre (más szóval mondva a relációjelekhez képest alacsonyabb a precedenciájuk). \n", "A három logikai művelet közül a **not** értékelődik ki legelőször (neki a magasabb a precedenciája a másik kettőhöz képest), és az **or** értékelődik ki utolsónak. \n", "\n", "Tehát az A and not B or C ugyanazt jelenti, mint az (A and (not B)) or C. Természetesen a zárójeleket használhatjuk a kívánt feltétel eléréséhez." ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "fX-bPwU7aYji", "outputId": "0aeb8639-f538-41c7-d2c3-3d817054bdc8", "colab": {} }, "source": [ "b=3\n", "((1==2) and (3==4)) or (b==3)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 47 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "T8Ef3khqaYjn" }, "source": [ "---\n", "\n", "### Összes névtér foglat szavak listája\n", "\n", "\n", "```\n", " dir(__builtins__)\n", "```\n", "---" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Nli69a3MaYjn" }, "source": [ "\n", "---\n", "\n", "## Karakterláncok (Stringek)\n", "\n", "A számok mellett a Python karakterláncokkal, például szavakkal is tud műveleteket végezni. A karakterláncokat egyszeres ('...') vagy dupla idézőjelek (\"...\") közé lehet zárni. A két jelölés között nincs jelentős különbség. A \\\\ használható arra, hogy a karakterláncbeli idézőjeleket levédjük\n", "\n", "A sztring adattípus szöveges értékek tárolására szolgál. Pythonban a sztring nem más mint Unicode\n", "szimbólumok (másnéven Unicode karakterek) nem módosítható sorozata.\n", "\n", "A jelőlés választást gyakran a karakterlánc tartalma szabja meg egyszeres idézőjelet tartalmazó stringet kettős idézőjellel deklarálunk és viszont. \n", "\n", "A többi  esetben az idézőjel fajtája indifferens. \n", "\n", "A Pythonban minden objektum, így a karakterláncok is azok\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "RTfGj6P5aYjo", "outputId": "8ec8d8fa-ebbc-4bcd-a5c8-5ed9b8eff1ec", "colab": {} }, "source": [ "'spam eggs'" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'spam eggs'" ] }, "metadata": { "tags": [] }, "execution_count": 48 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "RAemkYItaYjp", "outputId": "02101d10-d037-4b6b-a87d-9fa076691daf", "colab": {} }, "source": [ "'doesn\\'t'" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "\"doesn't\"" ] }, "metadata": { "tags": [] }, "execution_count": 49 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "jBW3puSLaYjq", "outputId": "741e41d5-283a-4079-90e9-f3e31ce9e80b", "colab": {} }, "source": [ "\"doesn't\"" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "\"doesn't\"" ] }, "metadata": { "tags": [] }, "execution_count": 50 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "benrxNNnaYjr", "outputId": "346e44be-8fce-4249-eb37-40da72bfd374", "colab": {} }, "source": [ "'\"Yes,\" he said.'" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'\"Yes,\" he said.'" ] }, "metadata": { "tags": [] }, "execution_count": 51 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "xT1cijUQaYju", "outputId": "69fba1db-cfa7-4bf3-92b7-a5efeaae13e5", "colab": {} }, "source": [ "\"\\\"Yes,\\\" he said.\"" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'\"Yes,\" he said.'" ] }, "metadata": { "tags": [] }, "execution_count": 52 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "SMY4zmaOaYjv", "outputId": "4527b5be-4c87-4d18-d30c-206fb7951990", "colab": {} }, "source": [ "'\"Isn\\'t,\" she said.'" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'\"Isn\\'t,\" she said.'" ] }, "metadata": { "tags": [] }, "execution_count": 53 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "dooUrEkVaYjw" }, "source": [ "---\n", "\n", "A kimeneti karakterlánc idézőjelekben jelenik meg, a speciális karakterek vissza-perrel (\\\\) levédve.\n", "\n", "Bár ez néha különbözőnek látszik a bemenettől (az idézőjel fajtája megváltozhat), a két karakterlánc egyenértékű. \n", "\n", "A `print()` függvény egy sokkal olvashatóbb kimenetet eredményez, elhagyva az idézőjeleket és kiírva a levédett és speciális karaktereket:\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "T_TN9v-jaYjw", "outputId": "a64ac72b-4411-4e10-f92f-6a53cef7fd85", "colab": {} }, "source": [ "print('\"Isn\\'t,\" she said.')" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "\"Isn't,\" she said.\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "r8YEGX_8aYjx", "colab": {} }, "source": [ "s = 'First line.\\nSecond line.' # \\n újsort jelent" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "mcZSUAwIaYjy", "outputId": "34fac3c0-1659-44f7-b01c-4be3bb0911ee", "colab": {} }, "source": [ "s # print() nélkül a \\n benne van a kimenetben" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'First line.\\nSecond line.'" ] }, "metadata": { "tags": [] }, "execution_count": 56 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "SDTdRVATaYjz", "outputId": "f5a219d4-9a44-4552-c80c-5cb403682e95", "colab": {} }, "source": [ "print(s) # print()-tel az \\n újsort hoz létre" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "First line.\n", "Second line.\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "5P4wLMOBaYj2" }, "source": [ "Ha nem akarod, hogy a \\ jellel kezdődő karakterek speciális karakterként értelmeződjenek, akkor nyers karakterláncokat használhatsz egy r-et helyezve a kezdő idézőjel elé:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Ts67mtgoaYj2", "outputId": "b1b1250f-631b-4cf6-e40e-ea77b6feee51", "colab": {} }, "source": [ "print('C:\\some\\name') # \\n újsort jelent" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "C:\\some\n", "ame\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "nEtX176YaYj4", "outputId": "c0ee445d-cb3b-4a27-fd0f-d8e087ff8d4e", "colab": {} }, "source": [ "print(r'C:\\some\\name') # r van az idézőjel előtt" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "C:\\some\\name\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "F2VObRqOaYj5" }, "source": [ "A literális karakterláncok többsorosak is lehetnek. Egy lehetőség erre a hármas idézőjelek használata: \"\"\"...\"\"\" vagy '''...'''. Ilyenkor az újsorok automatikusan belekerülnek a karakterláncba, de ez a viselkedés megszüntethető, ha a sor végére egy \\\\-t adsz. A következő példa" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "jBES2IP6aYj6", "outputId": "bea34198-1b01-46ee-eeda-f81e359e3abc", "colab": {} }, "source": [ "print(\"\"\"\\\n", "Usage: thingy [OPTIONS]\n", " -h Display this usage message\n", " -H hostname Hostname to connect to\n", "\"\"\")" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Usage: thingy [OPTIONS]\n", " -h Display this usage message\n", " -H hostname Hostname to connect to\n", "\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "gZDONs6XaYj7" }, "source": [ "Karakterláncokat a + művelettel ragaszthatunk össze, és *-gal ismételhetünk." ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "rQgLcaVgaYj8", "outputId": "6421c960-3ddb-4087-cc82-8361780ab427", "colab": {} }, "source": [ "3 * 'un' + 'ium'" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'unununium'" ] }, "metadata": { "tags": [] }, "execution_count": 61 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "U4vHPUMraYj9" }, "source": [ "Két egymást követő literális karakterláncot (azokat, amik idézőjelben vannak, és nem egy változóban, vagy nem egy függvény hoz létre) az értelmező magától összefűz:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "9Q9dMDM6aYj9", "outputId": "8aec3141-50ef-48eb-8910-bd6617c723c4", "colab": {} }, "source": [ "'Py' 'thon'" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Python'" ] }, "metadata": { "tags": [] }, "execution_count": 62 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "XnvCAKs6aYj-" }, "source": [ "De ez csak két literálissal működik, változóval vagy kifejezéssel nem:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "uo3f7erYaYj_", "outputId": "80e266d3-ac56-4dc7-8e5d-d2ac74ebcbcf", "colab": {} }, "source": [ "prefix = 'Py'\n", "prefix 'thon' # nem tud változót és literális karakterláncot összefűzni" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "SyntaxError", "evalue": "invalid syntax (, line 2)", "traceback": [ "\u001b[0;36m File \u001b[0;32m\"\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m prefix 'thon' # nem tud változót és literális karakterláncot összefűzni\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n" ] } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "UaEYgY8LaYkB" }, "source": [ "Ha változókat akarsz összefűzni, vagy változót literálissal, használj + műveletet:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "bHOHY2awaYkB", "outputId": "cf5da0a3-72d4-4e4a-c651-c3f28eae7704", "colab": {} }, "source": [ "prefix = 'Py'\n", "prefix + 'thon'" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Python'" ] }, "metadata": { "tags": [] }, "execution_count": 64 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "CtaAUEsfaYkC" }, "source": [ "A literálisok összefűzése különösen hasznos hosszú sorok széttörésére:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "MF0p8rHGaYkD", "outputId": "f903a95b-396f-45da-df6d-0c49abdd6954", "colab": {} }, "source": [ "text = ('Több karakterláncot írhatunk zárójelbe, '\n", " 'hogy összefűzhessük azokat.')\n", "text" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Több karakterláncot írhatunk zárójelbe, hogy összefűzhessük azokat.'" ] }, "metadata": { "tags": [] }, "execution_count": 65 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "OFoYvu8VaYkE" }, "source": [ "Minden karakterhez a karakterláncban a `Python` rendel egy sorszámot (indexet). Az első karakterhez tartozik a `0` index, a következőhöz az `1`-es index és így tovább. (Ez a konvenció tükrözi a C-ben megszokottakat.) " ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "collapsed": true, "id": "a1bJi0SVaYkE", "colab": {} }, "source": [ "szo = 'Python'" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Jn8q1VnyaYkF", "outputId": "a69ed043-f0ef-4f24-d9b7-7524932cfd3d", "colab": {} }, "source": [ "szo[0] # karakter a 0 pozícióban" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'P'" ] }, "metadata": { "tags": [] }, "execution_count": 67 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "yjPSj5xBaYkH", "outputId": "a2b31c6b-6ecc-4d40-9cd3-50811fad27b1", "colab": {} }, "source": [ "szo[5] # karakter a 5 pozícióban" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'n'" ] }, "metadata": { "tags": [] }, "execution_count": 68 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "eU1CIrq7aYkK" }, "source": [ "Az indexek negatívak is lehetnek, ilyenkor jobbról kezdünk el számolni:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "3sINx5AoaYkL", "outputId": "fe64c422-c317-41a5-8f97-6e85605ecee0", "colab": {} }, "source": [ "szo[-1] # utolsó karakter" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'n'" ] }, "metadata": { "tags": [] }, "execution_count": 69 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "j2P6o5O5aYkN", "outputId": "c1825e47-4b55-4e01-d635-6ca70fe1b9e6", "colab": {} }, "source": [ "szo[-2] # utolsó előtti karakter" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'o'" ] }, "metadata": { "tags": [] }, "execution_count": 70 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "8COJlJ94aYkQ", "outputId": "fb85a586-f91f-447f-888a-0d38da86172d", "colab": {} }, "source": [ "szo[-6]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'P'" ] }, "metadata": { "tags": [] }, "execution_count": 71 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "pZzysBzraYkR" }, "source": [ "Az indexelésen felül a szeletelés is támogatott. Míg az indexelés egyetlen karaktert jelöl ki, a szeletelés egy részkarakterláncot:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "YDFRqfG_aYkR", "outputId": "95c72c9e-caa8-46f8-9810-6340c296af39", "colab": {} }, "source": [ "szo[0:2] # karakterek a 0 pozíciótól (benne van) a 2-esig (az már nem)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Py'" ] }, "metadata": { "tags": [] }, "execution_count": 72 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "jfgXY_nhaYkS", "outputId": "81f56548-3475-4ec0-eac5-d5982c3d469d", "colab": {} }, "source": [ "szo[2:5] # karakterek a 2 pozíciótól (benne van) a 5-esig (az már nem)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'tho'" ] }, "metadata": { "tags": [] }, "execution_count": 73 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "uk-kdLz-aYkT" }, "source": [ "A kezdő index mindig beleértendő az eredménybe, a végső index pedig nem. Ez teszi lehetővé, hogy s[:i] + s[i:] mindig egyenlő s-el:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "mRlvXXsraYkU", "outputId": "5d3a697b-a710-4fd5-e248-973f96e9b614", "colab": {} }, "source": [ "szo[:2] + szo[2:]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Python'" ] }, "metadata": { "tags": [] }, "execution_count": 74 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "yi9d5IkZaYkV", "outputId": "c62b8df7-d36f-4fd1-b996-a9794f5066b5", "colab": {} }, "source": [ "szo[:4] + szo[4:]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Python'" ] }, "metadata": { "tags": [] }, "execution_count": 75 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "8mKquRKDaYkW" }, "source": [ "A szeletek indexeinek hasznos alapértékei vannak; a kihagyott első index alapértéke 0, az elhagyott második index alapértéke a szeletelendő karakterlánc hossza:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "h-UNEgv_aYkX", "outputId": "063df139-7559-4fde-f3b0-328bcb7750f6", "colab": {} }, "source": [ "szo[:2] # karakterek az elejétől a 2-esig (már nincs benne)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Py'" ] }, "metadata": { "tags": [] }, "execution_count": 76 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "2_BLvexkaYkZ", "outputId": "5f8bfef6-bd36-482d-a724-524a23524807", "colab": {} }, "source": [ "szo[4:] # karekterek a 4-es pozíciótól (benne van) a végéig" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'on'" ] }, "metadata": { "tags": [] }, "execution_count": 77 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "tdYaqH5VaYkb", "outputId": "d4caba5d-5166-4844-e332-de9fac3846a0", "colab": {} }, "source": [ "szo[-2:] # karakterek az utolsó előttitől (beleértve) a végéig" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'on'" ] }, "metadata": { "tags": [] }, "execution_count": 78 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "UflasWgeaYkc" }, "source": [ "Jegyezd meg, hogy a -0 valóban azonos a 0-val, így ez nem jobbról számol!" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "DzlurESaaYkc", "outputId": "39347dcb-416a-444d-f31a-aa08791f8c06", "colab": {} }, "source": [ "szo[-0] # mivel -0 és 0 egyenlőek" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'P'" ] }, "metadata": { "tags": [] }, "execution_count": 79 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "QBR4m5O9aYkd" }, "source": [ "A nem negatív indexek esetén a szelet hossza az indexek különbségével egyenlő, ha mindkettő a valódi szóhatárokon belül van. Például a szo[1:3] hossza 2.\n", "Ha olyan indexet használunk, amely túl nagy, az eredmény hibát ad:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "hB8TT3KnaYkd", "outputId": "24a8e225-db93-4301-ce90-c5ab51d17b9b", "colab": {} }, "source": [ "szo[42] # a szo csak 7 karakteres" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "IndexError", "evalue": "string index out of range", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mszo\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m42\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# a szo csak 7 karakteres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mIndexError\u001b[0m: string index out of range" ] } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "b6feKqsNaYkf" }, "source": [ "A Python karakterláncait nem lehet megváltoztatni, azok megváltoztathatatlanok. Ezért, ha egy adott indexű helyhez értéket rendelünk, hibát kapunk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "fhdxzT5LaYkg", "outputId": "d805fc06-be98-4b9d-c1f9-09db475832cf", "colab": {} }, "source": [ "szo[0] = 'J'" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "TypeError", "evalue": "'str' object does not support item assignment", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mszo\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'J'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment" ] } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "o5Lo1f0ZaYkh" }, "source": [ "Ha másik karakterláncra van szükség, alkothatunk egy újat:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "N2_WURTYaYkh", "outputId": "aec4b982-da01-48a0-b946-35cd6bee962c", "colab": {} }, "source": [ "'J' + szo[1:]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Jython'" ] }, "metadata": { "tags": [] }, "execution_count": 82 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "7HMN1YWSaYki", "outputId": "2612d2dd-55be-4a4e-e922-99ad8e709a11", "colab": {} }, "source": [ "szo[:2] + 'py'" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'Pypy'" ] }, "metadata": { "tags": [] }, "execution_count": 83 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "UV4ZqKYsaYkj" }, "source": [ "A beépített len() függvény a karakterlánc hosszával tér vissza:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "IjdyCHBQaYkj", "outputId": "c2dce102-54ac-470b-c55d-b4e1be407255", "colab": {} }, "source": [ "s = 'legeslegelkáposztásíthatatlanságoskodásaitokért'\n", "len(s)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "47" ] }, "metadata": { "tags": [] }, "execution_count": 84 } ] }, { "cell_type": "code", "metadata": { "id": "8qTIRO2SP42n", "colab_type": "code", "colab": {}, "outputId": "4cf37d53-cc11-4264-f90b-72b24cbe1442" }, "source": [ "# Hány bájton tárolódnak a magyar ábécé ékezetes kisbetüi UTF-8 kódolás esetén?\n", "print(len('á'.encode('utf-8')))\n", "print(len('é'.encode('utf-8')))\n", "print(len('í'.encode('utf-8')))\n", "print(len('ó'.encode('utf-8')))\n", "print(len('ö'.encode('utf-8')))\n", "print(len('®'.encode('utf-8')))\n", "print(len('ú'.encode('utf-8')))\n", "print(len('ü'.encode('utf-8')))\n", "print(len('¶'.encode('utf-8')))\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "2\n", "2\n", "2\n", "2\n", "2\n", "2\n", "2\n", "2\n", "2\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "8I8k-4hJP42p", "colab_type": "code", "colab": {}, "outputId": "5a543b26-32fb-45ad-b93d-bf9d6d17f761" }, "source": [ "# Hány bájton tárolódik a π és a ∞ szimbólum?\n", "print(len('π'.encode('utf-8')))\n", "print(len('∞'.encode('utf-8')))" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "2\n", "3\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "bBurnnsCP42r", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "### Hasznos szöveg sztring metodusok\n", "\n", "\n", "`s.lower(), s.upper()` a sztring kisbetűs, nagybetűs verziójával tér vissza\n", "\n", "`s.strip()` a whitespace karaktereket levágja a sztring elejéről és végéről\n", "\n", "`s.isalpha() / s.isdigit() / s.isspace()`... megnézi, hogy a sztring vmennyi karaktere az adott karakterosztályba tartozik-e\n", "\n", "`s.startswith('other'), s.endswith('other')` megnézi, hogy a sztring a másik sztringgel kezdődik-e / végződik-e\n", "\n", "`s.find('other')` A sztringben szerepel-e a másik sztring (nem reguláris kifejezésként adjuk meg). Ha igen, akkor az első előfordulás első karakterének indexével tér vissza. Ha nem, akkor -1 a visszatérési érték.\n", "\n", "`s.replace('old', 'new')` a sztringben az 'old' vmennyi előfordulását 'new'-ra cseréli\n", "\n", "`s.split('delim')` A sztringet az adott szeparátor mentén részsztringek listájára bontja. A szeparátor nem reguláris kifejezés. Ha csak `s.split()` -et írunk, akkor a whitespace karakterek mentén bontja fel a sztringet.\n", "\n", "`s.join(list)` A `split()` ellentéte. Egy lista elemeit kapcsolja össze egy adott szeparátorral (ez lesz az s sztring).\n", "\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "id": "RX1Vrf6dP42r", "colab_type": "code", "colab": {}, "outputId": "6266d8bb-1254-422b-aeca-7cd00e7e377e" }, "source": [ "# Fehér karakterek (szóköz, tabulátor, sortörés) eltávolítása\n", "# a sztring elejéről és végéről.\n", "print('e1 : ',' \\talma\\n'.strip())\n", "\n", "# Megadott karakterek eltávolítása a sztring elejér®l és végér®l.\n", "print('e2 : ','---alma+++'.strip('+-'))" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "e1 : alma\n", "e2 : alma\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "by1xEU65P42t", "colab_type": "code", "colab": {}, "outputId": "e887b01e-774f-4a0a-c041-cad84aa12103" }, "source": [ "## Minták\n", "szoveg='minta szüveg a python bemutatására' \n", "print(szoveg.upper()) ## -> MINTA SZÜVEG A PYTHON BEMUTATÁSÁRA\n", "print('old szovegben az old részt kicseréli majd'.replace('old', 'new')) ## -> new szovegben az new részt kicseréli majd\n", "print('aaa,bbb,ccc'.split(',')) ## -> ['aaa', 'bbb', 'ccc'].\n", "print('---'.join(['aaa', 'bbb', 'ccc']) ) ## -> aaa---bbb---ccc" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "MINTA SZÜVEG A PYTHON BEMUTATÁSÁRA\n", "new szovegben az new részt kicseréli majd\n", "['aaa', 'bbb', 'ccc']\n", "aaa---bbb---ccc\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "9vnd4erGP42u", "colab_type": "code", "colab": {}, "outputId": "d4d91dab-b7d0-4f89-8b87-32522404550e" }, "source": [ "##--- tömeges replace()\n", "##--- használat : str=s.maketrans( régiek, újak, törlendők)\n", "\n", "cserélő= str.maketrans(\"alk\", \"k?a\")\n", "print('V1 : ',\"ablak\".translate( cserélő)) ## -> 'kb?ka'\n", "\n", "\n", "cser= str.maketrans(\"öü\",\"üö\", \" k\")\n", "print('V2 : ', \"tükröm tükröm\".translate(cser)) ## -> 'törümtörüm'\n", "\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "V1 : kb?ka\n", "V2 : törümtörüm\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "h6W9BDBoP42v", "colab_type": "text" }, "source": [ "### Módosított jelentéssel bíró karaktersorozatok és hatásuk:\n", "\n", "\\n : A karakterfolyam kiírása a következő sorban folytatódik.\n", "\n", "\\t : A kiírás a következő tabulátorpozíción folytatódik.\n", "\n", "\\r : A kiírás a sor elejére visszaugorva folytatódik (carriage return, azaz „kocsi vissza” parancs, aminek elnevezése még az írógépes-teleprinteres korszakból származik).\n", "\n", "\\\\ : Maga a '\\', a visszavágás jele kerül kiírásra.\n", "\n", "\\a : A számítógép hangszóróján egy pittyegés lesz halható( bell, csengő).\n", "\n", "\\xhh : A kiírandó karakter kódját hexa-számrendszerben adtuk meg két számjeggyel.\n", "\n", "\\ooo : A kiírandó karakter kódja oktális számrendszerben három számjeggyel.\n", "\n", "\\uxxxx : A kiírandó karakter kódpontja hexa-számrendszerben négy számjeggyel.\n", "\n", "\\Uxxxxxxxx : A kiírandó karakter kódpontja hexa-számrendszerben nyolc számjeggyel.\n", "\n", " \n", "\n", "### A karakterláncok leghasznosabb metódusait:\n", "\n", "upper() - nagybetűs láncot állít elő az eredetit alapul véve;\n", "\n", "lower() - kisbetűs láncot állít elő;\n", "\n", "capitalize() - az első karakter nagybetűs lesz, a többi kicsi;\n", "\n", "title() - minden szó nagybetűvel fog kezdődni;\n", "\n", " \n", "\n", "#### center(), ljust(), rjust() \n", "\n", "az új lánc az első argumentumként megadott hosszúságú lesz, amiben az eredeti lánc másolata középre ill. \n", "balra vagy jobbra igazítva kerül elhelyezésre, az üres helyeken a második argumentumként szereplő „kitöltő” karakter fog ismétlődni. \n", "\n", "Ha nem adunk meg „kitöltőt”, akkor az a szóköz lesz.\n", "\n", " \n", "\n", "#### strip() \n", "\n", "az új lánc két végéről levágja a szóköz és az egyéb vezérlő karaktereket, az ún. 'whitespace'-ket. Ezek a string modulban a whitespace változóban vannak felsorolva:\n", "\n", " \n", "\n", "#### startswith(minta, start, stop), endswith(minta, start, stop) \n", "\n", "Általuk ellenőrizhetjük, hogy egy karakterlánc egy megadott mintával kezdődik-e ill. végződik. \n", "\n", "A start, stop értékeivel kijelölhetünk egy szeletet, amikor is csak ezen történik az ellenőrzés. \n", "\n", "Egyszerre több mintát is megadhatunk zárójelek között felsorolva.\n", "\n", " \n", "\n", "#### count(minta, start, stop) \n", "\n", "Megszámolja a minta előfordulását a láncban vagy annak egy szeletében és a darabszám lesz a visszatérési érték.\n", "\n", " \n", "\n", "#### find(), rfind(), index(), rindex() \n", "\n", "Mind a négy metódus a (minta, start, stop) paramétereket fogadja el és a megadott minta első \n", "előfordulásának az indexét adja meg. \n", "A start és stop értékeivel kijelölhetünk egy szeletet, ha nem az egész láncban szeretnénk keresni.\n", "\n", "Az rfind() és az rindex() jobbról balra keres.\n", "\n", "Ha a keresett minta nincs a láncban vagy a szeletben, akkor az első két metódus -1-et ad vissza, míg az utolsó kettő „ValueError” típusú eseményt hoz létre. \n", "\n", "Választhatunk, hogy melyik módon kívánjuk a hiányt kezelni.\n", "\n", "Azonban, ha csak a minta tartalmazásának ténye fontos és nem az indexe, akkor használjuk az in-operátort!\n", "\n", " \n", "\n", "#### replace(régi, új, darabszám) \n", "A láncban a régiként megadott összes mintát az újra cseréli ill. ha a darabszámot megadtuk, akkor csak annyit. \n", "\n", "Az új minta lehet az üres lánc is, ami a régi törlését eredményezi.\n", "\n", " \n", "\n", "### A sztring ellenőzések \n", "\n", "isalpha() - Igaz értéket ad vissza, ha a karakterlánc csak betűket tartalmaz, egyébként hamisat.\n", "\n", "isdecimal() - Igaz, ha csak számok vannak a láncban, egyébként hamis.\n", "\n", "islower() - Igaz, ha csupa kisbetűs karakter van a láncban.\n", "\n", "isupper()- Igaz, ha csupa nagybetűs karakter van a láncban.\n", "\n", "isspace() - Igaz, ha a lánc csak az ún. whitespace típusú karakterekből áll.\n", "\n", " \n", "\n", "A speciális írásjeleket a string modulban lévő `punctuation` nevű változó tartalmazza, ami\n", "ugyancsak jól használható a karakterláncok kezelésénél.\n", "\n", " \n", "\n", "### formázó hivatkozással, ami általánosságban ilyen lehet:\n", "\n", "{ [sorszám|név][:[[kitöltő]igazító][előjel][#][0][szélesség][,][.pontosság][típus]] }\n", "\n", "print( \"\\n Csak {0}? Nem hiszem, hogy csak {0}!\\n\".format( kor) )\n", "\n", " \n", "\n", "#### típus\n", "a számok formázására szolgál, és az így megadható ábrázolási módok két csoportba sorolhatók. Az elsőben, az egész számok esetében az alábbiak adhatók meg:\n", "\n", "• 'd' - decimális, azaz tízes számrendszer szerinti megjelenítés, ez lesz érvényben akkor is, ha nem adunk meg típust;\n", "\n", "• 'b' - bináris, azaz kettes számrendszerbeli megjelenítés;\n", "\n", "• 'x', 'X' - hexadecimális, azaz tizenhatos számrendszerbeli megjelenítés kis (abcdef) betűkkel ill. nagyokkal (ABCDEF).\n", "\n", "• 'o' - oktális, azaz nyolcas számrendszerbeli megjelenítés;\n", "\n", "• 'c' - karakteres (angolul: character) megjelenítés, amikor a megadott egész számot egy karakter kódjaként kell értelmezni.\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "id": "GkkJgzXZP42w", "colab_type": "code", "colab": {}, "outputId": "fc15aa8c-bdda-4440-d631-f1c3aaf4aa1c" }, "source": [ "for x in range(1, 11):\n", " print(repr(x).rjust(2), repr(x * x).rjust(3), end=' ')\n", " print(repr(x * x * x).rjust(4))\n", " \n", "#----------------------------------- \n", "for x in range(1,11):\n", " print('{0:2d} {1:3d} {2:4d}'.format(x, x * x, x * x * x))\n", " \n", "#----------------------------------- \n", "print('12'.zfill(5))\n", "print('Nevem {}, születtem \"{}-en.\"'.format('Lajos', 'Budapest'))\n", "\n", "#----------------------------------- \n", "import math\n", "print('PI értéke {!r}.'.format(math.pi))\n", "print('PI kerekített értéke {0:.3f}.'.format(math.pi))" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ " 1 1 1\n", " 2 4 8\n", " 3 9 27\n", " 4 16 64\n", " 5 25 125\n", " 6 36 216\n", " 7 49 343\n", " 8 64 512\n", " 9 81 729\n", "10 100 1000\n", " 1 1 1\n", " 2 4 8\n", " 3 9 27\n", " 4 16 64\n", " 5 25 125\n", " 6 36 216\n", " 7 49 343\n", " 8 64 512\n", " 9 81 729\n", "10 100 1000\n", "00012\n", "Nevem Lajos, születtem \"Budapest-en.\"\n", "PI értéke 3.141592653589793.\n", "PI kerekített értéke 3.142.\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "xbkI3YBsP42x", "colab_type": "text" }, "source": [ "---\n", "\n", "\n", "### Bytes tipus: \n", "Nem módosítható byte kód sorozat\n", "\n", "\n", "``` python\n", "b'akarmi' → (sztring) \n", "bytes('talicska') → (sztring) \n", "```\n", "\n", "`bytes([source[, encoding[, errors]]])`\n", "\n", "\n", "\n", "\n", "### Bytearray tipus: \n", "\n", "ua. mint bytes, csak módosítható \n", "\n", "``` python\n", "bytearray([66, 67, 68]) → bytearray(b'BCD') \n", "```\n", "\n", "\n", "`bytearray([source[, encoding[, errors]]])`\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "id": "wwKHnRCmP42x", "colab_type": "code", "colab": {}, "outputId": "15c797f9-d9cf-44e8-a380-b04dbc2b7677" }, "source": [ "bt = b'Byte tipus'\n", "print('bsz : ', bt)\n", "z = list(bt)\n", "print('z : ', z)\n", "\n", "bat = bytes('Bytearray tipus éáűúőóüö', 'utf8')\n", "print('bat : ', bat)\n", "\n", "s = bat.decode()\n", "print('s : ', s)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "bsz : b'Byte tipus'\n", "z : [66, 121, 116, 101, 32, 116, 105, 112, 117, 115]\n", "bat : b'Bytearray tipus \\xc3\\xa9\\xc3\\xa1\\xc5\\xb1\\xc3\\xba\\xc5\\x91\\xc3\\xb3\\xc3\\xbc\\xc3\\xb6'\n", "s : Bytearray tipus éáűúőóüö\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "whJG3NFYP42y", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "\n", "## Különleges értékadások\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "lY10CAcKP42y", "colab_type": "code", "colab": {}, "outputId": "0e9e75be-c8bc-4dd4-f209-f7111f45b5c1" }, "source": [ "## Kicsomagolás (unpacking)\n", "x, (y, z) = [10, (20, [30, 40])] # Általános eset\n", "\n", "\n", "# Többszörös értékadás. \n", "a, b = 20, 30 \n", "print(a) \n", "print(b)\n", "\n", "\n", "# Csere. \n", "a, b = b, a \n", "print(a) \n", "print(b)\n", "\n", "\n", "\n", " # Kicsomagolás alkalmazása for ciklusnál. \n", "data = [('a', 1), ('b', 2), ('c', 3)] \n", "for x, y in data: \n", " print(x) \n", " print(y)\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "20\n", "30\n", "30\n", "20\n", "a\n", "1\n", "b\n", "2\n", "c\n", "3\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "DNWUWnWTaYkk" }, "source": [ "\n", "---\n", "\n", "\n", "## Kollekciók, összetett adat tipusok\n", "\n", "\n", "\n", " - Nem modosítható lista(tuple) / sokaság, \n", " \n", " - Lista (list), \n", " \n", " - Halmaz(set), \n", " \n", " - Nem módósítható halmaz (Frozenset), \n", " \n", " - Könyvtár(dir) / szótárhoz hasonló típusú objektumokat összefoglalóan asszociatív tömböknek nevezzük.\n", " \n", "\n" ] }, { "cell_type": "markdown", "metadata": { "id": "NM07zaHnP421", "colab_type": "text" }, "source": [ "---\n", "\n", "\n", "\n", "### Tuple használata (nem változtatható lista) / sokaság \n", "\n", "()\n", "\n", "\n", "\n", "A tuplek megváltoztathatatlan (immutable) elemek rendezett együttesei. \n", "\n", "A tuplek különböző típusú elemeket tartalmazhatnak. \n", "\n", "A tuple természetes számokkal indexelhető, nem módosítható tömb. \n", "\n", "A tuple-ok mindig zárójelezve vannak, így azok egymásba ágyazva is helyesen értelmezhetők.\n", "\n", "Megadhatjuk zárójelekkel és anélkül is, néha azonban feltétlenül szükségesek a zárójelek (amikor az egy nagyobb kifejezés része).\n", "\n", "Nem lehetséges a tuple elemeinek új értéket adni, de létrehozható olyan tuple, amelynek vannak megváltoztatható elemei, például listák.\n", "\n", "A listákhoz hasonlóan a tuplek elemeihez is indexeléssel férhetünk hozzá és az in szerkezettel tesztelhetjük egy elem jelenlétét a listában. \n", "\n", "Ha már létrehoztunk egy listát,  akkor annak a tartalma többé nem változtatható meg.\n", "\n", "\n", "\n", "Jegyezzük meg, hogy a többszörös értékadás valójában csak a tuple-ba csomagolás és a sorozat-szétpakolás kombinációja és minden jobboldalon álló sorozattípusra működik. \n", "\n", "A sorozat szétpakolásához az szükséges, hogy a bal oldalon annyi elem szerepeljen, ahány elem van a tuple-ban.\n", "\n", "``` python\n", "t = 1234, 4321, 'Itt vagyok'\n", "\n", ">>> x, y, z = t\n", "\n", "```\n", "\n", "\n", "#### Egy lista illetve egy tuple közötti választás kritériumai :\n", "\n", " - a tuplek bejárása gyorsabb, mint a listáké \n", "\n", " - konstansok definiálására használjunk tupleket\n", "\n", "\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "id": "tMjS0Vp6P421", "colab_type": "code", "colab": {}, "outputId": "749b7ae9-1f04-4a81-cee9-1f3b8751c80d" }, "source": [ "t = 12345, 54321, 'Lajos'\n", "print( t[0])\n", "print(t)\n", "t = ('Lajos', 12345, 54321, 'Dani')\n", "print(t)\n", "u = t, (1, 2, 3, 4, 5)\n", "print(u)\n", "egyTuple = 'Lajos',\n", "print(egyTuple)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "12345\n", "(12345, 54321, 'Lajos')\n", "('Lajos', 12345, 54321, 'Dani')\n", "(('Lajos', 12345, 54321, 'Dani'), (1, 2, 3, 4, 5))\n", "('Lajos',)\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "gz5tyRiDaYkl" }, "source": [ "\n", "---\n", "\n", "## Listák (List)\n", "\n", "[]\n", "\n", "A Python többfajta összetett adattípust ismer, amellyel több különböző értéket csoportosíthatunk. \n", "\n", "Egy igen sokoldalú összetett adattípus a lista, amelyet vesszőkkel elválasztott értékekként írhatunk be szögletes zárójelbe zárva. \n", "\n", "Az alábbiakban a listákkal kapcsolatos műveletek alapjait tekintjük át. \n", "\n", "A lista elemeinek nem kell azonos típusúaknak lenniük, bár sok alkalmazásban minden elem azonos típusú.\n", "\n", "A lista a tuple módosítható változata. Új elemet is hozzálehet adni, illetve meglévő elemeken is lehet módosítani.\n", "\n", " +---+---+---+---+---+---+\n", " \n", " | 1 | 2 | 4 | 8 | 16| 32|\n", " \n", " +---+---+---+---+---+---+\n", " \n", " | a | b | c | d | e | f |\n", " \n", " +---+---+---+---+---+---+\n", " \n", " | P | y | t | h | o | n |\n", " \n", " +---+---+---+---+---+---+\n", " \n", " 0 1 2 3 4 5 6\n", " \n", "-6 -5 -4 -3 -2 -1\n", "\n", "\n", "\n", "\n", "#### Lista műveletek :\n", "\n", "A lista végéhez az `append()` metódussal, \n", "\n", "egy adott indexű helyéhez az `insert()` metódussal adhatunk elemeket. \n", "\n", "Az `extend()` metódus a paramétereként megadott lista tartalmát hozzáadja a  listához.\n", "\n", "Az `index()` metódus megadja egy elem listabeli első előfordulásának indexét. \n", "\n", "Abban az esetben,  ha a paraméterként megadott elem nincs a listában, egy `ValueError` generálódik. \n", "\n", "Az `in` utasítás  `True` értéket ad vissza, ha az elem a listában van, egyébként `False` -ot.\n", "\n", "Ahhoz hasonlóan, ahogyan elemeket adunk egy listához, törölhetünk is elemeket egy listából. A  `remove()` metódus segítségével törölhetjük a megadott elem első elpfordulását egy listából.  \n", "\n", "Ha a paraméterként megadott elem nem fordul elő a listában, akkor egy  `ValueError`  kivétel  (exeption) generálódik. \n", "\n", "\n", "A Pythonban minden objektum, így egy lista is, a `del` (delete)  operátorral szüntethető meg.\n", "\n", "\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "BphCa6I1aYkl", "outputId": "6dd70cf2-c645-447a-9bb9-a60ceece1e5f", "colab": {} }, "source": [ "## Üres lista létrehozása. \n", "a=[]\n", "a.append('bor') \n", "a.append('sör') \n", "a.insert(1, '''pálinka''') ## beszúrás 1 pozicióba (0 val kezdődik)\n", "print(a) ## ['bor', 'pálinka', 'sör']\n", "print('---------')\n", "\n", "a = ['spam', 'tojások', 100, 1234]\n", "print(a) ## ['spam', 'tojások', 100, 1234]\n", "print('---------')\n", "\n", " # Tartalmazásvizsgálat. \n", "print('tartalmazás',30 in a)\n", "\n", "## Első előfordulás / indexének meghatározása\n", "print('index', a.index('spam'))\n", "print('---------')\n", "\n", "## Egy szekvencia összes elemének hozzáfűzése a listához. \n", "a.extend([22, 23, 24, 'sör', 'bor']) \n", "print('extend',a) ## ['spam', 'tojások', 100, 1234, 22, 23, 24, 'sör', 'bor']\n", "print('---------')\n", "\n", "##Az extend különbözik az append-től! \n", "a.append([22, 23, 24]) \n", "print('append', a) \n", "\n", "print('---------')\n", "# Adott indexű elem törlése. \n", "a.pop(2)\n", "print('pop(2)', a) \n", "\n", "# Utolsó elem törlése. \n", "a.pop()\n", "print('pop()', a) \n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "['bor', 'pálinka', 'sör']\n", "---------\n", "['spam', 'tojások', 100, 1234]\n", "---------\n", "tartalmazás False\n", "index 0\n", "---------\n", "extend ['spam', 'tojások', 100, 1234, 22, 23, 24, 'sör', 'bor']\n", "---------\n", "append ['spam', 'tojások', 100, 1234, 22, 23, 24, 'sör', 'bor', [22, 23, 24]]\n", "---------\n", "pop(2) ['spam', 'tojások', 1234, 22, 23, 24, 'sör', 'bor', [22, 23, 24]]\n", "pop() ['spam', 'tojások', 1234, 22, 23, 24, 'sör', 'bor']\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "UzhQazHpaYkm" }, "source": [ "Ahogy a karakterláncokat, a listákat is indexelhetjük és szeletelhetjük:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "xa-ttMR3aYkm", "outputId": "87b6f4e2-66a1-422b-b79f-e098bc90839e", "colab": {} }, "source": [ "a[0]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'spam'" ] }, "metadata": { "tags": [] }, "execution_count": 86 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "JYt9db3baYkn", "outputId": "02228188-0cf7-4df1-8361-9405984d44f7", "colab": {} }, "source": [ "a[3]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "1234" ] }, "metadata": { "tags": [] }, "execution_count": 87 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "taReYt3OaYko", "outputId": "91f391a7-3b53-4cdb-8d33-a5ed445e4353", "colab": {} }, "source": [ "a[-2] " ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "100" ] }, "metadata": { "tags": [] }, "execution_count": 88 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "6snv6yXjaYkp", "outputId": "5c4191ef-d962-4c04-e5af-3839f1199a5c", "colab": {} }, "source": [ "a[1:-1] # a szeletelés új listát ad" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['tojások', 100]" ] }, "metadata": { "tags": [] }, "execution_count": 89 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "JScvQV_KaYkq" }, "source": [ "A listák az összefűzést is támogatják:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "9pc_auftaYkq", "outputId": "a10d8a0c-13d5-4f29-c298-5b6c24824306", "colab": {} }, "source": [ "a[:2] + ['sonka', 2*2]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['spam', 'tojások', 'sonka', 4]" ] }, "metadata": { "tags": [] }, "execution_count": 90 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "X_meAkSgaYkr", "outputId": "faf4596c-1ff1-4549-ac32-f9318158a164", "colab": {} }, "source": [ "3*a[:3] + ['Boe!']" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['spam',\n", " 'tojások',\n", " 100,\n", " 'spam',\n", " 'tojások',\n", " 100,\n", " 'spam',\n", " 'tojások',\n", " 100,\n", " 'Boe!']" ] }, "metadata": { "tags": [] }, "execution_count": 91 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "EVpmwSqsaYks" }, "source": [ "A karakterláncokkal ellentétben – amelyek megváltoztathatatlanok – a listák egyes elemeit módosíthatjuk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "vaBfcKRDaYks", "outputId": "d77d83f3-f8fc-4995-c1ed-20febc0179b3", "colab": {} }, "source": [ "a[2] = a[2] + 23\n", "a" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['spam', 'tojások', 123, 1234]" ] }, "metadata": { "tags": [] }, "execution_count": 92 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "2ZEfKzt1aYkt" }, "source": [ "A szeleteknek értékeket is adhatunk, és ez akár a lista elemszámát is megváltoztathatja:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "relL0Wq_aYku", "outputId": "af67b518-482a-440c-85e2-80af02b3fdad", "colab": {} }, "source": [ "a[0:2] = [1, 12] # Pár elem átírása:\n", "a" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[1, 12, 123, 1234]" ] }, "metadata": { "tags": [] }, "execution_count": 93 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "tWtmWVGxaYkw", "outputId": "d987b703-278d-42f2-e7c9-3ae8d666e751", "colab": {} }, "source": [ "a[0:2] = [] # Pár elem törlése:\n", "a" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[123, 1234]" ] }, "metadata": { "tags": [] }, "execution_count": 94 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "0gzFGYr1aYky", "outputId": "040d3d2b-e178-45d3-bff5-c42eeff9521e", "colab": {} }, "source": [ "a[1:1] = ['bletch', 'xyzzy'] # Pár elem beszúrása:\n", "a" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[123, 'bletch', 'xyzzy', 1234]" ] }, "metadata": { "tags": [] }, "execution_count": 95 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "CrqmdJ4JaYkz", "outputId": "57eadaaa-3efa-42f8-ab9f-e82319f0cb2e", "colab": {} }, "source": [ "a[:0] = a # Beszúrja magát (pontosabban egy másolatát) a saját elejére.\n", "a" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]" ] }, "metadata": { "tags": [] }, "execution_count": 96 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "HJ44OG8BaYk0" }, "source": [ "A beépített len() függvény listákra is alkalmazható:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "ZxKjy69EaYk0", "outputId": "8e7d516f-90c5-4976-ac48-c425c258f64f", "colab": {} }, "source": [ "len(a)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "8" ] }, "metadata": { "tags": [] }, "execution_count": 97 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "lULm7mBraYk2" }, "source": [ "A listák egymásba ágyazhatóak, azaz listába elhelyezhetünk listát elemként:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "9Ti5v29daYk3", "outputId": "1277abdf-ab3c-4911-e6f2-e5e649dd622e", "colab": {} }, "source": [ "a = ['a', 'b', 'c']\n", "n = [1, 2, 3]\n", "x = [a, n]\n", "x" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "[['a', 'b', 'c'], [1, 2, 3]]" ] }, "metadata": { "tags": [] }, "execution_count": 98 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "P5LHhroMaYk3", "outputId": "19060af6-6bfc-4e8d-aa7e-9aea79c962fe", "colab": {} }, "source": [ "x[0]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['a', 'b', 'c']" ] }, "metadata": { "tags": [] }, "execution_count": 99 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "bSmhBqFVaYk4", "outputId": "00c09a0c-c9ed-4254-fe04-8bb53de42b75", "colab": {} }, "source": [ "x[0][1]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'b'" ] }, "metadata": { "tags": [] }, "execution_count": 100 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "rzl3B5NeaYk5", "outputId": "d9fb382e-3fa7-4f60-ccf8-5b990367a04d", "colab": {} }, "source": [ "x[0][1]" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'b'" ] }, "metadata": { "tags": [] }, "execution_count": 101 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "V2Ehzp17aYk7" }, "source": [ "Előfordul hogy meg szeretnénk tudni, hogy egy adott elem hanyadik helyen van a listában ezt az `.index()` függvény alkalmazásával kaphatjuk meg. Például nézzük meg hogy a lent definiált `autok` lista hanyadik eleme a `'merci'` karakter:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "4IFqU-lZaYk7", "colab": {} }, "source": [ "autok=['skoda','vw','merci','mazda']" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "VnZ8QKGsaYk8", "outputId": "5f803955-ec5a-4de2-eec9-c3a31e54b650", "colab": {} }, "source": [ "autok.index('merci')" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "2" ] }, "metadata": { "tags": [] }, "execution_count": 103 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "I-ya0nKQaYk9" }, "source": [ "Mint ahogy azt láttuk, a karakterláncok is indexelhetőek. Karakterláncban szereplő karakterek indexére is rákérdezhetünk az `.index()` paranccsal:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "wPwmyR-TaYk9", "colab": {} }, "source": [ "betuk='abcdef'" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "egnSPJTeaYk-", "outputId": "bca06597-8987-4347-9eeb-648fdd94135f", "colab": {} }, "source": [ "betuk.index('e')" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "4" ] }, "metadata": { "tags": [] }, "execution_count": 105 } ] }, { "cell_type": "markdown", "metadata": { "id": "a1W6Ocq8P43c", "colab_type": "text" }, "source": [ "---\n", "\n", "### Listát többféleképpen hozhatunk létre:\n", "\n", "• szögletes zárójelek között vesszővel elválasztott elemeket felsorolva, s ha nem adunk meg\n", "\n", "elemet, akkor az üres lista jön létre;\n", "\n", "• a list() standard függvénnyel, amelynek argumentumként bármilyen olyan objektumot\n", "\n", "megadhatunk, amelynek az elemei felsorolhatók, s ekkor ezen elemek lesznek a lista\n", "\n", "elemei; az üres lista jön létre, ha nem adunk meg elemet;\n", "\n", "• a [ kif1 for elem in obj if kif2 ] kifejezéssel, ahol az obj egy felsorolható elemekkel bíró\n", "\n", "objektum. A 'kif1' elemképző kifejezéssel hozzuk létre az új elemeket, de a kif2 kifejezéssel\n", "\n", "ezeket még előzetesen megszűrhetjük. Az if szerkezetet nem kötelező megadni. E\n", "\n", "konstrukciót listaépítő vagy listaalkotó kifejezésnek fogjuk nevezni.\n", "\n", "---\n", "\n", "A teljes körű másolásnál a másolandó listának nem csak az elemei, hanem az általuk hivatkozott módosítható objektumok is duplikálásra kerülnek, s az elemek ezekre fognak mutatni (angolul: deep copy). \n", "\n", "Az eljárás során a módosíthatatlan objektumok nem lesznek megkettőzve. \n", "\n", "A másolást a copy modulban lévő deepcopy() függvénnyel végezhetjük el.\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "LfD-ahRBP43c", "colab_type": "text" }, "source": [ "### Pár minta a listák használatára" ] }, { "cell_type": "code", "metadata": { "id": "VGqkwB4_P43d", "colab_type": "code", "colab": {}, "outputId": "49ee95dd-c60e-4e3b-d9d7-b89490fd6421" }, "source": [ "a = [42.25, 420, 4200, 1, 42.5]\n", "print(a.count(420), a.count(42.25), a.count('x'))\n", "a.insert(2, -1)\n", "a.append(420)\n", "print(a) \n", "print(a.index(420))\n", "a.remove(420)\n", "print(a) \n", "a.reverse()\n", "print(a) \n", "a.sort()\n", "print(a) \n", "print(a.pop())\n", "del a[2:4]\n", "print(a) \n", "\n", "print('----------------- Csúcs Négyzet sor számítás --------------------')\n", "print(list(map(lambda x: x**2, range(10))))\n", "print('==')\n", "print([x ** 2 for x in range(10)])\n", "\n", "print('----------------- Csúcs márix számítás azonos kizárással --------------------')\n", "print([(x, y) for x in [1,2,3] for y in [3,1,4] if x != y])\n", "print('==')\n", "combs = []\n", "for x in [1,2,3]:\n", " for y in [3,1,4]:\n", " if x != y:\n", " combs.append((x, y))\n", "\n", "print(combs)\n", "\n", "print('----------------- Csúcs négyzet sor számítás --------------------')\n", "\n", "print([(x, x ** 2) for x in range(11)])\n", "\n", "print('----------------- Csúcs sor kibontás --------------------')\n", "\n", "vec = [[1,2,3], [4,5,6], [7,8,9]]\n", "print( [num for elem in vec for num in elem])\n", "\n", "print('----------------- Csúcs PI kerekítgetés --------------------')\n", "from math import pi\n", "print( [str(round(pi, i)) for i in range(1, 6)])\n", "\n", "print('----------------- Csúcs mátrix átszámolás 4x3 -> 3x4--------------------')\n", "\n", "matriz = [\n", " [1, 2, 3, 4],\n", " [5, 6, 7, 8],\n", " [9, 10, 11, 12],\n", " ]\n", "print( [[fila[i] for fila in matriz] for i in range(4)])\n", "print('==')\n", "\n", "trans = []\n", "for i in range(4):\n", " trans.append([fila[i] for fila in matriz])\n", "print( trans)\n", "print('==')\n", "\n", "print(list(zip(*matriz)))" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "1 1 0\n", "[42.25, 420, -1, 4200, 1, 42.5, 420]\n", "1\n", "[42.25, -1, 4200, 1, 42.5, 420]\n", "[420, 42.5, 1, 4200, -1, 42.25]\n", "[-1, 1, 42.25, 42.5, 420, 4200]\n", "4200\n", "[-1, 1, 420]\n", "----------------- Csúcs Négyzet sor számítás --------------------\n", "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n", "==\n", "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n", "----------------- Csúcs márix számítás azonos kizárással --------------------\n", "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]\n", "==\n", "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]\n", "----------------- Csúcs négyzet sor számítás --------------------\n", "[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49), (8, 64), (9, 81), (10, 100)]\n", "----------------- Csúcs sor kibontás --------------------\n", "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "----------------- Csúcs PI kerekítgetés --------------------\n", "['3.1', '3.14', '3.142', '3.1416', '3.14159']\n", "----------------- Csúcs mátrix átszámolás 4x3 -> 3x4--------------------\n", "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n", "==\n", "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n", "==\n", "[(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "0cdeu4DsP43e", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "\n", "### Halmaz (SET)\n", "\n", "{} `Jegyezzük meg, hogy az üres halmaz létrehozásához csak a set() használható, a {} nem, mert az utóbbi üres szótárat hoz létre.` \n", "\n", "\n", "\n", "A Python a set / halmaz adattípust is tartalmazza. \n", "\n", "A halmaz adat típus a matematikai halmaz fogalom számítógépes megfelelője. \n", "\n", "A halmaz elemek rendezetlen halmaza, amelyben minden elem csak egyszer fordulhat elő.\n", "\n", "\n", "#### Alapvető használata: \n", "\n", " - megadott elem meglétének ellenőrzése, \n", " - elemek kettőzésének kiszűrése. \n", " \n", " \n", " \n", "##### A set /halmaz objektumok támogatják az olyan matematikai műveleteket, mint \n", "\n", " - az egyesítés, \n", " - metszet, \n", " - különbség, \n", " - és a szimmetrikus eltérés.\n", " \n", "\n", "A halmazok létrehozására a kapcsos zárójel, vagy a set() függvény használható. \n", "\n", "\n", "\n", "\n", "\n", "Halmazt indexelni nem lehet.\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "yoiAyey_P43e", "colab_type": "code", "colab": {}, "outputId": "f0b566e7-fbc8-462d-9c68-f2210d784fa2" }, "source": [ "# Üres halmaz létrehozása. \n", "a= set() ## üres halmaz / set létrehozása\n", "print(type(a))\n", "\n", "a={} ## üres szótár / Dict létrehozása\n", "print(type(a))\n", "\n", "s= {2, 3, 42}\n", "s.remove(2) # Elem eltávolítása. s\n", "print(type(s), len(s),s)\n", "\n", "a = set('abracadabra')\n", "b = set('alkatresz')\n", "print(a)\n", "print(a - b)\n", "print(a | b)\n", "print(a & b)\n", "print(a ^ b)\n", "\n", "a = {x for x in 'abracadabra' if x not in 'abc'}\n", "print(a)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "\n", "\n", " 2 {3, 42}\n", "{'b', 'd', 'c', 'a', 'r'}\n", "{'b', 'c', 'd'}\n", "{'b', 'd', 'c', 'a', 't', 'e', 's', 'r', 'k', 'z', 'l'}\n", "{'a', 'r'}\n", "{'b', 'd', 'c', 't', 'e', 's', 'k', 'z', 'l'}\n", "{'d', 'r'}\n" ], "name": "stdout" } ] }, { "cell_type": "code", "metadata": { "id": "dkh9qMQ-P43i", "colab_type": "code", "colab": {}, "outputId": "7d97718c-27d4-4a81-c0c5-1d2d3f2b3381" }, "source": [ "# Hozzunk létre egy s nevű halmazváltozót! \n", "s = {2, 3, 4}\n", "# Ellen®rizzük s típusát és elemszámát! \n", "type(s), len(s)\n", "# Halmazműveletek.\n", "print({1, 2, 3} | {3, 4, 5}) # unió\n", "print({1, 2, 3} & {3, 4, 5}) # metszet\n", "print({1, 2, 3} - {3, 4, 5}) # kivonás\n", " # A halmazba bármilyen nem módosítható típusú elemet be lehet tenni. \n", "print({1, 2, (3, 4)})\n", "# Üres halmaz létrehozása. \n", "set()\n", "\n", "\n", "\n" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "{1, 2, 3, 4, 5}\n", "{3}\n", "{1, 2}\n", "{1, 2, (3, 4)}\n" ], "name": "stdout" }, { "output_type": "execute_result", "data": { "text/plain": [ "set()" ] }, "metadata": { "tags": [] }, "execution_count": 25 } ] }, { "cell_type": "markdown", "metadata": { "id": "xt30x-7IP43l", "colab_type": "text" }, "source": [ "----" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ZrxfSvpLaYk_" }, "source": [ "\n", "---\n", "\n", "## Szótárak (Dictionary)\n", "\n", "{ : }\n", "\n", "A szótárhoz hasonló típusú objektumokat összefoglalóan asszociatív tömböknek nevezzük.\n", "\n", "A szótár kulcs érték párok halmaza, ahol a kulcsok egyediek. A kulcs lehet egyszeru˝ típus, tuple, vagy bármely módosíthatatlan adatszerkezet. Indexelni a kulccsal lehet\n", "\n", "Sokszor előfordul, hogy adatokat nem valamilyen sorrendben, hanem inkább valamilyen címke szerint szeretnénk tárolni. \n", "\n", "Tipikus példája ennek egy idegen nyelvű szótár, ahol egy magyar kifejezést egy más nyelvbeli kifejezéssel párosítunk. \n", "\n", "Ezeknél a struktúráknál sokszor nem lényeges a sorrend, gondoljunk itt például valamilyen tárgy tulajdonságaira. Legyen mondjuk egy autónk ami \n", "\n", "- piros színű\n", "- 1976-ban gyártották\n", "- 3m hosszú \n", "- aok621 rendszámú\n", "\n", "Ezek a tulajdonságok egyértelműen meghatározzák az autót attól függetlenül, hogy a felsorolást milyen sorrendben tettük. \n", "\n", "Ilyen jellegű adatstruktúra a Python nyelvben a szótár vagy angolul a dictionary, röviden dict. \n", "\n", "A szótárak − néha asszociatív tömböknek is nevezik őket − kulcsokkal indexelt, nem rendezett adategyüttesek. \n", "\n", "Egy kulcsnak kötelezően megváltoztathatatlannak (immutábilisnak) (string, egész  vagy tuple) kell lenni. \n", "\n", "Másrészt egy kulcs mindig egyedi. Egy üres szótárat két kapcsos zárójellel  definiálunk. \n", "\n", "\n", "A szótárak létrehozása kulcsszavak és a hozzájuk rendelt érték segítségével az alábbi szintaxis alapján történik:\n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "0U68rYPPaYlA", "outputId": "5571b058-d9c3-49a8-ef31-7b8e78431056", "colab": {} }, "source": [ "tel = {'János': 4098, 'Simon': 4139}\n", "tel" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'János': 4098, 'Simon': 4139}" ] }, "metadata": { "tags": [] }, "execution_count": 106 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "VQhAlZDlaYlB" }, "source": [ "A listákkal ellenben, ahol sorszám alapján hivatkozunk egy elemre, itt kulcsszó alapján:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "ai_bnHm2aYlC", "outputId": "8f7197b4-7649-489b-be2a-b76ce29e0eff", "colab": {} }, "source": [ "tel['János']" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "4098" ] }, "metadata": { "tags": [] }, "execution_count": 107 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "wwYfYXcFaYlD" }, "source": [ "Új elemet is kulcsszó alapján adhatunk egy dict-hez:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "D1US8kFxaYlG", "outputId": "ff0052ab-b9e4-4980-ed28-31c06f3b6f8e", "colab": {} }, "source": [ "tel['Géza'] = 4127\n", "tel" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'Géza': 4127, 'János': 4098, 'Simon': 4139}" ] }, "metadata": { "tags": [] }, "execution_count": 108 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "NHA8AvLraYlH" }, "source": [ "Természetesen nem csak számokat adhatunk meg a szótárunkba mint hozzárendelt értéket:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "zF98CVeXaYlH", "outputId": "2f20e528-c8a2-4fc1-e091-9f1420df9c99", "colab": {} }, "source": [ "tel['Brünhilda']='NEM TUDOM A SZÁMÁT'\n", "tel" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'Brünhilda': 'NEM TUDOM A SZÁMÁT', 'Géza': 4127, 'János': 4098, 'Simon': 4139}" ] }, "metadata": { "tags": [] }, "execution_count": 109 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "C992dj_yaYlI" }, "source": [ "Így törlünk valakit a telefonkönyvből:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "0J2cC9G-aYlI", "outputId": "c4253885-e6e9-47f7-e62e-e4f4e727061d", "colab": {} }, "source": [ "del tel['Simon']\n", "tel" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'Brünhilda': 'NEM TUDOM A SZÁMÁT', 'Géza': 4127, 'János': 4098}" ] }, "metadata": { "tags": [] }, "execution_count": 110 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "2HOib4ZcaYlJ" }, "source": [ "A dict-ben szereplő kulcsszavakat a \".keys()\" metódus alkalmazásával tudjuk elérni. " ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "IcW63_4faYlJ", "outputId": "62a1f662-81ca-4039-f4a8-e0c6ea4fe0da", "colab": {} }, "source": [ "tel.keys()" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "dict_keys(['Géza', 'Brünhilda', 'János'])" ] }, "metadata": { "tags": [] }, "execution_count": 111 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "lAadWOAbaYlK" }, "source": [ "A fenti parancs kimenete látszólag tartalmazza az általunk kért információt. Sokszor azonban célszerű ezt az outputot a `list()` parancs segítségével listává konvertálni:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "WyQD5DiVaYlK", "outputId": "fe2f14d3-1daf-4263-d29b-349b9bbb7043", "colab": {} }, "source": [ "list(tel.keys())" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "['Géza', 'Brünhilda', 'János']" ] }, "metadata": { "tags": [] }, "execution_count": 112 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "kSBpK_mpaYlL" }, "source": [ "Vajon Géza benne van a telefonkönyvben? Ezt a listáknál megismert \"in\" parancsal tudjuk ellenőrizni:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "o4WG_6_3aYlM", "outputId": "19de1e30-51a5-4f6d-f649-396d65a3a74e", "colab": {} }, "source": [ "'Géza' in tel" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 113 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ST1GeaqNaYlN" }, "source": [ "*Megjegyzés:* Nyilván attól, mert Brünhilda benne van a telefonkönyvben, nem biztos, hogy tudjuk a telefonszámát:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "_3LBdlxZaYlN", "outputId": "a7f95c8d-d17e-4bed-fc1b-e89bbd877b24", "colab": {} }, "source": [ "'Brünhilda' in tel" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 114 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "C0jzCdKgaYlP", "outputId": "4aaeedef-8301-44d9-f02e-7075c7037e58", "colab": {} }, "source": [ "tel['Brünhilda']" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "'NEM TUDOM A SZÁMÁT'" ] }, "metadata": { "tags": [] }, "execution_count": 115 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "S8AsZmPaaYlQ" }, "source": [ "\n", "---\n", "\n", "A szótáraknak vannak a kulcsok manipulálására szolgáló metódusai. \n", "\n", "A `keys()` metódus a  szótár kulcsainak listáját adja visszatérési értékként, a has_key metódus True értéket ad vissza,  ha a paraméterként megadott kulcs szerepel a szótárban, ellenkező esetben False -ot.\n", "\n", "A `values()` metódussal egy szótárban tárolt értékeket tartalmazó listához férünk hozzá.  \n", "\n", "Az `items()` metódus egy tuplekből álló listát ad, melyben midegyik tuple egy kulcs-érték párt  tartalmaz\n", "\n", "Egy kulcshoz asszociált értéket úgy módosítunk, hogy újra értéket rendelünk a szótárban a kérdéses  indexhe. \n", "\n", "Végul a `del` operátorral törölhetünk egy kulcs-érték párt a szótárból\n", "\n", "\n", "\n", "A **dict** függvény segítségével az alábbi módon is definiálhatunk szótárakat:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "VXm7_UiTaYlQ", "outputId": "35cce577-77ea-4927-ed3e-dc7808c95754", "colab": {} }, "source": [ "tel2=dict(Ica=1234,Maca=4321,Dada=5567)\n", "tel2" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "{'Dada': 5567, 'Ica': 1234, 'Maca': 4321}" ] }, "metadata": { "tags": [] }, "execution_count": 116 } ] }, { "cell_type": "code", "metadata": { "id": "aywzNfSEP43_", "colab_type": "code", "colab": {}, "outputId": "7ec4fe31-f452-4c29-ba2a-2f5d78e538d5" }, "source": [ "tel = {'jack': 4098, 'sape': 4139}\n", "tel['guido'] = 4127\n", "print( tel)\n", "print(sorted(tel.keys()))\n", "print(list(tel.keys()))\n", "print(list(tel.values()))\n", "\n", "dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])\n", "print('==')\n", "dict(sape=4139, guido=4127, jack=4098)\n", "\n", "for k, v in tel.items():\n", " print(k, v)\n", "\n", "\n", "print('----------------- Csúcs generálás--------------------')\n", "print( {x: x ** 2 for x in (2, 4, 6)})\n", "\n", "print('----------------- Csúcs generálás--------------------')\n", "for i, v in enumerate(['ta', 'te', 'ti']):\n", " print(i, v)\n", " \n", "print('----------------- Csúcs generálás--------------------')\n", "pre = ['pre1', 'pre2', 'pre3']\n", "res = ['res1', 'res2', 'res3']\n", "for p, r in zip(pre, res):\n", " print(p,r)" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "{'jack': 4098, 'sape': 4139, 'guido': 4127}\n", "['guido', 'jack', 'sape']\n", "['jack', 'sape', 'guido']\n", "[4098, 4139, 4127]\n", "==\n", "jack 4098\n", "sape 4139\n", "guido 4127\n", "----------------- Csúcs generálás--------------------\n", "{2: 4, 4: 16, 6: 36}\n", "----------------- Csúcs generálás--------------------\n", "0 ta\n", "1 te\n", "2 ti\n", "----------------- Csúcs generálás--------------------\n", "pre1 res1\n", "pre2 res2\n", "pre3 res3\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "EANdpEj4aYlR" }, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "Fn89WIvxaYlS" }, "source": [ "## Bool változók és más változók kapcsolata\n", "Ahogy fentebb láttuk, egy objektumot egész számmá (**int()** függvény) vagy lebegőpontos számmá tudunk konvertálni ( **float()** függvény), illetve láttunk példát arra is hogy listává konvertáljunk valamit. Objektumokat Bool-változóvá is tudunk konvertálni. Erre szolgál a **bool()** függvény. Alább néhány példát nézzünk meg, hogy bizonyos dolgok hogy konvertálódnak a **bool()** függvénnyel.\n", "\n", "Egy szám vagy egy karakterlánc **True** értéket ad:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "-uVTaxgqaYlS", "outputId": "903c1bfa-428d-44d3-d02e-d50cce38c945", "colab": {} }, "source": [ "bool(1.0)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 117 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "cbY2Nk8MaYlT", "outputId": "3e49d291-ac2a-40ea-8696-2858d2936398", "colab": {} }, "source": [ "bool('szoveg')" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 118 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "vdLFYMCIaYlU" }, "source": [ "Hasonlóan **True** értéked ad, ha egy nem üres listát vagy általában egy más létező objektumot vizsgálunk:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "LSjd1SppaYlV", "outputId": "2a861b11-996e-4555-bfef-3e5743c7b34c", "colab": {} }, "source": [ "bool([1,'Bela'])" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 119 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "SP8CaUu5aYlW" }, "source": [ "**False** értéket ad a 0 az üres karakterlánc, illetve az üres lista:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "ub9HqrZ5aYlW", "outputId": "f1dcdd3e-9a48-49fb-81d2-d430359b5109", "colab": {} }, "source": [ "bool(0)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 120 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "uD9ti530aYlX", "outputId": "1f141921-aa1d-403d-d42e-7f11d1d6d5c4", "colab": {} }, "source": [ "bool(0.0)" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 121 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "utsrEpXhaYlY", "outputId": "a3f6d120-5d8e-4e82-9bc3-f49e51c0115f", "colab": {} }, "source": [ "bool('')" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 122 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "CogdZqGQaYle", "outputId": "de02c658-d6d8-455c-d863-ab4b453c2002", "colab": {} }, "source": [ "bool([])" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 123 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ubJjHS8laYlf" }, "source": [ "Egy látszólag rosszul működő példa:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "YPG85fgNaYlf", "outputId": "490b3938-e3aa-4be3-a1aa-82c95f745c95", "colab": {} }, "source": [ "'a' == ('a' or 'b') " ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 124 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "zDXbAa-YaYlj", "outputId": "6558f718-139d-40f0-eeba-e9ece6ad91ac", "colab": {} }, "source": [ "'b' == ('a' or 'b') " ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 125 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "GvpVVxGsaYlk", "outputId": "260d5ba3-f5b4-496b-d4f1-e7e398e7dd9a", "colab": {} }, "source": [ "'a' == ('a' and 'b') " ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 126 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "J5n07imBaYll", "outputId": "3e7c174c-e382-4284-8745-87656a84e69c", "colab": {} }, "source": [ "'b' == ('a' and 'b') " ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 127 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "iUnPgVmSaYlo" }, "source": [ "A második példa vajon miért **False**, ha az első **True** ? \n", "\n", "A harmadik miért **False**, ha a látszólag hasonló negyedik **True**?\n", "Ezen a ponton úgy tűnhet, hogy az **and** és **or** utasítások nem működnek megfelelően!\n", "\n", "Ha részletesen kiböngésszük, hogy mit is csinál a Python-értelmező, akkor kiderül, hogy pontosan azt teszi, amire megkértük. DE ez nem pontosan az, amire elsőnek gondolnánk! Az első két példa tehát nem azt ellenőrzi, hogy a **==** előtt álló karakter az szerepel-e a zárójelben. Mi is történik pontosan?\n", "\n", "Amikor a Python egy **or** kifejezéssel találkozik (a zárójeleken belül), sorba megy az **or** kifejezés által kapcsolatba hozott elemeken, és az első **True**-ként kiértékelhető objektum **értékét** adja vissza, tehát nem **True** vagy **False**-t hanem a változó értékét. \n", "\n", "Ez azért van így, mert ha egy **or** kifejezés egyik tagja igaz, akkor az egész kifejezés igaz. Az **and** ezzel szemben addig lépdel végig az alkotó kifejezéseken, amíg meggyőződött róla, hogy mindegyik kifejezés igaznak számít, és a legutolsó értéket adja vissza. \n", "\n", "A bool operációk ezen viselkedését *rövid zár*-nak hívják, és sok programozási nyelvben hasonlóan működik. \n", "Tehát ha arról akarunk meggyőződni, hogy egy kifejezés valamely kifejezéscsoport egyikével megegyezik, akkor az alábbiak szerint szükséges eljárni: " ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "Mz9EfK98aYlo", "outputId": "b8042e12-8b98-4eb1-f958-d17b4c8783b5", "colab": {} }, "source": [ "(('a' == 'a') or ('a' == 'b'))" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 128 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "JiCm4lLBaYlp", "outputId": "b0aa451a-b4af-45a1-8ad4-bb4a19dcda62", "colab": {} }, "source": [ "(('b' == 'a') or ('b' == 'b'))" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 129 } ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "ndZ0QlTsaYlp" }, "source": [ "Előfordul azonban sokszor, hogy az a csoport, amihez egy lehetséges elemet össze kell hasonlítani, igen népes. Például hogy mondjuk meg, hogy egy karakterlánc szerepel egy adott hosszú listában? Erre alkalmazható az **in** kulcsszó:" ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "urZ3n9OJaYlq", "colab": {} }, "source": [ "nemet_hetnevek=['Montag','Dienstag','Mittwoch','Donnerstag','Freitag','Samstag','Sonntag']" ], "execution_count": 0, "outputs": [] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "ni9iCY80aYlq", "outputId": "82cb73ac-1234-4fa1-cbc9-d43b1f04365b", "colab": {} }, "source": [ "'hetfo' in nemet_hetnevek" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "False" ] }, "metadata": { "tags": [] }, "execution_count": 34 } ] }, { "cell_type": "code", "metadata": { "colab_type": "code", "id": "arC4m9ehaYlr", "outputId": "d57400fb-152a-4ec5-c9db-279bdf2ac476", "colab": {} }, "source": [ "'Montag' in nemet_hetnevek" ], "execution_count": 0, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "True" ] }, "metadata": { "tags": [] }, "execution_count": 35 } ] }, { "cell_type": "markdown", "metadata": { "id": "X0sMsKPdP44X", "colab_type": "text" }, "source": [ "\n", "---\n", "\n", "## Standard függvények használata\n", "\n", "A nyelvhez tartozó ún. alapfüggvények („standard” függvények), modulok\n", "\n", "\n", "\n", "### Modulokat többféleképpen importálhatunk. \n", "\n", "Az `import modul_név` parancs használata esetén a modul elemeire úgy hivatkozhatunk, hogy elé írjuk a modul nevét.\n", "\n", "A másik módszer esetén `from modul_név import elem`, nem kell a modul nevét használnunk a modul elemére hivatkozásnál, viszont ilyenkor könnyen név ütközés fordulhat elő. \n", "\n", "Ez utóbbi változat esetén vesszővel elválasztva a modul több felhasználandó elemét is megadhatjuk vagy * karakterrel az összes elemet importálhatjuk (pl. `from math import *` ). \n", "\n", "---\n" ] }, { "cell_type": "code", "metadata": { "id": "bRasFVqbP44X", "colab_type": "code", "colab": {}, "outputId": "d11a13b3-fd76-4626-c3a8-86a3fefa0641" }, "source": [ "print(\"Tömb tagjainak összege: \",sum([1,2,3,4]))\n", "print(\"Tömb tagjainak száma: \",len([1,2,3,4]))\n", "print(\"Abszolult érték: \",abs(-1234))\n", "print(\"Kerekített érték: \",round(1.2234))\n", "nevem='lajos'\n", "print('A nevem tipusa : ', type(nevem))\n", "\n", "import math as mt # Csopmag importálása (matematikai csomag)\n", "print(\"Log értéke : \",mt.log(10)) ## rövid név és pont utánni konkrét névvel hívatkozhatonk rá(használhatjuk)\n", "\n", "from math import log\n", "print(\"Log értéke : \",log(10)) ## mostmár így is hivatkozhatunk rá" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "Tömb tagjainak összege: 10\n", "Tömb tagjainak száma: 4\n", "Abszolult érték: 1234\n", "Kerekített érték: 1\n", "A nevem tipusa : \n", "Log értéke : 2.302585092994046\n", "Log értéke : 2.302585092994046\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "y0pTJfzuP44Y", "colab_type": "text" }, "source": [ "---\n", "\n", "Ha információt szeretnénk kapni egy függványról, csomagrol\n", "\n", "---" ] }, { "cell_type": "code", "metadata": { "id": "_m40ak9gP44Y", "colab_type": "code", "colab": {}, "outputId": "e41cbbc1-4d4d-4e67-be95-2c89d103daa5" }, "source": [ "import pydoc ## importáljuk a pydoc modult\n", "import sys ## importáljuk a kérdéses modult\n", "# pydoc.help(sys) ## használjuk sys modulra meghívva\n", "\n", "\n", "from pydoc import help ## vagy mportáljuk a pydoc modulból csak a help fuugvényt\n", "# help(sum) ## használjuk fuggvényre meghívva\n", "# help(int) ## használjuk typusra meghívva\n", "\n", "print(globals) ## kinyomtathatjuk a global változóinkat\n", "print(locals) ## kinyomtathatjuk a local változóinkat" ], "execution_count": 0, "outputs": [ { "output_type": "stream", "text": [ "\n", "\n" ], "name": "stdout" } ] }, { "cell_type": "markdown", "metadata": { "id": "xg8TmW9WP44a", "colab_type": "text" }, "source": [ "---\n", "\n", "#### A math modul néhány függvényei :\n", "\n", "• A ceil(a) az argumentumként megadott a-hoz a nála nagyobb legkisebb egész számot\n", "\n", "rendeli (az angol 'ceil' plafont jelent, utalva arra, hogy felfelé kerekít).\n", "\n", "• A floor(a) az a-hoz a nála kisebb legnagyobb számot rendeli ('floor': padló, mert lefelé kerekít).\n", "\n", "• A trunc(a) azt az egészet adja meg, ami a-ból a törtrész levágása után marad ('truncate': levág).\n", "\n", " \n", "\n", " \n", "\n", "'inf' és '-inf' hatására egy float típusú objektumot, ami bizonyos vonatkozásokban úgy viselkedik mint ahogy azt a matematikában a végtelentől elvárjuk.\n", "\n", "Az 'inf' rövidítés az angol 'infinity', azaz végtelenség szóból származik.\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "tQP4kzqjP44a", "colab_type": "text" }, "source": [ "---\n", "\n", "Az eddig megismert standard függvények, mint például a `min(), type(), len()` mindig meghívhatók a program bármely részében.\n", "\n", "A metódusokhoz az objektumok belső függvényei, ezért előszőr az nobjektumot kell létrehozni és utánna az objektumra hívatkozva kell meghívni, hiszen abban vannak ezek a függvények „beágyazva”.\n", "\n", "` objektum.metodus(valtozo)`\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": { "id": "Yq7yDNP4P44a", "colab_type": "text" }, "source": [ "---\n", "\n", "## Különleges parancsok\n", "\n", "### pass --> nem csinál semmit jelző parancs oda ahol kötelező parancs megadása\n", "\n", "A pass utasítás egy null operáció, amikor kiértékelődik, semmi sem történik. Vagyis az üres utasításnak felel meg.\n", "\n", "Ez akkor hasznos, amikor az utasítás szintaktikailag elvárt, ott az utasítás számunkra felesleges.\n", "\n", " \n", "\n", "### assert --> Az assert utasítás talán a legalkalmasabb arra, hogy hibát keressünk a programunkban.\n", "\n", " a feltétel teljesülése esetén nem történik semmi, de nem talsesülés esetén hiba váltódik ki\n", " \n", " \n", " \n", "### yield\n", "szüneteltet egy függvényt. \n", "Ez egy különleges függvény, amely időről időre értékeket állít elő. Úgy képzelheted el, mint egy folytatható függvényt. A meghívása egy generátort ad vissza, amely az x egymást követő értékeinek előállítására használható.\n", " \n", " \n", "### next()\n", " ott folytatja, ahol az abbamaradt.\n", "ismételt hívása ugyanazzal a generátor objektummal pontosan ott folytatja a végrehajtást, ahol abbahagyta, és addig folytatja, amíg nem találja meg a következő yield utasítást. \n", "Minden változó, helyi állapot stb. mentésre kerül a yield hívásakor, és visszaállításra kerül a next() hívásakor. \n", "A végrehajtásra váró következő kódsor a print() függvényt hívja, amely kiírja az incrementing x kifejezést. \n", "Ezután végrehajtja az x = x + 1 utasítást. \n", "Majd végighalad újra a while cikluson, és az első dolog, amivel találkozik, az a yield x utasítás, amely elmenti az összes állapotot, és visszaadja az x aktuális értékét .\n", "\n", "---\n", "\n" ] }, { "cell_type": "code", "metadata": { "id": "_f_HLQMyP44a", "colab_type": "code", "colab": {}, "outputId": "c0af5bbb-21bb-41d1-a0c9-8015d210f8c7" }, "source": [ "x = \"hello\"\n", "\n", "assert x == \"hello\" # OK, ág nem csinál semmit\n", "\n", "assert x == \"goodbye\" # hiba üzenettel elszál //AssertionError is raised:\n", "\n", "assert x == \"goodbye\", \"x should be 'hello'\"\n", "\n", "assert 2 + 2 == 5, \"Nagy baj van nem működik a matematika, vagy csak bennem van a hiba?\"" ], "execution_count": 0, "outputs": [ { "output_type": "error", "ename": "AssertionError", "evalue": "", "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mAssertionError\u001b[0m Traceback (most recent call last)", "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;32massert\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"hello\"\u001b[0m \u001b[1;31m# OK, ág nem csinál semmit\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[1;32massert\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"goodbye\"\u001b[0m \u001b[1;31m# hiba üzenettel elszál //AssertionError is raised:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m 6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 7\u001b[0m \u001b[1;32massert\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;34m\"goodbye\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"x should be 'hello'\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", "\u001b[1;31mAssertionError\u001b[0m: " ] } ] }, { "cell_type": "code", "metadata": { "id": "a1YH1yEdP44b", "colab_type": "code", "colab": {} }, "source": [ "" ], "execution_count": 0, "outputs": [] } ] }