Python nyelv

• Szerző: Sallai András
• Copyright © 2011, Sallai András
• Szerkesztve: 2011-2024
• Licenc: CC BY-SA 4.0
• Web: https://szit.hu

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

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

A Python egy általános célú, magas szintű nyelv, amelyet leggyakrabban a következőkre használnak:

• robotika
• beágyazott rendszerek
• Arduino
• adatelemzés

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

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

Kérdések:

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

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ű
• Parancssorból:

python hello.py

Ha Linuxon telepítve van a python 2-s verziója is, akkor a futtatás

python3 hello.py

Futtathatjuk a 2-s python verzióval is, de akkor meg kell adni karakterkódolást.

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.

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

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.

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.

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

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

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

• 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.);

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

Láthatjuk, hogy a # karakternek többféle szerepe is van:

• Python interpreter útvonalának megadása.
• Karakterkódolás beállítása.
• Megjegyzést.

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

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

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

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

print("-"*5)

Kimenet:

-----

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

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

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.

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

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

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

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ó típusának annotálása
x: int = 10
y: float = 20.5
name: str = "Mari"
is_valid: bool = True

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.

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

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

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

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

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

• modulo operátor
• format függvény
• f-string

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

A #-re minta:

print("%#x" % 12)

Eredmény:

0xc

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

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

• https://pyformat.info/

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

Lehetséges kimenet:

=======Valami=======

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

Lehetséges kimenet:

Valami==============

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

==============Valami

• f-string

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

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

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

• https://docs.python.org/3.7/library/math.html (2020)

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

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

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.

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.

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

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

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

and  és
or   vagy
not  tagadás

Zárójelek használatával egy lehetséges példa:

(A and (not B)) or C

>
<
>=
<=
==
!=

Még több operátor:

• https://docs.python.org

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

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)

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)

konvert.py

#!/usr/bin/python3
 
szam = 345
szamStr = str(szam)
print("Szám: ", szamStr + " db")

konvert.py

#!/usr/bin/python3
 
szam = 345.12345
szamStr = str(szam)
print("Szám: ", szamStr + " kg")

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

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

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

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.

szam = 9
if szam % 2 == 0:
    print "páros"
else:
    print "páratlan"

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

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.

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

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]

A számokat kiíratjuk 0-tól – 9-ig

for i in range(10):
    print(i)

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

szoveg3 = szoveg1 + szoveg2

Szöveg hossza:

szoveg = "körte"
print(len(szoveg))

Eredmény:

5

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.

szoveg = 'valami'
for karakter in szoveg:
    print(karakter)

szoveg='valami'
hossz=len(szoveg)
for i in range(1, hossz):
    print(szoveg[i])

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

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

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

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.

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

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

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

ip=input("IP cím: ")
ipDigitsStr=ip.replace('.','')

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

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

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

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)

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

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

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

A Python nyelvben nincs a tömb közvetlenül támogatva, helyette használjuk a listát.

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.

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

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

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

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.

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.

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

dupla.py

def dupla(szam):
    print(szam*2)
 
dupla(30)

szorzo.p

def szorzas(szam1, szam2):
    print(szam1*szam2)
 
szorzas(30, 35)

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

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.

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.

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

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.

1. seek()
   • Pozicionálás
   • fp.seek(3) # Pozicionálás 4.-dik bájthoz
   • Kezdő index: 0

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.

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)

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.

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?

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

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

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

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

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

fp = open('adat.txt', 'r')
 
lines = fp.readlines()
 
for line in lines:
    line = line.rstrip()
    print(line)
 
fp.close()

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)

olvas.py

fp = open('adat.txt', 'r', encoding='utf-8')
lista = fp.read().splitlines()
print(lista)

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 használható a := értékadó operátor:

olvas.py

fp = open('adat.txt', 'r')
 
while line := fp.readline():    
    print(line.rstrip())
 
fp.close()

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

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

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

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

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)

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