{
"cells": [
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"# Függvények bevezetés\n",
"\n",
"Python-ban a kódban bárhol definiálható függvény, a def
kulcsszóval."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def fv_neve(n):\n",
" \"... kód ...\""
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"## Példa függvényre és meghívására\n",
"\n",
"Ez egy függvény definíció, itt csak azt írjuk le, hogy mit csináljon a negyzetel
függvény, ha meghívjuk:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def negyzetel(L):\n",
" uj_L = []\n",
" for i in L:\n",
" uj_L.append(i*i)\n",
" return uj_L"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"A def
kulcsszó után a függvény nevét írjuk, utána zárójelekben felsoroljuk a bemeneti paramétereket. A kettőspont után új blokk kezdődik, mint például egy for
ciklusban, ez a blokk fut le amikor meghívjuk a függényt.\n",
"\n",
"A blokkon belül új kulcsszó a return
mely hatására a függvény futása leáll és visszatér a return
után írt kifejezéssel."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Egy függvényt a nevével tudunk meghívni, mely után zárójelekben a bemeneti argumentumokat kell felsorolni (itt csak egy lista a bemeneti argumentum):"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"[16, 9, 25]"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"negyzetel([4, 3, 5])"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Természtesen egy változón is meg lehet hívni a függvényt:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 1, 8] [25, 1, 64]\n"
]
}
],
"source": [
"szamok = [5, 1, 8]\n",
"negyzetelt_szamok = negyzetel(szamok)\n",
"print szamok, negyzetelt_szamok"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Mivel \"jól\" volt megírva a függvényünk így semmi nem kívánt dolog nem történt, de nézzük meg mi lesz, ha ezt a megvalósítást használjuk:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[25, 1, 64] [25, 1, 64]\n"
]
}
],
"source": [
"def negyzetel2(L):\n",
" i = 0\n",
" while i < len(L):\n",
" L[i] = L[i] ** 2\n",
" i += 1\n",
" return L\n",
"\n",
"szamok = [5, 1, 8]\n",
"negyzetelt_szamok = negyzetel2(szamok)\n",
"print szamok, negyzetelt_szamok"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Tehát amilyen műveletet a függvényen belül végrehajtottunk a listán az a beadott argumentumon végrehajtódott, megváltozott a szamok
lista. Erről egy későbbi előadáson még részletesen beszélünk, addig is tudjunk róla, hogy ez egy lehetséges hibaforrás."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"## Példa többváltozós függvényre\n",
"\n",
"A paramétereket szóközzel választjuk el:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def skalaris_szorzat(v1, v2):\n",
" osszeg = 0\n",
" for i in range(len(v1)):\n",
" osszeg += v1[i] * v2[i]\n",
" return osszeg"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"27"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"skalaris_szorzat([2, 3, 5], [1, 5, 2])"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"A paraméterek bármilyen típusúak lehetnek. Akárhány paramétere lehet egy függvénynek, akár nulla is, a zárójelek ebben az esetben is kellenek:"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def ures_lista():\n",
" return []"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5]\n"
]
}
],
"source": [
"L = ures_lista()\n",
"L.append(5)\n",
"print L"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"## Különbség függvény és metódus között\n",
"\n",
"Első (felszínes) megközelítésben **függvényről** beszélünk, ha meghívásának módja: függvénynév, majd zárójelpárban az argumentumok felsorolása, **metódusról**, ha meghívásának módja: az objektum után pont, majd a metódus neve, majd zárójelben az argumentumok. Pl.:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 4, 5]\n"
]
}
],
"source": [
"L = [5, 2, 4]\n",
"L.sort()\n",
"print L"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"A sort
a pythonban egy beépített metódusa a listáknak, mely rendezi az adott listát. Jó példa, mert létezik függvény formában is:"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[5, 2, 4] [2, 4, 5]\n"
]
}
],
"source": [
"L = [5, 2, 4]\n",
"ujL = sorted(L)\n",
"print L, ujL"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"A sorted
függvény nem rendezi az argumentumként adott listát, csak visszatér egy rendezett listával.\n",
"\n",
"Ez a hozzáállás igaz a beépített metódusokra és függvényekre, tehát a függvények nem módosítják a kapott változókat, míg a metódusok módosítják az objektumot (változót) amin meg vannak hívva. Ezt a megállapodást hasznos követni és csak olyan függvényeket írni, melyek nem módosítják a kapott változókat.\n",
"\n",
"Metódus írásról később tanulunk."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"## A return
használata \n",
"\n",
"A return
utasítás függvényből kilépését ki lehet használni, például:"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def prim_e(n):\n",
" for oszto in range(2, n/2):\n",
" if n % oszto == 0:\n",
" return False\n",
" return True"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n",
"True\n"
]
}
],
"source": [
"print prim_e(15)\n",
"print prim_e(23)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Itt azt használtuk ki, hogy amint egy return
parancshoz ér a függvény azonnal kilép és visszaadja ezt az eredményt. Tehát amint találunk egy osztót azonnal visszatérünk a hamis eredménnyel. Igazzal pedig csak akkor térünk vissza, ha végigért a ciklus, azaz nem találtunk megfelelő osztót."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"## Függvények használata függvényekben\n",
"\n",
"Általunk írt függvényeket természetesen használhatunk más általunk írt függvényekben. Ez erősen ajánlott is. Egy kódolási stílus szerint (nem kell követni, főleg nem így az elején) 4-5 sornál hosszabb függvényeket tilos írni. Így a függvényeink rövidek és egyértelműek lesznek. A működésüket nem kommentekkel, hanem a változó és függvénynevekkel írjuk le.\n",
"\n",
"Nézzünk egy példát:\n",
"\n",
"**Írjunk egy függvényt, melynek bemenete egy lista, a függvény keresse meg a lista legkisebb és legnagyobb elemét és nullázza ki az összes valamelyikükkel azonos értéket a listában!**\n",
"\n",
"Hogyan futunk neki egy ilyen feladatnak?\n",
"1. Részfeladatokra bontjuk\n",
"2. A részfeladatokat megvalósítjuk\n",
"3. Összekötjük a teljes programot\n",
"\n",
"Itt a következő részfeladatokra bontható:\n",
"- Listában minimum keresés\n",
"- Listában maximum keresés\n",
"- Adott elemmel egyenlő elemek kinullázása egy listában\n",
"\n",
"Oldjuk is meg ezeket:"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def minimum(L):\n",
" min_elem = float(\"inf\")\n",
" for e in L:\n",
" if e < min_elem:\n",
" min_elem = e\n",
" return min_elem\n",
"\n",
"def maximum(L):\n",
" max_elem = -float(\"inf\")\n",
" for e in L:\n",
" if e > max_elem:\n",
" max_elem = e\n",
" return max_elem\n",
"\n",
"def kinullaz(L, elem):\n",
" ujL = L[:] # Másolatot készítek a listáról (elejétől végéig részlista)\n",
" for i in range(len(ujL)):\n",
" if ujL[i] == elem:\n",
" ujL[i] = 0\n",
" return ujL"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Most, hogy a részfeladatokat már megoldottuk nem maradt hátra más, mint hogy összerakjuk egybe a fő függvényt:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def min_max_nullaz(L):\n",
" minelem = minimum(L)\n",
" maxelem = maximum(L)\n",
" ujL = kinullaz(L, minelem)\n",
" ujL = kinullaz(ujL, maxelem)\n",
" return ujL"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"[2, 3, 0, 4, 6, 2, 0, 3, 0, 3, 0, 0, 3, 0]"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min_max_nullaz([2, 3, 1, 4, 6, 2, 9, 3, 1, 3, 1, 9, 3, 9])"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[]"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min_max_nullaz([])"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[0, 0, 0, 0]"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min_max_nullaz([1, 1, 1, 2])"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Az utolsó három sor helyett írhattuk volna akár ezt is:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
" return kinullaz(kinullaz(L, minelem), maxelem)"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Természetesen meg lehetett volna oldani ezt a feladatot egy függvénnyel is, itt az eredmény:"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def min_max_nullaz2(L):\n",
" min_elem = float(\"inf\")\n",
" for e in L:\n",
" if e < min_elem:\n",
" min_elem = e\n",
" \n",
" max_elem = -float(\"inf\")\n",
" for e in L:\n",
" if e > max_elem:\n",
" max_elem = e\n",
" \n",
" ujL = L[:] # Másolatot készítek a listáról (elejétől végéig részlista)\n",
" for i in range(len(ujL)):\n",
" if ujL[i] == min_elem:\n",
" ujL[i] = 0\n",
" \n",
" for i in range(len(ujL)):\n",
" if ujL[i] == max_elem:\n",
" ujL[i] = 0\n",
" \n",
" return ujL"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"[2, 3, 0, 4, 6, 2, 0, 3, 0, 3, 0, 0, 3, 0]"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min_max_nullaz2([2, 3, 1, 4, 6, 2, 9, 3, 1, 3, 1, 9, 3, 9])"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Olvashatóság szempontjából az első megoldás sokkal szebb, bár a második is jó megoldás."
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"# Ciklusok ciklusokban, bonyolultabb algoritmusok\n",
"\n",
"## Rendezés\n",
"\n",
"**Írjunk függvényt, mely rendez egy adott listát, de nem használja se a sort
metódust, se a sorted
függvényt!**\n",
"\n",
"Első ötlet a buborékrendezés [zenés](https://www.youtube.com/watch?v=Cq7SMsQBEUw), [táncos](https://www.youtube.com/watch?v=lyZQPjUT5B4) szemléltetéssel:"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def buborek(L):\n",
" ujL = L[:]\n",
" for i in range(len(ujL) - 1):\n",
" for j in range(len(ujL) - i - 1):\n",
" if ujL[j] > ujL[j + 1]:\n",
" ujL[j], ujL[j + 1] = ujL[j + 1], ujL[j]\n",
" return ujL"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 6, 9, 9, 9]"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"buborek([2, 3, 1, 4, 6, 2, 9, 3, 1, 3, 1, 9, 3, 9])"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"buborek(range(10, 0, -1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A kód 6-dik sorában kicseréljük a j-edik és (j+1)-edik elemeket a listában, ami a Pythonban egyszerűen megoldható:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
" ujL[j], ujL[j + 1] = ujL[j + 1], ujL[j]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ezt egyszerű értékadással csak egy segédváltozó bevezetésével végezhetjük el:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
" temp = ujL[j]\n",
" ujL[j] = ujL[j + 1]\n",
" ujL[j + 1] = temp"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Írjuk ki minden lépés után a rendezés aktuális állapotát:"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def buborek_kiir(L):\n",
" ujL = L[:]\n",
" for i in range(len(ujL) - 1):\n",
" for j in range(len(ujL) - i - 1):\n",
" print ujL # Kiírás \n",
" if ujL[j] > ujL[j + 1]:\n",
" temp = ujL[j]\n",
" ujL[j] = ujL[j + 1]\n",
" ujL[j + 1] = temp\n",
" return ujL"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true,
"scrolled": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
"[9, 10, 8, 7, 6, 5, 4, 3, 2, 1]\n",
"[9, 8, 10, 7, 6, 5, 4, 3, 2, 1]\n",
"[9, 8, 7, 10, 6, 5, 4, 3, 2, 1]\n",
"[9, 8, 7, 6, 10, 5, 4, 3, 2, 1]\n",
"[9, 8, 7, 6, 5, 10, 4, 3, 2, 1]\n",
"[9, 8, 7, 6, 5, 4, 10, 3, 2, 1]\n",
"[9, 8, 7, 6, 5, 4, 3, 10, 2, 1]\n",
"[9, 8, 7, 6, 5, 4, 3, 2, 10, 1]\n",
"[9, 8, 7, 6, 5, 4, 3, 2, 1, 10]\n",
"[8, 9, 7, 6, 5, 4, 3, 2, 1, 10]\n",
"[8, 7, 9, 6, 5, 4, 3, 2, 1, 10]\n",
"[8, 7, 6, 9, 5, 4, 3, 2, 1, 10]\n",
"[8, 7, 6, 5, 9, 4, 3, 2, 1, 10]\n",
"[8, 7, 6, 5, 4, 9, 3, 2, 1, 10]\n",
"[8, 7, 6, 5, 4, 3, 9, 2, 1, 10]\n",
"[8, 7, 6, 5, 4, 3, 2, 9, 1, 10]\n",
"[8, 7, 6, 5, 4, 3, 2, 1, 9, 10]\n",
"[7, 8, 6, 5, 4, 3, 2, 1, 9, 10]\n",
"[7, 6, 8, 5, 4, 3, 2, 1, 9, 10]\n",
"[7, 6, 5, 8, 4, 3, 2, 1, 9, 10]\n",
"[7, 6, 5, 4, 8, 3, 2, 1, 9, 10]\n",
"[7, 6, 5, 4, 3, 8, 2, 1, 9, 10]\n",
"[7, 6, 5, 4, 3, 2, 8, 1, 9, 10]\n",
"[7, 6, 5, 4, 3, 2, 1, 8, 9, 10]\n",
"[6, 7, 5, 4, 3, 2, 1, 8, 9, 10]\n",
"[6, 5, 7, 4, 3, 2, 1, 8, 9, 10]\n",
"[6, 5, 4, 7, 3, 2, 1, 8, 9, 10]\n",
"[6, 5, 4, 3, 7, 2, 1, 8, 9, 10]\n",
"[6, 5, 4, 3, 2, 7, 1, 8, 9, 10]\n",
"[6, 5, 4, 3, 2, 1, 7, 8, 9, 10]\n",
"[5, 6, 4, 3, 2, 1, 7, 8, 9, 10]\n",
"[5, 4, 6, 3, 2, 1, 7, 8, 9, 10]\n",
"[5, 4, 3, 6, 2, 1, 7, 8, 9, 10]\n",
"[5, 4, 3, 2, 6, 1, 7, 8, 9, 10]\n",
"[5, 4, 3, 2, 1, 6, 7, 8, 9, 10]\n",
"[4, 5, 3, 2, 1, 6, 7, 8, 9, 10]\n",
"[4, 3, 5, 2, 1, 6, 7, 8, 9, 10]\n",
"[4, 3, 2, 5, 1, 6, 7, 8, 9, 10]\n",
"[4, 3, 2, 1, 5, 6, 7, 8, 9, 10]\n",
"[3, 4, 2, 1, 5, 6, 7, 8, 9, 10]\n",
"[3, 2, 4, 1, 5, 6, 7, 8, 9, 10]\n",
"[3, 2, 1, 4, 5, 6, 7, 8, 9, 10]\n",
"[2, 3, 1, 4, 5, 6, 7, 8, 9, 10]\n",
"[2, 1, 3, 4, 5, 6, 7, 8, 9, 10]\n"
]
},
{
"data": {
"text/plain": [
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"buborek_kiir(range(10, 0, -1))"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Ennél hatékonyabb algoritmusok léteznek a keresésre, ezekről részletesebben az Algoritmuselmélet című tárgyban lesz szó.\n",
"\n",
"Valósítsuk meg még azt az ötletet, hogy egyesével megkessük a legkisebb, a második legkisebb, stb. elemet és ezeket a megfelelő helyre tesszük."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def minimum_index(L):\n",
" min_index = 0\n",
" for i in range(len(L)):\n",
" if L[i] < L[min_index]:\n",
" min_index = i\n",
" return min_index\n",
"\n",
"def min_rendez(L):\n",
" ujL = L[:]\n",
" for i in range(len(ujL) - 1):\n",
" minindex = i + minimum_index(ujL[i:])\n",
" ujL[i], ujL[minindex] = ujL[minindex], ujL[i]\n",
" return ujL"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 6, 9, 9, 9]"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min_rendez([2, 3, 1, 4, 6, 2, 9, 3, 1, 3, 1, 9, 3, 9])"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min_rendez(range(10, 0, -1))"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def min_rendez_kiir(L):\n",
" ujL = L[:]\n",
" for i in range(len(ujL) - 1):\n",
" print ujL\n",
" minindex = i + minimum_index(ujL[i:])\n",
" ujL[i], ujL[minindex] = ujL[minindex], ujL[i]\n",
" return ujL"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]\n",
"[1, 9, 8, 7, 6, 5, 4, 3, 2, 10]\n",
"[1, 2, 8, 7, 6, 5, 4, 3, 9, 10]\n",
"[1, 2, 3, 7, 6, 5, 4, 8, 9, 10]\n",
"[1, 2, 3, 4, 6, 5, 7, 8, 9, 10]\n",
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
]
},
{
"data": {
"text/plain": [
"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min_rendez_kiir(range(10, 0, -1))"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[4, 5, 2, 3, 6, 7, 1]\n",
"[1, 5, 2, 3, 6, 7, 4]\n",
"[1, 2, 5, 3, 6, 7, 4]\n",
"[1, 2, 3, 5, 6, 7, 4]\n",
"[1, 2, 3, 4, 6, 7, 5]\n",
"[1, 2, 3, 4, 5, 7, 6]\n"
]
},
{
"data": {
"text/plain": [
"[1, 2, 3, 4, 5, 6, 7]"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min_rendez_kiir([4, 5, 2, 3, 6, 7, 1])"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"A kiírástól csalóka lehet, mert kevesebb kimenetet kaptunk, ez azért van, mert itt csak a külső for
ciklusban van a kiírás, nem a belsőben. Itt a belső ciklus el van rejtve a minimum_index
függvényben.\n",
"\n",
"## Tömbök\n",
"\n",
"Pythonban a 2-dimenziós tömböket listák listájával, a 3-dimenziósakat listák listájának listájával... tudjuk legegyszerűbben reprezentálni:"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"M = [[1, 2], [3, 4]]"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Tömb egy elemét így érhetjük el:"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"M[0][1]"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"M = [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[0, 9], [0, 0]]] # 3x2x2-es tömb"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"9"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"M[2][0][1]"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"Írjunk olyan függvényt, mely kiír egy 2D tömböt táblázatszerűen ilyesmi formában:\n",
"\n",
"1 2\n",
"
\n",
"3 4"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": true,
"deletable": true,
"editable": true
},
"outputs": [],
"source": [
"def tomb_kiir(M):\n",
" for i in range(len(M)):\n",
" for j in range(len(M[i])):\n",
" print M[i][j], \"\\t\", # TAB karakter\n",
" print"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 \t2 \t3 \t\n",
"4 \t5 \t6 \t\n",
"7 \t8 \t9 \t\n"
]
}
],
"source": [
"tomb_kiir([[1,2,3],[4,5,6],[7,8,9]])"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": false,
"deletable": true,
"editable": true
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 \t2 \t3 \t3.5 \t\n",
"4 \t5 \t6 \t6.5 \t\n",
"7 \t8 \t9 \t9.5 \t\n"
]
}
],
"source": [
"tomb_kiir([[1,2,3, 3.5],[4,5,6, 6.5],[7,8,9, 9.5]])"
]
},
{
"cell_type": "markdown",
"metadata": {
"deletable": true,
"editable": true
},
"source": [
"## Bonyolultabb adatszerkezetek\n",
"\n",
"Törzsvásárlói kedvezményt szeretnénk adni a vásárlóinknak. Adott a nevük (egyedi, string) és az eddigi vásárlásaik végösszege (egyenként). Minden ügyfélhez egy lista tartozik, melynek első eleme a személy neve, a második egy lista a vásárlások összegéről, például: \n",
"
.\n",
"\n",
"A kedvezményt a következő módon adnánk:\n",
"\n",
"Összes vásárlás > 200: 10%\n",
"
[\"Anett\", [54, 23, 12, 56, 12, 71]]
\n",
"Összes vásárlás > 500: 15%\n",
"
\n",
"Összes vásárlás > 1000: 20%\n",
"\n",
"Írjuk meg a függvényt, mely megkapja a vásárlók listáját (elemei, mint a fenti \"Anett\" lista) és visszaad egy listát melyben 2 elemű listák vannak, az első elem a vásárló neve, a második a kedvezménye. Pl:\n",
"[\"Anett\", 10]
\n",
"\n",
"Hogyan fogjunk neki? Ismét bontsuk részfeladatokra:\n",
"