Tartalomjegyzék

< Python

Python nyelv

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:

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:

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:

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.

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:

# 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.

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:

#!/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...")

Ü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 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

#!/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 „#” 1) 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")

Láthatjuk, hogy a # karakternek többféle szerepe is 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.

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

""" 
több
soros
megjegyzés
"""
'''
több
soros
megjegyzés
'''

Gyakorlat 003

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)

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:

print('alma', end = '')
print('alma', end = ' ')

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:

print(45, 23, 97, sep=",")

A kimenet:

45,23,97

Szeparálás kettősponttal:

print(45, 23, 97, sep=":")

Kimenet:

45:23:97

A file paraméter

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

fp = open('dolgozok.txt', 'w')
print('Lali:Szeged:347', file = fp)
fp.close()

Szorzás

print("-"*5)

Kimenet:

-----

sys modul

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

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

test.py
print("alma", "körte", Barack)
print("egy";"kettő")
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

Típusok

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.

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

from typing import Final
pi: Final[float] = 3.14159265359

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

Formázott kivitel

A formázást három módon oldhatjuk meg:

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:

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

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
+ 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:

print("%#x" % 12)

Eredmény:

0xc

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))

Index és formázás együtt:

num1 = 35
num2 = 18
 
print("{1:10} {0:10}".format(num1, num2))

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
^ Középre igazítás

További formázási lehetőségek:

String metódusok

print('Valami'.center(20, '='))

Lehetséges kimenet:

=======Valami=======
print('Valami'.ljust(20, '='))

Lehetséges kimenet:

Valami==============
print('Valami'.rjust(20, '='))
==============Valami

Lásd még

Gyakorlat 007

print('{:>10}'.format(45))
print("%10d" % 45)
print('|{:10}|'.format(45))

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

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

A math modul

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

Gyökvonás és importálás:

import math
print(math.sqrt(9))

Így importálva, mindig elé kell írni a math objektumnevet.

import math
print(math.pow(2, 8))
import math
szog = 1
rad = szog * math.pi / 180
print(math.sin(rad))
print(math.cos(rad))
print(math.tan(rad))
import math
print(math.ceil(4.1))
print(math.floor(4.9))

Statikus importálás

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. 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:

from math import sqrt,sin,pi
print(sqrt(9))
print(sin(1 * pi / 180))

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

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ó:

Gyakorlat 008

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.

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:

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, é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.

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 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.

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

Az in kulcsszó után felsoroljuk a számokat:

for i in 1, 2, 3, 4, 5:
    print(i)

Az i változóban sorra megkapjuk a számokat.

A számokat szögletes zárójelbe is tehetjük:

for i in [1, 2, 3, 4, 5]:
    print(i)

A számoknak nem kell rendezettek legyenek:

for i in 25, 2, 9, 45, 52:
    print(i)

A kimenet:

25
2
9
45
52

Szöveg is lehet a számok helyett:

for gyumolcs in 'alma', 'körte', 'barack':
    print(gyumolcs)
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

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.

>>> 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

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.

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])

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.

Kódból

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

Darabolás

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

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 újra:

dolgozo = 'Nagy János:Szolnok:3840000'
(nev, telepules, fizetes) = dolgozo.split(':')

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:

sor = "vi farkas más"
if "farkas" in sor:
	print("ok")

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.

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('.','')

Részszöveg megszámolása

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

szoveg = 'Kati, Lajos, Mari, Lajos'
darab = szoveg.count('Lajos')
print(darab)

A whitespace karakter törlése

Használható függvények:

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)

Kezdet

Milyen karakterrel kezdődik egy szöveg?

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

Több karakter vizsglata:

szo = 'almát ennék'
 
if szo.startswith('alm'):
    print('almát enne')
else:
    print('mást enne')

Vég

szoveg = 'alma'
 
if szoveg.endswith('a'):
    print('a-ra végződik')
else:
    print('másra végződik')

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

Listák összefűzése ciklussal:

egyList = [ 35, 40, 27 ]
kettoList = [43, 27, 85 ]
 
for elem in kettoList
    egyList.append(elem)
 
print(egyList)

Listák összefűzése az extend() függvénnyel:

egyList = [ 'a', 'b', 'c' ]
kettoList = [43, 27, 85 ]
 
egyList.extend(kettoList)
 
print(egyList)

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)

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

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

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)

Az összes elem törlése:

egyList = [ 35, 40, 27 ]
egyList.clear()
print(egyList)

Index lekérdezése:

egyList = [3, 8, 5, 6, 2, 9]
index = egyList.index(2)
print(index)

A mintaprogramban a 2 számot keressük, szeretnénk megtudni mi az indexe.

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át létrehozhatunk a list() konstruktorral is.

Konstruktor használata:

egyList = list((35, 40, 27))
print(egyList)
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:

matrixList = [[1,1,1],[1,1,1],[1,1,1]]
print(matrixList[0][0])

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

Mátrix bejárása:

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()

A futtatás kimenete:

2 1 7 
9 3 8 
5 3 1 
5 6 8 

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:

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.

Üres függvény

def valami():
    pass

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.

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.

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

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

  1. write()
    • Írás a fájlba.
  2. writelines()
    • Írás a fájlba.

Olvasás fájlból

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

Pozicionálás

  1. 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()

Í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()

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

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.

program01.py
from haromszog import szamitKerulet
from haromszog import szamitTerulet
 
print(szamitKerulet(30, 35, 40))
print(szamitTerulet(30, 35))
program01.py
from haromszog import szamitKerulet, szamitTerulet
 
print(szamitKerulet(30, 35, 40))
print(szamitTerulet(30, 35))

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']
>>>
>>> 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']
>>>

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.

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ó.

1)
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