diff --git a/python/beginner/hu/01.md b/python/beginner/hu/01.md new file mode 100644 index 0000000..d8b4a8d --- /dev/null +++ b/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. \ No newline at end of file diff --git a/python/beginner/hu/02.md b/python/beginner/hu/02.md new file mode 100644 index 0000000..5e0d015 --- /dev/null +++ b/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. diff --git a/python/beginner/hu/03.md b/python/beginner/hu/03.md new file mode 100644 index 0000000..18dfeb2 --- /dev/null +++ b/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! diff --git a/python/beginner/hu/04.md b/python/beginner/hu/04.md new file mode 100644 index 0000000..9be6c78 --- /dev/null +++ b/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!") + ``` diff --git a/python/beginner/hu/05.md b/python/beginner/hu/05.md new file mode 100644 index 0000000..686084b --- /dev/null +++ b/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!") + ``` diff --git a/python/beginner/hu/06.md b/python/beginner/hu/06.md new file mode 100644 index 0000000..bb03b3f --- /dev/null +++ b/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. diff --git a/python/beginner/hu/07.md b/python/beginner/hu/07.md new file mode 100644 index 0000000..3114800 --- /dev/null +++ b/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! diff --git a/python/beginner/hu/_data.json b/python/beginner/hu/_data.json new file mode 100644 index 0000000..30f0a84 --- /dev/null +++ b/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" + } +} diff --git a/python/beginner/hu/_sushi.json b/python/beginner/hu/_sushi.json new file mode 100644 index 0000000..11ea3b2 --- /dev/null +++ b/python/beginner/hu/_sushi.json @@ -0,0 +1,47 @@ +{ + "serie_title": "Bevezetés a Python nyelvbe kezdőknek", + "language": "hu", + "subject": "python", + "cards": [ + { + "title": "Előkészületek", + "filename": "01", + "card_number": 1 + }, + { + "title": "Az első Python programod", + "filename": "02", + "card_number": 2 + }, + { + "title": "Beszélgetés a felhasználóval", + "filename": "03", + "card_number": 3 + }, + { + "title": "Összehasonlítás és feltételes elágazás", + "filename": "04", + "card_number": 4 + }, + { + "title": "Valódi elágazások", + "filename": "05", + "card_number": 5 + }, + { + "title": "Ciklusok", + "filename": "06", + "card_number": 6 + }, + { + "title": "Készíts egy játékot!", + "filename": "07", + "card_number": 7 + } + ], + "description": "Hungarian translation of the 'Get started with Python' series of sushi cards for beginner Python programming.", + "difficulty": 1, + "author": "CoderDojo Foundation, translation by Levente Buttyán, CoderDojo Szentendre", + "website": "https://coderdojo.com", + "twitter": "CoderDojo" +}