<jupyter_start><jupyter_text>1. előadás_Tartalom_: Python bevezetés, Python 2 vs Python 3, IDE, egyszerű matematika, változók, szintaxis, és logika, ciklusok I., string I.A Python egy népszerű, általános célú, magas szintű szkript nyelv, melyet <NAME> holland programozó publikált 1991-ben. A Python keresztplatformos nyelv, futtatókörnyezete több operációs rendszeren (Windows, Linux, OsX, Android) elérhető. A népszerűségéhez nagyban hozzájárul számos kiegészítőcsomagja, mint a később tárgyalandó numpy, matplotlib, TensorFlow, pyQT, openCV, iPython, stb.A Pythont tanuláshoz és egyszerűbb esetekben használhatjuk interaktívan is, az értelmezővel soronként végrehajttathatjuk az utasításainkat. Persze lehetőségünk van `.py` kiterjesztésű fájlokat készíteni és futtatni is, sőt lehet generálni futtatható fájlt vagy telepítőt. Egyelőre viszont maradjunk az alapoknál, ismerkedjünk a szintaktikával és az egyszerű matematikával. _Megjegyzés_: az előadások során a Jupyter notebookot fogjuk használni ez interaktív python notebook (`.ipynb`) fájlokat hoz létre, amiben a kódok és kimenetek szerkeszthetőek, illetve GitHub-on a legutolsó futás lesz látható. A gyakorlati `.py` kiterjesztésű fájlokhoz a Jupyter notebook nem fog kelleni, ez csak a demonstrációt könnyíti meg._Kedvcsinálóként_ nézzünk meg egy rövid videót, ahogy hogyan használhatjuk a VS code könnyűsúlyú kódszerkesztőjét python scriptek futtatására. Közvetlen link: [youtu.be/QKFjbnWpQ-E](https://www.youtube.com/watch?v=QKFjbnWpQ-E)<jupyter_code># Youtube
from IPython.lib.display import YouTubeVideo
YouTubeVideo('QKFjbnWpQ-E', width = 1000, height = 600)<jupyter_output><empty_output><jupyter_text>Python 2 vs Python 3Sajnos a Python még relatív széles körben használt 2.x változata, és a 2008 óta elérhető 3.x változat között nincs teljes kompatibilitás. Tehát, ha például az interneten ilyen kóddokat találunk:``` pythonprint "Hello, World!"```gyaníthatjuk, hogy Python 2.x -el van dolgunk. Ugyanez a kód Python 3.x-ben így néz ki:``` pythonprint("Hello, World!")```Erről még lesz szó, egyelőre annyit kell tudnunk, hogy ez a segédlet a 3.x verzióval lett tesztelve.<jupyter_code># mivel a Python 2.x és 3.x szintakitiája enyhén eltér ellenőrizzük, hogy a 3-ast használjuk-e
# később további magyarázat lesz ezekről is
import platform
print(platform.python_version())<jupyter_output>3.7.1<jupyter_text>Térjük tehát rá a matematikai alapokra. Egyszerű matematika<jupyter_code>6 * 8 # szorzás
2 ** 10 # hatványozás
100 / 3 # osztás
100 // 3 # egész osztás
52 % 10 # modulo osztás<jupyter_output><empty_output><jupyter_text>Pythonban a megszokott *aritmetikai operátorok* jelen vannak, sőt további hasznosak is.| Operátor| Leírás|         | ------------- |-------------||`+`| összeadás ||`-`| kivonás||`*`| osztás ||`**`| hatványozás ||`//`| egész osztás ||`/`| osztás ||`%`| modulo osztás |A Python a  karakter utáni szöveget a sor végéig megjegyzésnek értelmezi, több soros megjegyzést 3 idézőjellel vagy aposztróffal kezdhetünk és zárhatunk le.```python"""Ez több soros komment"""'''Ez is.'''``` VáltozókA változókba mentett értékek esetén interaktív módban nem jelenik meg a művelet adott eredménye. Pl:<jupyter_code>x = (3 ** 3 ) + 0.2<jupyter_output><empty_output><jupyter_text>De kiírhatjuk például a `print` funkcióval<jupyter_code>print(x)<jupyter_output>27.2<jupyter_text>Python-ban nincs automatikus típus konverzió a változókra, de a  `type` függvénnyel kiírathatjuk egy változó típusát.<jupyter_code>s = "1024"
type(s)<jupyter_output><empty_output><jupyter_text>A következő műveletben sincs automatikus típus konverzió, így hibát kapunk.  `x + s```` pythonTypeError: unsupported operand type(s) for +: 'float' and 'str'```<jupyter_code>type(s)
type(s) is str 
type(x)<jupyter_output><empty_output><jupyter_text>A Python alapvetően 3 numerikus típust ismer: `int`, `float` és `complex`.<jupyter_code>a1 = 120
print(type(a1))

a2 = 12.0
print(type(a2))

a3 = 5 + 1j
print(type(a3))

a4 = float(7)
print(type(a4))<jupyter_output><class 'int'>
<class 'float'>
<class 'complex'>
<class 'float'><jupyter_text>A `sys.float_info.dig` megadja a tizedesjegyek maximális pontosságát.<jupyter_code>import sys
sys.float_info.dig<jupyter_output><empty_output><jupyter_text>A változóinkat integerré konvertálhatjuk, például így:<jupyter_code>x + int(s)
s * 20  # ez nem megszorozza, hanem többszörözi<jupyter_output><empty_output><jupyter_text>Pythonban az osztályokat `StudlyCaps` a konstanasokat `ALLCAPS` a változókat, metódusokat pedig `snake_case` konvenccióval szokás jelölni.   String I.Stringeket többféleképp definiálhatunk: például aposztróffal és idézőjellel is.<jupyter_code>s1 = "Ez az egyik mód."
s2 = 'De ez is működik.'
print(s1, s2)<jupyter_output>Ez az egyik mód. De ez is működik.<jupyter_text>Emlékeztető a karakterkódolásokról:- Az egybájtos karakterkódolások: - *ASCII* » 128 karakter, 7 bit (2^7 = 128) - *Latin-1* » másnéven ISO8859-1 » az első 128 ugyanaz, mint az ASCII, de, utána még 96 betűt használ (160-255 tartományban), így is belefér az egy bájtba (2^8 = 256) » nincs benn magyar ő és ű csak û és õ - *Latin-2* » hasonló a Latin-1-hez, de ebben a magyar ő és ű is megtalálható - *Windows-1250* » ez hasonlít a Latin-2-hez, többek közt a Windows szöveges fájok is használják, konzolos alkalmazásoknál előfordul. - *OEM-852* » konzolban szintén előfordulhat, de nem hasonlít a Latin2-höz- A többbájtos karakterkódolások: - *Unicode* » A Unicode az előzőekkel ellentétben nem egyetlen szabvány, inkább egy szabványcsomag. Az első 128 karaktere ugyanaz, az ASCII-é, de több, mint 120000 karaktert tartalmaz a világ majdnem összes nyelvén. Több bájtos, de az egybájtosról viszonylag könnyen átalakítható kódolás, de vissza már kevésbé, hiszen egy Unicode karakter nem biztos, hogy létezik pl.: Latin-2-ben. További probléma, hogy a 2 bájtot nem minden architektúra ugyanabban a sorrendben tárolja. Ezt a BOM (byte order mark) hivatott jelezni, mely vagy 0xFEFF vagy 0xFFFE. A Unicode szövegeket különböző karakterkódolással tárolhatjuk. A Unicode szabvány meghatározza az `UTF-8`, `UTF-16` és az `UTF-32` karakterkódolást, de számos más kódolás is használatban van. - *UTF-8* » Változó méretű karakterkódolás, 1 bájtos egységeket használ, így nem csak sorrendben, de tényleges bináris kódban is kompatibilis az ASCIIvel, hiszen az egy bájtba beleférő értékeket egy bájton is tárolja. Neve a 8-bit Unicode Transformation Format, 8 bites Unicode átalakítási formátum, ami utal arra, hogy bármilyen Unicode karaktert képes reprezentálni, gyakran használják internet-alapú karakterkódolásra. A `sys.getdefaultencoding()` megadja, mi az alapértelmezett kódolás.<jupyter_code>import sys
print(sys.getdefaultencoding())<jupyter_output>utf-8<jupyter_text>A különbség az aposztróffal és idézőjellel készített stringek között, hogy ``` python"ebben így lehet ' karakter" 'ebben viszont \' kell a visszaper elé''illetve fordítva: itt lehet " '"itt  viszont így: \" "``` Formázott kiíratásA `print` funckió rengeteg lehetőséget ad. Később erre még visszatérünk, most nézzük meg a `sep` elválasztó és az `end` működését példákon szemléltetve.<jupyter_code>print('a','b', 'c', 'da\'sda"as"sd--e')
print("a","b", "c", "deas'aaa'asd")
print("a","b", "c", "de", sep="")
print("a","b", "c", "de", sep="***")
print("x\ny")
print("Ez kerüljön", end=" ")
print("egy sorba.")<jupyter_output>a b c da'sda"as"sd--e
a b c deas'aaa'asd
abcde
a***b***c***de
x
y
Ez kerüljön egy sorba.<jupyter_text>Ciklusok I., alapvető szintaktikaÖsszetettebb kódsorok készítése előtt ki kell emelni a Python azon sajátosságát, hogy a Python programokban a kód blokkokata sor elején található szóközökkel  vagy tabulátorokkal jelöljük. Más nyelvekben a blokk elejét és végét jelölik meg, például C-ben, C++-ban stb. `'{'` és `'}'` zárójelekkel. A nyelv ezen tulajdonsága kikényszeríti a könnyen olvasható kód készítését, másik oldalon nagyobb figyelmet igényel a sorok írásánál. A szóköz és tabulátor karaktereket nem lehet keverni, gyakran négy szóközös tagolást alkalmaznak.<jupyter_code>print("range(6):   \t", end="")
# 0 1 2 3 4 5
for x in range(6):
    print("%4d" % x, end="")
    
print("\nrange(3, 9):   \t", end="")
# 3 4 5 6 7 8
for x in range(3, 9):
    print("%4d" % x, end="") 

print("\nrange(3,14,2):\t", end="")
# 3 5 7 9 11 13
for x in range(3, 14, 2):
    print("%4d" % x, end="")
    

print("\nrange(14,3,-2):\t", end="")
# 14 12 10 8 6 4
for x in range(14,3,-2):
    print("%4d" % x, end="")
    

print("\narray (tömb):\t", end="") 
primes = [2, 3, 5, 7] # ez egy tömb, később erről bővebben
for prime in primes:
    print("%4d"  % prime, end="")


print("\nwhile:\t\t", end="")
# 0  1  2  3  4 
i = 0
while i < 5:
    print("%4d" % i, end="")
    i += 1<jupyter_output>range(6):   	   0   1   2   3   4   5
range(3, 9):   	   3   4   5   6   7   8
range(3,14,2):	   3   5   7   9  11  13
range(14,3,-2):	  14  12  10   8   6   4
array (tömb):	   2   3   5   7
while:		   0   1   2   3   4<jupyter_text>ComprehensionA listaértelmezések (list comprehension) a listák létrehozásának rövidebb módja. _Megjegyzés_: a listákról még később lesz szó.<jupyter_code>print([i for i in range(6)])
print([i for i in range(3,14,2)])
print([2**i for i in range(3,14,2)])<jupyter_output>[0, 1, 2, 3, 4, 5]
[3, 5, 7, 9, 11, 13]
[8, 32, 128, 512, 2048, 8192]
{'fraction_non_alphanumeric': 0.11185057964791756, 'fraction_numerical': 0.033061399742378705, 'mean_word_length': 5.14983498349835, 'pattern_counts': {'":': 0, '<': 59, '<?xml version=': 0, '>': 58, 'https://': 1, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '15', 'dir': 'jupyter-structured-clean-dedup', 'id': '89243', 'license': 'MIT', 'n_tokens_mistral': 4300, 'n_tokens_neox': 4229, 'n_words': 1105, 'path': 'eload/ea01.ipynb', 'repo_name': 'horverno/sze-academic-python', 'size': '9326'}