[[:oktatas:programozás:python|< Python]]

====== Python nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) 2011, Sallai András
  * Szerkesztve: 2011-2023
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0]]
  * Web: https://szit.hu

===== A Python nyelv =====

A Python nyelvet **Guido van Rossum**, holland programozó kezdte
fejleszteni a **Matematikai és Informatikai Központ**
(CWI, Centrum Wiskunde & Informatica) kutatóintézetében, 1989-ben. 

A Python az ABC nyelv utódjaként **1991**-ben jelent meg először.

A Python egy általános célú, magas szintű nyelv, amelyet 
leggyakrabban a következőkre használnak:
  * robotika
  * beágyazott rendszerek
  * Arduino
  * adatelemzés

A Python egy értelmezett nyelv. Idegen szóval interpretált.
Ez azt jelenti, hogy a program terjesztéséhez nem fordítjuk le a programot, a forráskódot terjesztjük. A felhasználó egy .py kiterjesztésű fájlt kap.
A Python interpreter elsőként byte-kódot fordít és azt futtatja.
A bájt-kód gépi kódra fordul, mivel a gép csak azt képes megérteni.

A program névadója a **Monty Python csoport**. 


==== Gyakorlat 001 ====

Kérdések:
  * Ki kezdte el fejleszteni a Python nyelvet?
  * Milyen nemzetiségű programozó kezdte fejleszteni a Python nyelvet?
  * Milyen intézetben dolgozott aki fejleszteni kezdte a Python nyelvet?
  * Mikor kezdődött a Python nyelv fejlesztése?
  * Mikor volt az első kiadása a Python nyelvnek?
  * Milyen nyelv utódjaként jött létre a Python nyelv?
  * Milyen célú a Python nyelv? Válasszon:
    - általános
    - matematikai
    - tudományos
    - mesterséges intelligencia programozás
  * Ki, vagy mi a névadója a Python nyelvnek?

===== Helló Világ =====

Készítsük el az alábbi programot. A fájl neve lehet hello, a kiterjesztése
.py.



<code python hello.py>

print("Helló Világ!")

</code>

Futtatás:
  * Geany programban: F5 billentyű
  * Parancssorból:


  python hello.py


Ha Linuxon telepítve van a python 2-s verziója is, akkor a futtatás 
  python3 hello.py
Futtathatjuk a 2-s python verzióval is, de akkor meg kell adni 
karakterkódolást. 

==== Elemzés ====

A program egyetlen függvényt használ utasításként: print().
A függvények neve után zárójelet írunk, nyit és bezáró zárójelet. 
Egy függvénynek lehetnek paraméterei. A programunknak egyetlen
paramétere van: "Helló Világ!".

A "Helló Világ!" egy karakterlánc. A Python nyelvben a karakterláncokat
aposztrófok vagy idézőjelek közé zárjuk.

A print() függvény a képernyőre írja a paraméterül kapott értéket.




==== Karakterkódolás ====
A **Python 3**-s verziótól az alapértelmezett karakterkódolás az **UTF-8**.
Ha nem UTF-8-al kódoljuk a program forráskódját, szintaktikai
hibát kapunk. Ilyenkor, vagy áttérünk az UTF-8 kódolásra,
vagy meg kell adjuk a használt karakterkódolást. 
Például:
  # coding: iso-8859-2

Ha Python3-t használunk és a szerkesztő karakterkódolása
legyen például **iso-8859-2**, de ez nincs megadva a kódban, akkor
a következő képen látható hibaüzenetet kapjuk.

{{:oktatas:programozas:python:non-utf-8_code.png}}


A 2.x python verziókban, még nem alapértelmezés az UTF-8.
Ilyen python verzió esetén ha nem állítjuk be a kódolást,
és nem ASCII karaktert írtunk, hibajelzést kapunk.
A kódszerkesztőben, szövegszerkesztőben használt 
dokumentum kódolást mindig egyezzen meg a programban
beállítottal. 

A programban a kódolást -- hasonlóan a megjegyzésekhez --
# karakterrel kezdjük, majd coding szó ":" kettősponttal,
majd a kódolás. Ezt a sort mindig a forráskód elejére tesszük.


Latin2 beállítása:

<code python>
# coding: iso-8859-2
</code>

UTF-8 beállítása:
<code python>
# coding: utf8
</code>



Hagyományosan használjuk a "-*-" (kötőjel, csillag, kötőjel) karaktereket is:
<code python>
# -*- coding: <encoding name> -*-
</code>

==== Interpreter ====
Unix alapú rendszereken a legelső sorban megadhatjuk
a Python értelmező útvonalát:

<code python>
#!/usr/bin/python
# -*- coding: utf-8 -*-

print("ok")
</code>
Unixon, Linuxon, BSD és macOS-en azért működik, mert ezeken a rendszereken
úgy derül ki, hogy melyik értelmező hajtja végre az ilyen programot, hogy
kiolvassa a rendszer az első két bájtot. 

Vegyük észre, hogy a Python értelmező teljes, azaz abszolút útvonala van megadva.

Unix alapú rendszeren akkor használjuk az útvonal megadását, ha parancssorból futtatjuk 
a Python programot. Kódszerkesztőt (Például: Visual Studio Code) használva nem szükséges Unix
alapú rendszeren sem megadni.


A Unix alapú rendszereken, az útvonal megadása lehetővé teszi különböző Python verziók használatát. A hármas verziót például:
<code python>
#!/usr/bin/python3
# -*- coding: utf-8 -*-

print("ok")
</code>

Az értelmező útvonalát olvashatjuk a környezetből is:
<code python>
#!/usr/bin/env python
# -*- coding: utf-8 -*-

print("ok")
</code>

Windowson az interpreter beírása hatástalan, de hibát nem okoz.
A Windows operációs rendszerek a kiterjesztés alapján döntik el, 
mivel kell futtatni egy állományt. 

==== Billentyűvárás ====

Fájlkezelőből futtatva a python program azonnal bezáródik. Ha szeretnénk
egy billentyűre várni, használhatjuk az input() függvényt. 

<code python hello.py>
#!/usr/bin/python
# coding: utf8
print("Helló Világ!")

input("Folytatáshoz nyomjon Enter billentyűt...")
</code>

Ügyeljünk arra, hogy az input() függvény valójában nem bármilyen billentyű vár, hanem egy Enter billentyűt.
==== Behúzások ====

A Python nyelven felesleges behúzásokat nem alkalmazhatunk. 
Ha írok önmagában egy utasítást, például <nowiki>print("valami")</nowiki>,
azt kötelező a sor elején kezdeni. Ha akár egyetlen szóközt is
teszek az utasítás elé, futtatáskor hibát kapok. 

  IndentationError: unexpected indent

{{:oktatas:programozas:python:indentationerror.png}}


==== Gyakorlat 002 ====

  * Válaszoljon a kérdésekre:
    * Melyik Python verzióban kötelező karakterkódolás megadása, ha nem ASCII karaktert írunk?
    * Hogyan adjuk meg Unix alapú rendszerek számára az interpreter útvonalát. 
  * Írjon programot, amely kiírja lakhelyének a nevét, és lakcímét.
  * Írjon programot, amely kiírja születési idejét, egy újabb sorba helyét.
  * Miért hatástalan az első sorban megadni Windows rendszeren az értelmezőt?
  * Miért hatékony megadni az értelmezőt, az első sorban egy Unix alapú rendszeren?
  * Ha egyetlen print() utasíátsom van, hány szóköz behúzással írhatom beljebb?
  * A Windows mi alapján dönti el egy állományról, hogy milyen programmal kell futtatni?
  * Mit csinál a print() függvény?
  * Hogyan adunk meg karakterláncot a Python nyelvben?
  * Milyen kiterjesztése van egy Python programnak?
  * Hogyan futtathatunk parancssorból egy Python programot?

  * A következő program, két hibát is tartalmazz. Keresse meg.

{{:oktatas:programozas:python:hiba_feladat_01.png}}

  * A következő program, két hibát is tartalmazz. Keresse meg.

{{:oktatas:programozas:python:hiba_feladat_02.png}}

  * A következő program, hat hibát is tartalmazz. Keresse meg.

{{:oktatas:programozas:python:hiba_feladat_03.png}}


  * A következő program, három hibát tartalmaz. Keresse meg.

{{:oktatas:programozas:python:hiba_feladat_04.png}}

  * A következő program, öt hibát tartalmaz. Keresse meg.

{{:oktatas:programozas:python:hiba_feladat_05.png}}

  * A következő program, két hibát is tartalmazz. Keresse meg.

<code>
#!/usr/bin/python
# coding: utf8

print(Budapest);
print(Kék utca 45.);
</code>

===== Megjegyzés =====
==== Egysoros megjegyzés ====

