szit

Ez az oldal csak olvasható. Megtekintheted a forrását, de nem változtathatod meg. Ha úgy gondolod, hogy ez helytelen, kérdezd az Adminisztrátorokat!
[[oktatas:programozás:python|< Python]]

====== Python haladó ======

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

===== A None =====

A None nem létező érték, mint más nyelvekben a NULL.

Írassuk ki típusát:
<code python>
print(type(None))
</code>

===== Halmazok =====
A halmaz, angolul set egy olyan kollekció amely 
nincs számozva, nincs indexelve. A halmazban
egy elem csak egyszer szerepelhet.
A Python nyelvben a halmazokat kapcsos-zárójelek között
adjuk meg.

<code python>
egyHalmaz = {'alma', 'barack', 'szilva'}
print(egyHalmaz)
</code>


A halmaz bejárása:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva'}

for elem in egyHalmaz:
    print(elem)
</code>


Hozzáadás a halmazhoz:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva'}

egyHalmaz.add('körte')

print(egyHalmaz)

</code>
Ha a halmaz már tartalmazza az elemet, nem történik semmi. 



Halmaz mérete:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva'}
print(len(egyHalmaz))
</code>

Törlés a halmazból:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva', 'körte'}
egyHalmaz.remove('barack')
print(egyHalmaz)
</code>

Törlés másként:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva', 'körte'}
egyHalmaz.discard('barack')
print(egyHalmaz)
</code>

A pop() függvény is használható, de mivel nem rendezett a halmaz,
nem lehet tudni, melyik elem kerül eltávolításra.

Halmaz ürítése:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva', 'körte'}
egyHalmaz.clear()
print(egyHalmaz)
</code>

A halmaz törlése:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva', 'körte'}
del egyHalmaz
print(egyHalmaz)
</code>
A print() függvény hibát ad, mivel a halmaz már nem létezik.

Halmazok uniója:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva', 'körte'}
kettoHalmaz = {'banán', 'citrom'}
haromHalmaz = egyHalmaz.union(kettoHalmaz)

print(haromHalmaz)
</code>
Új halmaz keletkezik.


Egy halmazt bővítünk egy másikkal:
<code python>
egyHalmaz = {'alma', 'barack', 'szilva', 'körte'}
kettoHalmaz = {'banán', 'citrom'}
egyHalmaz.update(kettoHalmaz)

print(egyHalmaz)
</code>

Itt nem keletkezik új halmaz, egyHalmaz kerül bővítésre.

Halmaz létrehozása konstruktorral:
<code python>
egyHalmaz = set(('alma', 'barack', 'szilva', 'körte'))
print(egyHalmaz)
</code>


| add()     | Elem hozzáadása  |
| clear()   | Összes elem törlése  |
| copy()    | Másolat  |
| difference()   | Visszatér kettő vagy több halmaz különbségével. \\ Új halmaz jön létre  |
| difference_update()  | Eltávolítja azokat az elemeket, amelyek szerepelnek a másik halmazban. |
| discard()       | Adott elem törlése.  |
| intersection()  | Két halmaz metszete.  |
| intersection_update  | Azon elemek törlése, amely szerepel a másik halmazban.  |
| isdisjoint()         | Van-e metszéspontja a két halmaznak.  |
| issubset()           | A másik halmazt tartalmazza-e.  |
| pop()     | Elem eltávolítása  |
| remove()  | Adott elem eltávolítása  |
| symmetric_difference()  | Olyan halmaz létrehozása, \\ amely a nem közös részeket tartalmazza. |
| symmetric_difference_update()  | Adott halmazban csak a nem közös elemek maradnak. \\ Nem jön létre új halmaz.  |
| union()   | Két halmaz uniója. Új halmaz jön létre  |
| update()  | Halmazok uniója, de nem jön létre új halmaz  |

===== Szótár =====

A szótár, angolul dictionary, egy kollekció, amely számozatlan,
változtatható és indexelt. A Python nyelvben kulcs érték párokkal
határozzuk meg a szótárakat. 

Létrehozás:
<code python>
egySzotar = {
    'nev': 'Nagy János',
    'telepules': 'Szolnok',
    'fizetes': 2850000
}

print(egySzotar)
</code>


Hivatkozás egy elemre:
<code python>
egySzotar = {
    'nev': 'Nagy János',
    'telepules': 'Szolnok',
    'fizetes': 2850000
}

