diff --git a/app/docs/guides/training/_category_.json b/app/docs/guides/training/_category_.json
new file mode 100644
index 0000000000000000000000000000000000000000..6628dd9267b4fe1a35b227b5daf25b3dfdbf537b
--- /dev/null
+++ b/app/docs/guides/training/_category_.json
@@ -0,0 +1,5 @@
+{
+    "label": "Képzésanyagok",
+    "position": 20
+}
+  
\ No newline at end of file
diff --git a/app/docs/guides/training/bev.md b/app/docs/guides/training/bev.md
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/app/docs/guides/training/python/01_introduction.md b/app/docs/guides/training/python/01_introduction.md
new file mode 100644
index 0000000000000000000000000000000000000000..5eca11b23e0470c37131584ee1326c030545ea8f
--- /dev/null
+++ b/app/docs/guides/training/python/01_introduction.md
@@ -0,0 +1,110 @@
+# Bevezetés
+
+## Elöljáróban
+
+Van Sötét téma, oldalt a menüben betudod kapcsolni 😉  
+Ugyanitt megtalálod az egyes fejezeteket.
+Használd bátran!
+
+Az oldalak elején található egy rövid összefoglaló,
+továbbá pár extra feladat amik megoldásával
+jobban elsajátíthatod az anyagot.
+
+Ha bármi hibát találnál az oldalon, jelezd bátran vagy
+akár adj fel merge requestet a kapcsolódó
+[GitSCH Repo](https://git.sch.bme.hu/rlacko/python-presentation)-ban.
+
+<Note type="tip" label>
+
+**Ahol mi használjuk a Pythont**
+
+- Újonc weboldal backendje: [GitSCH](https://git.sch.bme.hu/kszk/devteam/kszkepzes/old/kszkepzes-backend)
+- Mátrix egyes kódjai: [GitSCH](https://git.sch.bme.hu/matrix-group)
+- Mattermost botok
+- SCH hálózatát működtető programok
+- [AdminSCH](https://admin.sch.bme.hu/)
+- És megannyi kisebb-nagyobb projektünk
+
+</Note>
+
+## Python nyelvről pici ízelítő
+
+A Python egy viszonylag könnyen tanulható, viszont elképesztően
+sok funkcióval ellátott nyelv.  
+Magasszintű, azaz különböző adatstruktúrákat, könyvtárakat
+biztosít nekünk, hogy minél kevesebbet kelljen kódolnunk
+és ne az alacsony szintű dolgokon kelljen törnünk a fejünk.
+
+Amellett, hogy mennyi lehetőséget bizosít, az iparban is igen elterjedt nyelv.
+Különböző ágazatokban előszeretettel használják az apró
+probléma megoldásától a legbonyolultabbakig.
+Lehet benne apróbb szkripteket, webszervereket vagy akár
+gépi tanulásra képes szoftvereket is írni.
+
+## Tipp
+
+A doksiban több kódsort is fogsz találni, melyeket arra
+bíztatnálak, hogy bátran próbáld ki a saját gépeden.  
+Az egyes részek közt továbbá javasolt, hogy tarts szüneteket
+és próbáld feldolgozni amit tanultál.
+
+## Telepítés
+
+### Windows
+
+Három opciód van, ebből válassz egyet:
+
+- Microsoft Store-ban a [Python 3.8](https://www.microsoft.com/en-us/p/python-38/9mssztt1n39l?activetab=pivot:overviewtab)-ra keresel és azt feltelepíted
+- [Pyhton weboldaláról](https://www.python.org/downloads/windows/) letöltöd a hivatalos telepítőt.  
+  Itt a `Latest Python 3`-ra kattints, majd az oldal legalján megtalálod a `Windows installer (64-bit)` nevű fájlt.
+- Utolsó opció, hogy feltelepítesz egy Windows Subsystem for Linux-ot ([WSL](https://docs.microsoft.com/en-us/windows/wsl/install-win10)) és arra telepíted fel a lentebb leírt módon.
+
+### MacOS
+
+Két módot találtam, de ha elakadnál, keress bátran.
+
+- [Pyhton weboldaláról](https://www.python.org/downloads/windows/) letöltöd a hivatalos telepítőt.  
+  Itt a `Latest Python 3`-ra kattints, majd az oldal legalján megtalálod a `macOS 64-bit ... Installer`-t nevű fájlt.
+  Description-be látod, hogy melyik kell a te rendszeredhez.
+- Letöltöd a [Brew](https://brew.sh/) nevű Package manager-t,
+  majd pedig egy `brew install python`-al feltelepíted.
+
+### Linux
+
+Linuxon viszonylag egyszerű.
+A kedvenc csomagkezelőd ha kiválasztod, abban
+megfogod találni a `python3` nevezetű csomagot.
+Azt telepítsd fel.
+Például egy Ubuntu rendszeren a terminálból telepítve:
+
+- `sudo apt install python3`
+
+_vagy a grafikus csomagkezelőben rákeresel és feltelepíted._
+
+## Rólam
+
+Lehet, hogy ezt nem az oldal végére kellett volna tennem,
+de mostmár hogy ennyi mindent elolvastál, Szia!
+
+A KSZK-ba még gólyaként volt szerencsém csatlakozni és akkor még nem hogy a Linux-hoz nem értettem, de még azt se tudtam, hogy mi az az API kérés és hol induljak el, ha fejleszteni szeretnék egy alkalmazást. Ez idő alatt nem csak megannyi szakmai tapasztalatot szereztem, de életre szóló barátságokra is leltem ebben a közösségben.  
+A félév során, mint DevTeam körvezető és VMWare rendszergazda tevékenykedtem. Volt szerencsém ez idő alatt megismerkedni különböző virtualizációs technológiákkal, üzemeltetéssel, szoftver fejlesztéssel és projekt menedzsmenti megoldásokkal. Mostanában legfőképp webfejlesztéssel foglalkozom.  
+Harmadéves infósként szinte bármivel megtalálhattok, legyen az szakmai kérdés, újonc oldalon felmerülő ötlet vagy csak egy baráti beszélgetés. Szóval csak keress bátran!
+
+((Az [Újonc oldalon](https://ujonc.kszk.bme.hu/mentors) lévő
+leírással való egyezés csak a véletlen műve))
+
+Elérhetőségeim:
+
+- Email: laszlo.rafael[AT]kszk.bme.hu
+- Mattermost: [@rlacko](https://mattermost.kszk.bme.hu/kszkepzes-21/messages/@rlacko)
+- Telegram: [@rlacko](https://t.me/rlacko)
+
+<img 
+  src={require('./rafael_laszlo-min.jpg').default}
+  border="false" 
+  width="200"
+/>
+
+A dokumentációhoz főképp a
+[hivatalos doksikat](https://docs.python.org/3/),
+a Google-t és a saját tapasztalataim használtam fel
diff --git a/app/docs/guides/training/python/02_interpreter.md b/app/docs/guides/training/python/02_interpreter.md
new file mode 100644
index 0000000000000000000000000000000000000000..c8cf8c8607767d8356c03c9b49d6971445ad217d
--- /dev/null
+++ b/app/docs/guides/training/python/02_interpreter.md
@@ -0,0 +1,126 @@
+# Az Interpreter és a nyelv felépítése
+
+<Note type="tip" label>
+
+**TL;DR Tartalom** = _Too long; didn't read_
+
+- [Interpreted / Compiled nyelv](#interpreted--compiled-nyelv) - Picit szó van az interpreterről, továbbá a REPL-ről. (Érdemes
+  ránézni a REPL-re)
+- Végén pedig van egy pár példa kód
+
+</Note>
+
+## Parancsok és azok feldolgozása
+
+Python Interpreter egy olyan kis program, ami a
+háttérben fut és várja szövegként a parancsokat amit futtason.
+
+Ha csak egy parancsot szeretnénk lefuttatni, akkor
+a terminál megnyitása után:  
+`python3 -c "parancs"`
+
+```shell-session
+$ python3 -c "print('Első python kódom')"
+```
+
+_C-ben mennyi munka lett volna egy hasonló kódot megírni?_
+
+```c
+#include <stdio.h>
+
+int main() {
+   printf("N+1-edik C kódom\n");
+
+   return 0;
+}
+// Látható, hogy mennyi mindent megspórol nekünk a Python
+```
+
+<Note type="tip" label>
+
+<Badge type="tip">Linux</Badge>  
+`$` jellel a parancssorban kiadott parancsokat szokták
+jelölni.
+
+</Note>
+
+## Interpreted / Compiled nyelv
+
+Kódunkat többféleképp oda adhatjuk a gépünknek, hogy
+dolgozza fel.
+Első opciónk, hogy előtte lefordítjuk, azaz
+**Compile**-oljuk.
+Ilyenkor igazából mielőtt futtathatnánk a kódunk,
+készítünk belőle egy gépi kódot.  
+Ilyen nyelv például a C, C++, Rust és a Go.
+
+Második opció esetén fut egy programunk a gépen,
+mely különböző instrukciókat vár és az alapján
+végez műveleteket. Ezeket nevezik **Interpretált**
+nyelveknek. Ilyen a Python is.
+
+<Note type="tip" label>
+
+<Badge type="tip">REPL</Badge>  
+Read-Eval-Print-Loop, azaz egy olyan környezet,
+mely interaktív mód várja az utasításokat és
+ezeket azonnal végrehajtja, majd várja a következőt.  
+_Hasznos ismeret, mert sok nyelv követi ezt a logikát._
+[Wikipédia](https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop)
+
+</Note>
+
+Következő fejezetben ki is próbálhatod!
+
+## Python Interpreter
+
+A Python interpreterét a `python3` parancs kiadásával
+érheted el.
+
+<Note type="tip" label>
+
+<Badge type="tip">Tipp</Badge>  
+A gépünkön a pythonnak egy régebbi 2-es verziója is jelen
+lehet.
+Ebben a verzióban több dolog máshogy működik, mint a 3-asban.
+Ennek elkerülése érdekében használd a `python3` parancsot.
+
+</Note>
+
+```python
+$ python3
+Python 3.8.5 (default, Jan 27 2021, 15:41:15)
+[GCC 9.3.0] on linux
+Type "help", "copyright", "credits" or "license" for more information.
+>>>
+```
+
+Láthatunk több adatot is a python interpreterünkről.
+Nálam például a `3.8.5`-ös verzió van meg és
+Január 27-én került telepítésre.
+
+Azt is észrevehetjük, hogy GCC-t használ az interpreterünk,
+azaz a program, mely majd futtatja a Python utasításaink
+az C-ben íródott.
+
+Akkor az előzők alapján próbáljuk is ki a Python értelmezőt.
+
+```python
+>>> # Adjuk ki az előző példánk parancsát
+... print('Második Python kódom')
+...
+Második Python kódom
+```
+
+Valamivel bonyolultabb példa:  
+_Próbáld értelmezni, hogy vajon mit csinálhat futtatás után_
+
+```python
+>>> lapos_a_fold = True
+>>> if lapos_a_fold:
+...     print("Hol van ausztrália?")
+...
+```
+
+Következő két fejezetben a különböző típusoktól kezdve
+a nyelv vezérlési szerkezeteivel fogunk megismerkedni
diff --git a/app/docs/guides/training/python/03_types.md b/app/docs/guides/training/python/03_types.md
new file mode 100644
index 0000000000000000000000000000000000000000..4f10fe16513eebe437b34728ba075970362d4ff7
--- /dev/null
+++ b/app/docs/guides/training/python/03_types.md
@@ -0,0 +1,508 @@
+# Típusok
+
+<Note  type="tip" label>
+
+**TL;DR Tartalom**
+
+- [Int - Egész](#int---egész) - Jó hosszú lehet, több
+  számrendszert is kezel
+- [Float - Tört](#float---tört) - Max 64 bites és könnyedén lehet
+  10-es hatvánnyal szorozni
+- [Complex - Komplex szám](#complex---komplex-szám)
+- [String - Szöveg](#string---szöveg) - Pár hasznos függvény,
+  escapelés, speciális karakterek, """
+- [Boolean - Logikai](#boolean---logikai) - Típus, truthiness
+- [Pár művelet a típusainkkal](#pár-művelet-a-típusainkkal) -
+  Matek, extra operátorok, \_ jel,
+  sztring műveletek, indexelés, sliceolás
+- [List - Lista](#list---lista) - Létrehozás, tömb műveletek,
+  pár függvény
+
+</Note>
+
+<Note label>
+
+**Extra feladatok**  
+_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb
+megtanulni a dolgokat_
+
+- 192.168.1.101 oktetjeit konvertáld át binárisba és írd ki
+- 255.255.255.240 oktetjeit konvertáld át binárisba és írd ki
+- Írd ki a hálózat címét az előző kettő alapján 10-es
+  számrendszerben. (Spoiler: Össze éseled a bináris formát, majd vissza konvertálsz)
+- Hogyan írnád le a 3.14\*10^87 -ent Pythonban?
+- [Eiffel 65 - Blue](https://youtu.be/zA52uNzx7Y4) című
+  slágerét hallgatva észre vetted,
+  hogy van egy pár ismétlődő rész.  
+  Mint jó programozó féltve az elpazarolt biteket,
+  szeretnéd ezt kódból lerövidíteni.
+  Tedd ezt meg a lehető legegyszerűbben (Spoiler:
+  Sztring műveleteknél találsz hasonlót)
+- Készíts egy listát a kedvenc 7 számoddal.  
+  (_nem zene szám, hanem numerikus szám_)  
+  Ezt követően ezekből vedd ki három legkedvencebb számod.
+  Végül pedig oszd el az első és az utolsó számot úgy, hogy
+  csak az egész része maradjon meg. (Spoiler: `Pár művelet`
+  fejezetnél találsz majd egy operátort)
+
+</Note>
+
+## Int - Egész
+
+Szám értéket jelöl és mérete bármekkora lehet. (Amíg van ram)
+
+```python
+>>> print(123123123123123123123123123123123123123123123123123123123123123123 + 1)
+123123123123123123123123123123123123123123123123123123123123123124
+```
+
+_Bármilyen számjegyből álló sorozatot egészként fog értelmezni
+a Python egészen addig, míg nincs benne egy tizedes pont._
+
+Több **számrendszer**ben is tudunk dolgozni.
+
+| Szintaxis  | Számrendszer  | Konstruktor |
+| ---------- | ------------- | ----------- |
+| 0b vagy 0B | Bináris       | bin         |
+| 0o vagy 0O | Oktális       | oct         |
+| 0x vagy 0X | Hexadecimális | hex         |
+
+```python
+>>> 0x10 + 0x02
+18 # 16  +  2
+```
+
+Ezeknek mind `Int` a típusa
+
+```python
+>>> type(10)
+<class 'int'>
+>>> type(0o10)
+<class 'int'>
+>>> type(0x10)
+<class 'int'>
+```
+
+A megfelelő konstruktort használva, akár át is tudjuk
+őket konvertálni.
+
+```python
+>>> hexa = hex(79) # 10-es számrendszerből hexába
+>>> hexa
+'0x4f'
+>>> int(hexa, 16) # Vissza hexából 10-esbe
+79
+```
+
+## Float - Tört
+
+Bármilyen számsorozat amiben van egy decimális pont.
+
+64 bites precízióra vagyunk képesek, tehát a max értéke
+kb 1.8 \* 10^308-on lehet.  
+E fölött `inf`-nek értelmezi a Python.
+
+```python
+>> 1.79e308
+1.79e+308
+>> 1.8e308
+inf
+```
+
+<Note type="tip" label>
+
+<Badge type="tip">Magyarázat</Badge>  
+Itt az `e` egy 10-es hatványt jelent és ilyenkor mindig
+Float-ot kapunk vissza.  
+Pl.: `3e4 = 30000.0`
+
+</Note>
+
+```python
+>>> 4e7
+40000000.0
+>>> .4e7
+4000000.0
+```
+
+## Complex - Komplex szám
+
+Komplex szám ugyanúgy egy típus, mint az egész vagy a tört,
+továbbá egyes kódolást megkönnyítő funkciókkal is rendelkezik.
+
+```python
+>>> 2+3j # létrehozása: szám + szám * j
+(2+3j)
+>>> complex(2, -3) # Vagy konstruktort használva
+(2-3j)
+>>> complex("2-3j") # Akár szövegesen is jó
+(2-3j)
+>>> type(2+3j)
+<class 'complex'>
+>>> (2+3j).conjugate()
+(2-3j)
+>>> (2+3j).real
+2.0
+>>> (2+3j).imag
+3.0
+>>> pow(3 + 4j, 2) # Második hatványát vesszük
+(-7+24j)
+```
+
+## String - Szöveg
+
+Jelölése `str` és hossza bármekkora lehet. (Megint a RAM a határ)
+
+`"`-k vagy `'`-k közti karaktersorozatot értünk `str`-nek
+
+```python
+>>> "Egy szöveg vagyok"
+'Egy szöveg vagyok'
+>>> 'Én is'
+'Én is'
+```
+
+Akár egy beépített `print` funkciót is használhatunk,
+mely a különböző speciális karaktereket is kifogja írni.
+
+```python
+>>> print("Egy kis szöveg")
+Egy kis szöveg
+```
+
+Ha szeretnénk benne `"`-t, akkor **escapel**nünk kell, mely
+igazából a speciális karakterek nem feldolgozását jelenti.
+Ezt a `\` jel használatával tehetjük meg.
+
+```python
+>>> print("Itt egy macskaköröm (") karakter.")
+  File "<stdin>", line 1
+    print("Itt egy macskaköröm (") karakter.")
+                                   ^
+SyntaxError: invalid syntax
+>>> print("Itt egy macskaköröm (\") karakter.")
+Itt egy macskaköröm (") karakter.
+```
+
+<Note type="tip" label>
+
+<Badge type="tip">Error</Badge>  
+Részletesebben a [Hibák és azok kezelése](/guide/09_error) című fejezetben lesz szó a hibák működéséről.
+Addig is látható, hogy a Python hogyan írja ki ezeket.
+
+</Note>
+
+Említettem, hogy a Python sorról sorra értelmezi a kódunk.  
+Mégis akkor hogyan írunk egy több soros szöveget például?  
+→ Escapelünk
+
+```python
+>>> print("a
+  File "<stdin>", line 1
+    print("a
+           ^
+SyntaxError: EOL while scanning string literal
+
+>>> print("a\
+... b\
+... c")
+abc
+```
+
+Sőt, akár az escapelést is escapelhetjük.
+<Badge type="danger">
+[Escapeception](https://inception.davepedu.com/)
+</Badge>
+
+```python
+>>> print('foo\\bar')
+foo\bar
+```
+
+A sztringükben egyes speciális karakterek is lehetnek.  
+Ilyen például az új sor (`\n`) és a tabulátor (`\t`).
+
+```python
+>>> print("a\tb")
+a    b
+>>> print("a\141\x61")
+aaa
+>>> print("a\nb")
+a
+b
+>>> print('\u2192 \N{rightwards arrow}')
+→ →
+```
+
+Akár "raw" sztringünk is lehet.
+Ebben nem kerülnek értelmezésre a speciális karakterek.
+
+```python
+>>> print('C:\user\name')  # \n új sort jelent
+C:\user
+ame
+>>> print(r'C:\user\name')  # vedd észre az r-t a szöveg előtt
+C:\user\name
+```
+
+Tripla idézőjeles stringben lehet ugyanaz a karakter,
+továbbá a sortörést is megőrzi.
+
+```python
+>>> print('''Itt már minden is van, pl " és ' is.''')
+Itt már minden is van, pl " és ' is.
+```
+
+Sőt ilyenkor az új sorok is belekerülnek.
+
+```python
+>>> """Ez a
+... szöveg több
+... soros."""
+'Ez a\nszöveg több\nsoros.'
+>>> print("""Ez a
+... szöveg több
+... soros.""")
+Ez a
+szöveg több
+soros.
+```
+
+## Boolean - Logikai
+
+`True` vagy `False` értéke lehet.
+
+```python
+>>> type(True)
+<class 'bool'>
+>>> type(False)
+<class 'bool'>
+```
+
+A különböző típusainkat képesek vagyunk logikaira
+konvertálni.
+Ilyenkor szoktunk beszélni a Truthiness / Falsinessről.
+Például hamis az üres sztring, a `0`.
+
+```python
+>>> bool(0)
+False
+>>> bool("")
+False
+>>> bool("0")
+True
+>>> bool(2+3j)
+True
+>>> bool([]) # Üres lista (2 alfejezettel lejebb)
+False
+```
+
+## Pár művelet a típusainkkal
+
+<Note type="tip" label>
+
+<Badge type="tip">Question of the Day</Badge>  
+A Python használható számológépként?
+
+</Note>
+
+```python
+>>> 2 + 2
+4
+>>> 50 - 5*6
+20
+>>> (50 - 5*6) / 4
+5.0
+>>> 8 / 5  # Osztás mindig Float-tal tér vissza
+1.6
+```
+
+Az alap matematikai műveletek mellett pár extra
+funkcionalitást is nyújt.
+
+```python
+>>> 17 // 3  # Kerekítve osztás
+5
+>>> 17 // 4
+4
+>>> 5 ** 3  # Hatványozás
+125
+>>> 2 ** 7
+128
+>>> 1235 % 3 # Maradékos osztás
+2
+```
+
+<Note type="tip" label>
+
+<Badge type="tip">\_</Badge>  
+Ezek mellett egy másik érdekes beépített dolog
+az interpreterbe, hogy vissza tudjuk kérni az
+utoljára kapott értéket.
+
+</Note>
+
+```python
+>>> afa = 27 / 100 # Így hozunk létre változót
+>>> ar = 1314
+>>> afa * ar
+354.78000000000003
+>>> ar + _
+1668.78
+>>> round(_, 1) # Első tizedesre kerekítünk
+1668.8
+```
+
+Egyébként lehet egy változó névben [UTF-8](https://en.wikipedia.org/wiki/UTF-8) karakter is.
+Tehát az `Áfa = 27 / 100` is egy valid kód.
+Viszont nem ajánlott, ugyanis lehet, hogy más is olvassa majd
+a kódod, sőt az is lehet, hogy nem is ismeri a magyar nyelvet.
+
+Sztringeket akár össze tudunk adni `+`-al vagy
+megismételni `*`-al.
+
+```python
+>>> "ski" + 2 * "-ba-bop" + "-ba-dop-bop"
+'ski-ba-bop-ba-bop-ba-dop-bop' # ?v=Hy8kmNEo1i8
+```
+
+Ha csak szövegeink vannak, akkor el is hagyhatjuk a `+`-t és
+automatikusan összevonásra kerülnek.
+
+```
+>>> 'Egy' 'be'
+'Egybe'
+```
+
+Ez akkor hasznos például, ha egy hosszú szöveget szeretnénk
+több sorban megadni.
+
+```python
+>>> text = ('Írj pár dolgot így, '
+...          'hogy összevonásra kerüljenek')
+>>> text
+'Írj pár dolgot így, hogy összevonásra kerüljenek'
+```
+
+Viszont ugyanez a változókkal nem fog működni.
+
+```python
+>>> gyumolcs1 = "alma"
+>>> gyumolcs2 = "korte"
+>>> gyumolcs1 gyumolcs2
+  File "<stdin>", line 1
+    gyumolcs1 gyumolcs2
+              ^
+SyntaxError: invalid syntax
+```
+
+Sztringjeink egyes karaktereit akár indexelni is tudjuk:
+
+```python
+>>> word = 'Python'
+>>> word[0]  # Karakter a 0. pozícióban
+'P'
+>>> word[5]  # Karakter az 5. pozícióban
+'n'
+```
+
+Akár visszafele is tudunk indexelni
+
+```python
+>>> word[-1]  # Hátulról az első karakter
+'n'
+>>> word[-2]  # Hátulról a második karakter
+'o'
+>>> word[-6]
+'P'
+```
+
+<Note type="tip" label>
+
+<Badge type="tip">Mutatók</Badge>  
+Indexeléskor az egyes karakterek memória címére mutatunk
+rá.  
+Az ez alatti ábra ezt jól mutatja
+
+</Note>
+
+```python
+ +---+---+---+---+---+---+
+ | P | y | t | h | o | n |
+ +---+---+---+---+---+---+
+ 0   1   2   3   4   5   6
+-6  -5  -4  -3  -2  -1
+```
+
+Indexelés mellett sliceolni is tudunk (szeletet kivenni).
+
+```python
+>>> word[0:2]  # Karakterek 0-tól (benne van) 2-ig (nincs benne)
+'Py'
+>>> word[2:5]  # Karakterek 2-tól (benne van) 5-ig (nincs benne)
+'tho'
+```
+
+Látható, hogy az eleje még benne van az indexnek, viszont
+az utolsó nem.
+
+```python
+>>> word[:2] + word[2:]
+'Python'
+>>> word[:4] + word[4:]
+'Python'
+```
+
+## List - Lista
+
+Különböző típusainkat akár listába is tudjuk tenni.  
+Ehhez csak `[...]` közé kell tenni őket.
+
+```python
+>>> negyzetszamok = [1, 4, 9, 16, 25]
+>>> negyzetszamok
+[1, 4, 9, 16, 25]
+```
+
+Ezt is tudjuk indexelni, továbbá sliceolni, mint a
+sztringet.  
+_Hasonló logikát követ, mint a sztringnél_.
+
+```python
+>>> negyzetszamok[0]  # Visszatér az adott elemmel
+1
+>>> negyzetszamok[-1]
+25
+>>> negyzetszamok[-3:]  # Slice visszatér egy új listával
+[9, 16, 25]
+```
+
+Sztringgel ellentétben a megindexelt elemeink módosíthatóak.
+
+```python
+>>> negyzetek = [1, 8, 27, 65, 125] # Az a 65 ott hibás!
+>>> negyzetek[3] = 64  # Javítás
+>>> negyzetek
+[1, 8, 27, 64, 125]
+```
+
+Akár egy elemet ki is tudunk venni!
+
+```python
+>>> negyzetek = [1, 8, 27, 65, 125]
+>>> negyzetek = negyzetek[:3] + negyzetek[4:]
+>>> negyzetek
+[1, 8, 27, 125]
+```
+
+Akár a méretét is lekérhetjük a `len()` funkcióval.
+
+```python
+>>> letters = ['a', 'b', 'c', 'd']
+>>> len(letters)
+4
+```
+
+Ugyanez a függvény (`len`) sztringekkel is működik. _próbáld ki!_
+
+Akár a tömbünkbe tömböt is bele tehetünk. _próbáld ki!_
diff --git a/app/docs/guides/training/python/04_language_and_control.md b/app/docs/guides/training/python/04_language_and_control.md
new file mode 100644
index 0000000000000000000000000000000000000000..8c7669f4fe7491f717999df3a7b0f56adb9add9e
--- /dev/null
+++ b/app/docs/guides/training/python/04_language_and_control.md
@@ -0,0 +1,585 @@
+# Nyelvi dolgok és Vezérlési folyam
+
+<Note  type="tip" label>
+
+**TL;DR Tartalom**
+
+- [Változók](#változók) - Létrehozás, dinamikus típus, törlés,
+  helyben csere
+- [Indentáció](#indentáció) - Szóköz vagy tab, sor escapelés
+- [if](#if) - if, elif, else, operátorok
+- [while](#while-) - Példa
+- [for ... in ...](#for--in-) - Iterálható objektumok, példa
+- [range](#range) - Létrehozás, paraméterek
+- [break, continue, else](#break-continue-else) - Példák
+- [pass](#pass) - ¯\\_(ツ)_/¯
+- [funkciók](#funkciók) - Felépítés, dokumentáció
+  - [Argumentum](#argumentum) - Kötelező / nem, \* és \*\*
+  - [Lambda](#lambda) - Egy példa
+
+</Note>
+
+<Note label>
+
+**Extra feladatok**  
+_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb
+megtanulni a dolgokat_
+
+- Készíts egy függvényt, egy kapott IP címből és MASZK-ból
+  eldönti, hogy mi a hálózat amiben van.  
+  (Spoiler: `.split('.')`)
+- Implementálj egy szöveg rendezési algoritmust, mely
+  a paraméterben bármennyi szót kaphat és azok alapján
+  egy tömmbel tér vissza.  
+  A függvény ezután legyen képes akár listákat is elfogadni
+  a paraméterében.
+- Dokumentálj egy függvényt.
+
+</Note>
+
+## Változók
+
+Az előző fejezetben láttál pár változót, viszont
+még részletesebben nem meséltem róluk.
+
+```python
+>>> width = 20
+>>> height = 5 * 9
+```
+
+Észreveheted, hogy semmi típus definíciónk nincs a
+változónál.
+Sőt, ezt a típust menet közben cserélhetjük is.
+
+```python
+>>> test = 1
+>>> test
+1
+>>> test = "alma"
+>>> test
+'alma'
+```
+
+Ez egy kényelmi része annak, hogy interpretált nyelv
+a Python.  
+Menet közben képes rá az interpreter, hogy eldobja
+az előző értéket, majd kicserélje egy teljesen újra
+típustól függetlenül.
+
+<Note type="tip" label>
+
+<Badge type="tip">TypeError go brrr</Badge>  
+Ez a kényelem azt is jelenti, hogy gyakran futhatunk típus
+hibákba.  
+Például feltételezzük, hogy egy változó szám és mégis
+sztring lesz, akkor egy osztás műveletnél elszáll
+a programunk.  
+Próbáld ki! _De csak saját felelősségre_
+
+</Note>
+
+Mi van akkor, ha egy változóra többé nincs szükségünk?  
+A `del` segítségével azt ki tudjuk törölni.
+
+```python
+>>> test = "alma"
+>>> test
+'alma'
+>>> del test
+>>> test
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'test' is not defined
+```
+
+Sőt akár egy listából is ki tudunk venni a `del` segítségével.
+
+```python
+>>> # Előző fejezet kódja
+... negyzetek = [1, 8, 27, 65, 125]
+>>> negyzetek = negyzetek[:3] + negyzetek[4:]
+>>> negyzetek
+[1, 8, 27, 125]
+>>> # Új kód
+... negyzetek = [1, 8, 27, 65, 125]
+>>> del(negyzetek[3])
+>>> negyzetek
+[1, 8, 27, 125]
+```
+
+Másik elképesztő képessége a pythonnak, hogy akár
+egyszerre több változót is tudunk létrehozni különböző
+értékekkel.
+
+```python
+>>> a, b = 2, 3 # a = 2, b = 3
+>>> print(a, b)
+2 3
+```
+
+Sőt akár meg is tudjuk őket cserélni **egy sorban**
+
+```python
+>>> a, b = 2, 3 # a = 2, b = 3
+>>> a, b = b, a # a = 3 és b = 2
+>>> print(a, b)
+3 2
+```
+
+## Indentáció
+
+Indentációban a kód blokkosítását értjük, azaz mikor az egyes
+logikai egységeket külön választjuk.  
+Például C-ben `{}` -el tudjuk ezt megtenni.
+
+Pythonban ehhez tabulátort vagy szóközt használunk.
+
+C++-ban:  
+_Megjelölt sorok 1-1 új blokkot kezdenek meg_
+
+```cpp {highlight:[2, 4]}
+int j = 0;
+for (int i= 0; i < 10; i++) {
+  std::cout<<i
+  if (j % 2 == 0) {
+    std::cout<<"2-vel oszthato iteraciohoz ertunk"
+  }
+  j++
+}
+```
+
+Pythonban:
+
+```python {highlight:[2, 4]}
+j = 0
+for i in range(0, 10):
+  print(i)
+  if j % 2 == 0:
+    print("2-vel oszthato iteraciohoz ertunk")
+  j += 1
+```
+
+Ha netán elfelejtenénk indentálni, akkor szól a Python.
+
+```python
+>>> if 1>0:
+... print("hi")
+  File "<stdin>", line 2
+    print("hi")
+    ^
+IndentationError: expected an indented block
+```
+
+Ilyenkor felismerte a Python, hogy egy új blokkot
+kezdünk meg és beljebb fogunk kezdeni a következő sorban.
+
+Tabulátorral: (_ajánlott_)
+
+```python
+>>> if 1 > 0:
+...     print("hi")
+...
+hi
+```
+
+Szóközzel: (_nehezen látható_)
+
+```python
+>>> if 1 > 0:
+...  print("hi") # Itt van egy szóköz
+...
+hi
+```
+
+Egy feltételt akár több sorban is tudunk írni, csak
+szimplán jelezzük az interpreternek egy escapeléssel.
+
+```python
+>>> if 1 > 0 \
+...    and 3 > 2:
+...     print("Több soros feltétel")
+...
+Több soros feltétel
+```
+
+## if
+
+`if`-nek több része is van.
+
+- `if`: Feltétel
+- `elif`: else if, avagy egy különben ág feltétellel
+- `else`: Ha már egy feltétel sem teljesül
+
+```python
+>>> x = int(input("Adj meg egy számot: "))
+Adj meg egy számot: 42
+>>> if x < 0:
+...     x = 0
+...     print('Negatív értéket 0-ra cseréltük')
+... elif x == 0:
+...     print('Nulla')
+... elif x == 1:
+...     print('Egy')
+... else:
+...     print('Több')
+...
+Több
+```
+
+Az `input` függvény szöveget kér be, szóval át kellett alakítani.
+
+<Note type="tip" label>
+
+<Badge type="tip">Valaki felkapcsolta a lámpát?</Badge>  
+`switch` és a hozzá kapcsolódó `case` nincs a pythonban.
+Helyette sok-sok `elif`-et tudunk írni.
+
+</Note>
+
+Feltételünket tovább tudjuk spékelni köztük elhelyezett
+**logikai operátorok**kal.
+
+- `and`: `x < 3 and x > 0`
+- `or`: `x >= 3 or x =< 0`
+- `not`: `not (x < 3 and x > 0)`
+
+Sőt bit operátorok is elérhetőek. (`&`, `|`, `^`, `~`, ...)
+
+```python
+>>> a = 10 # 1010 (binárisan)
+>>> b = 6  # 0110
+>>> a & b         # És operátor
+2          # 0010
+```
+
+## while ...
+
+Talán a legegyszerűbben magyarázható eszközunk a
+pythonban.
+Addig fut újra és újra, amig a feltétele igaz.
+
+```python
+>>> iteracio_szam = 0
+>>> while True:
+...   iteracio_szam += 1
+...   print(iteracio_szam)
+...   print("Nyomj CTRL + C -t, hogy megállíts")
+```
+
+<Note type="tip" label>
+
+<Badge type="tip">De lassú ez a terminálra kiíratás :/</Badge>  
+Ha kiveszed a kiíratásokat és ctrl + c után kiírod a változódat
+azt fogod tapasztalni, hogy sokkal nagyobb lett az
+`iteracio_szam`, mint kiíratásokkal. Szerinted miért?
+
+</Note>
+
+```python
+>>> paros = False
+>>> while True:
+...     if not paros:
+...             print("work hard")
+...     else:
+...             print("play hard")
+...     paros = not paros # ?v=5dbEhBKGOtY
+```
+
+## for ... in ...
+
+A for cíklus Pythonban lehetővé teszi, hogy
+szekvenciákon menjünk végig.  
+Tehát nem a szokásos `ciklus i=0 ...`-t fogjuk eljátszani.
+
+Ilyen szekvencia például egy lista.
+
+```python
+>>> # Írjunk ki egymás alá a szavakat:
+... szavak = ['macska', 'kutya', 'horcsog']
+>>> for szo in szavak:
+...     print(szo)
+...
+macska
+kutya
+horcsog
+```
+
+Sőt a sztring is egy szekvencia.
+
+```python
+>>> kszk = "KSZK"
+>>> for betu in kszk:
+...     print(betu)
+...
+K
+S
+Z
+K
+```
+
+Na és mi van akkor ha 0-tól 18-ig kiakarjuk írni a számokat?
+
+Sima ügy.
+
+```python
+>>> for i in [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18]:
+...     print(i)
+...
+0  # ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+1  # ░░░░░░░░░░░░░▄▄▄▄▄▄▄░░░░░░░░░
+2  # ░░░░░░░░░▄▀▀▀░░░░░░░▀▄░░░░░░░
+3  # ░░░░░░░▄▀░░░░░░░░░░░░▀▄░░░░░░
+4  # ░░░░░░▄▀░░░░░░░░░░▄▀▀▄▀▄░░░░░
+5  # ░░░░▄▀░░░░░░░░░░▄▀░░██▄▀▄░░░░
+6  # ░░░▄▀░░▄▀▀▀▄░░░░█░░░▀▀░█▀▄░░░
+7  # ░░░█░░█▄▄░░░█░░░▀▄░░░░░▐░█░░░
+8  # ░░▐▌░░█▀▀░░▄▀░░░░░▀▄▄▄▄▀░░█░░
+9  # ░░▐▌░░█░░░▄▀░░░░░░░░░░░░░░█░░
+10 # ░░▐▌░░░▀▀▀░░░░░░░░░░░░░░░░▐▌░
+11 # ░░▐▌░░░░░░░░░░░░░░░▄░░░░░░▐▌░
+12 # ░░▐▌░░░░░░░░░▄░░░░░█░░░░░░▐▌░
+13 # ░░░█░░░░░░░░░▀█▄░░▄█░░░░░░▐▌░
+14 # ░░░▐▌░░░░░░░░░░▀▀▀▀░░░░░░░▐▌░
+15 # ░░░░█░░░░░░░░░░░░░░░░░░░░░█░░
+16 # ░░░░▐▌▀▄░░░░░░░░░░░░░░░░░▐▌░░
+17 # ░░░░░█░░▀░░░░░░░░░░░░░░░░▀░░░
+18 # ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
+```
+
+_Vagy használd a range nevezetű funkciót ez alatt_
+
+### range
+
+Ez a funkció arra képes, hogy egy olyan iterálható
+objektumot készítsen nekünk, melyet a for cíklus
+képes elfogadni.  
+(Ne aggódj, nem generál egy 0-tól millióig tartó tömböt,
+ennél okosabb)
+
+```python
+>>> for i in range(5): # 0,1,2,3,4
+...     print(i)
+...
+0
+1
+2
+3
+4
+```
+
+Ez a `range` függvény több paramétert is elfogad.
+
+`range(mettől, meddig, lépésszám)`
+
+```python
+range(5, 10)
+   5, 6, 7, 8, 9
+
+range(0, 10, 3)
+   0, 3, 6, 9
+
+range(-10, -100, -30)
+  -10, -40, -70
+```
+
+Ha egy szekvencián mégis index alapján szeretnénk végig menni,
+akkor tudjuk a `len`-t és a `range`-t kombinálni.
+
+```python
+>>> abc = "abcdefghijklmnopqrstuvwxyz"
+>>> for i in range(len(abc)):
+...     print(str(i) + ". betű: " + abc[i])
+
+```
+
+### break, continue, else
+
+Egy ciklus szokásos lefutásán tudunk módosítani is ha
+szeretnénk.
+
+`break`: Kitör a legközelebi `for` vagy `while` ciklusból
+
+```python
+>>> for i in range(5):
+...     print(i)
+...     if i == 3:
+...             break
+...
+0
+1
+2
+3 # 4-es számot szkippeltük
+```
+
+`continue`: Kihagyja a jelenlegi iteráció többi részét
+
+```python {highlight: [13]}
+>>> for i in range(5):
+...     print("< " + str(i))
+...     if i == 3:
+...             continue
+...     print("> " + str(i))
+...
+< 0
+> 0
+< 1
+> 1
+< 2
+> 2
+< 3 # > 3 hiányzik utána
+< 4
+> 4
+```
+
+`else`: Akkor fut le, ha a ciklusban nem történik `break`
+vagy valami error
+
+```python
+>>> for i in range(5):
+...     print(i)
+... else:
+...     print("Nem volt break")
+...
+0
+1
+2
+3
+4
+Nem volt break
+```
+
+```python
+>>> for i in range(5):
+...     print(i)
+...     break
+... else:
+...     print("Nem volt break")
+...
+0
+```
+
+## pass
+
+¯\\_(ツ)_/¯
+
+Nem csinál semmit.
+Arra használható, ha szintaktikailag valahova írni kell
+valamit.
+
+```python
+>>> class MyEmptyClass: # Spoiler: Így néz ki egy osztály
+...     pass
+...
+```
+
+Például hasznos lehet, ha a programozó még nem szeretne
+implementálni egyes részeket.
+
+```python
+>>> def how_to_make_a_lot_of_money(a):
+...     pass   # TODO: Ne felejtsd el implementálni
+...
+```
+
+## funkciók
+
+Hasonló, mint C-ben, viszont továbbra sincsenek típusaink
+
+`def funkció_neve(paraméterek):`
+
+Például így tudunk egy fibonacci kiíró funkciót készíteni:
+
+```python
+>>> def fib(n):
+...     """Fibonacci sorozat kiíró n-ig."""
+...     a, b = 0, 1
+...     while a < n:
+...         print(a, end=' ')
+...         a, b = b, a+b
+...     print()
+...
+```
+
+```python
+>>> fib(2000)
+0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
+```
+
+<Note type="tip" label>
+
+<Badge type="tip">Dokumentáció</Badge>  
+Funkcióink első soraiban eltudunk helyezni dokumentációt, majd
+azt később akár elérni.  
+Javasolt, hogy hasonlóképp dokumentáld a funkcióid.
+
+</Note>
+
+```python
+>>> fib.__doc__
+'Fibonacci sorozat kiíró n-ig.'
+```
+
+### Argumentum
+
+Akár alapértelmezett argumentum definícióink is lehetnek.
+
+```python
+>>> def primek_bejelentkezes_utan(udvozlo_uzenet, # vessző miatt
+...                     max_probalkozas=4,        # tudja a python
+...                     hiba_eseten='Próbáld újra!'): # hogy több soros
+...   """Helyes jelszó beírása esetén kiírja az első 30 prímszámot"""
+...   pass # Próbáld implementálni
+```
+
+Ilyenkor a függvény hívásakor nem kötelező átadni az
+alapértelmezett értékeket.
+
+Akár **kulcsszó** szerint is hívhatjuk a függvényeink.
+
+```python
+>>> primek_bejelentkezes_utan(udvozlo_uzenet="Helló",
+...                           max_probalkozas=3)
+```
+
+Sőt, nem kell minden paramétert feltüntetni!
+
+```python
+>>> def hmmm(required, *tuple_arg, **dictionary_arg):
+...     print(required)
+...     print(tuple_arg)
+...     print(dictionary_arg)
+```
+
+És utána így tudjuk meghívni:
+
+```python
+>>> hmmm("Kotelezo mezo",
+...     "ez mar nem",
+...     "ez se",
+...     foszereplo="Kata",
+...     postas="Pista")
+```
+
+Ilyenkor az arguments úgynevezett Tuple-ként működik, a
+keywords pedig Dictionary-ként. Következő fejezetben lesz
+ezekről szó.
+
+Egyenlőre látható, hogy `Tuple`-be csak az értékek
+kerültek be sorban, míg a `Dictionary`-be már kulcs-érték
+párosok.
+
+### Lambda
+
+Akár le is tudjuk rövidíteni a függvény definícióink.
+
+`lambda a, b: a + b`: Ilyenkor készítünk egy függvényt,
+melynek a két paramétere `a` és `b` és visszatér ezek
+összegével.
+
+```python
+>>> f = lambda a, b: a+b
+>>> f
+<function <lambda> at 0x7fb0602f31f0>
+>>> f(1, 2)
+3
+```
diff --git a/app/docs/guides/training/python/05_data_structures.md b/app/docs/guides/training/python/05_data_structures.md
new file mode 100644
index 0000000000000000000000000000000000000000..df1055b2993fe539353569a7370516b46a9a3c43
--- /dev/null
+++ b/app/docs/guides/training/python/05_data_structures.md
@@ -0,0 +1,272 @@
+# Adatstruktúrák
+
+<Note  type="tip" label>
+
+**TL;DR Tartalom**
+
+- [List](#list) - Lista metódusai példával
+- [Tuple](#tuple) - Példa és kapcsolódó metódusok
+- [Sets](#sets) - Példa
+- [Dictionary](#dictionary) - {kulcs: érték}
+  Példa és függvény paraméter
+- [Iterálás](#iterálás)
+  - [Dictionary](#dictionary-2) - kulcs, értéken lehet egyszerre
+  - [enumerate](#enumerate) - megszámozva az elemeket
+  - [zip](#zip) - egyszerre több szekvencián
+  - [reversed](#reversed) - uno reverse card
+
+</Note>
+
+<Note label>
+
+**Extra feladatok**  
+_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb
+megtanulni a dolgokat_
+
+- Készíts egy `Tuple`-t, majd írd ki az elemeit úgy, hogy egyszerre
+  indulsz az elejétől és a végétől.  
+  Pl.: ("A", "B", "C") esetén: (Spoiler: `zip`)
+  ```
+  A C
+  B B
+  C A
+  ```
+- Készíts egy programot, mely megszámolja egy szövegben,
+  hogy az egyes betűkből mennyi van. (Spoiler: `Sets`)
+
+</Note>
+
+## List
+
+Listának az említetteken kívül van egy pár beépített függvénye.
+
+```python
+>>> gyumolcs = ['narancs', 'alma', 'körte', 'banán', 'kiwi', 'alma', 'banán']
+>>> gyumolcs.count('alma')
+2
+>>> gyumolcs.count('mandarin')
+0
+>>> gyumolcs.index('banán')
+3
+>>> gyumolcs.index('banán', 4)  # Következő banán a 4. index után
+6
+>>> gyumolcs.reverse() # Elemek megfordítása helyben
+>>> gyumolcs
+['banán', 'alma', 'kiwi', 'banán', 'körte', 'alma', 'narancs']
+>>> gyumolcs.append('szőlő') # Új elem a végére
+>>> gyumolcs
+['banán', 'alma', 'kiwi', 'banán', 'körte', 'alma', 'narancs', 'szőlő']
+>>> gyumolcs.sort()
+>>> gyumolcs
+['alma', 'alma', 'banán', 'banán', 'szőlő', 'kiwi', 'narancs', 'körte']
+>>> gyumolcs.pop() # Töröl egyet a végéről és azzal visszatér
+'körte'
+```
+
+Például `stack`-ként egy listát elég egyszerűen lehet
+használni ha csak az `append` és a `pop` függvényt használjuk.
+
+`pop` mellet tudunk akár a `del` -el is egy adott elemet
+törölni.
+
+```python
+>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
+>>> del a[0]
+>>> a
+[1, 66.25, 333, 333, 1234.5]
+>>> del a[2:4]
+>>> a
+[1, 66.25, 1234.5]
+>>> del a[:]
+>>> a
+[]
+```
+
+## Tuple
+
+Lista mellett `Tuple`-t is tudunk készíteni.
+
+Ezek definiálásához csak értékeket kell felsorolnunk
+vesszővel elválasztva.
+(Akár zárójelbe is tehetjük őket)
+
+```python
+>>> t = 12345, 54321, 'hello!'
+>>> t[0]
+12345
+>>> t
+(12345, 54321, 'hello!')
+>>> # Több tuple-t össze illeszthetünk:
+... u = t, (1, 2, 3, 4, 5)
+>>> u
+((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
+>>> # Nem tudjuk változtani az értékeit:
+... t[0] = 88888
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: 'tuple' object does not support item assignment
+>>> # Viszont lehet bennük változtatható objektum:
+... v = ([1, 2, 3], [3, 2, 1])
+>>> v
+([1, 2, 3], [3, 2, 1])
+>>> v[0][0] = 4
+>>> v
+([4, 2, 3], [3, 2, 1])
+```
+
+Egy függvényben `*` -al tudjuk jelölni, hogy az extra mezőket
+mely változóba szeretnénk tenni.
+
+```python
+>>> def fv(*a):
+...     print(a)
+...
+>>> fv(2,3,4,5)
+(2, 3, 4, 5)
+```
+
+Ilyenkor az átadott értékeket becsomagolja az a változóba, mint
+Tuple.
+
+```python
+>>> fv((1,2,3))
+((1, 2, 3),)
+```
+
+## Sets
+
+A `set` egy duplikátumok nélküli lista.  
+Köztük a különböző halmaz műveleteket is ellehet végezni.
+
+```python
+>>> kosar = {'alma', 'narancs', 'alma', 'korte', 'narancs', 'banan'}
+>>> print(kosar)  # Duplikátumok törölve lettek
+{'korte', 'banan', 'alma', 'narancs'}
+>>> 'narancs' in kosar # Tudjuk a tagokat gyorsan ellenőrizni
+True
+>>> 'szilva' in kosar
+False
+
+>>> # Alapértelmezett konstruktor a kapott sztringet
+... # betűnként set-be konvertálja
+>>> a = set('abracadabra')
+>>> b = set('alacazam')
+>>> # Halmaz műveletek
+...
+>>> a                       # Egyedi karakterek a-ban
+{'b', 'c', 'a', 'd', 'r'}
+>>> a - b                   # Betűk a-ban, de b-ben nem
+{'d', 'b', 'r'}
+>>> a | b                   # Betű a-ban vagy b-ben
+{'b', 'c', 'm', 'z', 'a', 'l', 'd', 'r'}
+>>> a & b                   # Betűk a-ban és b-ben is
+{'a', 'c'}
+>>> a ^ b                   # Betűk a-ban vagy b-ben,
+{'b', 'm', 'l', 'z', 'd', 'r'} # metszetet kivéve
+```
+
+## Dictionary
+
+Kulcs - Érték párosokat tudunk ebben az adatstruktúrában
+tárolni.
+
+```python
+>>> telefon = {'bella': 4098, 'kata': 4139}
+>>> telefon['attila'] = 4127 # Így tudunk kulcs szerint indexelni
+>>> telefon
+{'bella': 4098, 'kata': 4139, 'attila': 4127}
+>>> telefon['bella']
+4098
+>>> del telefon['kata']
+>>> telefon['vivi'] = 4127
+>>> telefon
+{'bella': 4098, 'attila': 4127, 'vivi': 4127}
+>>> list(telefon)
+['bella', 'attila', 'vivi']
+>>> sorted(telefon)
+['attila', 'vivi', 'bella']
+>>> 'attila' in telefon
+True
+>>> 'bella' not in telefon
+False
+```
+
+Hasonlóan a `Tuple`-höz, a függvényekben a `**`-al tudjuk
+jelölni azon változót, melyben szeretnénk a
+kulcs érték párosokat összegyüjteni.
+
+```python
+>>> def fv(**dic):
+...     print(dic)
+...
+>>> fv(a=1, b=2, c=3)
+{'a': 1, 'b': 2, 'c': 3}
+```
+
+## Iterálás
+
+A felsorolt objektumok mind iterálható objektumok, tehát
+for ciklussal hasonlóan a listához végig tudunk menni rajtuk.
+
+### Dictionary
+
+Egy **Dictionary**-n kulcs és érték párossal tudunk
+végig iterálni.
+
+```python
+>>> kosar = {'alma': 23, 'korte': 41}
+>>> for kulcs, ertek in kosar.items():
+...     print(kulcs, str(ertek) + " db.")
+...
+alma 23 db.
+korte 41 db.
+```
+
+### enumerate
+
+Ha indexel szeretnénk végig iterálni, akkor
+az `enumerate` függvénnyel ezt megtudjuk oldani.
+
+```python
+>>> for i, v in enumerate(['tic', 'tac', 'toe']):
+...     print(i, v)
+...
+0 tic
+1 tac
+2 toe
+```
+
+### zip
+
+Egyszerre akár több szekvencián is végig tudunk menni a
+`zip` segítségével.
+
+```python
+>>> kerdesek = ['neved', 'küldetésed', 'kedvenc szined']
+>>> valaszok = ['Szófia', 'Átmenni analízisból', 'Kék']
+>>> for k, v in zip(kerdesek, valaszok):
+...     print('Mi a {0}? {1}.'.format(k, v))
+...
+Mi a neved? Szófia.
+Mi a küldetésed? Átmenni analízisból.
+Mi a kedvenc szined? Kék.
+```
+
+Itt használtam a `.format` függvényt. Ezzel egy szövegben
+`{szám}`-al megjelölt helyekre tudjuk beilleszteni a paraméterben
+megadott változókat.
+
+### reversed
+
+Akár meg is tudjuk fordítani a listánkat.
+
+```python
+>>> for i in reversed(range(1, 10, 2)):
+...     print(i)
+...
+9
+7
+5
+3
+1
+```
diff --git a/app/docs/guides/training/python/06_modules.md b/app/docs/guides/training/python/06_modules.md
new file mode 100644
index 0000000000000000000000000000000000000000..fb17b606d0d9409cb53d140c94d7ffb09994ecdd
--- /dev/null
+++ b/app/docs/guides/training/python/06_modules.md
@@ -0,0 +1,206 @@
+# Modulok
+
+<Note  type="tip" label>
+
+**TL;DR Tartalom**
+
+- [Fájl és enkódolás](#fájl-és-enkódolás) -
+  Fájl fibonaccival, enkódolás
+- [Importálás](#importálás) - Importálás többféleképp
+- [Szkriptként indítás](#szkriptként-indítás) - Elindítjuk
+  közvetlen a fájlt, \_\_main\_\_
+
+</Note>
+
+<Note label>
+
+**Extra feladatok**  
+_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb
+megtanulni a dolgokat_
+
+- Készíts egy fájlt, melyben az eddig megírt függvényeid
+  összegyüjtöd
+- Importáld be egy másik fájlba és kezd el használni.
+  Keletkezik valami új fájl?
+- Írj egy szkriptet, ami az argumentumban kapott IP cím és
+  hálózati maszk párosról megmondja, hogy milyen hálózatban van,
+  továbbá, hogy mi a Broadcast címe.  
+  (Tipp: Előzőleg írtál egy hasonló funkciót már)
+
+</Note>
+
+## Fájl és enkódolás
+
+Miután kilépsz az Interpreterből tapasztalhatod,
+hogy elvesznek a módosításaid mikor újra belépsz.
+Továbbá az is feltünhetett, hogy egy valamivel
+bonyolultabb programot nehéz lenne csak
+az interpreterben megírni.
+
+Erre megoldás, hogy egy fájlba írjuk meg a kódunkat,
+majd pedig később azt fordítja le az interpreter.
+
+Ezeket a fájlokat a python alapértelmezette UTF-8 fogja
+értelmezni. (python 2-ben ASCII volt az alap)
+Ezt akár definiálhatjuk is ha a fájl elejére írjuk, hogy  
+`# coding=<Kódolás>`  
+`# coding=UTF-8`
+
+Egy modul egy fájl, melyben Python definíciók és utasítások
+találhatóak.
+Ezeknek a kiterjesztése `.py`
+
+Hozz létre egy fájlt `fibo.py` néven a kedvenc
+szövegszerkesztődben.
+
+```python
+# Fibonacci számokért felelős modul
+
+def fib(n):    # Fibonacci kiírása n-ig
+    a, b = 0, 1
+    while a < n:
+        print(a, end=' ')
+        a, b = b, a+b
+    print()
+
+def fib2(n):   # Fibonacci-k listája n-ig
+    result = []
+    a, b = 0, 1
+    while a < n:
+        result.append(a)
+        a, b = b, a+b
+    return result
+```
+
+Az itt definiált függvényeket később más fájlokból is elérjük.
+
+## Importálás
+
+Akár az interpreterünkbe is tudjuk használni a definiált
+függvényeink.
+
+```python
+>>> import fibo
+```
+
+```python
+>>> fibo.fib(1000)
+0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
+>>> fibo.fib2(100)
+[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
+>>> fibo.__name__ # modul neve
+'fibo'
+```
+
+Akár egy lokális változóhoz is rendelhetjük egy modul
+függvényét / változóját.
+
+```python
+>>> fib = fibo.fib
+>>> fib(500)
+0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
+```
+
+Többféleképp is importálhatunk.
+
+Ha csak pár függvényt szeretnénk:
+
+```python
+>>> from fibo import fib, fib2
+>>> fib(500)
+0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
+```
+
+Ha az összes függvényt:
+
+```python
+>>> from fibo import *
+>>> fib(500)
+0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
+```
+
+Ha átszeretnénk nevezni:
+
+```python
+>>> import fibo as fib
+>>> fib.fib(500)
+0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
+```
+
+De akár ötvözhetjük az eddigieket is:
+
+```python
+>>> from fibo import fib as fibonacci
+>>> fibonacci(500)
+0 1 1 2 3 5 8 13 21 34 55 89 144 233 377
+```
+
+## Szkriptként indítás
+
+Akár el is tudunk egy modult önállóan indítani.
+
+```shell-session
+$ python3 fajl_neve.py <argumentumok>
+```
+
+Például nálam van egy ilyen fájl:
+
+```python
+print("Első fájlba írt Python kódom")
+py_szoveg = "Python"
+
+for betu in reversed(py_szoveg):
+    print(betu)
+
+if __name__ == '__main__':
+    print("main")
+```
+
+Ha ezt futtatom:
+
+```python
+n
+o
+h
+t
+y
+P
+main
+```
+
+A modul neve `__main__`-re változott.
+Így akár tudjuk ellenőrizni, hogy tényleg
+az adott fájlt indítottuk-e és csak akkor
+lefuttatni a programot.
+
+```python
+if __name__ == "__main__":
+    import sys
+    fib(int(sys.argv[1]))
+```
+
+Ilyenkor a python nem fogja feldolgozni 1-1 importáláskor
+a feltételben lévő dolgokat, mivel nem azt indítottuk.
+Ezt tudjuk is ellenőrizni egy interpreterben.
+Próbáld ki if-el és a nélkül.
+
+```python
+>>> import fibo
+```
+
+Láthattuk ennél a kódnál, hogy a `sys` nevű modult beimportáltuk,
+majd az argv tömbből lekértük az első elemet.
+Ez valójában a kapott argumentumokat jelenti a függvény
+meghívásakor.
+
+```shell-session
+$ python fibo.py 50
+0 1 1 2 3 5 8 13 21 34
+```
+
+Az importált modulokat a python folyamatosan cacheli a
+`__pycache__` nevű mappában.
+Importáld be a fibo.py fájlodat egy másik fájlba és nézd meg mi
+történik.
+
+_The Cake: 🍔_
diff --git a/app/docs/guides/training/python/07_scope_class.md b/app/docs/guides/training/python/07_scope_class.md
new file mode 100644
index 0000000000000000000000000000000000000000..579b815bb1d881587989ca934da91b832eba0139
--- /dev/null
+++ b/app/docs/guides/training/python/07_scope_class.md
@@ -0,0 +1,509 @@
+# Scope és Osztály
+
+<Note  type="tip" label>
+
+**TL;DR Tartalom**
+
+- [Osztályok](#osztályok) - Ízelítő az osztályokról
+- [Elnevezések](#elnevezések) - snake_case, UpperCaseCamelCase
+- [Scope](#scope) - általánosságban
+  - [Built-in Namespace - Beépített névtér](#built-in-namespace---beépített-névtér) -
+    bárhol elérhető objektumok
+  - [Global Namespace - Globális névtér](#global-namespace---globális-névtér) -
+    Modulon belül elérhető objektumok
+  - [Local Namespace - Lokális névtér](#local-namespace---lokális-névtér) -
+    Lokálisan, függvény példák, katalógus
+- [Python osztály](#python-osztály) - Felépítés,
+  példák, init és dunder metódusok
+- [Láthatóság](#láthatóság) - \_ -al privátnak tekintjük
+- [Öröklés](#öröklés) - `Osztály(Ős1, Ős2, ...)`,
+  Melyik függvényt hívjam?
+  - [super](#super) - Függvény keresés egy sorrend
+    alapján
+
+</Note>
+
+<Note label>
+
+**Extra feladatok**  
+_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb
+megtanulni a dolgokat_
+
+- Készíts osztályokat a kutyáknak, macskáknak és a
+  medvéknek úgy, hogy ezeknek legyen ősosztálya és
+  a legtöbb közös tulajdonságot reprezentálja.
+- Injektálj be egy osztályt a kutyák és a készített
+  ősosztály közé úgy, hogy minden konstruktor
+  lefusson. (Tipp: super)
+
+</Note>
+
+## Osztályok
+
+Az osztályok egy lehetőséget biztosítanak, hogy
+az adatainkat és a hozzájuk kapcsolódó funkcionalitást
+összecsatoljuk.  
+Osztályainkból különböző objektumokat tudunk létrehozni,
+melyek saját egyedi adatokkal rendelkeznek.  
+Ezek mellett az egyes osztályainknak lehetnek leszármazottaik,
+melyek az ősosztály funkcionalitásait és adatait
+megöröklik.
+
+Na de miért használnék Pythonban osztályokat?  
+Először is biztosítja, hogy objektum orientált szemlélettel
+dolgozzunk, továbbá függvényben mikor objektumot adunk át,
+akkor valójában a háttérben csak egy arra mutató pointert
+visz tovább a Python, tehát sokkal hatékonyabbá válik
+a program.  
+Továbbá az objektumainkat tudjuk a függvényen
+belül módosítani és nem csak egy másolatával dolgozunk.
+
+## Elnevezések
+
+Pythonban a függvényeinket és változóinkat szokás
+`snake_case`-esítve írni. Ez annyit jelent, hogy
+minden betű kisbetűs és a szóköz helyett `_`-k vannak.
+
+Osztályainkat pedig `UpperCaseCamelCase` írjuk, azaz
+egybe, és minden szó kezdő betűjét nagy betűvel
+szóköz nélkül.
+
+## Scope
+
+Ahhoz, hogy megértsük, hogy hogyan tudunk egy objektumhoz
+adatot hozzá csatolni, meg kell értsük a Scope-okat is.
+
+A Python folyamatosan menedzseli a jelenleg kezelt neveket
+és hozzájuk tartozó objektumokat.
+Egy katalógusként tudod ezt az egészet elképzelni.  
+Ezeket névtereknek (namespace) nevezzük és több
+fajtáját különböztetjük meg.
+
+### Built-in Namespace - Beépített névtér
+
+Itt vannak azok az objektumok, melyeket bármikor elérünk a
+kódunkban.
+
+```python
+>>> dir(__builtins__)
+['ArithmeticError', 'AssertionError', 'AttributeError',  ... ]
+```
+
+### Global Namespace - Globális névtér
+
+Bármi, amit a futtatott programunkon definiáltunk.  
+Minden modulhoz készül egy ilyen.  
+A modulon belül bárhonnan elérjük az itt definiált
+dolgokat.
+
+### Local Namespace - Lokális névtér
+
+Minden függvényen belül egy saját névteret készít
+a python. Tehát ha belül definiálunk egy változót,
+az csak azon a funkción belül lesz elérhető.
+
+```python
+>>> def fv():
+...     a = 3
+...     if a == 1:
+...             b=2
+...     print(a)
+...     print(b)
+...
+>>> fv()
+3
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "<stdin>", line 6, in fv
+UnboundLocalError: local variable 'b' referenced before assignment
+```
+
+Látható, hogy ennél a példánál még az `if` ágon belüli `b` is
+létezik, viszont nem kapott értéket és emiatt Error-t kaptunk.
+
+Például egy nem létező változóval:
+
+```python
+def fv2():
+...     a = 3
+...     if a == 1:
+...             b=2
+...     print(a)
+...     print(not_existing_variable)
+...
+>>> fv2()
+3
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+  File "<stdin>", line 6, in fv2
+NameError: name 'not_existing_variable' is not defined
+```
+
+Itt már azt a hibát kaptuk, hogy a változót nem is hoztuk létre.
+
+Ezt úgy képzeld el, hogy a Python mikor sorról sorra
+végigment a kódon, akkor felépített minden funkción belül
+egy saját katalógust a változóknak és oda felírta a talált
+neveket.
+Viszont az értékeket csak akkor írta bele, ha ténylegesen
+kapott is.
+
+## Python osztály
+
+Na és akkor nézzük meg, hogy hogyan néz ki egy osztály.
+
+```python
+class OsztalyNev:
+    .
+    .
+    .
+```
+
+Hogy legyen is benne valami:
+
+```python
+>>> class Osztalyom:
+...     """A simple example class""" # Dokumentáció
+...     i = 12345
+...     def f(self):
+...         return 'hello world'
+...
+```
+
+Ebből tudunk egy példányt készíteni:
+
+```python
+>>> x = Osztalyom() # Példányosítás
+>>> x.i
+12345
+```
+
+Ilyenkor meghívódott az alapértelmezett konstruktora.
+
+Ha saját konstruktort szeretnénk, akkor a beépített
+**\_\_init\_\_** függvényt tudjuk felhasználni.
+
+A különböző objektumainknak megannyi ilyen beépített
+függvénye van egyébként.
+Például felültudjuk írni, hogy mi történjen,
+ha az objektumot összeszorozzuk valamivel,
+vagy mit írjon ki ha simán ki Printeljük és így tovább.  
+_Ezeket Double Underscore, azaz "Dunder" metódusoknak
+hívják_  
+[Részletesebben](https://docs.python.org/3/reference/datamodel.html)
+
+```python
+>>> class Osztalyom:
+...     """Egy példa osztály"""
+...     i = 12345   # Minden objektum által megosztott
+...     def f(self):
+...         return 'hello world'
+...     def __init__(self): #
+...         self.data = []
+```
+
+Egy érdekes különbség C-től, hogy a változóinkat
+nem definiáljuk közvetlen, hanem az init metódusában
+vesszük fel őket.  
+Ha ezt nem így tennénk, akkor valójában egy statikus
+minden objektum közt megosztott változót készítenénk.
+
+A konstruktor metódusunkban feltűnhet az első paraméter.
+Ez az a változó, mely a jelenleg létrejövő objektumra mutat.
+Ha ehhez hozzáírunk új adatokat, akkor csak abban lesz benne.
+
+```python
+>>> class Komplex:
+...     def __init__(self, valos, imaginarius):
+...         self.r = valos
+...         self.i = imaginarius
+...
+>>> x = Komplex(3.0, -4.5)
+>>> x.r, x.i
+(3.0, -4.5)
+```
+
+Statikus változóval ilyesmi problémába üzközhetünk bele:
+
+```python
+class Dog:
+
+    tricks = []
+
+    def __init__(self, name):
+        self.name = name
+
+    def add_trick(self, trick):
+        self.tricks.append(trick)
+
+>>> d = Dog('Fido')
+>>> e = Dog('Buddy')
+>>> d.add_trick('roll over')
+>>> e.add_trick('play dead')
+>>> d.tricks
+['roll over', 'play dead']
+```
+
+Helyesen:
+
+```python
+class Dog:
+    def __init__(self, name):
+        self.name = name
+        self.tricks = []    # Minden kutyánál saját lista lesz
+
+    def add_trick(self, trick):
+        self.tricks.append(trick)
+
+>>> d = Dog('Fido')
+>>> e = Dog('Buddy')
+>>> d.add_trick('roll over')
+>>> e.add_trick('play dead')
+>>> d.tricks
+['roll over']
+>>> e.tricks
+['play dead']
+```
+
+Erre a magyarázat, hogy ezekre az objektumokra csak mutatók
+készülnek.
+Tehát mikor mi definiáltuk az osztályunk akkor készítettünk
+egy új listát `[]`, majd pedig a tricks változót rámutattuk a
+listánkra.
+Ezt követően mikor ebből új példányokat képeztünk,
+akkor ugyanazokat a mutató értékeket kapták az egyes
+leszármazottak.
+
+## Láthatóság
+
+Pythonban az osztályokban a tagváltozók és függvények
+publikusan elérhetőek és nem lehet őket priváttá tenni.
+Erre egy konvenció, hogyha `_`-al kezdődik a nevük, akkor
+privátként kezeljük őket.
+Ekkor nem lesznek privátak, ugyanúgy publikok maradnak,
+viszont ha valaki hozzányúl a kódhoz, akkor nem fogja
+ezeket használni, legfeljebb Getter, Setteren keresztül.
+
+```python
+class Lathatosag:
+    def __init__(self, privat_info):
+        self.privat_info = privat_info
+
+    def get_privat_info(self):
+        return self.privat_info
+
+    def set_privat_info(self, uj_ertek):
+        self.privat_info = uj_ertek
+
+```
+
+## Öröklés
+
+Mikor egy osztályból leöröklünk, akkor a gyerekosztály
+megjegyzi az ősét és később tudunk rá hivatkozni.  
+Az egyes függvények és változók elérhetőek
+a leszármazott osztály `self`-jében, viszont hogy
+pontosan melyik ősosztály függvényét hívjuk, ha
+egyezés van köztük az nem egyértelmű elsőre ha
+például több osztályunk is van.
+
+Nézzük is meg!  
+(`Osztálynév(Ősosztály, ...)`)
+
+```python
+class A:
+  pass
+
+class B(A):
+  pass
+
+b = B() # Példányosítottuk
+print(isinstance(b, A))
+# isinstance metódus ellenőrzi, hogy leszármazottja-e
+# az objektumunk A-nak
+
+# Kimenet:
+# True
+```
+
+Akár több osztályt is megadhatunk ősosztálynak.
+
+Tegyünk bele pár konstruktort
+
+```python
+class A:
+  def __init__(self):
+    print("A")
+
+class B(A):
+  def __init__(self):
+    print("B")
+```
+
+Mit gondolsz, példányosításkor mi fog történni?
+
+```python
+b = B()
+
+# Kimenet:
+# B
+```
+
+Nem futott le az A konstruktora.
+Ezt két féleképp tudjuk megoldani.
+
+```python
+class A:
+  def __init__(self):
+    print("A")
+
+class B(A):
+  def __init__(self):
+    A.__init__(self) # Explicit meghívjuk A konstruktorát
+    print("B")
+
+b = B()
+
+# Kimenet:
+# A
+# B
+```
+
+### super
+
+Másik megoldás, hogy használjuk a beépített `super` függvényt.
+
+```python
+class A:
+  def __init__(self):
+    print("A")
+
+class B(A):
+  def __init__(self):
+    super().__init__()
+    # ez super(B, self).init() -ként is írhatnánk
+    # alapértelmezetten az üres verzió python 3-ban
+    # (B, self)-re egészül
+    print("B")
+
+b = B()
+
+# Kimenet:
+# A
+# B
+```
+
+A `super` függvény ilyenkor egy úgynevezett
+metódus feloldási sorrendet követve végigjárja
+a megadott osztálytól kezdve az ősosztályokat
+és megkeresi a megfelelő függvényt, majd megáll.  
+Tehát a fenti példánál megtalálta `A`-ban az
+`__init__` függvényt és abbahagyta a keresést,
+majd meghívta a függvényt.
+
+A metódus feloldási sorrendünk ez esetben:
+
+```python
+print(B.__mro__) # Method Resolution Order
+
+# Kimenet:
+# (<class '__main__.B'>,
+# <class '__main__.A'>,
+# <class 'object'>)
+```
+
+Mikor a `super`-t alapértelmezetten `B`-től indítottuk,
+akkor a következő `A` osztályban kereste meg az `__init__`
+függvényt.
+
+_Azt is észrevehetted, hogy alapértelmezetten az osztályaink
+az object osztályból öröklődnek_
+
+Na de miért használjak `super` -t?
+
+```python
+class A(object):
+    def __init__(self):
+        print('A.__init__(self) -t hívtunk')
+
+class B(A):
+    def __init__(self):
+        print('B.__init__(self) -t hívtunk')
+        A.__init__(self) # Nem használtam Super-t
+
+class C(A):
+    def __init__(self):
+        print('C.__init__(self) -t hívtunk')
+        super(C, self).__init__() # Használtam Supert
+```
+
+Ha netán úgy döntenénk, hogy ezekből az osztályokból
+leszeretnénk származni, de úgy, hogy
+A alá még helyezünk egy osztályt, így:
+
+<!--TODO picture-->
+<img 
+  src={require('./injektalas.svg').default} 
+  border="false" 
+  width="100%"
+/>
+
+```python
+class Injektalt_Osztaly(A):
+    def __init__(self):
+        print('Injektalt_Osztaly.__init__(self) -t hívtunk')
+        super(Injektalt_Osztaly, self).__init__()
+
+class B_bol(B, Injektalt_Osztaly):
+  pass
+
+class C_bol(C, Injektalt_Osztaly):
+  pass
+
+B_bol()
+# Kimenet:
+# B.__init__(self) -t hívtunk
+# A.__init__(self) -t hívtunk
+
+C_bol()
+# Kimenet:
+# C.__init__(self) -t hívtunk
+# Injektalt_Osztaly.__init__(self) -t hívtunk
+# A.__init__(self) -t hívtunk
+```
+
+Miért nem futott le a B_bol esetén?  
+Nézzük meg a metódus feloldási sorrendet
+
+`<class '__main__.B_bol'>,`  
+`<class '__main__.B'>,`  
+`<class '__main__.Injektalt_Osztaly'>,`  
+`<class '__main__.A'>,`  
+`<class 'object'>`
+
+`B_bol` osztály után meghívódott `B` konstruktora,
+mert az alapértelmezett konstruktora `B`-nek meghívja
+a `super()` függvényt.  
+Ezt követően `B`-ben a következő hívás `A`-ra fog
+mutatni.
+Ezt követően pedig a végére érünk és ha hívnánk
+újabb `super`-t, akkor már az object jönne.
+
+Mikor a `C_bol` osztályból indultunk, akkor `C`
+osztályban a `super` függvény lefutott és
+az `Injektalt_Osztaly`-ban megtalálta a függvényünk.
+
+<Note type="tip" label>
+
+<Badge type="tip">Összefoglalva</Badge>  
+Mikör öröklünk és a super függvényunk használjuk,
+akkor felépít egy metódus feloldási sorrendet attól
+függően, hogy hogyan definiáltuk az osztályainkat.
+Ezt követően mikor hívogatjuk a super-eket,
+akkor mindig a sorrendben következő fog jönni, kivéve
+ha átugorjuk, mert statikusan definiáljuk, hogy
+melyik a következő osztály.
+
+A super-el akár más függvényeket is megtudunk így találni.
+
+</Note>
diff --git a/app/docs/guides/training/python/08_error.md b/app/docs/guides/training/python/08_error.md
new file mode 100644
index 0000000000000000000000000000000000000000..c7fe85aec13d977872467a6b129b76d377af27ca
--- /dev/null
+++ b/app/docs/guides/training/python/08_error.md
@@ -0,0 +1,204 @@
+# Hibák és azok kezelése
+
+<Note  type="tip" label>
+
+**TL;DR Tartalom**
+
+- [Hibák általánosságban](#hibák-általánosságban) -
+  Objektumok, példák
+- [Hibakezelés](#hibakezelés)
+  - [Saját hiba osztályok](#saját-hiba-osztályok) - Ugyanolyan
+    osztály
+  - [try ... catch ...](#try--catch-) - Dobunk és elkapunk hibát
+  - [else](#else) - Semmi hiba nem volt, csinálj valamit
+  - [raise](#raise) - Hibával dobálózás
+  - [finally](#finally) - Még a returnt is felülírjuk
+
+</Note>
+
+<Note label>
+
+**Extra feladatok**  
+_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb
+megtanulni a dolgokat_
+
+- Készíts egy saját hiba osztályt, melyben letárolsz
+  egy számot és híváskor kiírja azt.
+  (Tipp: `__init__`, `__str__`)
+- Imént definiált hibát kapd el, irasd ki és ne hagyd
+  miatta leállni a programot.
+
+</Note>
+
+## Hibák általánosságban
+
+Python, mint magasszintű nyelv hibák dobására és azok
+kezelésére is képes.
+Ezek olyan objektumok, melyekkel a program futásának
+vezérlési szerkezetét tudjuk megszakítani, majd valahol
+lekezelni őket.
+
+Alapvetően ha nem kerülnek lekezelésre, akkor a futás megáll
+és a hibát kiírja nekünk az interpeter.  
+A leggyakoribb hiba, amivel a Python tanulása közben fogsz
+találkozni, az a SyntaxError.
+
+```python
+>>> while True print('Hello world')
+  File "<stdin>", line 1
+    while True print('Hello world')
+                   ^
+SyntaxError: invalid syntax
+```
+
+Valamennyire próbál neked segíteni a fordító mikor ilyen
+keletkezik.
+
+Még egy pár hiba:
+
+```python
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+ZeroDivisionError: division by zero
+>>> 4 + spam*3
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: name 'spam' is not defined
+>>> '2' + 2
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+TypeError: Can't convert 'int' object to str implicitly
+```
+
+## Hibakezelés
+
+### Saját hiba osztályok
+
+Tudunk készíteni saját hibákat.  
+Ehhez csak egy osztályt kell készítenünk.
+
+```python
+class ForgovillaHiba(Exception): # Leszármazik az Exceptionből
+    """Valami baj van a forgóvillával"""
+    pass # sad SCH noises
+```
+
+### try ... catch ...
+
+`try` és `except` kulcsszavakkal eltudjuk kapni a különböző
+hibáinkat.
+
+```python
+>>> while True:
+...     try:
+...         x = int(input("Adj meg egy számot: "))
+...         break
+...     except ValueError:
+...         print("Ez nem egy szám...")
+...
+```
+
+A `try`-on belüli részen ha keletkezik bármilyen hiba, akkor
+azonnal tovább dobja az `except`-hez.
+Itt definiálhatjuk, hogy milyen típusú hibát szeretnénk
+elkapni.
+
+Akár többet is elkaphatunk egyben:
+
+```python
+... except (RuntimeError, TypeError, NameError):
+...     pass
+```
+
+Az `except` részben definiált osztályok akkor kapják el
+az adott hibát, ha kompatibilisek a dobott hibával.
+
+Tanulmányozd, hogy mit dob ez esetben a kód:
+
+```python
+class B(Exception):
+    pass
+
+class C(B):
+    pass
+
+class D(C):
+    pass
+
+for osztaly in [B, C, D]:
+    try:
+        raise osztaly()
+    except D:
+        print("D")
+    except C:
+        print("C")
+    except B:
+        print("B")
+```
+
+Különböző dobott hibákat akár le is menthetjük
+egy változóba, majd annak tartalmával dolgozhatunk.
+
+```python
+import sys
+
+try:
+    f = open('fajl.txt')
+    s = f.readline()
+    i = int(s.strip())
+except OSError as err:
+    print("OS error: {0}".format(err))
+except ValueError:
+    print("Nem sikerült intbe konvertálni.")
+except: # Minden más
+    print("Váratlan hiba:", sys.exc_info()[0])
+    raise
+```
+
+### else
+
+Egy `try`, `catch` blokk legvégére tehetünk egy `else`-t,
+hogy lefuttasunk valamit ha nem történt semmi hiba.
+
+### raise
+
+Mi is tudunk hibákat dobni a `raise`
+kulcsszó segítségével.
+
+```python
+>>> raise NameError('HiThere')
+Traceback (most recent call last):
+  File "<stdin>", line 1, in <module>
+NameError: HiThere
+```
+
+```python
+>>> try:
+...     raise NameError('HiThere')
+... except NameError:
+...     print('Egy hiba történt!')
+...     raise
+...
+An exception flew by!
+Traceback (most recent call last):
+  File "<stdin>", line 2, in <module>
+NameError: Egy hiba történt!
+```
+
+### finally
+
+Végül pedig a `try` lefutása után tudunk definiálni még
+lépéseket.
+Az itt definiált dolgok mindenképp lefognak futni, ha volt,
+ha nem volt hiba.
+
+```python
+>>> def fv():
+...     try:
+...         return True
+...     finally:
+...         return False
+...
+>>> fv()
+False
+```
diff --git a/app/docs/guides/training/python/09_virtual_env.md b/app/docs/guides/training/python/09_virtual_env.md
new file mode 100644
index 0000000000000000000000000000000000000000..436479da4518f4cebf24b85a7dfdda3f2bd34b6f
--- /dev/null
+++ b/app/docs/guides/training/python/09_virtual_env.md
@@ -0,0 +1,166 @@
+# Virtuális környezet
+
+<Note  type="tip" label>
+
+**TL;DR Tartalom**
+
+- [Bevezető](#bevezető)
+- [Hogyan készítünk ilyen környezetet?](#hogyan-készítünk-ilyen-környezetet) - `-m venv`, `source`
+- [Csomagkezelés Pip-el](#csomagkezelés-pip-el) -
+  `pip`, `install`, `show`, `freeze`, telepítés requirementsből
+
+</Note>
+
+<Note label>
+
+**Extra feladatok**  
+_Ezek nem kötelező feladatok, csak megoldásuk közben könyebb
+megtanulni a dolgokat_
+
+- Készíts el a saját környezeted, lépj bele és telepíts
+  fel egy szerinted funky csomagot.  
+  Használd a kódodban.  
+  Végül pedig tedd egy másik virtuális környezetbe a projektet
+  és érd el, hogy az ott is működjön a kódod.
+
+</Note>
+
+## Bevezető
+
+Az alap könyvtáraink (modulok) mellett néha szükségünk van
+mások által megírt könyvtárakra is.  
+Erre egyik lehetőségünk, hogy az adott csomagot feltelepítjük
+a gépünkre és onnantól a python majd megtalálja mikor
+beimportáljuk a kódunkba.
+Másik lehetőség, hogy felépítünk egy virtuális környezetet és
+csak azon belülre helyezünk egyes könyvtárakat amikre
+szükségünk lesz.
+
+## Hogyan készítünk ilyen környezetet?
+
+Nyissunk egy új mappát, majd pedig ott adjuk ki a
+`python3 -m venv tutorial-env` parancsot.  
+Ekkor keletkezik egy mappa, melyben megtalálható minden
+konfigurációnk ami a virtuális python környezetünkhöz kell.
+
+Hogy átlépjünk ebbe a környezetbe, OS-től függően:
+
+- Windows: `tutorial-env\Scripts\activate.bat`
+- Linux / MacOS: `source tutorial-env/bin/activate`
+
+Miután ezt kiadtuk, látni fogjuk a terminálunkban, hogy
+ezt jelöli is.
+
+```shell-session
+               ...$ source tutorial-env/bin/activate
+(tutorial-env) ...$ python
+```
+
+```python
+Python 3.8.5 (default, Jan 27 2021, 15:41:15)
+[GCC 9.3.0] on linux
+Type "help", "copyright", "credits" or "license" for more information.
+>>>
+```
+
+Ekkor már elég volt a `python` parancsot kiadnom, hogy a 3-as
+verzióval induljon az interpreter.  
+Ez azért van, mert python3-al hoztam létre a virtuális
+környezetem.
+Ha belelépek, utána már az ekkor definiált pythont fogja
+használni.
+
+## Csomagkezelés Pip-el
+
+Ahhoz, hogy külső csomagokat tudjunk behozni a projektünkhöz,
+a `pip` nevezetű csomagkezelőt fogjuk használni.
+
+Ellenőrizd, hogy elérhető-e a `pip`.  
+`python -m pip --version`  
+Ennek a parancsnak működnie kell ha benne vagy az
+environmentben.  
+Python 3 esetén a 3.4-nél nagyobb verziónál
+bele kerül generáláskor.
+
+A [PyPi](https://pypi.org/) honlapján lehet böngészni
+az elérhető csomagokat.
+Mikor ezt írtam kb. 292 ezer volt.
+
+Na miután megtaláltunk álmaink csomagját, azt letudjuk
+tölteni a jelenlegi virtuális környezetünkbe.
+
+```shell-session
+$ pip install requests
+```
+
+Megtudjuk akár nézni 1-1 csomag adatait a terminálból.
+
+```shell-session
+$ pip show requests
+Name: requests
+Version: 2.25.1
+Summary: Python HTTP for Humans.
+Home-page: https://requests.readthedocs.io
+Author: Kenneth Reitz
+Author-email: me@kennethreitz.org
+License: Apache 2.0
+Location: /tmp/sad/tutorial-env/lib/python3.8/site-packages
+Requires: certifi, chardet, urllib3, idna
+Required-by:
+```
+
+Mostmár elméletileg fel van telepítve a környezetünkben,
+de azért nézzük meg.
+
+```shell-session
+$ pip list
+Package       Version
+------------- ---------
+certifi       2020.12.5
+chardet       4.0.0
+idna          2.10
+pip           20.0.2
+pkg-resources 0.0.0
+requests      2.25.1
+setuptools    44.0.0
+urllib3       1.26.3
+```
+
+És itt van 2.25.1-es verzióval.
+
+Ha más gépre át akarjuk vinni a kért csomagokat, akkor
+akár ezt a listát ki is tudjuk exportálni és akkor
+később bárhol feltudjuk állítani ugyanezt a környezetet.
+
+```shell-session
+$ pip freeze > requirements.txt
+$ cat requirements.txt
+certifi==2020.12.5
+chardet==4.0.0
+idna==2.10
+requests==2.25.1
+urllib3==1.26.3
+```
+
+Készítettünk egy fájlt, ahol fel van listázva az összes
+csomag és kapcsolódó verziók.
+Ha csinálunk egy új virtuális környezetet, akkor ebből
+feltudjuk telepíteni a csomagjainkat.
+
+```shell-session
+$ python -m pip install -r requirements.txt
+Collecting certifi==2020.12.5
+  Using cached certifi-2020.12.5-py2.py3-none-any.whl (147 kB)
+Collecting chardet==4.0.0
+  Using cached chardet-4.0.0-py2.py3-none-any.whl (178 kB)
+Collecting idna==2.10
+  Using cached idna-2.10-py2.py3-none-any.whl (58 kB)
+Collecting requests==2.25.1
+  Using cached requests-2.25.1-py2.py3-none-any.whl (61 kB)
+Collecting urllib3==1.26.3
+  Using cached urllib3-1.26.3-py2.py3-none-any.whl (137 kB)
+Installing collected packages: certifi, chardet, idna, urllib3, requests
+Successfully installed certifi-2020.12.5 chardet-4.0.0 idna-2.10 requests-2.25.1 urllib3-1.26.3
+```
+
+_És igazából ezek az alapjai a virtuális környezetnek_
diff --git a/app/docs/guides/training/python/10_exercise.md b/app/docs/guides/training/python/10_exercise.md
new file mode 100644
index 0000000000000000000000000000000000000000..6046978671133293dfb67f2f878ddd2508494387
--- /dev/null
+++ b/app/docs/guides/training/python/10_exercise.md
@@ -0,0 +1,242 @@
+# Gyakorlat
+
+## 0. Virtuális környezet és Modulok bemutatása
+
+### Beépített fájlkezelő modul
+
+Alapból a Python a rendszerünkre feltelepített csomagokat fogja használni, melyeket
+be is tudunk importálni a fájlunkba.
+Alapértelmezetten rengeteg beépített modullal rendelkezünk, például
+tudunk fájlokat kezelni, melyet próbáljunk ki!
+
+```python
+# Beolvasás
+#
+# builtins.py fájlból jön ez az "open" függvény
+# első paramétere a fájl neve és mindig onnan értékelődik ki
+# ahonnan indítottuk a pythont.
+# utána jövő paraméter, hogy hogyan nyitjuk meg a fájlt.
+# r - read
+# w - write: felülírja az egészet
+# a - append: fájl végére ír hozzá
+# x - Create: Létrehozza a fájlt.
+
+# r,w,a,x -et próbálják ki
+
+# Készítsenek egy 01_file.txt -t vagy hasonlót
+
+# Read:
+fajl = open("01_file.txt", "r")
+print(fajl.read())
+
+fajl.close() # Mindig zárják be
+
+# Write
+fajl = open("01_file.txt", "w")
+fajl.write("Okay. ")
+# Mi történt a fájlal? - Felülírta teljesen
+
+
+fajl.close()
+
+# Append
+fajl = open("01_file.txt", "a")
+fajl.write("Okay?")
+# Mi történt? - Végére írta
+
+
+fajl.close()
+
+
+# Create
+fajl = open("something_new.txt", "x")
+# Mi történt? - Létrehozta
+# Ha újra lefutatják mi történik? - Errort kaptunk, ezt kezeljük is le!
+
+fajl.close()
+```
+
+### Hibakezelés
+
+```python
+# Előző példában fájl újra létrehozáskor kaptunk
+# egy hibát!
+# Python ezeket az úgynevezett "objektumokat" szokta
+# dobni, mikor hiba keletkezik és különféle
+# adatokkal rendelkeznek, mint üzenet.
+# Előzőben volt egy: FileExistsError: [Errno 17] File exists: 'something_new.txt'
+
+try: # Ezen a blokkon belüli dolgokat majd elkapja
+    fajl = open("something_new.txt", "x")
+    fajl.close() # Ha errort kap, akkor nem nyitja meg a fájlt,
+                 # szóval nem kell a finally blokkba tenni
+except FileExistsError as fe: # Itt feltudjuk típus szerint sorolni, hogy mit kapjon el.
+    print(fe)                 # Ha oda írjuk, hogy "as ...", akkor abba bele menti.
+                              # Első körben as nélkül. "Hogyan tudnánk kiírni a hibát?"
+
+
+# Ezután írjuk ki, hogy "kész a fájl" hibától független
+
+try:
+    fajl = open("something_new.txt", "x")
+    fajl.close() # Ha errort kap, akkor nem nyitja meg a fájlt,
+                 # szóval nem kell a finally blokkba tenni
+except FileExistsError as fe:
+    print(fe)
+finally:
+    print("Fájl elkészítve! (Vagy már el volt)")
+```
+
+### Virtuális környezet
+
+Láttuk, hogy hogyan tudunk beépített modullal fájlt kezelni, de mi van akkor ha
+egy külső csomagot szeretnénk használni?
+Feltelepíthetjük, viszont feleslegesen terhelnénk vele a rendszerünket.  
+Ennek megoldására tudunk `virtuális környezeteket` készíteni magunknak egy-egy
+mappában.
+
+```shell-session
+$ python3 -m venv awesome-env
+```
+
+Ezután aktiválhatjuk az environmentet.
+
+```shell-session
+Windows      : $ awesome-env\Scripts\activate.bat
+Linux / Mac  : $ source awesome-env/bin/activate
+```
+
+Ebben a virtuális környzetben kapunk egy saját csomagkezelőt, a pip-et.
+
+```shell-session
+$ python -m pip --version
+```
+
+Na és akkor a requests library-t fogjuk használni.
+
+```shell-session
+$ pip show requests
+```
+
+Telepítsük is fel!
+
+```shell-session
+$ pip install requests
+```
+
+Na de hogyan látjuk mi van feltelepítve?
+
+```shell-session
+$ pip list
+```
+
+Akár ezt a listát ki is tudjuk exportálni és megosztani másokkal, hogy aztán
+a saját virtuális környezetükben feltelepítsék.
+
+```shell-session
+$ pip freeze > requirements.txt
+$ cat requirements.txt
+certifi==2020.12.5
+chardet==4.0.0
+idna==2.10
+requests==2.25.1
+urllib3==1.26.3
+```
+
+Nyissanak egy új terminált, menjenek egy másik mappába, készítsenek ott egy
+virtual env-et és telepítsék fel a dolgokat.
+
+```shell-session
+$ python -m pip install -r requirements.txt
+```
+
+## 1. Hanyadik hét van?
+
+Készítsetek egy Python szkriptet, ami a https://hanyadikhetvan.attiss.eu/api -ról leszedett információ alapján kiírja, hogy hanyadik hét van.
+
+```python
+# https://hanyadikhetvan.attiss.eu/api
+
+import requests
+
+
+# Mi az az API?
+# Application Programming Interface, a lényeg, hogy
+# ez az interfész, amin 1-1 alkalmazást elérünk és valamilyen
+# formában tudunk vele kommunikálni.
+#
+# Nézzék meg, hogy mi van a https://hanyadikhetvan.attiss.eu/api oldalon.
+# Ez egy JSON, mely egy sztenderd adatközlési mód a weben,
+# a lényeg, hogy kulcs érték párosokat tudunk az oldalon lévőhöz hasonlóképp
+# leírni.
+# Na és használjuk!
+
+r = requests.get('https://hanyadikhetvan.attiss.eu/api')
+
+print(r) # <Response [200]> - Különböző státuszkódokkal térhet vissza
+         # egy API, pl 200 - OK, vagy 404 - Not Found
+# Vannak beépített függvényeink
+print(r.status_code) # Státuszkód számként
+print(r.ok) # Státuszkód 200 és 400 közé esik
+
+# Na de olvassuk ki az adatunkat végre
+print(r.content) # hmm ez így nem lesz tökéletes nekünk. Látható, hogy b'', azaz
+                 # ezek bájtok, továbbá egy új sor is van benne
+print(r.json()) # Újabb beépített függvény, mely készít nekünk egy Dictionary-t!!
+print(type(r.json())) # <class 'dict'>
+print(r.json()["week"]) # 5
+
+# Végleges kód:
+
+import requests
+
+r = requests.get('https://hanyadikhetvan.attiss.eu/api')
+
+print(r.json()["week"])
+```
+
+## 2. Írjátok meg a saját "hanyadikhétvan" apitokat.
+
+```python
+# Ehhez a flask könyvtárat fogjuk használni,
+# mellyel képesek vagyunk nagyon könnyedén
+# webszervereket készíteni.
+
+import flask
+import requests
+
+# Inicializáció. Ez az objektum fő amin
+# keresztül mindent elérünk Flask-ben.
+# Kosntruktorban átadtuk a jelenlegi App nevét,
+# emlékeztek ha ez = "__main__" akkor ezt a fájlt
+# indítottuk el.
+app = flask.Flask(__name__)
+# Engedélyezzük, hogy logoljon mindent
+app.config["DEBUG"] = True
+
+
+# Megmondjuk, hogy a /-re GET-el ezt a függvényt hívja meg.
+# Hogy ez hogyan működik a háttérben?
+# - Nézzenek utánna a különböző Python dekorátoroknak :)
+@app.route('/', methods=['GET'])
+def home():
+    # Lekérjük az előző oldalról :D Laziness 100
+    # Ha szeretnének saját json-el visszatérni, akkor készítsetek
+    # egy Dict objektumot és azzal térjetek vissza. Ezt majd a library
+    # megfelelő mód küldi le.
+    r = requests.get('https://hanyadikhetvan.attiss.eu/api')
+    # Visszatérünk vele
+    return r.json()
+
+app.run()
+```
+
+## 3. Kössétek össze az első szkriptetekkel
+
+```python
+import requests
+
+r = requests.get('http://127.0.0.1:5000')
+
+print(r.json()["week"])
+```
diff --git a/app/docs/guides/training/python/_category_.json b/app/docs/guides/training/python/_category_.json
new file mode 100644
index 0000000000000000000000000000000000000000..fdff4a38acdfdd2d23a744396dc26f534d0d1c82
--- /dev/null
+++ b/app/docs/guides/training/python/_category_.json
@@ -0,0 +1,5 @@
+{
+    "label": "Python 3",
+    "position": 10
+}
+  
\ No newline at end of file
diff --git a/app/docs/guides/training/python/injektalas.svg b/app/docs/guides/training/python/injektalas.svg
new file mode 100644
index 0000000000000000000000000000000000000000..7107de86f903b1eb2d20ff3ea884c4da791785c4
--- /dev/null
+++ b/app/docs/guides/training/python/injektalas.svg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65c3c8a1ad972a0662c708c0ee2370e43dbdf6adb3457307dff5ff146b0a287c
+size 9839
diff --git a/app/docs/guides/training/python/python.md b/app/docs/guides/training/python/python.md
new file mode 100644
index 0000000000000000000000000000000000000000..d72af314604e3b98e5c108efeb4815c64d2e267b
--- /dev/null
+++ b/app/docs/guides/training/python/python.md
@@ -0,0 +1 @@
+asd
diff --git a/app/docs/guides/training/python/rafael_laszlo-min.jpg b/app/docs/guides/training/python/rafael_laszlo-min.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..1fa893b4cddb078f9ff854c396e032eb983b8f0b
--- /dev/null
+++ b/app/docs/guides/training/python/rafael_laszlo-min.jpg
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c21297c3f40be407b50add7e6ff15bf19cb332db3bd3d1b6573d6aad28bbc0ba
+size 896640