Megjegyzés
Értékadás
Monitorra küldés
Változók
Egész
# int típus egész szám tárolására
szam = 5
print(type(szam))
Tört
# float típus tizedes tört tárolására
tizedes_tort = 0.25
print(type(tizedes_tort))
Szöveg
# str típus (string) karaktersorozat tárolására
szoveg = 'alma'
print(type(szoveg))
Logikai
# bool típus (boolean) két értéket vehet fel: True vagy False
oszthato = True
print(type(oszthato))
Bevitel
A Python mint minden programozási nyelv adatok bevitelére is alkalmas, itt az input utasítás szolgál adatok bekérésére.
szam = input('hány éves vagy?')
print('most',szam,'éves vagy')
Az első sorban a szam változóba kér be egy értéket az input utasítás segítségével. Itt értékadás után enterrel kell nyugtázni a bevitelt, csak ekkor folytatódik tovább a program futása. Tudnod kell, hogy az input szöveges típusba(str) olvassa be a megadott értéket, és szövegként is kezeli a program. Az általunk megírt kétsorosnál ez nem is okozott problémát, hiszen a printnek is mindegy, hogy milyen típust takar a szam változónév.
Mi történik akkor ha számolni szeretnénk a beírt értékel?
Rögtön hibaüzenetbe fullad a próbálkozásunk, szerencsére a python is tartalmaz típuskonverziókat ezek segítségével válik megoldhatóvá a feladat.
szam = input('hány éves vagy?')
print('most',szam,'éves vagy')
print ('dupla ilyen idősen',int(szam)*2,'éves leszel')
print ('fele ilyen idősen',float(szam)/2,'éves voltál')
Két konvertálást láthatunk a programban, az első egy egész típusú konvertálás:
int(szam) – itt a szam változóban tárolt szöveget(szövegként tárolt számot) átalakítja
egész típusú számá. Pl:: 12--> 12
Itt vigyázni kell arra, hogy bevitelnél semmilyen szöveges karaktert se tizedes számot
nem adhatunk meg, ellenkező esetben hibaüzenet a jutalmunk.
float(szam) – a szam változóban tárolt számot átalakítja tizedes számmá (lebegő pontos szám). pl.: 12 → 12.00
Itt a konverziónál csak a szöveges karaktereket kell mellőzni, az egészeket és a tizedes számokat is átalakítja.
Persze lehet rögtön az input elé is konvertálás tenni:
szam = int(input('kérek egy számot'))
print(szam*4)
szam = float(input('kérek egy számot'))
print(szam/4)
Működik egész és valós számokkal is.
Változók típusai
Az egész számokat mint láthattuk integer típusként menti el a python, ezt csak a szám nagysága befolyásolhatja. Az integer 4byte-on tárol, ez kb.: 2milliárdot jelent pluszba és mínuszba is. Ha ennél nagyobb a szám automatikusan long típusúvá válik. A long az integer határtól a végtelen nagyságig képes tárolni, csak az adott gép memóriája szabhat határt.
A valós számok vagy lebegőpontos számok a float típusba tárolódnak, a pontosságuk 12 számjegyig érvényes. Valós szám deklarálásához elég tizedes ponttal ellátott számot adni értékül a változónknak.
Itt még meg kell említeni a szövegek tárolására használt string típust. A szövegeket értékadáskor aposztrófok vagy idézőjelek közé tesszük.
szam = 231
nev = str(szam)+'gumibogyó'
print(nev)
Stringé is konvertálhatunk egész és valós számokat az str() függvény segítségével.
A szövegrészeket egyszerű plusz jelel fűzhetjük össze.
A sztring kezelésnek külön parancsai vannak amit egy másik cikkben lesz majd levezetve.
Műveletek
x = 7
y = 3
# összeadás
print(x + y)
# kivonás
print(x - y)
# szorzás
print(x * y)
# osztás
print(x / y)
# maradékos osztás, az osztás maradékát adja eredményül
print( x % y)
Összehasonlító operátorok
== egyenlő
!= nem egyenlő
< kisebb
> nagyobb
<= kisebb vagy egyenlő
>= nagyobb vagy egyenlő
Logikai operátorok
and és
or vagy
not nem
x = 5
y = -3
if x < 0 and y < 0:
print('mindkettő negatív')
if x < 0 or y < 0:
print('van köztük negatív')
if not x <= 0:
print('x pozitív')
http://szit.hu/doku.php?id=oktatas:programozas:python:python_nyelv
A modolo jel segítségével megvizsgáljuk a számot kettővel osztás után, ha van egész maradék (1) akkor igaznak veszi a feltételt és páratlant ír ki.
Néha megeshet, hogy többszörösen egybeágyazott feltételekre van szükség, ez is megoldható az if utasítással de szigorúan be kell tartani az utasítás blokkok kezelésének szabályait.
b = 15
if (b>10): #1.blokk
if(b<20): #2.blokk
if(b%2): #3.blokk
print('a szám 10-nél nagyobb, 20-ál kisebb páratlan szám')
else: #3.blokk
print('páros szám')
else: #2.blokk
print('20-nál nagyobb szám')
else: #1.blokk
print('10-nél kisebb szám')
b értékét írjuk át 8-ra,16-ra,21-re.
Véletlen
Véletlen szám generálás
Mint minden programozási nyelvben úgy itt is lehetőség van véletlenszerűen létrehozni szám értékeket. Erre szolgál a véletlen szám generálás.
import random
a = 0
while a<7:
a=a+1
velszam = random.randint(5,10)
print(velszam)
Az első sorban importáljuk a random könyvtárat ami a véletlen szám függvényeit
tartalmazza. A Pythonnak van egy alap utasítás készlete, de rengeteg dolog csak könyvtárakon keresztül érhető el, ilyen ez is. Az adott könyvtárhoz az import utasítás segítségével biztosíthatjuk az elérési utat. Miért van erre szükség? Takarékosság, ha alapból minden utasításkészlet bent lenne a fordítóba és a legkisebb programhoz is hozzá kapcsolna mindent akkor hatalmas,lassú, használhatatlan programokat kapnánk. Így viszont célirányosan csak a szükséges utasítások fordítódnak a szcriptjeink mellé.
A 2.-- 4. sor ciklusa segít, hogy láthatóvá váljon a véletlenszerű értékadás több példán keresztül.
Az 5. sor tartalmazza a generálást:
velszam = random.randint(5,10)
A velszam a változó amibe a generált értéket eltároljuk, ez a későbbiekben mindig így lesz ha függvényektől visszatérési értéket várunk, de ezt majd később.
random.randint(5,10) – ezzel a sorral íratjuk ki a számokat 5 és 10 között.
A random könyvtár utasításait a könyvtárnév utána az utasítás ponttal elválasztva írjuk a programba. A randint() teszi lehetővé hogy, egész számokat generáljunk.
A randint két értéke azt az intervallumot adja, ami a generálandó számok legkisebb és legnagyobb lehetséges értékét határozza meg.
import random
a = 0
while a<9:
a=a+1
szam = random.randrange(8)
print(szam)
Lehet máshogy is véletlen számot lekérni, egy ilyen lehetőség a random.randrange()
használata. Ez az utasítás ugyan azt teszi mint randinit csak a max határértéket már nem adja értékül ( a példában 8 a határérték a kiírás legnagyobb száma a 7.)
szam = random.randrange(8,16)
a randrange itt már két értéket tartalmaz, egy minimum és egy maximum értéket.
szam = random.randrange(8,16,2)
három értéket is adhatunk a randrange-nek, itt a harmadik érték a lépés közt állítja be.
A példában a 8-tól minden második érték 15-ig kiíródhat, tehát:
8, 10, 12, 14
szam = random.random()
0 és 1 közötti véletlen valós számot hoz létre.
szam = random.uniform(4,9)
a megadott határok között hoz létre valós számot.
import random
a = 0
while a<7:
a=a+1
szam = random.choice("abcdefghji")
print (szam)
a random.choice segítségével egy listából választ ki véletlenszerűen elemeket.
A könyvtár kezelésről még egy-két apróság, a könyvtáron belül közvetlenül utasításokat is importálhatunk a pythonban.
from random import randint
print(randint(4,12))
Az első sor változott, from-mal bővült aztán az import hozza a megadott utasítást.
Tehát a random könyvtárból a randint utasítást importáljuk. Mint láthatjuk a randint
meghívása előtt így már nem kell odaírni a könyvtár nevet ponttal elválasztva.
from random import randint,uniform
print(randint(4,12))
print(uniform(4,12))
Akár több könyvtárutasítást is importálhatunk vesszővel elválasztva.
Vagy az összes utasítást importálni lehet a csillag jellel.
from random import *
print(randint(4,12))
print(uniform(4,12))
A random könyvtár még jó néhány utasítást tartalmaz, de ezek speciálisabb eseteknél
használhatók
Véletlen
import random
random_szam = random.randint(1,10)
print(random_szam)
Számláló amíg
# while magyarul azt jelenti: amíg
szam = 1
while szam <= 10:
print(szam)
szam = szam + 1
Ciklusok, while
A Python lehetővé teszi egy-egy utasítás vagy utasítás blokk ismételt végrehajtását is.
Erre egy ciklikus utasítás szolgál amit a következő sorokba mutatok be.
b = 0
while (b < 9):
b = b + 1
print (b)
Két érdekes sor van itt számunkra, az egyik a ciklust létrehozó sor egy kifejezéssel.
While (b < 9): a ciklus mind addig végrehajtódik míg b értéke kisebb mint 9, tehát amíg igaz a kifejezés. (1-től 9-ig kiírja a számokat a ciklus).
A másik sor: b = b + 1 , ez egy matematikai lehetetlenség, de nem itt.! Mit is mondtunk az egy egyenlőségjelről? A programozásban mindig értékadásra használjuk, nem egyenlőség ként működik (==).
b legyen egyenlő b+1 értékkel, leegyszerűsítve b értékét növeljük eggyel.
Amire nagyon vigyáznunk kell, soha ne írjunk végtelen ciklust. A while ciklusban megadott feltétel idővel váltson hamisra!
Pl.: ha az alap programban nem növeljük a b értékét, akkor a while feltétele örökre igaz marad.
Fontos: 1. a while feltétele után mindig tegyünk kettőspontot, evvel kezdődik az utasítás blokk. 2. az utasítás blokk mindig beljebb kezdődjön, tartsuk a behúzást.
A zárójelek a kifejezésekben elhagyhatók az esetválasztásnál (if) és a while ciklusnál is, most csak az átláthatóság kedvéért kerültek ide.
a, b= 0, 0
while (a<10) :
a = a + 1
while (b<10):
b = b + 1
print(a*b)
b=0
Kiíratjuk a szorzótáblát ciklusokkal. Egymásba ágyaztunk két ciklust, az elsö ciklus eggyel növeli a értékét, a második ciklus b értékéért felelős, ez addig nem adja vissza az első ciklusra a program futását míg saját maga nem végzet. Tehát 10-szer lefuttatja magát b értékét egyesével növelve, és kiírja a és b szorzatát. Az a értéke ez alatt nem változik. Ha végzett nullázza b értékét és növeli a értékét eggyel, aztán vissza kerül b ciklusba. Ez mind addig fent áll míg a ciklus feltétele hamissá nem válik.
A while ciklus elég fontos összetevő érdemes több módon kipróbálni.
For ciklus
Mint minden más programozási nyelvben úgy itt is megtalálható a for ciklus egy egyedi változata. Mi is ez a for ciklus ? Legtöbbször számláló ciklusként lehet jellemezni (pythonban léptető ciklus). Működése általánosan a kifejezésben megadott értékek határozzák meg, hogy hányszor fusson le a ciklus.
for i in range(10):
print(i)
Első sor: létrehozunk egy egész típusú változót(i) aminek a for ciklus segítségével
a range(szám sorozat)-ban eltárolt számig, egyesével értéket adunk.
A range(10) jelentése az i egymás után 10 értéket fog kapni 0-9-ig, 10-szer hajtódik
végre a for ciklus. A range-ba több értéket is megadhatunk, ezek megváltoztatják a számsor feldolgozását.
for i in range(6,10):
print(i)
Range(6,10) – a számsor most is 10-ig (utolsó elem a 9) megy, de a 6-ostól írja ki a számokat.
for i in range(0,41,4):
print(i)
Itt a range arra utasít, hogy 0-tól 41-ig írjuk ki a számokat 4-esével.
A harmadik érték a lépésközöket adja.
Ugyanígy csökkenő számsort is létrehozhatunk:
for i in range(32,-17,-4):
print(i)
Itt 32-től -17-ig lépked -4-esével(lépésenként 4-et kivonva).
A for ciklusok is egymásba ágyazhatók többszörösen.
Ami nem szerencsés velük kapcsolatban a cikluson belül a számláló értékének változtatása, ez ugyan is összezavarhatja a ciklus futását.
A for ciklusnak lesznek sokkal fejlettebb felhasználásai is, de erről majd a későbbiekben.
While ciklus II.
szamlalo = 1
while szamlalo <= 5:
print('Programozni jó!')
szamlalo = szamlalo + 1
A print függvény a megadott szöveg kiírása után sort emel,
vagyis a következő print függvény már egy újabb sorba ír.
Az alapértelmezett viselkedés azonban felülírható a "t" paraméterrel.
'''
# a kiírást követően a kurzor egy tabulátornyit ugrik
print('Teszt', end='\t')
# a kiírást követően a kurzor a kiírás végén marad
print('Teszt', end='')
Próbáld ki!
Egymásba ágyazott ciklusok I.
sor = 1
while sor <= 3:
oszlop = 1
while oszlop <= 5:
print('O ', end='')
oszlop = oszlop + 1
print('')
sor = sor + 1
Listák
honapok = ['január', 'február','március', 'április']
# lista kiíratása
print(honapok)
# join(): a lista elemeit egy sztringgé fűzi össze
# a megadott elválasztó karakterekkel tagolva
print(', '.join(honapok))
# lista hossza: len( )
print(len(honapok))
# a 0. indexű az első elem
print(honapok[0])
# jelen esetben a 3. indexű az utolsó elem
print(honapok[3])
# túlindexelés, hibát okoz!
# ebben a listában az utolsó elem indexe: 3
# print(honapok[4]) <- HIBÁS!!!
# az 1-es és 2-es indexű elemek kiíratása
print(honapok[1:3])
# az elejétől a 2-es indexű elemmel bezárólag
print(honapok[:3])
# 2-es indexű elemtől a végéig
print(honapok[2:])
# hátulról az első, vagyis az utolsó elem
print(honapok[-1])
A sztringek elemeire is így hivatkozhatunk
szo = "almafa"
print(szo[:3])
Próbáld ki!
Üres lista és üres változó deklarálása
A megadott szavakat fűzi a listához mindaddig, amíg a felhasználó csak egy ENTER-t nem nyom, azaz nem ad meg újabb értéket.
# üres listát hoz létre
gyumolcsok = []
# kezdőérték nélküli változót hoz létre
gyumolcs = None
while gyumolcs != '':
gyumolcs = input('Adj meg egy gyümölcsöt! ')
if gyumolcs != '':
# hozzáfűzi a listahoz
gyumolcsok.append(gyumolcs)
print(gyumolcsok)
Lista bejárása
Lista bejárása
tantargyak = ['matek', 'töri', 'bio', 'kémia', 'info']
for tantargy in tantargyak:
print(tantargy)
Próbáld ki!
Számsorozat előállítása egy adott tartományban
# 0 -> 9
for i in range(10):
print(i)
# 5 -> 8
for i in range(5,9):
print(i)
# 3 -> 20-ig 6-osával
for i in range(3,21,6):
print(i)
Próbáld ki!
Lista bejárása index-szel I.
honapok = ['január', 'február','március', 'április', 'május', 'június']
index = 0
for honap in honapok:
print(index, honap)
index = index + 1
Lista bejárása index-szel II.
honapok = ['január', 'február','március', 'április', 'május', 'június']
for index in range(len(honapok)):
print(index, honapok[index])
Lista bejárása index-szel III.
honapok = ['január', 'február','március', 'április', 'május', 'június']
for index, honap in enumerate(honapok):
print(index, honap)
Próbáld ki!
Csak olvasod a listaelemeket, vagy módosítani is akarod?!
Nem mindegy, hogyan járod be a listát!
A fentiekben bemutatott három lehetőség közül az I. és III. számú esetben a lista bejárása úgy történik, hogy az egyes elemek - minden egyes cikluslépésben - egy 'honap' nevű átmeneti változóba kerülnek kimásolásra, és ezt használjuk fel a print utasításban. Ha módosítani szeretnéd a listaelemet (pl. nagybetűsre alakítani) akkor hiába tennéd ezt meg a 'honap' nevű változó esetében, ez az eredeti listaelemet NEM módosítaná! Így ez a bejárás csak az adatok olvasására alkalmas!
honapok = ['január', 'február','március', 'április', 'május', 'június']
for honap in honapok:
# az eredeti listaelem NEM módosul!
honap = honap.upper()
Ha módosítani szeretnéd a listaelemeket, akkor II. számú esetet kell mintaként venned! Ebben az esetben ugyanis az index segítségével közvetlenül az eredeti listaelemre hivatkozunk, így akár módosíthatjuk is azt!
for index in range(len(honapok)):
# az eredeti listaelem módosul!
honapok[index] = honapok[index].upper()
Listametódusok
Listák rendezése
nyelvek = ['Python', 'C', 'C++', 'Java']
# sorbarendezi a listát
nyelvek.sort()
# fordított sorrendbe rendezi a listát
nyelvek.reverse()
Keresés a listákban
# az adott elem első előfordulásának indexe
print(nyelvek.index('C'))
# az adott elem hányszor fordul elő
print(nyelvek.count('Python'))
# NEM listametódus, de így lehet eldönteni, hogy egy elemet tartalmaz-e a lista
print('C++' in nyelvek)
Listák bővítése
# a lista végére hozzáfűz egy elemet
nyelvek.append('Python')
# a listát másolja
nyelvek_masolat = nyelvek.copy()
# a lista végére hozzáfűz egy másik gyűjteményt (pl. listát)
nyelvek_honlapkesziteshez = ['HTML', 'CSS', 'JavaScript']
nyelvek.extend(nyelvek_honlapkesziteshez)
# adott indexű helyre beszúrja a megadott elemet
nyelvek.insert(1, 'Go')
Törlés a listákban
# eltávolítja a legutolsó elemet, és azzal tér vissza
# itt például a törölt értéket a 'torolt_nyelv' fogja tartalmazni
nyelvek.pop()
torolt_nyelv = nyelvek.pop()
# eltávolítja a megadott indexű elemet, és azzal tér vissza
nyelvek.pop(1)
# eltávolítja a megadott indexű elemet
del nyelvek[1]
# eltávolítja a megadott elemet az elsőként megtalált pozícióból
nyelvek.remove('Python')
# törli a listát
nyelvek.clear()
eredeti = [11, 19, 7, -3]
eredmeny = [x * 2 for x in eredeti]
eredmeny_szurve = [x * 2 for x in eredeti if x > 0]
Próbáld ki!
Ezeket a kifejezéseket használhatjuk kizárólag szűrésre is. Ebben az esetben a bejárást biztosító kifejezésrész előtt csupán a változó áll művelet nélkül. Az alábbi példában: x
szamok = [5, 8, 3, 11, 12]
paros_szamok = [x for x in szamok if x % 2 == 0]
napi_ertekesitesek = [3, 12, 3, 4, 7, 15, 1]
osszesen = 0
for ertekesites in napi_ertekesitesek:
osszesen = osszesen + ertekesites
print("A héten ennyi értékesítés történt: ", osszesen)
Próbáld ki!
print('Ez a program kiszámolja az átlagodat.')
print('Ha már nem akarsz több jegyet megadni, írj 0-át!')
print('--------------------------------------------')
darab = 0
osszeg = 0
erdemjegy = int(input('Add meg az első érdemjegyet: '))
while erdemjegy != 0:
darab = darab + 1
osszeg = osszeg + erdemjegy
erdemjegy = int(input('Add meg az következő érdemjegyet: '))
if darab != 0:
print('A jegyeid átlaga: ', osszeg / darab)
else:
print('Nem adtál meg egy jegyet sem!')
Az ELDÖNTÉS esetében azt vizsgáljuk,
hogy szerepel-e egy bizonyos tulajdonságú elem az adatsorban (itt a listában).
A program azt vizsgálja, hogy van-e hárommal osztható szám a listában.
'''
lista = [2, 5, 4, 8, 9, 11, 10, 12]
talalat = False
index = 0
while index < len(lista) and not talalat:
if lista[index] % 3 == 0:
talalat = True
index = index + 1
if talalat:
print('Van a listában hárommal osztható szám.')
else:
print('Nincs a listában hárommal osztható szám.')
A listát bejárhattuk volna egy for ciklus segítségével is természetesen, de felesleges végighaladnunk az összes elemen. A fenti program amint megtatálja az első olyan elemet, amely megfelel a feltételeknek, befejezi a lista átvizsgálását. Hiszen ha már találtunk egy ilyen elemet, megvan a válasz.
Próbáld ki!
'''
Az KERESÉS esetében azt vizsgáljuk,
hogy szerepel-e egy bizonyos tulajdonságú elem az adatsorban (itt a listában),
és ha igen, hányadik helyen.
A program azt vizsgálja, hogy szerepel-e a piros szín a listában, és ha igen, hányadik helyen.
'''
lista = ['kék', 'zöld', 'piros', 'fehér']
talalat = False
index = 0
while index < len(lista) and not talalat:
if lista[index] == 'piros':
talalat = True
index = index + 1
if talalat:
print('Van a listában piros szín, az indexe: ', index-1)
else:
print('Nincs a listában piros szín.')
Gondold végig! Miért kell találat esetén az index meghatározásánál, az 'index' nevű változó értékéből egyet levonnunk ahhoz, hogy helyes eredményt kapjunk?
Próbáld ki!
'''
A KIVÁLASZTÁS esetében azt tudjuk, hogy szerepel (legalább) egy bizonyos tulajdonságú elem
az adatsorban (itt a listában), és ennek az elemnek az indexére vagyunk kíváncsiak.
A program azt vizsgálja, hogy hányadik indexű helyen áll a hárommal osztható szám a listában.
Az első ilyen elem előfordulása érdekel bennünket.
'''
lista = [2, 5, 4, 8, 9, 11, 10, 12]
talalat = False
index = 0
while not talalat:
if lista[index] % 3 == 0:
talalat = True
index = index + 1
print('A hárommal osztható szám indexe a listában: ', index-1)
Ez az algoritmus csak akkor használható, ha biztosak lehetünk benne, hogy szerepel legalább egy darab megadott tulajdonságú elem a listában, különben túlindexelési hibát kapunk.
A SZÁMLÁLÁS esetében azt vizsgáljuk, hogy egy bizonyos tulajdonságú elemből
hány darab van az adatsorban (itt a listában).
A program azt vizsgálja, hogy hány darab hárommal osztható szám van a listában.
'''
lista = [12, 5, 4, 8, 9, 11, 10, 12, 6]
darab = 0
for szam in lista:
if szam % 3 == 0:
darab = darab + 1
print('A listában lévő hárommal osztható számok száma: ', darab)
A SZÉLSŐÉRTÉK MEGHATÁROZÁSA esetében azt vizsgáljuk, hogy melyik a legkisebb,
illetve a legnagyobb érték az adatsorban (itt a listában).
'''
lista = [12, 5, 4, 8, 9, 11, 10, 12, 6]
min = lista[0]
max = lista[0]
for szam in lista:
if szam < min:
min = szam
if szam > max:
max = szam
print('A legkisebb szám a listában: ', min)
print('A legnagyobb szám a listában: ', max)
Eljárás paraméter nélkül, 1 paraméterrel, ill. 2 paraméterrel:
def koszont():
print('Üdv a fedélzeten!')
koszont()
def koszont_nevvel(nev):
print('Szia '+ nev +', üdv a fedélzeten!')
koszont_nevvel('Ádám')
def koszont_ket_nevvel(nev1, nev2):
print('Szia '+ nev1 + ', ' + nev2 +'!\nÜdv a fedélzeten!')
koszont_ket_nevvel('Nóra', 'Ádám')
Próbáld ki!
'''
Az argumentum (aktuális paraméter) lehet érték, kifejezés, változó is!
Az 'x', 'y' és 'eredmeny' nevű változók LOKÁLISAK, csak az eljáráson belül érhetők el!
'''
def osszead(x, y):
eredmeny = x + y
print('A két szám összege: ', eredmeny)
osszead(10, 9)
osszead(5+5, 5+4)
a = 10
b = 9
osszead(a, b)
Próbáld ki!
Az eljárás paramétere természetesen lehet összetett adattípus is:
def osszegzo(list):
osszesen = 0
for szam in list:
osszesen = osszesen + szam
print('A listában lévő számok összege: ', osszesen)
szamok = [3, 5, 19, 11, 17, 1]
osszegzo(szamok)
Próbáld ki!
'''
Változók hatóköre: globális és lokális változók
'''
def kepernyore_ir():
lokalis_valtozo = 'alma'
print(lokalis_valtozo)
print(globalis_valtozo)
globalis_valtozo = 'gyümölcs'
kepernyore_ir()
print(globalis_valtozo)
# a lokalis_valtozo az eljáráson KÍVŰL nem elérhető !!!
print(lokalis_valtozo) # hibát eredményez !!!
# Függvény definíciója
def festek_kalkulator(x, y):
'''
Kiszámolja az adott falfelület festéséhez
szükséges festék mennyiségét
'''
t = x * y
l = t * 0.13
return l
# Függvény hívása
liter = festek_kalkulator(5, 2)
# A függvény hívása lehet egy kifejezés része is
ar = festek_kalkulator(5, 2) * 700
def szamolo(a, b, c=100):
'''
c alapértelmezett értéke: 100
'''
return (a+b)*c
# alapértelmezett paraméter használata
print(szamolo(1, 7))
# alapértelmezett paraméter felülírása
print(szamolo(1, 7, 10000))
# név szerinti paraméter átadás
print(szamolo(c=10000, a=1, b=7))
def max_kereso(x, *args):
'''
egy kötelező paraméter van, és a többi (tetszőlegesen sok)
paraméter az 'args' nevű listában tárolódik
'''
max = x
for szam in args:
if szam > max:
max = szam
return max
print(max_kereso(1, 19, 11, 7, 17))
Adattípusok
Milyen adattípusok állnak rendelkezésünkre Python-ban, amelyekben logikailag összetartozó adatokat tudunk tárolni? A listákat már ismerjük. A Listák létrehozása című (6.1) fejezet Extra részében röviden volt már szó egyéb adatszerkezetekről is, ezeket tárgyaljuk most részletesebben, gyakorlati példákon keresztül is. Megvizsgáljuk, milyen típusú adatokat melyik szerkezetben érdemes tárolni?
Python-ban használt adattípusok
int (egész számok)
float (tizedes törtek)
complex (komplex számok)
str (sztringek)
bool (logikai típus: True / False)
list (lista)
tuple
set (halmaz)
dict (szótár)
Hőmérséklet értékek 7:00, 15:00, 23:00 órakor
'''
homersekletek = []
pentek = [11, 19, 17]
szombat = [13, 22, 20]
vasarnap = [15, 30, 25]
hetfo = [7, 16, 15]
homersekletek.append(pentek)
homersekletek.append(szombat)
homersekletek.append(vasarnap)
homersekletek.append(hetfo)
[[11, 19, 17], [13, 22, 20], [15, 30, 25], [7, 16, 15]]
[[11, 19, 17],
[13, 22, 20],
[15, 30, 25],
[7, 16, 15]]
Hivatkozás a 'homersekletek' lista első (0. indexű) elemére, ami maga is egy lista
print(homersekletek[0]) # [11, 19, 17]
Hivatkozás a 'homersekletek' lista első (0. indexű) elemének második (1. indexű) elemére
print(homersekletek[0][1]) # 19
Az összes adat kiíratása (listák listájának bejárása)
for nap in homersekletek:
for meres in nap:
print(meres)
Módosítás, beszúrás, törlés
# érték módosítása
homersekletek[0][1] = 22
# érték beszúrása
homersekletek[0].insert(0, 0)
# sor beszúrása
homersekletek.insert(1, [0, 0, 0])
# érték törlése, a pop() metódus visszatérési értéke a törölt érték
del homersekletek[0][0]
homersekletek[0].pop(0)
# sor törlése
del homersekletek[1]
homersekletek.pop(1)
Szótár létrehozása
# üres szótár létrehozása
raktar = {}
print(raktar)
# szótár létrehozása adatokkal
diak = {
'vezeteknev': 'Kiss',
'keresztnev': 'Péter',
'eletkor': 17,
'menza': True
}
Hivatkozás a szótár elemeire kulcs alapján
# szótár elemeinek elérése kulcs alapján
print(diak['eletkor'])
print(diak.get('eletkor'))
# nem létező kulcsra való hivatkozás -> KeyError
# print(diak['osztaly'])
# nem létező kulcsra hivatkozunk a .get metódussal,
# ilyenkor a megadott alapértékkel tér vissza
print(diak.get('kollegista', 'nem'))
# ellenőrzés, hogy létezik-e a kulcs
print('keresztnev' in diak)
Érték módosítása
# érték módosítása
diak['eletkor'] = 21
print(diak['eletkor'])
# még nem létező kulcs megadása értékkel
diak['osztaly'] = '10.A'
# kulcs-érték törlése
del diak['vezeteknev']
Próbáld ki!
Szótár bejárása
for kulcs in diak:
print(kulcs, diak[kulcs])
for ertek in diak.values():
print(ertek)
for kulcs, ertek in diak.items():
print(kulcs, ertek)
A gyakorlatban rendszeresen használunk különböző adatszerkezeteket adatok rendezett tárolására. Ezekben az adatszerkezetekben gyakran különböző típusokat ágyazunk egymásba. Az alábbi példában a 'polc' nevű lista felel meg egy könyvespolcnak, a rajta lévő könyveket pedig a listaelemként egy-egy szótár tipusban tárolt információk képviselik.
polc = []
polc.append({
'szerzo': 'William Golding',
'cim': 'A legyek ura'
})
polc.append({
'szerzo': 'Ottlik Géza',
'cim': 'Iskola a határon'
})
print(polc)
[{'szerzo': 'William Golding', 'cim': 'A legyek ura'},
{'szerzo': 'Ottlik Géza', 'cim': 'Iskola a határon'}]
Halmaz létrehozása
'''
Halmaz (set):
- rendezetlen (elemeknek nincs indexe)
- egy elem csak egyszer szerepelhet
- többféle típust tárolhat egyszerre is
- a halmaz eleme maga nem változtatható meg
'''
# halmaz létrehozása
reggeli = {'tea', 'vaj', 'piritós'}
# üres halmaz létrehozása
# ebed = {} <- SZÓTÁRT hoz létre!!!
ebed = set()
# bejárható gyűjteményből, pl. listából
ebed = set(['halászlé', 'kenyér', True])
Halmaz módosítása
# egy elem hozzáadása
reggeli.add('lekvár')
# egy nem meghatározott elem eltávolítása
reggeli.pop()
# egy bizonyos elem eltávolítása
# ha nincs ilyen elem, akkor hibát eredményez
reggeli.remove('sajt')
# egy bizonyos elem eltávolítása
# ha nincs ilyen elem, nem eredményez hibát
reggeli.discard('sajt')
Halmazműveletek
reggeli = {'víz', 'tea', 'vaj', 'pirítós'}
ebed = {'víz', 'halászlé', 'kenyér'}
# metszet
print(reggeli & ebed)
# unio
print(reggeli | ebed)
# különbség
print(reggeli - ebed)
# csak az egyikben, vagy csak a másikban
print(reggeli ^ ebed)
Nézzünk konkrét példát
Algoritmus: Kérjünk egy számot, ha kisebb mint 0, akkor negatív, ellenkező esetben pozitív!
Programozás
szam = int(input('Adj meg egy számot! '))
if szam < 0:
print('A megadott szám negatív.')
else:
print('A megadott szám pozitív.')
print('>> A program vége! <<')
Házi feladat
1. Feladat
Írj egy programot, amely kiírja a páros számokat 1 és 10 között!
2. Feladat
Írj egy programot, amely csökkenő sorrendben írja ki a számokat 1 és 10 között!
3. Feladat
Írj egy programot, amely kiírja a páratlan számokat csökkenő sorrendben 1 és 10 között!
4. Feladat
Írj egy programot, amely a felhasználó által meghatározott alkalommal írja ki a bekért szöveget!
5. Feladat
Írj egy programot, amely a felhasználótól páros számot kér be. Amennyiben a megadott szám páratlan, újra és újra megtörténik az adatbekérés mindaddig, amíg végül páros számot nem ad meg a felhasználó.
6. Feladat
Írj egy programot, amely [1;12] intervallumon állít elő 20 darab véletlenszámot! A képernyőre kizárólag csak a 3-mal oszthatóakat írja ki, és a végén informálja a felhasználót arról is, hány darab ilyen szám volt.
Helló Világ
Készítsük el az alábbi programot. A fájl neve lehet hello, a kiterjesztése .py.
hello.py
print("Helló Világ!")
Futtatás:
Geany programban: F5 billentyű
Parancsorbó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.
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 mondjuk iso-8859-2, de ez nincs megadva a kódban, akkor a következő képen látható hibaüzenetet kapjuk.
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, be 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:
# coding: iso-8859-2
UTF-8 beállítása:
# coding: utf8
Hagyományosan használjuk a „-*-” (kötőjel, csillag, kötőjel) karaktereket is:
# -*- coding: <encoding name> -*-
Interpreter
Unix alapú rendszereken a legelső sorban megadhatjuk a Python értelmező útvonalát:
#!/usr/bin/python
# -*- coding: utf-8 -*-
print("ok")
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.
A Unix alapú rendszereken, így különböző Python verziók használhatók. A hármas verziót például:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
print("ok")
Az értelmező útvonalát olvashatjuk a környezetből is:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
print("ok")
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.
hello.py
#!/usr/bin/python
# coding: utf8
print("Helló Világ!")
input("Folytatáshoz nyomjon 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 print("valami"), 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
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ásos megadni az értelmezőt, az első sorban egy Unix alapú rendszeren?
A következő program, két hibát is tartalmazz. Keresse meg.
A következő program, két hibát is tartalmazz. Keresse meg.
A következő program, hat hibát is tartalmazz. Keresse meg.
A következő program, három hibát tartalmaz. Keresse meg.
A következő program, öt hibát tartalmaz. Keresse meg.
A következő program, két hibát is tartalmazz. Keresse meg.
#!/usr/bin/python
# coding: utf8
print(Budapest);
print(Kék utca 45.);
Megjegyzés
Egysoros megjegyzés
Egysoros megjegyzéseket tehetünk a kódba a „#” jel segítségével.
# Megjegyzés
A megjegyzések állhatnak utasítás után is
print("ok") # Megjegyzés
if "joska" in nevek: # Megvizsgáljuk benne van-e
print("benne van")
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.
"""
több
soros
megjegyzés
"""
'''
több
soros
megjegyzés
'''
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
Kivitel
A print utasítás
Szöveget írathatunk ki idézőjelek és felső vesszők között is:
print("Alma")
print('Alma')
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ó:
a = 3
print("Szám: ", a)
print("egy", "kettő", "három")
a=30
b=35
c=45
print(a, b, c)
A print() automatikusan sortörést ír a szöveg végén. Ha szeretnénk a sortörést tiltani:
print('alma', end = '')
print('alma', end = ' ')
Több utasítás is írható (;) pontosvesszővel tagolva, egy sorba.
print('egy'); print('kettő')
sys
program01.py
import sys
sys.stdout.write("Valami\n")
Azokat a változókat amelyek szám értékeket tartalmaznak, át kell konvertálni szöveggé:
program01.py
import sys
szam = 35
sys.stdout.write(str(szam))
Összevonás más karaktersorozattal:
program01.py
import sys
szam = 35
sys.stdout.write(str(szam) + " kg")
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.
test.py
print("alma", "körte", Barack)
print("egy";"kettő")
Az alábbiakban két print() utasítást lát. Melyik helyes szintaktikailag?
print('alma')
print("alma")
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
\" 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:
print("alma\bkörte")
A fenti utasítás kitörli az alma szó utolsó „a” betűjét.
Soremelés használata:
print("alma\nkörte")
Tabulátor használata:
print("alma\tkörte")
Karakter kiírása hexadecimális kód alapján:
print("\x45")
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
semmi (NULL)
Egész:
egesz = 15
valos = 15.1234
gyumolcs = 'alma'
fa = "körte"
ehes_vagyok = True
fazok = False
valami = None
A típusok lekérdezhetők a type() függvénnyel. Például:
Egész példa:
szam = 17
print(type(szam))
A kimenet:
<class 'int'>
Valós példa:
szam = 17.612345
print(type(szam))
Kimenet:
<class 'float'>
Karaktersorozat példa:
nev = "Nagy János"
print(type(nev))
Kimenet:
<class 'str'>
Logikai példa:
szam = 5
eredmeny = szam > 5
print(type(eredmeny))
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.
szam = 3
print("Teszt" , szam)
Több változó összeadással:
szam1 = 3
szam2 = 5
osszeg = szam1 + szam2
print("Összeg: " , osszeg)
Több változó szöveg összevonásával:
szoveg1 = "Szeretem"
szoveg2 = " az almát"
kiirando = szoveg1 + szoveg2
print("Következtetés: " , kiirando)
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:
num = float(5)
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:
from typing import Final
pi: Final[float] = 3.14159265359
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.
szam = 2840000
A jobb átláthatóság kedvéért a szám literálisok tagolhatók: alulvonással:
szam = 2_840_000
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.
print("vmi'va")
print('vmi"va')
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
Korábbi változat
A print() függvény segítségével az értékek formázva is kiírhatók. Formázott kimenethez egy formátum sztringet kell készíteni. A formátum sztringben 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.
Először nézzük meg, különösebb formázás nélkül hogyan íratunk ki egy számot:
szam = 3
print("Szám: %d" % szam)
A következő programban már egy kis formázást is végzünk. Egy egész szám íratunk ki 10 helyen.
szam = 3
print("Szám: %10d" % szam)
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.
szam = 3.12345678
print("Szám: %10.2f" % szam)
Szöveg kiíratása
nev = "körte"
print("Név: %s" % nev)
Több érték formázása:
print("%10d %10d" % (97, 48))
print("Életkor: %s, Fizetés: %f" % (28, 2800000))
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
> Jobbra igazítás
0 Vezető nullák
, Ezredes elválasztás
= Előjeles ábrázolás
^ Középre igazítás
format() függvény
print('{} {}'.format(48, 8400000))
print('{} kg {} Ft'.format(48, 8400000))
Szélesség (elavult):
print('%20d'% 8400000)
Szélesség (új):
print('{:20}'.format(8400000))
A szöveg alapértelmezetten, balra van igazítva:
print('{:10}'.format('8400000'))
A szöveg jobbra igazítása:
print('{:>10}'.format('8400000'))
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:
print('{:<10}'.format(8400000))
Kitöltés, alulvonással:
print('{:_<10}'.format('8400000'))
Középre igazítás:
print('{:^15}'.format(8400000))
A formátum szöveget tehetjük külön változóba:
gyumolcs = "Mennyiség: {} kg"
print(gyumolcs.format(16))
gyumolcs = "Mennyiség: {} kg Ár: {} Ft"
print(gyumolcs.format(16, 840))
Tizedesjegyek megadása:
gyumolcs = "Mennyiség: {} kg Ár: {:.2f} Ft"
print(gyumolcs.format(16, 840.12345))
Szélesség megadása:
gyumolcs = "Mennyiség: {:10} kg Ár: {:10} Ft"
print(gyumolcs.format(16, 840))
Vezető nulla:
gyumolcs = "Ár: {:010} Ft"
print(gyumolcs.format(840))
Ezredes tagolás:
gyumolcs = "Ár: {:,} Ft"
print(gyumolcs.format(8400000))
Előjel:
gyumolcs = "Ár: {:+20} Ft"
print(gyumolcs.format(8400000))
Sorrend megadása:
szoveg = "Az ő neve {1}. {1} életkora: {0}"
print(szoveg.format(34, "Mari"))
print('{0} {1}'.format(45, 28))
print('{1} {0}'.format(45, 28))
További formázási lehetőségek:
https://pyformat.info/
Igazítás és kitöltés
print('Valami'.center(20, '='))
Lehetséges kimenet:
=======Valami=======
print('Valami'.ljust(20, '='))
Lehetséges kimenet:
Valami==============
print('Valami'.rjust(20, '='))
==============Valami
A sep
Megadhatjuk a szeparátort:
print(45, 23, 97, sep=",")
A kimenet:
45,23,97
Kettősponttal:
print(45, 23, 97, sep=":")
45:23:97
Lásd még
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.
print('{:>10}'.format(45))
print("%10d" % 45)
Mit ír a képernyőre a következő utasítás?
print('|{:10}|'.format(45))
Matematikai eszközök
A math modul
A matematikai modul használatához, importálnunk kell a math modult. A „*” karakterrel a math modul összes függvényét importáljuk, de megadhatunk egy vagy több függvényt is vesszővel elválasztva.
Gyökvonás és importálás:
import math
print(math.sqrt(9))
Így importálva, mindig elé kell írni a math objektumnevet.
Az sqrt statikusan importálva:
from math import sqrt
print(sqrt(9))
Vegyük észre hogy fentebb csak az sqrt függvényt importáltuk a math modulból.
A következőkben a sqrt() és a sin() függvényt is importáljuk:
from math import sqrt,sin,pi
print(sqrt(9))
print(sin(1 * pi / 180))
Az összes függvény importálása:
from math import *
print(sqrt(9))
print(sin(1 * pi / 180))
Most nézzünk néhány függvényt. Koszinusz számítása:
import math
szog = 1
rad = szog * math.pi / 180
print(math.cos(rad))
Tangens:
import math
szog = 1
rad = szog * math.pi / 180
print(math.tan(rad))
Kerekítés felfelé:
import math
print(math.ceil(5.1))
Kerekítés lefelé:
import math
print(math.floor(5.9))
Szög konvertálása radiánba:
import math
print(math.radians(1))
Radián konvertálása szöggé:
import math
print(math.degrees(0.017453292519943295))
Hatványozás:
import math
print(math.pow(2, 8))
A math.pow() lebegőpontos értékekhez megfelelő. A pow() és a ** operátor egész értékekhez.
Több információ:
https://docs.python.org/3.7/library/math.html (2020)
Natív függvények
Hatványozás
print(pow(2, 8))
Abszolút érték:
print(abs(-9))
print(round(15.61234))
Kimenet:
16
print(round(15.61234, 2))
Kimenet:
15.62
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
import random
print(random.random())
from random import random
print(random())
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:
import random
Szintaxis:
random.randrange([start,] stop[, step])
Példák:
0-tól – 5-ig számok:
print(random.randrange(6))
Megadható alsó határ is. 10-től – 14-ig számok:
print(random.randrange(10, 15))
iterálva:
veletlenek.py
import random
for szam in range(20):
print(random.randrange(3))
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 <= N <= b. A randrange(a,b+1) formával azonos.
Példa:
dobokocka.py
import random
# 1-től -- 6--ig szám előállítása:
print(random.randint(1,6))
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()
seq="abcd"
random.choice(seq)
print(random.choice("abcd"))
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.
from random import seed
from random import random
seed(1)
print(random(), random(), random())
seed(1)
print(random(), random(), random())
Lehetséges kimenet:
0.13436424411240122 0.8474337369372327 0.763774618976614
0.13436424411240122 0.8474337369372327 0.763774618976614
10 véletlenszám generálása:
from random import seed
from random import random
seed(1)
for _ in range(10):
vel = random()
print(vel)
Lehetséges kimenet:
0.13436424411240122
0.8474337369372327
0.763774618976614
0.2550690257394217
0.49543508709194095
0.4494910647887381
0.651592972722763
0.7887233511355132
0.0938595867742349
0.02834747652200631
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
** hatványozás
+x, -x, ~x unary plusz és mínusz, bitenkénti nem
*, /, //, % szorzás, osztás, egész osztás, maradék
+, - összeadás, kivonás
<<, >> bitmozgató shift operátorok
& bitmozgató AND
^ bitmozgató XOR
| bitmozgató OR
==, !=, >, >=, <, <=, 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
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.
not szam1 > 100
Az is és a not használható együtt. Például:
szam is not 100
Konvertálás
Sztring valóssá
A konvertáláshoz a float() függvényt használjuk:
a = "123.12345"
float(a)
konvert.py
szamStr = "343.34521"
szam = float(szamStr)
print("Szám: ", szam*2)
Sztring egésszé
a = "123.12345"
int(float(a))
konvert.py
#!/usr/bin/python3
szamStr = "343.34521"
szam = int(float(szamStr))
print("Szám: ", szam*2)
konvert.py
#!/usr/bin/python3
szamStr = "345"
szam = int(szamStr)
print("Szám: ", szam*2)
Egész sztringgé
konvert.py
#!/usr/bin/python3
szam = 345
szamStr = str(szam)
print("Szám: ", szamStr + " db")
Valós sztringgé
konvert.py
#!/usr/bin/python3
szam = 345.12345
szamStr = str(szam)
print("Szám: ", szamStr + " kg")
Bevitel
program01.py
szam = int(input("Szám: "))
print(szam * 2)
Szöveg bekérése:
szoveg = input("Szöveg: ")
Egész szám bekérése:
eszam = int(input("Egész szám: ")
Valós szám bekérése:
vszam = float(input("Valós szám: ")
Két szám bekérése, összeadása:
szam1 = int(input('Szám1: '))
szam2 = int(input('Szám2: '))
eredmeny = szam1 + szam2
print('Eredmény: ', eredmeny)
Az input() függvény használható paraméter nélkül is:
print("Szám: ", end='')
szam = int(input())
print(szam * 2)
A példában, a bekérő szöveget print() függvénnyel íratjuk ki.
Régi forma:
szoveg = raw_input("Szöveg: ")
Szekvencia
A szekvenciális tevékenység, csak annyit jelent, hogy egymás után sorba írjuk az utasításokat.
tevékenység1
tevékenység2
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.
if feltétel:
tevékenység
Ha ellenben ág is létrehozható, az else kulcsszóval. Az else után (:) kettőspontot írunk:
if feltétel:
tevékenység
else:
tevékenység2
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:
if feltétel:
tevékenység
elif feltétel2:
tevékenység2
else:
tevékenység3
Példák
a = 3
if a > 0:
print "Pozitív"
elif a < 0:
print "Negatív"
else
print "Nulla"
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.
if a < 0:
print "Negatív szám"
print "Nem jó nekünk"
print "Folytatás..."
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:
a = 5
if a < 0:
print "Negatív szám"
print "Nem jó nekünk"
print "Folytatás..."
a = 5
if a < 0:
print "Negatív szám"
print "Nem jó nekünk"
print "Folytatás..."
Futtassuk le, és nézzük meg mi a kettő különbsége.
Relációs operátorok használata a szelekcióban
szam = 9
if szam % 2 == 0:
print "páros"
else:
print "páratlan"
Boolean változó
A feltétel lehet egy boolean változó is:
szam = 30
paros = szam % 2 == 0
if paros:
print("Páros")
else:
print("Nem páros")
Iteráció
while
A Python nyelvben az egyik ciklus meghatározási lehetőség a while. A while után í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.
i = 0
while i < 10:
i = i + 1
print i, " Valami"
print "Vege"
A while ciklus különleges a Python nyelvben, mert mondhatok a végén egy else:-t.
szam = 0
while szam<5:
print(szam)
szam += 1
else:
print('vége')
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:
szam = -1
while szam != 0:
szam = int(input('Szám: '))
if szam == 10:
break
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
lista = ['macska', 'ablak', 'utca']
for b in lista:
print(b)
# Kiírja 4-szer a 'Helló Világ' szöveget
for n in range(1, 5):
print("Helló Világ")
for n in range(1, 5):
print(n, end=' ')
# A következő sorozatot állítjuk elő:
# 1 2 3 4
for n in range(5):
print(n, end=' ')
# A következő sorozatot állítjuk elő:
# 0 1 2 3 4
Intervallum
A range segítségével listákat hozhatunk létre:
# [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)
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
for i in range(10):
print(i)
Szövegkezelés
Karakter
>>> chr(97)
'a'
>>> chr(35)
'#'
>>> chr(8364)
'€'
>>> chr(8721)
'∑'
>>> ord('a')
97
Az ord() visszaadja a Unicode értéket is:
>>> ord('€')
8364
Konkatenálás
szoveg3 = szoveg1 + szoveg2
Ha bekérjük a szöveget, ne felejtsük el, hogy a szöveg végére egy „kocsi vissza” karakter is beíródik. Annak eltávolítására használható a rstrip() függvény:
vnev = input("Vezetéknév: ")
knev = input("Keresztnév: ")
teljesnev = vnev.rstrip() + knev.rstrip()
Az rstrip() függvény törli egy szöveg jobboldaláról a whitespace karaktereket.
De létezik lstrip() és strip() metódus is. Az lstrip() balról törli a whitespace karaktereket, a strip() mindkét oldalról.
Hossz
Szöveg hossza:
szoveg = "körte"
print(len(szoveg))
Eredmény:
5
Karakterenként
szoveg = 'szilva'
betu = szoveg[0]
A fenti program, az „s” betűt adja eredményül. Az szoveg[1] a „z” betűt adja, stb.
A karakterláncok tagjait negatív indexel is megadhatjuk.
Karakterlánc szeletek
>>> gy = 'szilva'
>>> gy[2:5]
'ilv'
>>> gy = 'szilva'
>>> gy[:3]
'szi'
>>> gy = 'szilva'
>>> gy[3:len(gy)]
'lva'
>>>
Új hivatkozás létrehozása:
>>> gy = 'szilva'
>>> id(gy)
140327646241600
>>> gy2 = gy[:]
>>> id(gy2)
140327646241600
>>> gy is gy2
True
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.
Darabolás
tomb = szoveg.split()
Megadhatjuk a szeparátort:
szoveg = "alma:körte:barack"
tomb = szoveg.split(':')
Rakhatjuk külön változókba is:
szoveg = "alma:körte:barack"
elso, masodik, harmadik = szoveg.split(':')
Whitespace karakterek esetén, elég így:
szoveg = "alma körte barack"
elso, masodik, harmadik = szoveg.split()
Tárolás változókban:
dolgozo = 'Nagy János:Szolnok:3840000'
(nev, telepules, fizetes) = dolgozo.split(':')
Benne van-e?
sor = "vi farkas más"
if "farkas" in sor:
print("ok")
Keresés
A find() visszaadja a keresett szöveg helyét. Indexelés 0-tól.
szoveg = 'Mari, Kati, Lajos'
print(szoveg.find('Kati'))
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.
szoveg = 'Mari, Kati, Lajos'
try:
print(szoveg.index('Kaati'))
except ValueError:
print('A szöveg nem található!')
else:
print('Találat')
Karakterek osztályozása
Szám?
szoveg = '6'
print(szoveg.isdigit())
Csak számok és betűk?
szoveg = '6'
print(szoveg.isalnum())
Csak betűk?
szoveg = '6'
print(szoveg.isalpha())
Csak kisbetűs?
szoveg = '6'
print(szoveg.islower())
Csak nagybetűs?
szoveg = '6'
print(szoveg.isupper())
Cím? Vagyis minden szó nagybetűvel kezdődik?
szoveg = '6'
print(szoveg.istitle())
Whitespace karakterek?
szoveg = '6'
print(szoveg.isspace())
Nyomtatható karakterek:
szoveg = '6'
print(szoveg.isprintable())
Csere
Töröljük a bekért IP címből a pontokat:
ip=input("IP cím: ")
ipDigitsStr=ip.replace('.','')
Karaktersorozat része
A karaktersorozat vége a 6-s indextől:
szoveg = 'Kati, Lajos, Mari'
resz = szoveg[6:]
print(resz)
Eredmény: Lajos, Mari
A 6-s indextől a 9-s indexig:
szoveg = 'Kati, Lajos, Mari'
resz = szoveg[6:9]
print(resz)
Eredmény: Laj
A 9-s indexig, a karaktersorozat eleje:
szoveg = 'Kati, Lajos, Mari'
resz = szoveg[:9]
print(resz)
Eredmény: Kati, Laj
Részszöveg megszámolása
szoveg = 'Kati, Lajos, Mari, Lajos'
darab = szoveg.count('Lajos')
print(darab)
Bejárás
szoveg = 'valami'
for karakter in szoveg:
print(karakter)
szoveg='valami'
hossz=len(szoveg)
for i in range(1, hossz):
print(szoveg[i])
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.
fp = open('adat2.txt', 'r')
line = fp.readline()
while line != '':
print(line.strip())
line = fp.readline()
fp.close()
Tömb karaktersorozattá
lista1 = ['a', 'b', 'c']
str1 = ''.join(lista1)
print(str1)
Szeparáljuk : karakterrel:
lista1 = ['a', 'b', 'c']
str1 = ':'.join(lista1)
print(str1)
lista1 = []
lista1.append('egy')
lista1.append('kettő')
lista1.append('három')
szoveg = ':'.join(lista1)
Beépített függvények
Első betű nagybetű:
szoveg.capitalize()
Minden kisbetűs:
szoveg.lower()
Minden nagybetűs:
szoveg.upper()
Minden szó első betűje nagybetű:
szoveg.title()
A nagy volt legyen kicsi, ami kicsi volt legyen nagy:
szoveg.swapcase()
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:
egyLista = []
Lista létrehozása és kiíratása:
egyList = [3, 8, 5, 6, 2, 9]
print(egyList)
Elem átírása:
egyLista = [3, 8, 5, 6, 2, 9]
egyLista[1] = 12
Hivatkozás egy elemre:
egyList = [3,5,6,7]
print("Első elem: ", egyList[0])
print("Második elem: ", egyList[1])
Nézzük a listákat Python shellben:
>>> # 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'
Egyenlőség vizsgálat; értékük egyenlő:
egyLista == kettoLista
Ugyanarra mutat?:
egyLista is kettoLista
Listák összefűzése:
egyLista = [3,5,6,7]
kettoLista = [8,4,9]
haromLista = egyLista + kettoLista
Méret:
print(len(egyList))
Feltöltés számokkal:
egyLista = []
egyLista.extend(range(1, 60))
Bejárás:
egyList = [30, 41, 27, 19, 45, 35, 87, 53, 17]
for elem in egyList:
print(elem)
Tartalmazás:
if 45 in egyList:
print("Van 45")
Hozzáfűzés:
egyList = []
egyList.append(9)
egyList.append(4)
print("Első elem: ", egyList[0])
print("Második elem: ", egyList[1])
Beszúrunk egy elemet 1-s indexel:
egyList = [3, 8, 5, 6, 2, 9]
egyList.insert(1, 23)
print(egyList)
kettoList = ['körte', 'szilva', 'barack' ]
kettoList.insert(1, 'alma')
print(kettoList)
Kimenet:
[3, 23, 8, 5, 6, 2, 9]
['körte', 'alma', 'szilva', 'barack']
Elem törlése:
egyList = [3, 8, 5, 6, 2, 9]
egyList.remove(8)
print(egyList)
Utolsó elem törlése:
egyList.pop()
Első elem törlése:
egyList.pop(0)
Index lekérdezése:
egyList = [3, 8, 5, 6, 2, 9]
kettoList = egyList.index(2)
print(kettoList)
Az utolsó elem törlése:
egyList = [3, 8, 5, 6, 2, 9]
egyList.pop()
print(egyList)
Kimenet:
[3, 8, 5, 6, 2]
Megadható index is:
egyList = [3, 8, 5, 6, 2, 9]
egyList.pop(2)
print(egyList)
Kimenet:
[3, 8, 6, 2, 9]
Az összes elem törlése:
egyList = [ 35, 40, 27 ]
egyList.clear()
print(egyList)
Másolás:
egyList = [ 35, 40, 27 ]
kettoList = egyList.copy()
print(kettoList)
A másolást a list() függvénnyel is elvégezhetjük:
egyList = [ 35, 40, 27 ]
kettoList = list(egyList)
print(kettoList)
Másolás harmadik módon:
egyList = [ 35, 40, 27 ]
kettoList = egyList[::]
print(kettoList)
A másolás nem végezhető el egy egyszerű értékadással. Készítsünk egy listát:
egyLista = [ 3, 4, 5, 8]
masikLista = egyLista
print(masikLista)
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.
egyLista = [ 3, 4, 5, 8]
masikLista = egyLista
print(masikLista)
egyLista[2] = 20
print(masikLista)
Első és utolsó elem törlése szeleteléssel:
egyLista = [ 3, 4, 5, 8]
masikLista = egyLista[1:-1]
Marad: [ 4, 5 ]
Listák összefűzése:
egyList = [ 35, 40, 27 ]
kettoList = [43, 27, 85 ]
haromList = egyList + kettoList
print(haromList)
Másolás másként:
egyList = [ 35, 40, 27 ]
kettoList = [43, 27, 85 ]
for elem in kettoList
egyList.append(elem)
print(egyList)
Másolás az extend() függvénnyel:
egyList = [ 'a', 'b', 'c' ]
kettoList = [43, 27, 85 ]
egyList.extend(kettoList)
print(egyList)
Konstruktor használata:
egyList = list((35, 40, 27))
print(egyList)
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:
matrixList = [[1,1,1],[1,1,1],[1,1,1]]
print(matrixList[0][0])
Méret
A mátrix típusú lista mérete:
matrixList = [[2,1,7],[9,3,8],[5,3,1], [5,6,8]]
print(len(matrixList))
Eredmény:
4
Lista bejárása
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)
Kimenet:
Jóska
Kati
Mari
János
Gábor
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]
Kimenet:
0 Jóska
1 Kati
2 Mari
3 János
4 Gábor
Tuple
A tuple olyan számok és karaktersorozatok 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:
egyTuple = ()
Egy elemű tuple:
egyTuple = (25,)
egyTuple = (3, 8, 5, 6, 2, 8)
Hozzáférés egy elemhez:
print(egyTuple[0])
Negatív index:
print(egyTuple[-1])
A 8-s értéket adja. A -2 a 2-s értéket adja.
Tartomány:
print(egyTuple[2:5])
5-ig:
print(egyTuple[:5])
2-től:
print(egyTuple[2:])
Tartomány negatív értékekkel:
print(egyTuple[-4:-2])
Bejárás:
egyTuple = (3, 8, 5, 6, 2, 8)
for elem in egyTuple:
print(elem)
Tartalmazás:
if 45 in egyTuple:
print("Van 45")
Összefűzés:
egyTuple = (3, 8, 5, 6, 2, 9)
kettoTuple = (14, 20, 11)
haromTuple = egyTuple + kettoTuple
print(haromTuple)
Konstruktor:
egyTuple = tuple((3, 8, 5, 6, 2, 9))
print(egyTuple)
A tuple két beépített metódussal rendelkezik. A count() és az index().
A count():
egyTuple = (3, 8, 5, 6, 2, 9)
print(egyTuple.count(5))
A count() megszámolja, adott érték hányszor fordul elő a tuple-ben.
Az index, megmondja, hol található a keresett érték.
egyTuple = (3, 8, 5, 6, 2, 9)
print(egyTuple.index(5))
Lista és tuple konvertálása
t = ('alma', 'körte', 'barack', 'szilva')
print(list(t))
l = ['alma', 'körte', 'barack', 'szilva']
print(tuple(l))
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.
Utasítások összefogása
A következő példában, négy utasítást fogunk össze a függvénnyel.
nevjegy.py
def nevjegy():
print('--------------')
print(' Nagy János')
print(' Hatvan')
print('--------------')
nevjegy()
Argumentum használata
dupla.py
def dupla(szam):
print(szam*2)
dupla(30)
Több argumentum használata
szorzo.p
def szorzas(szam1, szam2):
print(szam1*szam2)
szorzas(30, 35)
Visszatérési érték
A függvények visszatérhetnek egy értékkel, vagy egy összetett adatszerkezet címével.
osszeado.py
def osszead(szam1, szam2):
eredmeny = szam1 + szam2
return eredmeny
print(osszead(3, 2))
haromszog.py
def haromszogTerulet(alap, magassag):
terulet = (alap*magassag)/2
return terulet
print(haromszogTerulet(30, 35))
Kulcsparaméterek használata
haromszog.py
def haromszogTerulet(alap=0, magassag=0):
terulet = (alap*magassag)/2
return terulet
print(haromszogTerulet(magassag=35, alap=30))
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.
Ha a globális változóra gondolunk:
szam = 35
def kiir():
global szam
print(szam)
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:
f = open('adat.txt', 'r')
tartalom = f.read()
print(tartalom)
f.close()
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:
s = f.read(5)
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.
f = open('adat.txt', 'a')
f.write('Üdv\n')
f.close()
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.
olvas.py
f = open('adat2.txt', 'w')
f.write("Első")
f.write("Második")
f.close()
Í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.
olvas.py
f = open('adat2.txt', 'w', encoding='utf-8')
f.write("Első")
f.write("Második")
f.close()
Lista írása fájlba
fp = open('adat.txt', 'w')
lista = ['egy\n', 'kettő\n', 'hátom\n']
fp.writelines(lista)
fp.close()
Eredmény:
adat.txt
egy
kettő
három
Olvasás fájlból
A szöveges fájlokat soronként dolgozzuk fel. Írja meg a következő programot.
olvas.py
fp = open('adat.txt', 'r')
line = fp.readline()
while line != '':
print(line.rstrip())
line = fp.readline()
fp.close()
Olvasás fájlból break utasítással
olvas.py
f = open('adat.txt', 'r')
while 1:
sor = f.readline()
if sor == '':
break
print(sor.rstrip())
f.close()
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.
olvas.py
with open("adat.txt") as f:
for sor in f:
print(sor)
Olvasás újabb verzió 2
olvas.py
fp = open('adat.txt', 'r')
lines = fp.readlines()
for line in lines:
line = line.rstrip()
print(line)
fp.close()
Olvasás listába
olvas.py
lista = open('adat.txt', 'r').read().splitlines()
print(lista)
olvas.p
fp = open('adat.txt', 'r')
lista = fp.read().splitlines()
fp.close()
print(lista)
Kódolás megadása
olvas.py
fp = open('adat.txt', 'r', encoding='utf-8')
lista = fp.read().splitlines()
print(lista)
Kivételkezeléssel
olvas.py
try:
fp = open('adat.txt', 'r', encoding='utf-8')
lista = fp.read().splitlines()
finally:
fp.close()
print(lista)
A Python 3.8-tól
A Python 3.8-tól használható a := értékadó operátor:
olvas.py
fp = open('adat.txt', 'r')
while line := fp.readline():
print(line.rstrip())
fp.close()
Mezőnevek az első sorban
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
olvas.py
fp = open('adat2.txt', 'r')
lines = fp.readlines()
for line in lines[1:]:
print(line.rstrip())
fp.close()
Vagy egyszerűen töröljük az elsőt:
lines.pop(0)
De akár a végéről is törölhetünk:
lines.pop()
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.
haromszog.py
def szamitKerulet(a, b, c):
return a + b + c
def szamitTerulet(alap, magassag):
return (alap*magassag)/2
A modul használata:
program01.py
import haromszog
print(haromszog.szamitKerulet(30, 35, 40))
Statikus használat
A modul használata, statikusan:
program01.py
from haromszog import szamitKerulet
print(szamitKerulet(30, 35, 40))
Így rövidebben használhatjuk a szamitKerulet() függvényt, azonban nagyobb az esély a névütközésre.
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:
>>> 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']
>>>
Saját útvonal beszúrása:
sys.path.insert(0, sajatUtvonal)
A __name__ változó
Amikor futtatok egy programot, az aktuális fájlban automatikusan létrejön __name__ nevű változó aminek az értéke: __main__
Tegyük fel, hogy adott egy projekt01.py főprogram, és egy modul, modul1.py néven:
projekt01/
|-modul1.py
`-projekt01.py
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 __name__ nevű állandó. Ebben az állandóban a __main__ 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:
modul1.py
def sajatFuggveny():
pass
if __name__ == "__main__":
sajatFuggveny()
A __name__ változóval, tehát tesztelhető, hogy a modulunkat közvetlenül futtatják, vagy másik programból hívják.
http://www.elektromanoid.hu/
Nincsenek megjegyzések:
Megjegyzés küldése