print(egySzotar['nev'])
</code>

Vagy:
<code python>
print(egySzotar.get('nev'))
</code>


Érték cseréje:
<code python>
egySzotar['nev'] = 'Kiss Mihály'
</code>


Szótár bejárása:
<code python>

egySzotar = {
    'nev': 'Nagy János',
    'telepules': 'Szolnok',
    'fizetes': 2850000
}


for elem in egySzotar:
    print(elem)
</code>

Vagy:
<code python>
for kulcs in egySzotar:
    print(egySzotar[kulcs])
</code>

Vagy:
<code python>
for elem in egySzotar.values():
    print(elem)
</code>

Kulcsok és értékpárok kiíratása:
<code python>
for kulcs, elem in egySzotar.items():
    print(kulcs, elem)
</code>

Van-e ilyen kulcs:
<code python>
if 'fizetes' in egySzotar:
    print('Van fizetes kulcs')
</code>

Szótár mérete:
<code python>
print(len(egySzotar))
</code>

Plusz elem hozzáadása:
<code python>
egySzotar = {
    'nev': 'Nagy János',
    'telepules': 'Szolnok',
    'fizetes': 2850000
}

egySzotar['kor'] = 38

print(len(egySzotar))
</code>

Elem törlése:
<code python>
egySzotar.pop('kor')
</code>


Utoljára beszúrt elem törlése:
<code python>
egySzotar.popitem()
</code>

Elem törlése:
<code python>
del egySzotar['kor']
</code>

A szótár törlése:
<code python>
del egySzotar
</code>

Az elemek törlése:
<code python>
egySzotar.clear()
</code>


A szótár másolása:
<code python>
kettoSzotar = egySzotar.copy()
</code>

Másolás másként:
<code python>
kettoSzotar = dict(egySzotar)
</code>



Beágyazott szótár:

<code python>
dolgozok = {
    'janos' : {
        'nev': 'Nagy János',
        'telepules': 'Szolnok',
        'fizetes': 2850000,
    },
    'mari' : {
        'nev': 'Pere Mária',
        'telepules': 'Miskolc',
        'fizetes': 2810000
    },
    'kati' : {
        'nev': 'Lamp Katalin',
        'telepules': 'Szeged',
        'fizetes': 2500000
    }
}

print(dolgozok)
</code>


Külön szótárak:
<code python>
janos = {
    'nev': 'Nagy János',
    'telepules': 'Szolnok',
    'fizetes': 2850000,
}

mari = {
    'nev': 'Pere Mária',
    'telepules': 'Miskolc',
    'fizetes': 2810000
}
 
kati = {
    'nev': 'Lamp Katalin',
    'telepules': 'Szeged',
    'fizetes': 2500000
}

dolgozok = {
    'janos' : janos,
    'mari' : mari,
    'kati' : kati
}

print(dolgozok)
</code>

Konstruktor használata
<code python>
dolgozo = dict(
    nev= 'Nagy János',
    telepules= 'Szolnok',
    fizetes= 2850000,
)
print(dolgozo)
</code>



| clear()     | Az összes elem törlése  |
| copy()      | Szótár másolása  |
| fromkeys()  | Egy szótárat kapunk adott kulccsal és értékkel  |
| get()       | Visszatérés adott kulcs értékével  |
| items()     | Egy tuple-t kapunk, amely tartalmazza \\ az összes kulcs értékpárokat.  |
| keys()      | A kulcsok listáját kapjuk  |
| pop()       | Adott elem törlése, kulcs alapján  |
| popitem()   | Utoljára beszúrt elem törlése  |
| setdefault()  | Adott értéket kapjuk kulcs alapján. \\ Ha a megadott kulcs nem létezik \\ létrejön.  |
| update()  | Adott kulcsa értékpár frissítése  |
| values()  | Az értékek listáját kapjuk  |

===== Változó hosszúságú argumentum =====

A függvények használhatnak változó hosszúságú argumentumokat.

<code python valto.p>
def osszead(*args):
    osszeg = 0
    for szam in args:
        osszeg = osszeg + szam
    return osszeg

print(osszead(3, 4))
print(osszead(3, 4, 5))
</code>

A másik megoldás, ha listaként adom át a paramétereket:

