Added Hungarian translation for Beginner Python Sushi Cards

python/beginner/hu/01.md

@@ -0,0 +1,24 @@
+1. Megismerkedünk a programozás alapjaival és egy játékot is fejlesztünk Python nyelven. 
+> ### Tudtad?
+Sok weboldal, mint a YouTube és az Instagram, Python-ban van készítve. 
+
+    Ahhoz, hogy el tudj kezdeni kódolni Python-ban, a számítógépet először fel kell készítened. Telepítened kell a Python-t és egy szövegszerkesztőre is szükséged lesz. Azt is meg kell tanulnod, hogyan lehet Python programokat futtatni.
+
+2. A Python telepítéséhez, menj a [dojo.soy/py-setup](http://dojo.soy/py-setup) weboldalra és kattints a *Download Python 3* gombra! A *3* után lesznek még más számok is, de ezek gyakran változnak, ezért itt nem foglalkozunk velük. Neked sem kell miattuk aggódnod. 
+
+    Ha letöltötted a Python telepítőt, akkor indítsd el és fogadj el minden alapbeállítást!
+
+3. Szükséged lesz egy szövegszerkesztőre is, amiben megírod a Python programjaidat. Erre a célra az Atom programot javasoljuk, amit az [atom.io](http://atom.io) oldalról tölthetsz le, de használhatsz más szövegszerkesztőt is, ha van olyan amit már ismersz vagy jobban szeretsz.
+
+4. Ha mindent telepítettél és minden működik, akkor kezdhetjük is a programozást. Kövesd az alábbi lépéseket:
+    * Hozz létre egy új könyvtárat, ahol a kezdő Python projektjeidet tartod majd!
+    * Indítsd el a szövegszerkesztőt és hozz létre egy új fájlt! Mentsd el *beginner_sushi.py* néven abba a könyvtárba amit az imént létrehoztál!
+    * Indítsd el a parancsértelmezőt a számítógépeden (ennek Windows-on *Command Prompt*, Mac-en és Linux-on pedig *Terminal* a neve) és a *cd* parancs segítségével lépj be a korábban létrehozott kezdő Python könyvtáradba!
+    * Most lefuttathatod a korábban idementett *beginner_sushi.py* fájlt, ha a következőt írod a parancsértelmezőbe:
+        ```bash
+            python3 beginner_sushi.py
+        ```
+        Ha minden jól megy, akkor nem kell látnod semmit a képernyőn, hiszen a fájl még üres, nem tartalmaz semilyen programot.
+    > ### Program futtatása
+    Később többször előfordul majd, hogy le kell *futtatnod* egy-egy programot.   
+    Ez pontosan azt jelenti, amit az imént csináltál: be kell lépned abba a könyvtárba, ahol a programot tartalmazó fájl található és be kell gépelned a *python3* parancsot és a fájl nevét. Ennek hatására a Python értelmező lefuttatja a fájlban található Python programot.

python/beginner/hu/02.md

@@ -0,0 +1,28 @@
+1. Itt az ideje, hogy megírd az első Python programodat! Ez annyit fog csinálni, hogy mindenkit üdvözöl. A szövegszerkesztő segítségével írd a következőket egy fájlba:
+      ```python
+        print("Üdv mindenkinek!")
+      ```
+    Futtasd le ezt a programot és figyeld meg mi történik!  
+    Változtasd meg a *"* jelek közötti szöveget, és futtasd újra! Mit tapasztalsz?
+2. Most adj hozzá a programhoz egy újabb sort az alábbiak szerint:
+    ```python
+      print("Üdv mindenkinek!")
+      print("Ez itt a programozás csodálatos világa. Előtted is nyitva áll!")
+    ```
+    Futtasd újra!  
+    Látod, hogy a második *print* utasításban található szöveg (amit egyébként idegen szóval **string**-nek hívunk) új sorban jelenik meg? Ez azért van, mert a *print* utasítást a számítógép a következőképpen hajtja végre:
+     * A gép beolvassa a zárójelek között található jeleket és értelmezi azokat.
+     * Miután a gép megértette, mi van a zárójelben, kinyomtatja azt a képernyőre (a *print* szó jelentése angolul “nyomtat”).
+     * Végül a gép egy láthatatlan “kezdj új sort” utasítást is végrehajt.
+
+3. Vajon miért kell a gépnek értelmeznie, hogy mi van a zárójelben? Azért, mert ott nemcsak egy **string** állhat, hanem több részből is összerakhatod, amit ki akarsz íratni.  
+    Próbáld ki a követlezőt! Írd be az alábbi programot úgy, hogy a "[nevem]" helyére a saját nevedet írod (de tartsd meg a *"* jeleket!):
+    ```python
+      nev = "[nevem]"
+      print("Üdv " + nev)
+      print("Ez itt a programozás csodálatos világa. Előtted is nyitva áll!")
+    ```
+     > ### Az "Üdv" utáni szóköz
+    Az Üdv szó után szóközt kell írni, különben azt kapnánk, hogy "Üdv[nevem]"! A gép nem tudja, hogy egy magyar mondat az, amit éppen kiír!
+
+4. A fenti programban a *nev* egy **változó**. A változó olyan, mint egy doboz a gépen belül, aminek van egy cimkéje. Éppen úgy ahogy egy dobozban, a változóban is bármit tárolhatsz. Ha ki akarod olvasni a tárolt értéket, akkor a cimkével hivatkozhatsz rá. Ha a programodban leírod a cimkét, a gép a változóban tárolt értékkel helyettesíti azt. Az előző példában a változó cimkéje (vagy egyszerűen neve) az volt, hogy *nev* és a *"[nevem]"* szöveget tároltuk benne. Az első *print* utasításban a *nev* változó értékét hozzáfűztük az "Üdv " **string**-hez a *+* jel segítségével.

python/beginner/hu/03.md

@@ -0,0 +1,36 @@
+1. Jó dolog, hogy az *"Üdv "* után tudtunk fűzni egy nevet, de miért volt erre szükség egy változóra? Miért nem írtuk egyszerűen, hogy *"Üdv [nevem]"*? A **változó** használatának nagy előnye, hogy a program írásának pillanatában nem  kell előre tudni, mi lesz az értéke. Akár a program felhasználóját is megkérhetjük, hogy adjon meg egy értéket, amit a változóban tárolunk! Írd át a programod a következők szerint:
+    ```python
+      nev = input("Mi a neved?")
+      print("Üdv " + nev)
+      print("Ez itt a programozás csodálatos világa. Előtted is nyitva áll!")
+    ```
+    Futtasd le! Miután beírtad a neved, meg kell nyomnod az "Enter" billentyűt, hogy a program tovább fusson.
+
+2. Most próbálj bekérni egy számot a felhasználótól! Figyeld meg az alábbi programban, hogy a *+* jel mindkét oldalán állhat változó!
+
+    Futtasd az alábbi programot, válaszolj a kérdéseire és figyeld meg mi történik!
+    ```python
+      nev = input("Mi a neved?")
+      szam = input("Üdv " + nev + ", kérlek, írj be egy számot!")
+      print("A szám, amit beírtál: " + szam)
+    ```
+3. Mi a helyzet akkor, ha egy számot szeretnél hozzáadni egy változóhoz? Írj hozzá egy sort a programodhoz, melyben hozzáadsz egyet a *szam* változó értékéhez!
+    ```python
+      nev = input("Mi a neved?")
+      szam = input("Üdv " + nev + ", kérlek, írj be egy számot!")
+      szam = int(szam) + 1
+      print("A számodnál eggyel nagyobb szám: " + str(szam))
+    ```
+    > Figyled meg, hogyan olvastad ki egy változó értékét, hogyan változtattad azt meg, és hogyan tároltad az új értéket ugyanabban a változóban! És mindezt egyetlen sorban!
+
+    De mi az az *int( )* és *str( )* a *szam* változó előtt?
+
+    A Python-ban az 1 szám nem ugyanaz, mint az "1" szöveg. Az egyik szám, amivel matematikai műveleteket lehet végezni, a másik szöveg, ami például egy mondat része lehet. Az *int( )* használatával a változó értékét **egész szám**-má (angolul **integer**) alakítjuk, az *str( )* használatával a változó értékét **szöveg**-ként (angolul **string**) értelmezzük.  
+
+    Az **integer** és a **string** is változó **típus**. Néhány műveletet (pl. *+* és *print*) csak akkor tud végrehajtani a gép, ha a megfelelő típusú változókkal használod. 
+
+    > ### Matek
+    Az előbb láttuk, hogyan lehet számokat összeadni, de vannak más műveletek is:
+    * A kivonáshoz használd a *-* jelet!
+    * A szorzáshoz használd a *** jelet!
+    * Az osztáshoz használd a */* jelet!

python/beginner/hu/04.md

@@ -0,0 +1,41 @@
+1. A Python-ban könnyen összehasonlíthatsz két számot. Ez sokszor hasznos lehet (pl. van-e elég aranya a játékosnak, hogy megvegye a varázskardot?). Az összehasonlításhoz a következő jeleket használhatod:
+     * *a > b* akkor igaz, ha *a* nagyobb, mint *b*
+     * *a < b* akkor igaz, ha *a* kisebb, mint *b*
+     * *a == b* akkor igaz, ha *a* megegyezik *b*-vel
+     * *a != b* akkor igaz, *a* nem egyenlő *b*-vel
+     * *a >= b* akkor igaz, ha *a* nagyobb, mint *b* vagy egyenlő vele
+     * *a <= b* akkor igaz, ha *a* kisebb, mint *b* vagy egyenlő vele  
+
+ > ### ==
+Figyeld meg, hogy az egyenlőség tesztelésére a dupla egyenlőségjelet használjuk, mert a sima egyenlőségjelet már felhasználtuk arra, hogy értéket adjunk egy változónak.
+
+2. A fenti összehasonlításokat gyakran *if* utasításokban használjuk. Az "if" magyarul azt jelenti "ha". Az *if* segítségével egy programrész végrehajtását feltételhez kötheted: az *if* utasításhoz tartozó programrészt csak akkor hajtja végre a gép, ha az *if* utáni zárójelben megadott feltétel teljesül. Például az alábbi program csak akkor ír szöveget a képernyőre, ha a *szam* változó értéke nagyobb, mint 100:
+    ```python
+      if(szam > 100):
+          print("Ez egy nagy szám!")
+    ```
+    > ### Behúzás
+    Figyeld meg, hogy a *print* utasítás **be van húzva** (azaz nem közvetlenül a sor elején található, hanem 4 db szóköz előzi meg)! A Python-ban a behúzás nagyon fontos dolog, ez jelzi, hogy mely utasítások tartoznak egy programrészbe. A fenti példában, a behúzás jelzi, hogy a *print* az *if*-hez tartozik (és csak akkor kell végrehajtani, ha a feltétel igaz).
+
+3. Most kombináljuk a fenti programot az előző kártyán található programmal:
+    ```python
+      nev = input("Mi a neved?")
+      szam = input("Üdv " + nev + ", kérlek, írj be egy számot!")
+      szam = int(szam)
+      print("A szám, amit beírtál: " + str(szam))
+
+      if(szam > 100):
+          print("Ez egy nagy szám!")
+    ```
+    Futtasd a programot többször is és adj meg különböző számokat! Legyen köztük 100-nál nagyobb és kisebb is! Mi történik? Mi történne, ha pont 100-at írnál be?
+
+4. Bonyolultabb összahasonlításokat végezhetsz az *and* (magyarul "és") és az *or* (magyarul "vagy") műveletek segítségével. Például olyanokat írhatsz, mint az alábbi:
+    ```python
+      if (szam >= 20 and szam < 30):
+          print("Ez a szám a huszasok közé tartozik!")
+    ```
+    Vagy mint ez:
+    ```python
+      if (etel == "Torta" or etel == "Csokoládé" or etel == "Cukor"):
+          print("Ez valami édesség!")
+    ```

python/beginner/hu/05.md

@@ -0,0 +1,36 @@
+1. Tegyük fel, hogy ellenőrizni szeretnéd, hogy a felhasználó által beírt szám elég nagy-e, és ha igen, akkor gratulálni szeretnél neki, ha viszont nem, akkor figyelmeztetni szeretnéd a felhasználót! Mondjuk, hogy az elég nagy azt jelenti, hogy nagyobb mint 100. Próbáld ki ezt:
+    ```python
+    nev = input("Mi a neved?")
+    szam = input("Üdv " + nev + ", kérlek, írj be egy 100-nál nagyobb számot!")
+    szam = int(szam)
+    print("A szám, amit kaptam: " + str(szam))
+
+    if (szam > 100):
+        print("Gratulálok! Ez valóban nagyobb, mint 100!")
+    else:
+        print("Sajnálom, de ez a szám túl kicsi!")
+    ```
+    A fenti programban van egy új elem, az *else* (magyarul "egyébként"). Az *else* az előtte álló *if* utasítás párja és a hozzá tartozó programrész akkor fut le, ha az *if* utáni zárójelben található feltétel nem teljesül (azaz hamis).
+
+2. Most tegyük fel, hogy jelezni szeretnénk a felhasználónak, hogy majdnem jó számot adott meg, ha a szám 100-nál ugyan kisebb, de azért közel van a 100-hoz, mondjuk nagyobb, mint 90. 
+
+    Ekkor az *elif* utasítást használhatod. Ez olyan mintha egy *else* és egy *if* utasítást összeragasztanál, azaz az *elif*-hez tartozó programrész akkor fut le, ha az előző *if* feltétele nem igaz, az *elif* feltétele azonban igaz. A következő sorokkal kell tehát kiegészítened az előző programot:
+    ```python
+    elif(szam > 90):
+        print("Majdnem jó!")
+    ```
+
+    Vizsgáld meg a teljes programot és próbáld meg kibogozni az egyes ágakat! Érdemes megjegyezned, hogy az *elif* mindig egy *if* és egy *else* között található (és akár több *elif* is lehet köztük).
+    ```python
+    nev = input("Mi a neved?")
+    szam = input("Üdv " + nev + ", kérlek, írj be egy 100-nál nagyobb számot!")
+    szam = int(szam)
+    print("A szám, amit kaptam: " + str(szam))
+
+    if (szam > 100):
+        print("Gratulálok! Ez valóban nagyobb, mint 100!")
+    elif (szam > 90):
+        print("Majdnem jó!")
+    else:
+        print("Sajnálom, de ez a szám túl kicsi!")
+    ```

python/beginner/hu/06.md

@@ -0,0 +1,35 @@
+1. Az előbb megkértük a felhasználót, hogy írjon be egy 100-nál nagyobb számot, ellenőriztük, hogy a beírt szám elég nagy-e, és ha nem, akkor ezt jeleztük a felhasználónak. Mi van akkor, ha azt szeretnénk, hogy ilyenkor a felhasználó újra próbálkozhasson? Sőt, mindaddig újabb számot szeretnénk bekérni, amíg a felhasználó által megadott szám túl kicsi!
+
+    Arra van tehát szükségünk, hogy újra és újra bekérjünk egy számot, amíg helyes választ nem kapunk. Ezt bármely progrmozási nyelvben egy **ciklus** segítségével tehetjük meg. A ciklusoknak több fajtája létezik, most a *while* ciklust fogjuk használni. A "while" szó jelentése magyarul "amíg".
+
+2. Egy *while* ciklus kicsit hasonlít egy *if* utasításhoz: van egy zárójelek között található feltétele és a hozzá tartozó programrész (amit itt is behúzással jelölünk) akkor fut le, ha a feltétel igaz. A különbség az, hogy a *while*-hoz tartozó programrész újra és újra lefut, mindaddig amíg a feltétel igaz. Vigyázni kell azonban arra, hogy a feltétel ne legyen örökké igaz, különben a program végtelen ciklusba kerül és sosem fejezi be működését! Így néz ki egy *while* ciklus:
+	```python
+	while (szam <= 100):
+	    szam = input("Üdv " + nev + ", kérlek, írj be egy 100-nál nagyobb számot!")
+		szam = int(szam)
+	```
+
+3. Most add hozzá a megfelelő *while* ciklust a programodhoz!
+	```python
+	nev = input("Mi a neved?")
+	szam = 0
+
+	# Csináld addig, amíg szam nem nagyobb 100-nál
+	while (szam <= 100):
+		# Kérj be egy számot a felhasználótól
+		szam = input("Üdv " + nev + ", kérlek, írj be egy 100-nál nagyobb számot!")
+		# Alakítsd át a beírt választ szövegből egész számmá
+		szam = int(szam)
+		print("A szám, amit kaptam: " + str(szam))
+		# Ellenőrizd, hogy a kapott szám nagyobb-e mint 100
+        if (szam > 100):
+            print("Gratulálok! Ez valóban nagyobb, mint 100!")
+        elif (szam > 90):
+            print("Majdnem jó! Próbáld meg újra!")
+        else:
+            print("Sajnálom, de ez a szám túl kicsi! Próbáld meg újra!")		
+		# Ha a kapott szám nem nagyobb mint 100, akkor a ciklus újra fut
+	```
+
+	> ### Megjegyzések
+	A programba elhelyezhetsz megjegyzéseket (angolul "comment"), a Python-ban ezek a *#* jellel kezdődő sorok. A megjegyzések a programozók számára hasznos információkat tartalmazhatnak a program működésével kapcsolatban, a számítógép azonban ezeket a megjegyzéseket figyelmen kívül hagyja.   

python/beginner/hu/07.md

@@ -0,0 +1,35 @@
+1. Sok mindent tanultál eddig, íme egy összefoglaló:
+     * *print* utasítás: ezzel kiírhatsz valamit a képernyőre
+     * változók: ezekben tudsz értékeket tárolni és ezeket bármikor előhívni
+     * szöveg: változóban tárolt érték lehet szöveg (angolul "string")
+	 * egész szám: változóban tárolt érték lehet egész szám (angolul "integer")
+     * matek: a számokkal különböző matematikai műveleteket végezhetsz (*+*, *-*, ***, */*)
+     * *input* utasítás: ezzel bekérhetsz a felhasználótól valamilyen szöveget
+     * *if* utasítás: segítségével feltételhez kötheted egy programrész végrehajtását
+     * *while* ciklus: segítségével addig ismételhetsz egy programrészt amíg valamilyen feltétel teljesül
+
+2. Próbáld felhasználni amit eddig tanultál a következő játék megírásához:
+     * A program választ egy véletlen egész számot 1 és 9 között
+     * A játékosnak 5 próbálkozása van, hogy kitalálja a számot
+     * A program kiírja a játékszabályokat a képernyőre
+     * A program a játékos minden sikertelen próbálkozása után kiírja, hogy a játékos tippje kisebb vagy nagyobb, mint a kitalálandó szám, és hány próbálkozás maradt még
+     * Ha a játékos kitalálja a számot, akkor a program egy győztes üzenetet ír ki
+     * Ha 5 próbálkozásból sem sikerül kitalálni a számot, akkor a program egy vesztes üzenetet ír ki és a játéknak vége
+
+3. A fenti játékot kipróbálhatod a [dojo.soy/py-dice](http://dojo.soy/py-dice) weboldalon.
+
+4. Egy dolgot még nem tanultál, amire szükséged lesz: ez a véletlen szám kiválasztása 1 és 9 között. Az alábbi példa az ehhez szükséges Python utasításokat tartalmazza. Később majd foglalkozunk még véletlen számok létrehozásával, mert ez sok játékban hasznos dolog.  
+
+Legyen ez az első sor a programodban:
+    ```python
+    from random import randint
+    ```
+Ezután bárhol a programban ahol véletlen számra van szükséged, használd a *randint(1,9)* utasítást. Például:
+    ```python
+    titkos_szam = randint(1,9)
+    ```
+
+4. Próbáld megírni a játékot most! Használhatod a korábbi sushi kártyákat. Ha elakadsz vagy ha úgy érzed elkészültél, megnézheted a [dojo.soy/py-guess](http://dojo.soy/py-guess) weboldalon található megoldást. Nem baj, ha a te programod máshogy néz ki, a lényeg, hogy jól működjön! Jó munkát!
+
+    > # Mi a véleményed?
+    Most, hogy befejezted ezt a sushi kártya paklit, kíváncsi vagyok a véleményedre. Ha van pár perced, kérlek, töltsd ki a [dojo.soy/py-beginner](http://dojo.soy/py-beginner) oldalon található kis kérdőívet! Köszönöm!

python/beginner/hu/_data.json

@@ -0,0 +1,65 @@
+{
+  "01": {
+    "title": "Előkészületek",
+    "filename": "01",
+    "language": "python",
+    "subject": "python",
+    "card_number": 1,
+    "series_total_cards": 7,
+    "series_title": "Bevezetés a Python nyelvbe kezdőknek"
+  },
+  "02": {
+    "title": "Az első Python programod",
+    "filename": "02",
+    "language": "python",
+    "subject": "python",
+    "card_number": 2,
+    "series_total_cards": 7,
+    "series_title": "Bevezetés a Python nyelvbe kezdőknek"
+  },
+  "03": {
+    "title": "Beszélgetés a felhasználóval",
+    "filename": "03",
+    "language": "python",
+    "subject": "python",
+    "card_number": 3,
+    "series_total_cards": 7,
+    "series_title": "Bevezetés a Python nyelvbe kezdőknek"
+  },
+  "04": {
+    "title": "Összehasonlítás és feltételes elágazás",
+    "filename": "04",
+    "language": "python",
+    "subject": "python",
+    "card_number": 4,
+    "series_total_cards": 7,
+    "series_title": "Bevezetés a Python nyelvbe kezdőknek"
+  },
+  "05": {
+    "title": "Valódi elágazások",
+    "filename": "05",
+    "language": "python",
+    "subject": "python",
+    "card_number": 5,
+    "series_total_cards": 7,
+    "series_title": "Bevezetés a Python nyelvbe kezdőknek"
+  },
+  "06": {
+    "title": "Ciklusok",
+    "filename": "06",
+    "language": "python",
+    "subject": "python",
+    "card_number": 6,
+    "series_total_cards": 7,
+    "series_title": "Bevezetés a Python nyelvbe kezdőknek"
+  },
+  "07": {
+    "title": "Készíts egy játékot!",
+    "filename": "07",
+    "language": "python",
+    "subject": "python",
+    "card_number": 7,
+    "series_total_cards": 7,
+    "series_title": "Bevezetés a Python nyelvbe kezdőknek"
+  }
+}