Egysoros megjegyzéseket tehetünk a kódba a "#" ((Számjel, hashmark, diez, létra vagy kettőskereszt. Az Egyesült Államokban fontjelként használták hagyományosan. Az informatika fejlődésével megjelent Magyarországon is, például a C programozási nyelvben fordítási direktívaként. [[https://hu.wikipedia.org/wiki/Sz%C3%A1mjel]])) jel segítségével.

<code python>
# Megjegyzés
</code>


A megjegyzések állhatnak utasítás után is

<code python>
print("ok") # Megjegyzés
</code>

<code python>
if "joska" in nevek: # Megvizsgáljuk benne van-e
    print("benne van")
</code>

Láthatjuk, hogy a # karakternek többféle szerepe is van:
  * Python interpreter útvonalának megadása.
  * Karakterkódolás beállítása.
  * Megjegyzést.


==== Többsoros megjegyzés ====

A Python nem veszi figyelembe azokat a karaktersorozatokat, 
amelyek nincsenek változóhoz rendelve. Ezért lehetséges
idézőjelekkel több soros megjegyzést készíteni.

Ez azt jelenti, hogy eredetileg nem megjegyzés volt a célja ennek 
formának, de erre használjuk, mivel megengedett.

<code python>
""" 
több
soros
megjegyzés
"""
</code>

<code python>
'''
több
soros
megjegyzés
'''
</code>
==== Gyakorlat 003 ====

  * Írjon programot, amely:
    * kiírja a szerző nevét
    * kiírja az aktuális dátumot
    * a kiíratások előtt megjegyzésben is szerepel a szerző neve és a dátum
  * Megengedi-e a Python nyelv egy utasát után írt megjegyzés használatát?
  * Hogan adhatunk meg egysoros megjegyzést Python forráskódban?
  * Hogyan lehet többsoros megjegyzést írni Python nyelvben?
  * Milyen szerepei van a # karakternek?
===== Kivitel =====

==== A print utasítás ====

Szöveget írathatunk ki idézőjelek és felső vesszők között is:
<code python>
print("Alma")
</code>

<code python>
print('Alma')
</code>

A Python 3.x verziótól, csak zárójellel használhatjuk
a print() utasítást:



A print paramétereként, vesszővel tagolva több érték is megadható:
<code python>
a = 3
print("Szám: ", a)
print("egy", "kettő", "három")
a=30
b=35
c=45
print(a, b, c)
</code>


=== Az end ===

A print() automatikusan  sortörést ír a szöveg végén.
Ha szeretnénk a sortörést tiltani, az end paraméterrel megtehetjük:

<code python>
print('alma', end = '')
print('alma', end = ' ')
</code>

Nem csak sortörést írhatunk a kimenet végére, bármi más megadható.

=== A sep ===

Megadhatunk szeparátort is, ami több paraméter esetén szabályozza, a kiírást.
Ha például vesszővel szeretnék szeparálni a kiírt értékeket, használjuk
a sep paramétert:

<code python>
print(45, 23, 97, sep=",")
</code>

A kimenet:
<code>
45,23,97
</code>

Szeparálás kettősponttal:
<code python>
print(45, 23, 97, sep=":")
</code>

Kimenet:
<code>
45:23:97
</code>

=== A file paraméter ===

A file paraméter segítségével a print() állományba is képes írni.

<code python>
fp = open('dolgozok.txt', 'w')
print('Lali:Szeged:347', file = fp)
fp.close()
</code>


=== Szorzás ===

<code python>
print("-"*5)
</code>

Kimenet:
<code>
-----
</code>


==== sys modul ====

A sys modul egy másik lehetőség a képernyőre íráshoz.

<code python program01.py>
import sys
sys.stdout.write("Valami\n")
</code>

Azokat a változókat amelyek szám értékeket tartalmaznak, át kell 
konvertálni szöveggé:
<code python program01.py>
import sys
szam = 35
sys.stdout.write(str(szam))
</code>

Összevonás más karaktersorozattal:
<code python program01.py>
import sys
szam = 35
sys.stdout.write(str(szam) + " kg")
</code>

==== Gyakorlat 004 ====

  * Válaszoljon a következő kérdésekre:
    * Hány paraméter adható meg a print() függvény számára?
  * A következő programban két hiba van. Keresse meg.

<code python test.py>
print("alma", "körte", Barack)
print("egy";"kettő")
</code>

  * Az alábbiakban két print() utasítást lát. Melyik helyes szintaktikailag?
<code python>
print('alma')
</code>
<code python>
print("alma")
</code>





===== Escape szekvenciák =====
Ha kiíratunk egy karaktert, akkor az megjelenik a képernyőn.
Egyes karaktereket a szokásostól eltérően is értelmezhetünk.
Megjelenés helyett valamilyen változást idézhetnek elő, ha egy
karakternek ilyen speciális jelentést szeretnénk adni, azt az elé
tett vissza-per jellel jelezzük, és a továbbiakban escape szekvenciának
nevezzük.

A következő táblázat bemutatja, milyen escape szekvenciák vannak és azokat
mire használjuk.
|  Escape szekvencia  |  Jelentés  |
| \\\\ | vissza-perjel megjelenítése |
| \' | aposztróf megjelenítése |
| \<nowiki>"</nowiki> | idézőjel megjelenítése |
| \a | ASCII csengőhang |
| \b | ASCII visszatörlés - Backspace (BS) |
| \f | ASCII lapdobás (FF) |
| \n  | ASCII soremelés (LF) |
| \r | ASCII kocsi vissza (CR) |
| \t | ASCII vízszintes tabulátor (TAB) |
| \v | ASCII függőleges tabulátor (VT) |
| \ooo | oktális érték |
| \xhh | hexadecimális érték |
| \uxxxx | karakter kiírása Unicode alapján |
| \Uxxxxxxxx | karakter kiírása Unicode alapján |
| \N{name}  | karakter kiírása Unicode név alapján |



Visszatörlés használata:
<code python>
print("alma\bkörte")
</code>
A fenti utasítás kitörli az alma szó utolsó "a" betűjét. 


Soremelés használata:
<code python>
print("alma\nkörte")
</code>

Tabulátor használata:
<code python>
print("alma\tkörte")
</code>


Karakter kiírása hexadecimális kód alapján:
<code python>
print("\x45")
</code>

==== Gyakorlat 005 ====
  * Mire való a \n escape szekvencia?
  * Mire való a \t escape szekvencia?
  * Mit ír a képernyőre a következő utasítás?
    * print("egy\nkettő")
  * Mire való a \a escape szekvencia?
  * Mire való a \f escape szekvencia?
  * Mire való a \u escape szekvencia?


===== Típusok =====

  * egész
  * valós
  * karaktersorozat
  * logikai
  * None - NoneType

Egész:
<code python>
egesz = 15
</code>

<code python>
valos = 15.1234
</code>


<code python>
gyumolcs = 'alma'
fa = "körte"
</code>


<code python>
ehes_vagyok = True
fazok = False
</code>

<code python>
valami = None
</code>


A típusok lekérdezhetők a type() függvénnyel. Például:

Egész példa:
<code python>
szam = 17
print(type(szam))
</code>

A kimenet:
  <class 'int'>

Valós példa:
<code python>
szam = 17.612345
print(type(szam))
</code>

Kimenet:
  <class 'float'>

Karaktersorozat példa:
<code python>
nev = "Nagy János"
print(type(nev))
</code>

Kimenet:
  <class 'str'>

Logikai példa:
<code python>
szam = 5
eredmeny = szam > 5
print(type(eredmeny))
</code>

Kimenet:
  <class 'bool'>



===== Változóhasználat =====
A változókat használatuk előtt nem kell deklarálni. Egyszerűen csak használnom.
A következő programban, a szam nevű változóba a 3-s egész számot teszem.

<code python>
szam = 3
print("Teszt" , szam)
</code>


Több változó összeadással:
<code python>
szam1 = 3
szam2 = 5
osszeg = szam1 + szam2
print("Összeg: " , osszeg)
</code>


Több változó szöveg összevonásával:
<code python>
szoveg1 = "Szeretem"
szoveg2 = " az almát"
kiirando = szoveg1 + szoveg2
print("Következtetés: " , kiirando)
</code>

A változók típusa attól függ milyen értéket adunk át számára. Ha egész típust 
adunk át akkor int lesz. Ha valós típust, akkor float. Ha szöveget akkor str.

Ha szeretnénk tudni milyen típusú a változónk, akkor a type függvényt használhatjuk:
  print(type(szam1))
Az eredmény: 
  <type 'int'>

Vagy:
  print(type(szoveg1))
Az eredmény:
  <type 'str'>

A float függvény használata:
<code python>
num = float(5)
</code>
A num egy float lesz. 

==== Nevesített állandó ====

A Python nyelv állandó használatát nem támogatja, de a 3.8 verzióban
már van egy typing modul, amiben használhatjuk a Final korlatozót.

A Python futtató így is lefuttatja, vagyis nincs korlátozás, de a
kódszerkesztő aláhúzza.

<code python>
from typing import Final
pi: Final[float] = 3.14159265359
</code>

  * https://www.python.org/dev/peps/pep-0591/

==== Literális állandók ====

Adjunk meg a szam változó számára egy nagyobb egész számot.

<code python>
szam = 2840000
</code>

A jobb átláthatóság kedvéért a szám literálisok tagolhatók:
alulvonással:
<code python>
szam = 2_840_000
</code>


A szöveges literálisokat aposztrófok, vagy idézőjelek között adjuk meg.
Ezek egymásba is ágyazhatók. Ha szeretnénk kiíratni aposztrófot, akkor
idézőjelek között megadhatók. 

<code python>
print("vmi'va")
</code>

<code python>
print('vmi"va')
</code>


==== Gyakorlat 006 ====

  * Milyen típusú lesz a num nevű változó a következő kifejezésben?
    * num = 3.5
  * Milyen típusú lesz a str nevű változó a következő kifejezésben?
    * str = 3.5?
  * Milyen függvénnyel lehet lekérdezni, egy változó milyen típust tárol?




===== Formázott kivitel =====

A formázást három módon oldhatjuk meg:
  * modulo operátor
  * format függvény
  * [[oktatas:programozas:python:python_halado#f-string|f-string]]
==== Modulo operator ====

A print() függvény segítségével az értékek formázva is kiírhatók.
Formázott kimenethez egy formátum stringet kell készíteni. 
A formátum stringben egy vagy több formátumkód adható meg.
A formátumkódot, mindig "%" karakterrel vezetjük be. 
Ezt követi egy formátumkarakter. A formátum karakter
a kiíratandó értéktől függően lehet, d, f, c, s stb.

A formátum string szintaxisa:

<code>
%[jelzők][szélesség][.precizitás]típus 
</code>



Először nézzük meg, különösebb formázás nélkül hogyan íratunk ki egy számot:
<code python>
szam = 3
print("Szám: %d" % szam)
</code>



A következő programban már egy kis formázást is végzünk. 
Egy egész szám íratunk ki 10 helyen.
<code python>
szam = 3
print("Szám: %10d" % szam)
</code>

Ha formázott kivitelt használunk, akkor a formátum karaktersorozat után a szeparátor % jel karakter, a vessző helyett.


Valós szám, két tizedesjegy pontossággal, tíz helyen ábrázolva.
<code python>
szam = 3.12345678
print("Szám: %10.2f" % szam)
</code>


Szöveg kiíratása
<code python>
nev = "körte"
print("Név: %s" % nev)
</code>



Több érték formázása:

<code python>
print("%10d %10d" % (97, 48))
</code>

<code python>
print("Életkor: %s, Fizetés: %f" % (28, 2800000))
</code>

{{:oktatas:programozas:python:formazott_kimenet_01.png|}}

^  Konverziós karakterek  ^^
^  Karakter  ^  Jelentés  ^
|  d  | előjeles decimális egész  |
|  i  | előjeles decimális egész  |
|  o  | előjel nélküli oktális  |
|  u  | Elavult és megegyezik a 'u' karakterrel  |
|  x  | előjel nélküli hexadecimális (kisbetűs)  |
|  X  | előjel nélküli hexadecimális (nagybetűs)  |
|  e  | lebegőpontos formátum  (kisbetűs)  |
|  E  | lebegőpontos formátum  (nagybetűs)  |
|  f  | lebegőpontos decimális formátum  |
|  F  | lebegőpontos decimális formátum  |
|  g  | Mint az 'e' karakter, ha a kitevő nagyobb mint -4, \\ vagy kisebb mint a pontosság, különben 'f'  |
|  G  | Mint az 'E' karakter, ha a kitevő nagyobb mint -4, \\ vagy kisebb mint a pontosság, különben 'F'  |
|  c  | Egyetlen karakter (elfogad egész számot és \\ karaktersorozatot  |
|  r  | String (Bármely python objektum konvertálódik a repr() függvénnyel  |
|  s  | String  (Bármely python objektum konvertálódik a str() függvénnyel  |
|  %  | Argumentumot nem konvertál, de visszatér % karakterrel  |

^  Jelzők  ^^
^  Jelző  ^  Leírás  ^
|  -  | Balra igazítás  |
|  +  | előjel megjelenítése  |
|  0  | Vezető nullák  |
|  #  | Az o, x vagy X mellett az érték előtt:  0, 0o, 0O, 0x vagy 0X |


A #-re minta:

<code python>
print("%#x" % 12)
</code>

Eredmény: 
  0xc

==== format() függvény ====

<code python>
print('{} {}'.format(48, 8400000))
</code>

{{:oktatas:programozas:python:formazott_kimenet_02.png|}}

<code python>
print('{} kg {} Ft'.format(48, 8400000))
</code>



Szélesség (elavult):
<code python>
print('%20d'% 8400000)
</code>


Szélesség (új):
<code python>
print('{:20}'.format(8400000))
</code>



A szöveg alapértelmezetten, balra van igazítva:
<code python>
print('{:10}'.format('8400000'))
</code>


A szöveg jobbra igazítása:
<code python>
print('{:>10}'.format('8400000'))
</code>


A '>' karakter a tartalom jobbra igazítására ad utasítást.




A szám alapértelmezetten jobbra igazodik. Ha szeretnénk balra igazítani:
<code python>
print('{:<10}'.format(8400000))
</code>


Kitöltés, alulvonással:
<code python>
print('{:_<10}'.format('8400000'))
</code>

Középre igazítás:
<code python>
print('{:^15}'.format(8400000))
</code>




A formátum szöveget tehetjük külön változóba:
<code python>
gyumolcs = "Mennyiség: {} kg"
print(gyumolcs.format(16))
</code>


<code python>
gyumolcs = "Mennyiség: {} kg Ár: {} Ft"
print(gyumolcs.format(16, 840))
</code>

Tizedesjegyek megadása:
<code python>
gyumolcs = "Mennyiség: {} kg Ár: {:.2f} Ft"
print(gyumolcs.format(16, 840.12345))
</code>

Szélesség megadása:
<code python>
gyumolcs = "Mennyiség: {:10} kg Ár: {:10} Ft"
print(gyumolcs.format(16, 840))
</code>

Vezető nulla:
<code python>
gyumolcs = "Ár: {:010} Ft"
print(gyumolcs.format(840))
</code>

Ezredes tagolás:
<code python>
gyumolcs = "Ár: {:,} Ft"
print(gyumolcs.format(8400000))
</code>

Előjel:
<code python>
gyumolcs = "Ár: {:+20} Ft"
print(gyumolcs.format(8400000))
</code>

Sorrend megadása:
<code python>
szoveg = "Az ő neve {1}. {1} életkora: {0}"
print(szoveg.format(34, "Mari"))
</code>

<code python>
print('{0} {1}'.format(45, 28))
print('{1} {0}'.format(45, 28))
</code>

Index és formázás együtt:
<code python>
num1 = 35
num2 = 18

print("{1:10} {0:10}".format(num1, num2))
</code>


{{:oktatas:programozas:python:formazott_kimenet_03.png|}}


^  Jelzők  ^^
^  Jelző  ^  Leírás  ^
|  <  | Balra igazítás  |
|  >  | Jobbra igazítás  |
|  0  | Vezető nullák  |
|  ,  | Ezredes elválasztás  |
|  +  | Előjeles ábrázolás  |
|  =  | Csak az előjel balra pozícionálása  |
|  <nowiki>^</nowiki>  | Középre igazítás  |



További formázási lehetőségek: 
  * https://pyformat.info/


==== String metódusok ====

<code python>
print('Valami'.center(20, '='))
</code>

Lehetséges kimenet:
<code>
=======Valami=======
</code>

<code python>
print('Valami'.ljust(20, '='))
</code>

Lehetséges kimenet:
<code>
Valami==============
</code>


<code python>
print('Valami'.rjust(20, '='))
</code>

<code>
==============Valami
</code>


==== Lásd még ====
  * [[oktatas:programozas:python:python_halado#f-string]]

==== Gyakorlat 007 ====
  * A következő program két formázott kimenetet tartalmaz. Határozza meg, melyik a régi stílusú kiíratás.

<code python>
print('{:>10}'.format(45))
print("%10d" % 45)
</code>

  * Mit ír a képernyőre a következő utasítás?

<code python>
print('|{:10}|'.format(45))
</code>


===== Matematikai eszközök =====
==== Natív függvények ====

Azért natív egy függvény, mert nem szükséges külön modult importálni a használatához.
Ilyen függvények a pow(), az abs(), round(), stb.

Hatványozás
<code python>
print(pow(2, 8))
</code>

Abszolút érték:
<code python>
print(abs(-9))
</code>


<code python>
print(round(15.61234))
</code>
Kimenet:
  16


<code python>
print(round(15.61234, 2))
</code>

Kimenet:
  15.62


==== A math modul ====

A matematikai modul használatához, importálnunk kell a math modult.  

Gyökvonás és importálás:
<code python>
import math
print(math.sqrt(9))
</code>
Így importálva, mindig elé kell írni a math objektumnevet. 

<code python>
import math
print(math.pow(2, 8))
</code>

<code python>
import math
szog = 1
rad = szog * math.pi / 180
print(math.sin(rad))
print(math.cos(rad))
print(math.tan(rad))
</code>


<code python>
import math
print(math.ceil(4.1))
print(math.floor(4.9))
</code>




=== Statikus importálás ===


Az sqrt statikusan importálva:
<code python>
from math import sqrt
print(sqrt(9))
</code>



Vegyük észre hogy fentebb csak az sqrt függvényt importáltuk a math modulból. 
Megadhatunk egy vagy több függvényt is vesszővel elválasztva. 

A következőkben a sqrt() és a sin() függvényt is importáljuk:
<code python>
from math import sqrt,sin,pi
print(sqrt(9))
print(sin(1 * pi / 180))
</code>

A "*" karakterrel a math modul összes függvényét importáljuk.

Az összes függvény importálása:
<code python>
from math import *
print(sqrt(9))
print(sin(1 * pi / 180))
</code>


Most nézzünk néhány függvényt. Koszinusz számítása:
<code python>
import math
szog = 1
rad = szog * math.pi / 180
print(math.cos(rad))
</code>


Tangens:
<code python>
import math
szog = 1
rad = szog * math.pi / 180
print(math.tan(rad))
</code>

Kerekítés felfelé: 
<code python>
import math
print(math.ceil(5.1))
</code>

Kerekítés lefelé: 
<code python>
import math
print(math.floor(5.9))
</code>

Szög konvertálása radiánba:
<code python>
import math
print(math.radians(1))
</code>

Radián konvertálása szöggé:
<code python>
import math
print(math.degrees(0.017453292519943295))
</code>

Hatványozás:
<code python>
import math
print(math.pow(2, 8))
</code>
A math.pow() lebegőpontos értékekhez megfelelő.
A pow() és a <nowiki>**</nowiki> operátor egész értékekhez. 


Több információ:
  * https://docs.python.org/3.7/library/math.html (2020)

==== Gyakorlat 008 ====

  * Válaszoljon a következő kérdésekre:
    * Milyen függvénnyel tudjuk kiszámítani, 8-nak a 12-dik hatványát.
    * Milyen modult kell importálni, szinusz számításához?
===== Véletlen szám =====
==== random() függvény ====

<code python>
import random
print(random.random())
</code>


<code python>
from random import random
print(random())
</code>


Egy 12 darab tizedesjegyből álló lebegőpontos számot generál.

Például:
  0.00727745707987


==== Randrange ====

A randrange használatához importálnunk kell a random modult:
<code python>
import random
</code>

Szintaxis:
  random.randrange([start,] stop[, step])


Példák:

0-tól -- 5-ig számok:
<code python>
print(random.randrange(6))
</code>

Megadható alsó határ is. 10-től -- 14-ig számok:
<code python>
print(random.randrange(10, 15))
</code>

iterálva:
<code python veletlenek.py>

import random

for szam in range(20):
	print(random.randrange(3))
</code>


A randrange elfogad egy harmadik paramétert is.
A random.randrange(3,13,3) a 3, 6, 9, 12 sorozat elemek valamelyikét adja vissza.

==== Randint ====

  random.randint(a, b)
Visszatér egy egész N számmal, amely a <nowiki><= N <=</nowiki> b. 
A randrange(a,b+1) formával azonos.


Példa:
<code python dobokocka.py>
import random

# 1-től -- 6--ig szám előállítása:
print(random.randint(1,6))
</code>





Megjegyzés:
Ne adjuk a futtatható állomány nevének a random szót, mert akkor ebből a fájlból akarja importálni a random objektumot.

==== choice() ====

<code python>
seq="abcd"
random.choice(seq)
</code>

<code python>
print(random.choice("abcd"))
</code>

A sorozatból választ egy elemet. A fenti példában tehát "a","b","c" vagy "d"-t ad majd vissza.


  * http://docs.python.org/py3k/library/random.html#random.choice



==== seed() ====
Az álvéletlenszám-generátor egy matematikai függvény, amely 
véletlenszerű számok sorozatát adja.

A sorozat indításához szükség van egy magra. A függvény determinisztikus,
vagyis ugyanazon mag esetén, ugyanazt a végeredményt kapjuk.

A seed() függvény előkészíti az álvéletlenszám-generátort. 
Paraméterként megadhatunk egy véletlen számot. 
Alapértelmezett az aktuális idő, másodpercekben, az 1970 óta eltelt
másodpercek száma.


A következő program, generál 3 véletlen számot. Mivel ugyanazzal a 
értékkel készítem elő, a következő véletlen szám sorozat ugyanazt adja.
<code python>
from random import seed
from random import random

seed(1)
print(random(), random(), random())
seed(1)
print(random(), random(), random())
</code>

Lehetséges kimenet:
<code>
0.13436424411240122 0.8474337369372327 0.763774618976614
0.13436424411240122 0.8474337369372327 0.763774618976614
</code>

10 véletlenszám generálása:
<code python>
from random import seed
from random import random
seed(1)
for _ in range(10):
    vel = random()
    print(vel)
</code>

Lehetséges kimenet:
<code>
0.13436424411240122
0.8474337369372327
0.763774618976614
0.2550690257394217
0.49543508709194095
0.4494910647887381
0.651592972722763
0.7887233511355132
0.0938595867742349
0.02834747652200631
</code>

===== Operátorok =====
==== Aritmetikai operátorok ====

  +  összeadás
  - kivonás
  * szorzás
  / osztás
  // egész osztás
  % maradékképzés (moduló)
  ** hatványozás      Három a második hatványon: 3**2

==== Logikai operátorok ====
  and  és
  or   vagy
  not  tagadás

Zárójelek használatával egy lehetséges példa:  
  (A and (not B)) or C

==== Relációs operátorok ====
  >
  <
  >=
  <=
  ==
  !=

==== Precedencia ====


^  Precedencia  ^^
| ()  | zárójelek  |
| <nowiki>**</nowiki>  | hatványozás  |
| +x, -x, ~x  | unary plusz és mínusz, bitenkénti nem  |
| <nowiki>*, /, //, %</nowiki> | szorzás, osztás, egész osztás, maradék |
| +, -  | összeadás, kivonás  |
| <nowiki><<, >></nowiki>  | bitmozgató shift operátorok  |
| &  | bitmozgató AND |
| <nowiki>^</nowiki>  | bitmozgató XOR |
| <nowiki>|</nowiki>  | bitmozgató OR  |
| <nowiki>==, !=, >, >=, <, <=,</nowiki> is, is not, in, not in  | összehasonlítók  |
| not | logikai nem  |
| and | logikai és  |
| or  | logikai vagy  |

Még több operátor:
  * [[https://docs.python.org/3/reference/expressions.html#operator-precedence|https://docs.python.org]]


==== Egyéb operátorok ====

Az is operátor két primitív típus esetén, tulajdonképpen egyenlőséget vizsgál.
Objektumok esetén, viszont arról tájékoztat, egyetlen objektum két hivatkozásáról
van-e szó.

A not negálja egy logikai kifejezés értékét. 
<code python>
not szam1 > 100
</code>

Az is és a not használható együtt. Például:
<code python>
szam is not 100
</code>

===== Konvertálás =====


==== Sztring valóssá ====
A konvertáláshoz a float() függvényt használjuk:
  a = "123.12345"
  float(a)


<code python konvert.py>
szamStr = "343.34521"
szam = float(szamStr)
print("Szám: ", szam*2)
</code>

==== Sztring egésszé ====
  a = "123.12345"
  int(float(a))

<code python konvert.py>
#!/usr/bin/python3

szamStr = "343.34521"
szam = int(float(szamStr))
print("Szám: ", szam*2)
</code>

<code python konvert.py>
#!/usr/bin/python3

szamStr = "345"
szam = int(szamStr)
print("Szám: ", szam*2)
</code>

==== Egész sztringgé ====

<code python konvert.py>
#!/usr/bin/python3

szam = 345
szamStr = str(szam)
print("Szám: ", szamStr + " db")
</code>

==== Valós sztringgé ====

<code python konvert.py>
#!/usr/bin/python3

szam = 345.12345
szamStr = str(szam)
print("Szám: ", szamStr + " kg")
</code>

===== Bevitel =====

<code python program01.py>
szam = int(input("Szám: "))
print(szam * 2)
</code>

Szöveg bekérése:
<code python>
szoveg = input("Szöveg: ")
</code>

Egész szám bekérése: 
<code python>
eszam = int(input("Egész szám: ")
</code>

Valós szám bekérése:
<code python>
vszam = float(input("Valós szám: ")
</code>


Két szám bekérése, összeadása:
<code python>
szam1 = int(input('Szám1: '))
szam2 = int(input('Szám2: '))
eredmeny = szam1 + szam2
print('Eredmény: ', eredmeny)
</code>


Az input() függvény használható paraméter nélkül is:
<code python>
print("Szám: ", end='')
szam = int(input())
print(szam * 2)
</code>
A példában, a bekérő szöveget print() függvénnyel íratjuk ki.


Régi forma:
<code python>
szoveg = raw_input("Szöveg: ")
</code>

===== Szekvencia =====
A szekvenciális tevékenység, csak annyit jelent, hogy egymás után sorba írjuk az utasításokat, és azok egymás után végrehajtódnak. 

  tevékenység1
  tevékenység2
  tevékenység3

A Python nyelvben fontos, hogy az utasításokat nem írhatjuk behúzással indoklás nélkül. 
Behúzással akkor írhatjuk, hogy az utasítás egy szelekciós, iterációs vagy más blokk
részét képezi.

A pontosvessző (;) megengedett, de nem követelmény:
  tev1
  tev2
  tev3;
  tev4

Ha egy sorba több utasítást írunk, akkor a két 
utasítás közzé szükséges a pontosvessző.
  tev1; tev2;

  tev1; tev2


===== Szelekció =====

==== Általánosan ====
A szelekciót az if kulcsszóval kezdjük. 
Ezt követi a feltétel. A feltételt egy (:) kettőspont
karakterrel kell zárni. 

<code python>
if feltétel:
    tevékenység
</code>

Ha ellenben ág is létrehozható, az else kulcsszóval.
Az else után (:) kettőspontot írunk:

<code python>
if feltétel:
    tevékenység
else:
    tevékenység2
</code>

A több ágú szelekció számára a Python egy elif kulcsszót 
biztosít. Az elif ugyanúgy használható mint az if, a végén itt is (:) kettőspont karakter. 

Több ágú szelekció általánosan:
<code python>
if feltétel:
    tevékenység
elif feltétel2:
    tevékenység2
else: 
    tevékenység3
</code>

==== Példák ====

<code python>
a = 3
if a > 0:
    print "Pozitív"
elif a < 0:
    print "Negatív"
else
    print "Nulla"
</code>


Több utasítás a szelekcióban

Azt szeretnénk, ha az "a" változó kisebb mint nulla akkor írja ki egy utasítás, hogy "Negatív szám", majd egy másik utasítás: "Nem jó nekünk". A szelekció ezzel véget ér, egy olyan utasítás jön ami már nem tartozik a szelekcióhoz, amely azt írja ki: "Folytatás...". Ez utóbb utasítás tehát mindenképpen végre kell hajtódjon. 

<code python>
if a < 0:
    print "Negatív szám"
    print "Nem jó nekünk"
print "Folytatás..."
</code>

Vegyük észre, hogy nincs blokk nyitó és blokk záró. Hogy a blokk még tart, jelzi a folyamatos beljebb kezdés. Ha a blokkot véget ért, akkor az if utasítással egy vonalban folytatjuk a következőt. A könnyebb érthetőség kedvéért hasonlítsuk össze a következő két programot:

<code python>
a = 5
if a < 0:
    print "Negatív szám"
    print "Nem jó nekünk"
print "Folytatás..."
</code>

<code python>
a = 5
if a < 0:
    print "Negatív szám"
print "Nem jó nekünk"
print "Folytatás..."
</code>

Futtassuk le, és nézzük meg mi a kettő különbsége. 

==== Relációs operátorok használata a szelekcióban ====

<code python>
szam = 9
if szam % 2 == 0:
    print "páros"
else:
    print "páratlan"
</code>

==== Boolean változó ====


A feltétel lehet egy boolean változó is:
<code python>
szam = 30
paros = szam % 2 == 0
if paros:
    print("Páros")
else:
    print("Nem páros")
</code>


===== Iteráció =====



==== while ====

A while egy ciklusutasítás. Használhatjuk ha tudjuk hányszor fordul a ciklus, de akkor is ha nem tudjuk hányszor fordul.


A while-t úgy használjuk, hogy utána írok egy feltételt. Ha feltétel igaz, végrehajtódik a 
ciklus törzs része, ha hamis, akkor vége a ciklusnak. 

A ciklus törzsének végrehajtása után a Python újból megvizsgálja, hogy
érvényes-e még a feltétel. Ha igen, újból végrehajtja a törzs részt. 


Ebben példában egy i változót hozunk létre. A ciklushoz érve
megvizsgáljuk, hogy a i<10 igaz-e. Mivel igaz, a ciklus törzse
végrehajtódik: növeljük az i értékét, 1-el, majd kiírjuk az i
értékét és a "Valami" szót. Ez ismétlődik, amíg az i<10 igaz.


<code python>
i = 0
while i < 10:
    i = i + 1
    print( i, " Valami")
print "Vege"
</code>


A while ciklus különleges a Python nyelvben, mert mondhatok a végén egy else:-t.

<code python>
szam = 0
while szam<5:
    print(szam)
    szam += 1
else:
    print('vége')
</code>

Amikor a ciklus véget ér, az else ág utáni rész hajtódik végre. 

A ciklusból kiléphetünk a break utasítással. 

A következő program számokat vár 0 végjelig, de kilép a 10 esetén is:

<code python>
szam = -1
while szam != 0:
    szam = int(input('Szám: '))
    if szam == 10:
        break
</code>


Ha programból is ki akarunk lépni:
  exit()
  quit()
  sys.exit()    # importálás szükséges: import sys
  os._exit(0)    # importálás szükséges: import os

Az os._exit() függvény 0-tól eltérő értékkel is visszatérhet.


==== for ====

Az in kulcsszó után felsoroljuk a számokat:
<code python>
for i in 1, 2, 3, 4, 5:
    print(i)
</code>
Az i változóban sorra megkapjuk a számokat.

A számokat szögletes zárójelbe is tehetjük:
<code python>
for i in [1, 2, 3, 4, 5]:
    print(i)
</code>

A számoknak nem kell rendezettek legyenek:

<code python>
for i in 25, 2, 9, 45, 52:
    print(i)
</code>


A kimenet:
<code>
25
2
9
45
52
</code>


Szöveg is lehet a számok helyett:

<code python>
for gyumolcs in 'alma', 'körte', 'barack':
    print(gyumolcs)
</code>


<code python>
lista = ['macska', 'ablak', 'utca']
for b in lista:
    print(b)
</code>


<code python>
# Kiírja 4-szer a 'Helló Világ' szöveget

for n in range(1, 5):
	print("Helló Világ")
</code>



<code python>
for n in range(1, 5):
	print(n, end=' ')

# A következő sorozatot állítjuk elő:
# 1 2 3 4
</code>

<code python>
for n in range(5):
	print(n, end=' ')

# A következő sorozatot állítjuk elő:
# 0 1 2 3 4
</code>



==== Intervallum ====
A range segítségével listákat hozhatunk létre:
<code python>
# [0,1,2,3,4,5,6,7,8,9] listát hozzuk létre

lista = range(10)

# Most járjuk be a listát:
for szam in lista:
    print(szam)
</code>

Előállíthatunk 5-től -- 12-ig számokat:
  range(5,13)
[5, 6, 7, 8, 9, 10, 11, 12]

3-tól -- 15-ig, hármasával:
  range(3,16,3)
[3, 6, 9, 12, 15]



==== Iterációk ====
A számokat kiíratjuk 0-tól -- 9-ig
<code python>
for i in range(10):
    print(i)
</code>

===== Szövegkezelés =====
==== Karakter ====
A karakterek áttekintését kezdjük Python Shell segítségével. Indítsuk el a Python Shellt:
  python3


Python Shellben próbáljuk ki a chr() függvényt. 

<code python>
>>> chr(97)
'a'
>>> chr(35)
'#'
</code>

<code python>
>>> chr(8364)
'€'
>>> chr(8721)
'∑'
</code>


<code python>
>>> ord('a')
97
</code>

Az ord() visszaadja a Unicode értéket is:
<code python>
>>> ord('€')
8364
</code>


==== Konkatenálás ====

<code python>
szoveg3 = szoveg1 + szoveg2
</code>



==== Hossz ====

Szöveg hossza:
<code python>
szoveg = "körte"
print(len(szoveg))
</code>

Eredmény: 
  5

==== Karakterenként ====

<code python>
szoveg = 'szilva'
betu = szoveg[0]
</code>

A fenti program, az "s" betűt adja eredményül. Az szoveg[1] a "z" betűt adja, stb.

{{:oktatas:programozas:python:string_indexek.png|}}

A karakterláncok tagjait negatív indexel is megadhatjuk.

{{:oktatas:programozas:python:string_indexek_02.png|}}


=== Bejárás ===

<code python>
szoveg = 'valami'
for karakter in szoveg:
    print(karakter)
</code>


<code python>
szoveg='valami'
hossz=len(szoveg)
for i in range(1, hossz):
    print(szoveg[i])
</code>


==== Karakterlánc szeletek ====

<code python>
>>> gy = 'szilva'
>>> gy[2:5]
'ilv'
</code>

<code python>
>>> gy = 'szilva'
>>> gy[:3]
'szi'
</code>

<code python>
>>> gy = 'szilva'
>>> gy[3:len(gy)]
'lva'
>>> 
</code>

Új hivatkozás létrehozása:
<code python>
>>> gy = 'szilva'
>>> id(gy)
140327646241600
>>> gy2 = gy[:]
>>> id(gy2)
140327646241600
>>> gy is gy2
True
</code>
Látszik, hogy nem jött létre új karakterlánc, csak az előzőre egy újabb hivatkozás.
Ha új értéket adok a gy számára, akkor viszont új karakterlánc jön létre.

=== Kódból ===

A karaktersorozat vége a 6-s indextől:
<code python>
szoveg = 'Kati, Lajos, Mari'
resz = szoveg[6:]
print(resz)

</code>
Eredmény: Lajos, Mari

A 6-s indextől a 9-s indexig:
<code python>
szoveg = 'Kati, Lajos, Mari'
resz = szoveg[6:9]
print(resz)
</code>
Eredmény: Laj

A 9-s indexig, a karaktersorozat eleje:
<code python>
szoveg = 'Kati, Lajos, Mari'
resz = szoveg[:9]
print(resz)
</code>
Eredmény: Kati, Laj


==== Darabolás ====

A split() függvény képes darabolni tömbbe és külön változókba is.

<code python>
tomb = szoveg.split()
</code>

Megadhatjuk a szeparátort:
<code python>
szoveg = "alma:körte:barack"
tomb = szoveg.split(':')
</code>

Rakhatjuk külön változókba is:
<code python>
szoveg = "alma:körte:barack"
elso, masodik, harmadik = szoveg.split(':')
</code>

Whitespace karakterek esetén, elég így:
<code python>
szoveg = "alma körte barack"
elso, masodik, harmadik = szoveg.split()
</code>

Tárolás változókban újra:
<code python>
dolgozo = 'Nagy János:Szolnok:3840000'
(nev, telepules, fizetes) = dolgozo.split(':')
</code>

==== Benne van-e? ====

Egy szövegben keresünk egy részt. 
A következő példában a "farkas" 
szót keressük a "sor" nevű változóban:

<code python>
sor = "vi farkas más"
if "farkas" in sor:
	print("ok")
</code>

Az if szerkezetnek lehet ellenben ágaz is. 
==== Keresés ====
A **find()** visszaadja a keresett szöveg helyét indexként. Indexelés 0-tól kezdődik.

<code python>
szoveg = 'Mari, Kati, Lajos'
print(szoveg.find('Kati'))
</code>

Eredmény: 6

Ha a keresett szöveg **nem található**, akkor **-1-t ad vissza**.

Az **index()** függvény ugyanezt csinálja, de **ha nem található** a 
keresett szöveg, akkor **ValueError kivételt dob**. 

<code python>
szoveg = 'Mari, Kati, Lajos'

try:
    print(szoveg.index('Kaati'))
except ValueError:
    print('A szöveg nem található!')
else:
    print('Találat')
</code>

==== Karakterek osztályozása ====

Szám?
<code python>
szoveg = '6'
print(szoveg.isdigit())
</code>

Csak számok és betűk?
<code python>
szoveg = '6'
print(szoveg.isalnum())
</code>

Csak betűk?
<code python>
szoveg = '6'
print(szoveg.isalpha())
</code>

Csak kisbetűs?
<code python>
szoveg = '6'
print(szoveg.islower())
</code>


Csak nagybetűs?
<code python>
szoveg = '6'
print(szoveg.isupper())
</code>


Cím? Vagyis minden szó nagybetűvel kezdődik?
<code python>
szoveg = '6'
print(szoveg.istitle())
</code>

Whitespace karakterek?
<code python>
szoveg = '6'
print(szoveg.isspace())
</code>

Nyomtatható karakterek:
<code python>
szoveg = '6'
print(szoveg.isprintable())
</code>




==== Csere ====

Töröljük a bekért IP címből a pontokat:

<code python>
ip=input("IP cím: ")
ipDigitsStr=ip.replace('.','')
</code>


==== Részszöveg megszámolása ====

**Hányszor** fordul elő a **Lajos** név a szövegben?

<code python>
szoveg = 'Kati, Lajos, Mari, Lajos'
darab = szoveg.count('Lajos')
print(darab)
</code>


==== A whitespace karakter törlése ====
Használható függvények:
  * strip()
  * rstrip()
  * lstrip()

Ha fájlokból olvasunk, a sortörés is beolvasásra kerül. 

<code python>
fp = open('adat2.txt', 'r')
line = fp.readline() 
while line != '':
    print(line.strip())
    line = fp.readline()
fp.close()
</code>


==== Tömb karaktersorozattá ====

<code python>

lista1 = ['a', 'b', 'c']
str1 = ''.join(lista1)

print(str1)
</code>

Szeparáljuk : karakterrel:
<code python>

lista1 = ['a', 'b', 'c']
str1 = ':'.join(lista1)

print(str1)
</code>

<code python>
lista1 = []
lista1.append('egy')
lista1.append('kettő')
lista1.append('három')
szoveg = ':'.join(lista1)
</code>

==== Kezdet ====

Milyen karakterrel kezdődik egy szöveg?

<code python>
szo = 'alma'

if szo.startswith('a'):
    print('a-val kezdődik')
else:
    print('Mással kezdődik')

</code>

Több karakter vizsglata:

<code python>
szo = 'almát ennék'

if szo.startswith('alm'):
    print('almát enne')
else:
    print('mást enne')
</code>

==== Vég ====

<code python>
szoveg = 'alma'

if szoveg.endswith('a'):
    print('a-ra végződik')
else:
    print('másra végződik')
</code>

==== Beépített függvények ====

Első betű nagybetű:
<code python>
szoveg.capitalize()
</code>


Minden kisbetűs:
<code python>
szoveg.lower()
</code>


Minden nagybetűs:
<code python>
szoveg.upper()
</code>

Minden szó első betűje nagybetű:
<code python>
szoveg.title()
</code>

A nagy volt legyen kicsi, ami kicsi volt legyen nagy:
<code python>
szoveg.swapcase()
</code>


===== Tömbök =====

A Python nyelvben nincs a tömb közvetlenül támogatva, helyette használjuk a listát.
==== Lista ====
A listák több elemet tartalmazhatnak. Valójában objektumok,
vagyis az értékadásnál referenciát adunk át, és vannak 
metódusai is.

A listák változtathatók és nem feltétlenül homogének. 
A számok közzé például tehetek karaktersorozatot,
keveredhetnek az egész és valós számok.


=== Vektor ===

Üres lista:
<code python>
egyLista = []
</code>



Lista létrehozása és kiíratása:
<code python>
egyList = [3, 8, 5, 6, 2, 9]
print(egyList)
</code>

Elem átírása:
<code python>
egyLista = [3, 8, 5, 6, 2, 9]
egyLista[1] = 12
</code>



Hivatkozás egy elemre:
<code python>
egyList = [3,5,6,7]

print("Első elem: ", egyList[0])
print("Második elem: ", egyList[1])
</code>


Nézzük a listákat Python shellben:
<code>
>>> # egyik elem:
...
>>> [3, 5, 2][1]
5
>>> # nevesítve, tartalmának kiíratása:
...
>>> szamok = [3, 5, 2]
>>> szamok
[3, 5, 2]
>>> #másolat
...
>>> szamok[::]
[3, 5, 2]
>>>
>>> #a másolat harmadik értékét megváltoztatom
>>> szamok[::][2] = 8
>>> szamok
[3, 5, 2]
>>>
>>> #fordítás
>>> szamok[::-1]
>>> 
>>> # szöveg is megfordítható
>>> 'valami'[::-1]
'imalav'
</code>



Egyenlőség vizsgálat; értékük egyenlő:
<code python>
egyLista == kettoLista
</code>


Ugyanarra mutat?:
<code python>
egyLista is kettoLista
</code>



Listák összefűzése:
<code python>
egyLista = [3,5,6,7]
kettoLista = [8,4,9]
haromLista = egyLista + kettoLista
</code>


Listák összefűzése ciklussal:
<code python>
egyList = [ 35, 40, 27 ]
kettoList = [43, 27, 85 ]

for elem in kettoList
    egyList.append(elem)

print(egyList)
</code>


Listák összefűzése az extend() függvénnyel:
<code python>
egyList = [ 'a', 'b', 'c' ]
kettoList = [43, 27, 85 ]

egyList.extend(kettoList)

print(egyList)
</code>





Méret:
<code python>
print(len(egyList))
</code>

Feltöltés számokkal:
<code python>
egyLista = []
egyLista.extend(range(1, 60))
</code>



Bejárás:
<code python>
egyList = [30, 41, 27, 19, 45, 35, 87, 53, 17]
for elem in egyList:
    print(elem)
</code>


Karakterlánc lista bejárásra példa:

<code python bejar.py>
# Készítünk egy listát:
nevsor = ['Jóska','Kati','Mari','János','Gábor']
 
# Bejárjuk:
for nev in nevsor:
    print(nev)
</code>

Kimenet:
<code>
Jóska
Kati
Mari
János
Gábor
</code>



<code python bejar.py>
# Készítünk egy listát:
nevsor = ['Jóska','Kati','Mari','János','Gábor']

# Bejárjuk:
for index in range(len(nevsor)):
    print index, nevsor[index]
</code>

Kimenet:
<code>
0 Jóska
1 Kati
2 Mari
3 János
4 Gábor
</code>





Tartalmazás:
<code python>
if 45 in egyList:
    print("Van 45")
</code>


Hozzáfűzés:
<code python>
egyList = []
egyList.append(9)
egyList.append(4)
 
print("Első elem: ", egyList[0])
print("Második elem: ", egyList[1])
</code>



Beszúrunk egy elemet 1-s indexel:
<code python>
egyList = [3, 8, 5, 6, 2, 9]
egyList.insert(1, 23)
print(egyList)

kettoList = ['körte', 'szilva', 'barack' ]
kettoList.insert(1, 'alma')
print(kettoList)
</code>

Kimenet:
<code>
[3, 23, 8, 5, 6, 2, 9]
['körte', 'alma', 'szilva', 'barack']
</code>



Elem törlése:
<code python>
egyList = [3, 8, 5, 6, 2, 9]
egyList.remove(8)
print(egyList)
</code>

Utolsó elem törlése:
<code python>
egyList.pop()
</code>

Első elem törlése:
<code python>
egyList.pop(0)
</code>


Az összes elem törlése:
<code python>
egyList = [ 35, 40, 27 ]
egyList.clear()
print(egyList)
</code>

Index lekérdezése:
<code python>
egyList = [3, 8, 5, 6, 2, 9]
index = egyList.index(2)
print(index)
</code>
A mintaprogramban a 2 számot keressük, szeretnénk megtudni mi az indexe.


Másolás:

<code python>
egyList = [ 35, 40, 27 ]
kettoList = egyList.copy()
print(kettoList)
</code>

A másolást a list() függvénnyel is elvégezhetjük:
<code python>
egyList = [ 35, 40, 27 ]
kettoList = list(egyList)
print(kettoList)
</code>

Másolás harmadik módon:
<code python>
egyList = [ 35, 40, 27 ]
kettoList = egyList[::]
print(kettoList)
</code>



A másolás nem végezhető el egy egyszerű értékadással.

Készítsünk egy listát:
<code python>
egyLista = [ 3, 4, 5, 8]
masikLista = egyLista
print(masikLista)
</code>
Az eredmény egyezik. Viszont, ha most új értéket adok az eredeti listának,
a változtatás a másik listában is megtörténik. Lényegében egyetlen listánk
van, de két néven érhető el.

<code python>
egyLista = [ 3, 4, 5, 8]
masikLista = egyLista
print(masikLista)

egyLista[2] = 20
print(masikLista)
</code>


Első és utolsó elem törlése szeleteléssel:
<code>
egyLista = [ 3, 4, 5, 8]
masikLista = egyLista[1:-1]
</code>
Marad: [ 4, 5 ]






Listát létrehozhatunk a list() konstruktorral is. 

Konstruktor használata:
<code python>
egyList = list((35, 40, 27))
print(egyList)
</code>

^  A listán alkalmazható függvények ^^
| append()  | Hozzáadás listához  |
| clear()  | Elemek törlése  |
| copy()   | Lista másolása  |
| count()  | Egy elem megszámolása |
| extend()  | Elemek hozzáadása egy listához |
| index()  | Az első talált elem indexe  |
| insert()  | Hozzáadás adott pozícióba  |
| pop()    | Elem törlése adott pozícióból  |
| remove()  | Adott érték törlése  |
| reverse()  | A lista sorrendjének megfordítása  |
| sort()    | Lista rendezése  |


=== Mátrix ===

A listák újabb listákat tartalmazhatnak.
Ekkor mátrixról beszélünk:

<code python>
matrixList = [[1,1,1],[1,1,1],[1,1,1]]
print(matrixList[0][0])
</code>


A mátrix típusú lista mérete:
<code python>
matrixList = [[2,1,7],[9,3,8],[5,3,1], [5,6,8]]
print(len(matrixList))
</code>

Eredmény:
<code>
4
</code>

Mátrix bejárása:

<code python matrix_bejar.py>
matrix = [[2,1,7],[9,3,8],[5,3,1], [5,6,8]]

for vektor in matrix:
    count = 0
    for num in vektor:
        print(num, end=' ')
        count += 1
        if count == 3:
            print()
</code>

A futtatás kimenete:
<code>
2 1 7 
9 3 8 
5 3 1 
5 6 8 
</code>

==== Tuple ====
A tuple olyan értékek listája, amelyek értéke
nem változtatható. Az elemek száma is állandó.
Igaz, hogy egy tuple szerepelhet egy érték adás
baloldalán, de ekkor a háttérben egy új tuple jön létre.


Üres tuple:
<code python>
egyTuple = ()
</code>

Egy elemű tuple:
<code python>
egyTuple = (25,)
</code>



<code python>
egyTuple = (3, 8, 5, 6, 2, 8)
</code>

Hozzáférés egy elemhez:
<code python>
print(egyTuple[0])
</code>

Negatív index:
<code python>
print(egyTuple[-1])
</code>

A 8-s értéket adja. A -2 a 2-s értéket adja. 

Tartomány:
<code python>
print(egyTuple[2:5])
</code>

5-ig:
<code python>
print(egyTuple[:5])
</code>

2-től:
<code python>
print(egyTuple[2:])
</code>

Tartomány negatív értékekkel:
<code python>
print(egyTuple[-4:-2])
</code>

Bejárás:
<code python>
egyTuple = (3, 8, 5, 6, 2, 8)
for elem in egyTuple:
    print(elem)
</code>


Tartalmazás:
<code python>
if 45 in egyTuple:
    print("Van 45")
</code>

Összefűzés:
<code python>
egyTuple = (3, 8, 5, 6, 2, 9)
kettoTuple = (14, 20, 11)
haromTuple = egyTuple + kettoTuple
print(haromTuple)
</code>

Konstruktor:
<code python>
egyTuple = tuple((3, 8, 5, 6, 2, 9))
print(egyTuple)
</code>


A tuple két beépített metódussal rendelkezik. A count() és az index().

A count():
<code python>
egyTuple = (3, 8, 5, 6, 2, 9)
print(egyTuple.count(5))
</code>

A count()  megszámolja, adott érték hányszor fordul elő a tuple-ben.

Az index, megmondja, hol található a keresett érték.

<code python>
egyTuple = (3, 8, 5, 6, 2, 9)
print(egyTuple.index(5))
</code>


==== Lista és tuple konvertálása ====

<code python>
t = ('alma', 'körte', 'barack', 'szilva')
print(list(t))

l = ['alma', 'körte', 'barack', 'szilva']
print(tuple(l))

</code>


===== Függvény =====

A függvények egyik haszna, hogy több utasítást tudunk velük összefogni, 
és egyetlen névvel futtatjuk a benne lévő utasításokat. 

Ugyanakkor a függvények tartalmazhatnak egyetlen utasítást, ami például
kiszámít egy kifejezést, vagy valamilyen értékre a függvény nevével szeretnénk
hivatkozni. 


Függvényt a def szóval hozhatunk létre. A def kulcsszót a függvénye neve követi,
majd zárójelek. A zárójelekben adatokat adhatunk át a függvény számára.
Az átadott adatokat argumentumoknak, vagy függvényeknek hívjuk. 

Vannak függvények, amelyek vissza adnak egy értéket, vagy egy összetett
adatszerkezet címét. 


A függvények lehetővé teszik, hogy egyes kódrészeket többször felhasználhassunk
egy programon belül. Ha egy programban, azt látjuk, hogy kód egyes részei 
ismétlődnek, akkor át kell gondolni, hogy rövidebb kódot írhatunk függvénnyel.

A függvények írásakor arra törekszünk, hogy azok többször felhasználhatók legyenek 
más programokban is, lehetőleg változtatás nélkül. A függvények használata 
mindenképpen hasznos, mivel a kód átláthatóvá válik általuk.

==== Üres függvény ====

<code python>
def valami():
    pass
</code>

A pass azt jelenti, hogy a függvényt még nem valósítottuk meg,
ezt majd később fogjuk megtenni.
==== Utasítások összefogása ====

A következő példában, négy utasítást fogunk össze a függvénnyel. 


<code python nevjegy.py>
def nevjegy():
    print('--------------')
    print('  Nagy János')
    print('  Hatvan')
    print('--------------')

nevjegy()
</code>

==== Argumentum használata ====

<code python dupla.py>
def dupla(szam):
    print(szam*2)

dupla(30)
</code>
==== Több argumentum használata ====

<code python szorzo.p>
def szorzas(szam1, szam2):
    print(szam1*szam2)

szorzas(30, 35)
</code>

==== Visszatérési érték ====

A függvények visszatérhetnek egy értékkel, vagy egy
összetett adatszerkezet címével. 

<code python osszeado.py>
def osszead(szam1, szam2):
    eredmeny = szam1 + szam2
    return eredmeny
 
print(osszead(3, 2))
</code>


<code python haromszog.py>
def haromszogTerulet(alap, magassag):
    terulet = (alap*magassag)/2
    return terulet

print(haromszogTerulet(30, 35))

</code>

==== Kulcsparaméterek használata ====

<code python haromszog.py>
def haromszogTerulet(alap=0, magassag=0):
    terulet = (alap*magassag)/2
    return terulet

print(haromszogTerulet(magassag=35, alap=30))
</code>

Az alap és a magasság esetén a 0, az alapértelmezett érték.
A paraméterek sorrendben ilyen formában felcserélhetők.

==== Globális változók elérése ====

Ha a **globális** változóra gondolunk:

<code python>
szam = 35
def kiir():
    global szam
    print(szam)
</code>

A szam látszik, global nélkül is, de így egyértelmű mire gondolunk.

===== Fájlkezelés =====

A fájlokat megnyithatjuk olvasásra, írásra, hozzáfűzésre. 
Minden megnyitási módhoz tartozik egy betű. 
A következő táblázat ezt mutatja be.

^  betű  ^  jelentés  ^
|  r  | Fájl megnyitása olvasásra. \\ A fájlmutató a fájl elején.  \\ Ha fájl nem létezik I/O hibát kapunk.   |
|  a  | Fájl megnyitása hozzáfűzésre. \\ Ha fájl nem létezik, létrejön. \\ A fájlmutató a fájl végére kerül.  |
|  w  | Fájl megnyitása írásra. \\ Ha a fájl létezik, felülírásra kerül. \\ Ha nemlétezik, létrehozza.   |
|  r+  | Fájl megnyitása írásara és olvasásra. \\ A fájlmutató a fájl elején. \\ Ha a fájl nem létezik I/O hibát jelez. \\ Az új tartalom a fájl elejére íródik |
|  w+  | Fájl megnyitása írásara és olvasásra. \\ A fájlmutató a fájl elején. \\ A fájl tartalma törlődik.  |
|  a+  | Fájl megnyitása írásara és olvasásra. \\ A fájl létre lesz hozva, ha nem létezik. \\ A fájlmutató a fájl végén. \\ A tartalom végére fűzzük az új adatokat.  |


==== Fájlkezelő függvények ====

=== Írása fájlba ===
  - write()
    * Írás a fájlba.
  - writelines()
    * Írás a fájlba.

=== Olvasás fájlból ===

  - read()
    * Visszatér az olvasott bájtokkal.
    * read()  # az egész fájlt olvassa.
    * read(n) # n darab bájtot olvas. 
  - readline()
    * Egy sor olvasása fájlból.
    * Megadott fájl létrehozása.
  - readlines()
    * Az összes sor olvasása.

=== Pozicionálás ===

  - seek()
    * Pozicionálás
    * fp.seek(3) # Pozicionálás 4.-dik bájthoz
    * Kezdő index: 0
==== Szekvenciális fájlkezelés ====

A fájl tartalmát bájtonként vagy blokkonként vesszük sorra. Ezzel szemben áll a 
szöveges fájlok kezelése, ahol soronként olvassuk, írjuk a fájlt. 

=== Olvasás ===

Ebben a példában a fájl tartalmát, egyetlen utasítással olvassuk:

<code python>
f = open('adat.txt', 'r')
tartalom = f.read()
print(tartalom) 
f.close()
</code>

Az open() függvény megnyitja az "adat.txt" állományt, olvasásra. 
Az open() függvénye második paramétere egy "r" betű, ebből tudjuk,
hogy olvasásra nyitjuk meg a fájlt. 
Az open() függvény visszaad egy fájlmutatót, amit az "f" nevű
változóban tárolunk el. Később így tudnunk a fájlra hivatkozni. 

A fájl mutatón keresztül olvashatunk a fájlból, a read() függvénnyel. 
Ez a fájl egész részét beolvassa. A példában a "tartalom" nevű
változóba másoljuk. 

A fájlt, végül a fájl mutatón keresztül bezárjuk.

A read() utasítás számára, beállítható, hogy csak 5 karaktert olvassunk be:
<code python>
s = f.read(5)
</code>

==== Szövegfájlok kezelése ====
A szöveges fájlokat soronként kezeljük. 
A fájlok kezelése, ugyanúgy az open(), close(), write() függvények használhatók.
A beolvasáshoz egy readline() függvényt fogunk használni.

=== Hozzáfűzés ===

A fájl véghez fűzünk újabb sorokat.

Próbáljuk ki a következő programot. 
<code python>
f = open('adat.txt', 'a')
f.write('Üdv\n')
f.close()
</code>

  * Figyelje meg, mi történik, ha nem létezik az adat.txt fájl.
  * Mi történik, ha újra futtatjuk a programot?


=== Írás fájlba ===

Ha írása nyitjuk meg a fájlt, a "w" karaktert használjuk.
A fájl tartalma megnyitáskor elvész, új fájl keletkezik. 

<code python olvas.py>
f = open('adat2.txt', 'w')

f.write("Első")
f.write("Második")

f.close()
</code>

=== Írás fájlba kódolással ===

Ha írása nyitjuk meg a fájlt, a "w" karaktert használjuk.
A fájl tartalma megnyitáskor elvész, új fájl keletkezik. 

<code python olvas.py>
f = open('adat2.txt', 'w', encoding='utf-8')

f.write("Első")
f.write("Második")

f.close()
</code>

=== Lista írása fájlba ===

<code python>
fp = open('adat.txt', 'w')
lista = ['egy\n', 'kettő\n', 'hátom\n']
fp.writelines(lista)
fp.close()
</code>

Eredmény: 
<file txt adat.txt>
egy
kettő
három
</file>


=== Olvasás fájlból ===

A szöveges fájlokat soronként dolgozzuk fel. 
Írja meg a következő programot. 

<code python olvas.py>
fp = open('adat.txt', 'r')

line = fp.readline()
while line != '':    
    print(line.rstrip())
    line = fp.readline()

fp.close()
</code>


=== Olvasás fájlból break utasítással ===


<code python olvas.py>
f = open('adat.txt', 'r')
while 1:
    sor = f.readline()
    if sor == '':
        break
    print(sor.rstrip())
f.close()
</code>

  * Derítse ki, mit csinál az rstrip() függvény.

=== Olvasás újabb verzió ===

Egy fájlból való soronkénti olvasásra, több variáció van. 
Itt egy újabbat láthatunk. Próbálja ki a programot. 

<code python olvas.py>
with open("adat.txt") as f:
	for sor in f:
		print(sor)

</code>

=== Olvasás újabb verzió 2 ===

<code python olvas.py>
fp = open('adat.txt', 'r')

lines = fp.readlines()

for line in lines:
    line = line.rstrip()
    print(line)

fp.close()
</code>

=== Olvasás listába ===

<code python olvas.py>
lista = open('adat.txt', 'r').read().splitlines()
print(lista)
</code>


<code python olvas.p>
fp = open('adat.txt', 'r')
lista = fp.read().splitlines()
fp.close()
print(lista)
</code>

=== Kódolás megadása ===

<code python olvas.py>
fp = open('adat.txt', 'r', encoding='utf-8')
lista = fp.read().splitlines()
print(lista)
</code>

=== Kivételkezeléssel ===

<code python olvas.py>
try:
    fp = open('adat.txt', 'r', encoding='utf-8')
    lista = fp.read().splitlines()
finally:
    fp.close()

print(lista)
</code>

=== A Python 3.8-tól ===

A Python 3.8-tól használható a := értékadó operátor:

<code python olvas.py>
fp = open('adat.txt', 'r')

while line := fp.readline():    
    print(line.rstrip())

fp.close()
</code>

=== Mezőnevek az első sorban ===

<code txt adat.txt>
No:Név:Település:Fizetés
1:Nagy János:Szolnok:3850000
2:Vere Béla: Szeged:2830000
3:Mardos Tibor: Szolnok:3430000
4:Fekete István: Miskolc:3130000
</code>


<code python olvas.py>
fp = open('adat2.txt', 'r')

lines = fp.readlines() 

for line in lines[1:]:
    print(line.rstrip())
fp.close()
</code>


Vagy egyszerűen töröljük az elsőt:
<code python>
lines.pop(0)
</code>

De akár a végéről is törölhetünk:
<code python>
lines.pop()
</code>

==== Gyakorlat ====

  * Írjon programot, amely dolgozók neveit kéri be, tetszőleges végjelig.
    * A program tárolja el a bekért neveket dolgozok.txt fájlba.


===== Modulok =====

A függvényeinket külső állományokba írhatjuk. 
Legyenek például háromszöggel kapcsolatos függvények,
amelyek kerületet területet számolnak. 

Készítsünk egy haromszog.py állományt, írjuk bele a függvényeinket.

<code python haromszog.py>

def szamitKerulet(a, b, c):
	return a + b + c

def szamitTerulet(alap, magassag):
	return (alap*magassag)/2
</code>


A modul használata:
<code python program01.py>
import haromszog

print(haromszog.szamitKerulet(30, 35, 40))
</code>

==== Statikus használat ====

A modul használata, statikusan:
<code python program01.py>
from haromszog import szamitKerulet

print(szamitKerulet(30, 35, 40))
</code>

Így rövidebben használhatjuk a szamitKerulet() függvényt, 
azonban nagyobb az esély a névütközésre. 


<code python program01.py>
from haromszog import szamitKerulet
from haromszog import szamitTerulet

print(szamitKerulet(30, 35, 40))
print(szamitTerulet(30, 35))
</code>

<code python program01.py>
from haromszog import szamitKerulet, szamitTerulet

print(szamitKerulet(30, 35, 40))
print(szamitTerulet(30, 35))
</code>
==== Modulok helye ====

A Python a sys.path-ban megadott útvonalakon keresi a modulokat. 
Írassuk ki egy python shellben. Indítsuk el python vagy python3 parancsot,
majd írjuk be:

<code python>

>>> import sys
>>> sys.path
['', '/usr/lib/python37.zip', '/usr/lib/python3.7', '/usr/lib/python3.7/lib-dynload', '/home/janos/.local/lib/python3.7/site-packages', '/usr/local/lib/python3.7/dist-packages', '/usr/lib/python3/dist-packages']
>>> 

</code>


<code python>
>>> import sys
>>> sys.path
['', 'C:\\Program Files\\Python310\\python310.zip', 'C:\\Program Files\\Python310\\DLLs', 'C:\\Program Files\\Python310\\lib', 'C:\\Program Files\\Python310', 'C:\\Program Files\\Python310\\lib\\site-packages']
>>>
</code>


Saját útvonal beszúrása:
<code>
sys.path.insert(0, sajatUtvonal)
</code>


==== A __name__ változó ====

Amikor futtatok egy programot,
az aktuális fájlban automatikusan létrejön 
<nowiki>__name__ nevű változó aminek az értéke: __main__</nowiki>


Tegyük fel, hogy adott egy projekt01.py főprogram, és egy modul,
modul1.py néven:
<code>
projekt01/
  |-modul1.py
  `-projekt01.py
</code>

A programot a projekt01.py fájlon keresztül futtatjuk, amely 
használja a modul1.py függvényeit. 

A futási időben, létrejön egy <nowiki>__name__ nevű állandó. 
Ebben az állandóban a __main__</nowiki> szó szerepel, jelezve, 
hogy ezt futtatjuk.

A modul fejlesztése során meghívhatjuk a fejlesztett
függvényeket. Amikor azonban a projekt01.py fájlból
hívjuk modulon belüli hívások feleslegesek. 
Ezért modulon belül egy if utasításban hívjuk a
függvényt:

<code python modul1.py>
def sajatFuggveny():
   pass

if __name__ == "__main__":
    sajatFuggveny()
</code>

A <nowiki>__name__</nowiki> változóval, tehát **tesztelhető**, hogy a modulunkat **közvetlenül futtatják**, vagy másik **programból hívják**. 

A pass azt jelenti, még nincs megvalósítva. Ha oda írjuk a pass szót, a függvény már fordítható.