<code python valtolista.py>
def osszead(args):
    osszeg = 0
    for szam in args:
        osszeg = osszeg + szam
    return osszeg

print(osszead([3, 4]))
print(osszead([3, 4, 5]))
</code>

==== Kulcs alapú argumentumok ====
Változó hosszúságú kulcs alapú argumentumokat a kettő darab * operátorral
hozunk létre. Például <nowiki>**kwargs</nowiki>.

<code python kulcs.py>
def szamitTerulet(**kwargs):
    alap = kwargs.get('alap')
    magassag = kwargs.get('magassag')
    return alap * magassag / 2


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

==== Vegyes argumentumok ====

Az argumentumok lehetnek vegyesen kulcs nélküli és kulcs alapú argumentumok.

<code python vegyes.py>
def doit(*args, **kwargs):
    if kwargs.get('operator') == '+':
        return args[0] + args[1]
    if kwargs.get('operator') == '-':
        return args[0] - args[1]

print(doit(3, 4, operator='-'))
</code>


===== Lambda =====

Kis névtelen függvény, amely csak egyetlen kifejezést tartalmazhat. 

<code>
lambda argumentumok : kifejezés
</code>


<code python>
dupla = lambda szam : szam * 2

print(dupla(5))
</code>


<code python>
haromszogTerulet = lambda alap, magassag : (alap*magassag)/2

print(haromszogTerulet(30, 35))
</code>


<code python>
haromszogKerulet = lambda a, b, c : a + b + c

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


Lehetséges használat:
<code python>

def sokszorozo(n):
    return lambda a : a * n

duplazo = sokszorozo(2)
triplazo = sokszorozo(3)

print(duplazo(5))
print(triplazo(5))
</code>

===== Üresek =====

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


Üres végtelen ciklus:
<code python>
while(True):
    pass
</code>

Üres if ág:
<code python>
igaz = True
if igaz :
    pass
else :
    print('Hamis')
</code>

==== Üres osztály ====

<code python empty.py>
class Dolgozo:
    pass
</code>


Munka üres osztállyal:

<code python empty.py>
class Dolgozo:
    pass

janos = Dolgozo()
janos.name = 'Valaki'
janos.tisztseg = 'kocka'
janos.telefon = 12345678

print(janos.name)
print(janos.tisztseg)
print(janos.telefon)
</code>

Az üres osztály használható osztály. Bármilyen
adattagot beállíthatunk, és amit beállítottunk
lekérdezhetjük.

==== Üres érték ====

<code python>
valami = None
</code>
===== Python fájlok =====



==== WHL fájlok ====

A WHL a **Python Wheel Package** szavakból származik. 
A **Wheel** a Python saját csomagformátuma. 
A Wheel valójában egy ZIP formátumú archív fájl,
amelyet whl kiterjesztéssel rendelkezik. 


==== Python fájlok ====

  * .py -- Python script
  * .pyc -- Python bájtkód
  * .pyd -- Python dinamikus modul
  * .pyo -- Python optimalizált kód
  * .pyr -- Python tároló (repository)
  * .p4a -- Python for Android Script
  * .re -- Python szabályos kifejezés forráskód
  * .pyt -- Python adatdeklaráció

===== Python könyvtárak =====

  * __pycache__ 

A Python futtatáskor elsőként bájtkódot fordít. 
A bájtkód ebben a könyvtárban jön létre. 
A forráskódban importálás mellett szokott megjelenni.
A könyvtárban .pyc vagy .pyo kiterjesztésű fájlokat
talál, amelyek a lefordított, optimalizált bájtkódok.

Ha másnak küldjük el a Python kódot, ezt a könyvtárat
töröljük. Git esetén a .gitignore fájlban szokás 
szerepeltetni.



===== Változó behelyettesítés =====

<code python>
a = 35
b = 'valami %d' % a
print(b)
</code>


<code python>
a = 35
b = 'valami {0}'.format(a)
print(b)
</code>



<code python>
a = 35

b = """
valami %s
""" % a
print(b)
</code>

===== Operációs rendszer parancsok =====

<code python>
import os
os.system('ls')
</code>

A program végrehajtja az operációs rendszer ls parancsát. 
===== Külső könyvtárak használata =====

  sys.path.append('/ahol/a/libek/vannak/')

===== Egy fájlban több osztály =====

Azok az osztályok, amikre hivatkozunk egy állományon belül 
előrébb kell legyenek, mint a hivatkozott hely. 

<code python>
class View:
    pass

class Model:
    pass

class Controller:
    view = View()
    model = Model()
</code>

===== f-String =====

Az f-Stringet a Python 3.6-ban vezették be. 

==== Változó behelyettesítés ====

Lehetővé teszi változók behelyettesítését.

<code python fstring.p>
name = 'Nagy János'
city = 'Szolnok'
print(f'Név: {name} Város: {city} ')
</code>

Mindegy, hogy aposztrófokat vagy idézőjeleket használunk:

<code python fstring2.p>
name = 'Nagy János'
city = 'Szolnok'
print(f"Név: {name} Város: {city} ")
</code>

==== Kifejezés ====

A f-sztring alkalmas kifejezések kiértékelésére is.

<code python fstring_kif.p>
oldal = 30

print(f'Kerület: {oldal*3}')
</code>

==== Szótár ====

Hivatkozhatunk szótárak tagjaira:

<code python fstring_dict.py>
employee = {'name': 'Nagy János', 'city': 'Szolnok'}

print(f"{employee['name']}:{employee['city']}")
</code>

==== Többsoros ====

<code python fstring_muliline.py>
name = 'Nagy János'
city = 'Szolnok'
salary = 3845000

datas = (
    f'Név: {name}\n'
    f'Város: {city}\n'
    f'Fizetés: {salary}\n'
)

print(datas)
</code>

==== Formázás ====

<code python fstring_format.py>
num = 3.834384
print(f'{num:.2f}')
</code>

Szélesség is:
<code python fstring_format.py>
num = 3.834384
print(f'{num:20.2f}')
</code>

Igazítás jobbra:
<code python fstring_format.py>
num1=1
num2=12
num3=123

print(f'{num1:>5d}')
print(f'{num2:>5d}')
print(f'{num3:>5d}')
</code>

Számrendszerek és tárolási osztályok:
<code python>
num=12

print(f'{num:d}') # decimális egész
print(f'{num:x}') # hexadecimális
print(f'{num:o}') # oktális
print(f'{num:f}') # fixpontos alak
print(f'{num:e}') # tudományos alak
print(f'{num:b}') # bináris
</code>

==== Dátum ====

<code python>
import datetime

today = datetime.datetime.today()
print(f'{today: %Y}')
</code>



===== Kurzor mozgatása =====


<code python>
def gotoxy(x,y):
    print ("%c[%d;%df" % (0x1B, y, x), end='')
</code>

===== Útvonal lekérdezése =====


Honnan fut a Python script?

<code python>
real_path = os.path.realpath(__file__)
base_path = os.path.dirname(real_path)
</code>



<code python>
real_path = os.path.realpath(__file__)
base_path = os.path.split(real_path)[0]
</code>

A real_path-ban megkapom a teljes útvonalat és a fájlnevét is.
A bas_path-ban csak az útvonalat kapom, fájlnév nélkül. 


A fájl neve:
<code python>
real_path = os.path.realpath(__file__)
base_name = os.path.basename(real_path)
</code>

===== Locale =====

Ha egy állományból olyan számokat olvasunk amelyekben tizedesvesszők
vannak, át kell azokat konvertálni, ha számolni szeretnénk vele.

Át is alakíthatjuk:
<code python>
num = float(num_str.replace(',', '.'))
</code>

Vagy locale-t használunk:

<code python main.py>
from locale import atof, setlocale, LC_NUMERIC

setlocale(LC_NUMERIC, 'hu_HU.UTF-8')
num_str = '35,47'

print(atof(num_str) * 2)
</code>

Beírható locale értékek lekérdezése:
<code python>
>>> import locale
>>> locale.locale_alias
</code>

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

<code python>
def double_num(num1: float, num2: float):
    return num1 + num2

print(double_num(6.2, 5.4))
</code>


<code python>
def double_num(num1: int, num2: int):
    return num1 + num2

print(double_num(6, 5))
</code>

<code python>
a: List[str] = ['alma', 'körte', 'barack']
b: Tuple[int, int, int] = [35, 40, 45]
c: Dict[str, int] = {'első': 35, 'második': 40}
</code>
szit

Felhasználói eszközök

Eszközök a webhelyen

Eszközök az oldalon
