Az operációs rendszer indításkor minden folyamathoz hozzárendel 3 szabványos adatfolyamot:
Alapértelmezés szerint a standard bemenet a billentyűzettel, a standard kimenet és hibakimenet pedig a képernyővel van összekötve.
Ez a beállítás módosítható, pl. a standard bemenet érkezhet egy fájlból vagy egy másik programból, a standard kimenet és hibakimenet pedig íródhat fájlba vagy továbbítódhat másik programnak.
A standard bemenetről adatokat bekérni az input
függvény segítségével lehetséges.
Az eredmény sztring típusú. Ha más adattípusra van szükség, akkor konvertálni kell.
A standard kimenetre és hibakimenetre kiírni a print
függvény segítségével lehet.
## több változó kiírása vesszövel tagoltan
print('Lajos', 57, 'BI', 40+2)
## összefüzéses kiíratás
print('Kecskeméti' + ' ' +'Lajos')
## Újsor jelzés kikapcsolása
print('a',end=' ')
print('b',end=' ')
print('c')
## promázott kiíratás
print('{0:.3f}'.format(1.033/33))
print('{0:_^13}'.format('Szia'))
print('{name} született {born} -ben'.format(name='Lajos', born=62))
szoveg=input('Adj meg egy szöveget : ')
szam = int(input('Kérek egy számot : '))
print(szoveg, szam)
# from __future__ import braces
i=5
if i < 10:
print(i)
i = i + 1 # növel 1-el
i += 4 # növel 4-el
i *= 2 # megkétszerez
print(i)
if True:
print('Ez egy mindíg igaz állítás')
Pythonban a vezérlési szerkezetek belsejét indentálással (azaz beljebb írással) kell jelölni. Emiatt garantált, hogy a program megjelenése és logikai jelentése összhangban van.
if FELTÉTEL1:
-> UTASÍTÁS1
elif FELTÉTEL2:
-> UTASÍTÁS2
else:
-> UTASÍTÁS3
Több elif ág is szerepelhet.
Az elif ágak és az else ág is elhagyható.
Ha az utasítás 1 soros, akkor írható az if-fel elif-fel ill. az else-zel azonos sorba.
for x in lista: Lista elemei kerülnek x-be
for x in tuple: Tuple elemei kerülnek x-be
for x in sztring: String karakterei kerülnek x-be
Szekvencia generálás listaként: range() range(5) -> [0, 1, 2, 3, 4]
szam = 1
szam = int(input("Szám? "))
paros = [] # ures lista (bővitgetés miatt)
paratlan = [] # ures lista (bővitgetés miatt)
while ( szam != 0 ):
szam = int(input("Szám? "))
if (szam != 0):
if (szam % 2 == 0):
paros.append(szam)
else:
paratlan.append(szam)
print ("Párosak: ", paros)
print ("Páratlanok: ", paratlan)
# Példa: Kérsz páleszt?
x = int(input('Hány éves vagy? '))
if x >= 18:
print('Kérsz sört?')
else:
print('Nem adhatok páleszt.')
# Példa: Másodfokú egyenlet megoldó.
a = float(input('a: '))
b = float(input('b: '))
c = float(input('c: '))
d = b**2 - 4 * a * c
if d > 0:
x1 = (-b + d**0.5) / (2 * a)
x2 = (-b - d**0.5) / (2 * a)
print(x1, x2)
elif d == 0:
x1 = -b / (2 * a)
print(x1)
else: print('Nincs megoldása!')
a: 2 b: 3 c: 1 -0.5 -1.0
for i in range(1,5):
print('Számoljunk', i)
else:
print('A for ciklus végetért')
print('Ez mindíg megjelenik')
Számoljunk 1 Számoljunk 2 Számoljunk 3 Számoljunk 4 A for ciklus végetért Ez mindíg megjelenik
## Kiolvasó ciklus 1.
szamok = ['egy', 'kettő', 'három', 'négy']
for p in szamok:
print(p, ' szám hossza ', len(p))
egy szám hossza 3 kettő szám hossza 5 három szám hossza 5 négy szám hossza 4
## Kiolvasó ciklus 2.
szamok = ['egy', 'kettő', 'három', 'négy']
for i in range(len(szamok)):
print(i, szamok[i])
0 egy 1 kettő 2 három 3 négy
# Prim keresés
for n in range(2, 21):
for x in range(2, n):
if n % x == 0:
print(n, ' nem prim, felbontható', x, '*', n/x)
break
else:
# sigue el bucle sin encontrar un factor
print(n, ' Ez prim szám ')
2 Ez prim szám 3 Ez prim szám 4 nem prim, felbontható 2 * 2.0 5 Ez prim szám 6 nem prim, felbontható 2 * 3.0 7 Ez prim szám 8 nem prim, felbontható 2 * 4.0 9 nem prim, felbontható 3 * 3.0 10 nem prim, felbontható 2 * 5.0 11 Ez prim szám 12 nem prim, felbontható 2 * 6.0 13 Ez prim szám 14 nem prim, felbontható 2 * 7.0 15 nem prim, felbontható 3 * 5.0 16 nem prim, felbontható 2 * 8.0 17 Ez prim szám 18 nem prim, felbontható 2 * 9.0 19 Ez prim szám 20 nem prim, felbontható 2 * 10.0
print('range(10) = ', range(10))
print('list(range(10)) =', list(range(10)))
range(10) = range(0, 10) list(range(10)) = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Megjegyzések:
Egy jól megírt program esetén az utasítás a feltételt előbb-utóbb hamisra állítja. (Ellenkező esetben végtelen ciklus keletkezik.)
Akkor érdemes while ciklust alkalmazni, ha a ciklus elején még nem tudjuk pontosan az iterációk számát.
number=42
kerdez=True
tip=0
while kerdez:
guess=int(input('Kérek egy számot (1-100 között) : '))
tip+=1
if guess == number:
print('Gratulálok eltaláltad. Neked ', tip, 'tipelésed volt.')
kerdez=False
elif guess < number:
print('Nem talált nagyobbat adjál meg.')
else:
print('Nem talált kisebbet adjál meg.')
else:
print('Itt a while ciklus vége.')
print('Kész vagyunk. Ha háromból eltaláltad ügyes vagy.')
Kérek egy számot (1-100 között) : 45 Nem talált kisebbet adjál meg. Kérek egy számot (1-100 között) : 25 Nem talált nagyobbat adjál meg. Kérek egy számot (1-100 között) : 31 Nem talált nagyobbat adjál meg. Kérek egy számot (1-100 között) : 35 Nem talált nagyobbat adjál meg. Kérek egy számot (1-100 között) : 41 Nem talált nagyobbat adjál meg. Kérek egy számot (1-100 között) : 43 Nem talált kisebbet adjál meg. Kérek egy számot (1-100 között) : 42 Gratulálok eltaláltad. Neked 7 tipelésed volt. Itt a while ciklus vége. Kész vagyunk. Ha háromból eltaláltad ügyes vagy.
## Fibonacci sor whilde ciklussal:
a, b = 0, 1
while b < 100:
print(b, end=' -> ') ## Egysorvba legyen az eredmény
a, b = b, a+b
1 -> 1 -> 2 -> 3 -> 5 -> 8 -> 13 -> 21 -> 34 -> 55 -> 89 ->
while True: # Most nem ismert a ciklusok száma.
s= input(" Kérek egy szöveget: ")
s= s.upper()
print(s)
if "STOP" in s:
break # A ciklus megtörése.
print('Vége')
Kérek egy szöveget: 1 1 Kérek egy szöveget: 2 2 Kérek egy szöveget: 3 3 Kérek egy szöveget: STOP STOP Vége
Az iteráció
legfőbb tulajdonsága az időbeni ismétlés, egy kódrészlet időben egymás utáni többszöri végrehajtása.
Egy másik típusú ismétlés a rekurzió
, amikor ugyancsak megtörténik az időbeli ismétlés, de emellett a kódblokk fizikailag is megtöbbszöröződik.
A függvény rábízhatjuk a megadott argumentumaink sokaságba foglalását, ha ezt a függvény definíciójában jelezzük neki, amihez csupán egy *
-ot kell az argumentum elé illeszteni.
Sőt még ennél többet is tehetünk, ha telhetetlenül **
„biggyesztünk” oda, mert ekkor nevesített argumentumokat adhatunk meg, amelyekből az értelmező egy szótárt készít.
def fib(n): # Függvény Fibonacci sor kiszámolására
"""Függvény Fibonacci sor kiszámolására."""
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
def fib2(n): # Függvény Fibonacci sor listába írására
"""Függvény Fibonacci sor listába írására."""
result = []
a, b = 0, 1
while a < n:
result.append(a) # ver abajo
a, b = b, a+b
return result
print(fib(2000)) ## Deffinició meghívása
print(fib) ## fib typus lekérése : <function fib at 0x00000192AEF69DC8>
f = fib ## alias létrehozása f névvel
print( f(100) ) ## Deffinició meghívása
print(fib(0)) ## Nincs eredmény : None
print('fib2(100) = ', fib2(100))
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 None <function fib at 0x00000192AEF69828> 0 1 1 2 3 5 8 13 21 34 55 89 None None fib2(100) = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
def f(a, L=[]):
L.append(a)
return L
def f2(a, L=None):
if L is None:
L = []
L.append(a)
return L
print(f(1))
print(f(2))
print(f(3))
print(f2(1))
print(f2(2))
print(f2(3))
[1] [1, 2] [1, 2, 3] [1] [2] [3]
## paraméter átadás
def param_olvaso(valt, *argument, **lista):
print("Változó : ", valt, " OK")
for arg in argument:
print(arg)
print("-" * 40) ## Elválasztás kiírása
claves = sorted(lista.keys())
for c in claves:
print(c, ":", lista[c])
param_olvaso("Lajos", "Egyes1.",
"kettes2.",
cliente="Dani",
vendedor="Tomi",
join="Testvérek")
#--------------------------------------
def concatenar(*args, sep="/"):
return sep.join(args)
print(concatenar("Lajos", "Tamás", "Dani"))
print(concatenar("Lajos", "Tamás", "Dani", sep="."))
#-------------------------------------
def lambda_incrementor(n):
""" Ez a függvény használja a lambda függvényt
a deffiniciós részében
érdekes lehet"""
return lambda x: x + n ## névtelen függvény használata
f = lambda_incrementor(42)
print(f(0))
print(f(5))
print(lambda_incrementor.__doc__) ## függvény dokumentációs infó megjelenítése
Változó : Lajos OK Egyes1. kettes2. ---------------------------------------- cliente : Dani join : Testvérek vendedor : Tomi Lajos/Tamás/Dani Lajos.Tamás.Dani 42 47 Ez a függvény használja a lambda függvényt a deffiniciós részében érdekes lehet
## modul tartalma /// fibo.py
def fib(n):
a, b = 0, 1
while b < n:
print(b, end=' ')
a, b = b, a+b
print()
def fib2(n):
resultado = []
a, b = 0, 1
while b < n:
resultado.append(b)
a, b = b, a+b
return resultado
## modul használat
from fibo import *
from fibo import fib, fib2
imp.reload(fibo)
if __name__ == "__main__":
import sys
fib(int(sys.argv[1]))
# modul használatos meghívás
python fibo.py 50
# modul info megjelenítése
import fibo, sys
dir(fibo)
## modul elérési könyvtár lista bővítése
import sys
sys.path.append('/ufs/guido/lib/python')
Egy generátor értékeket "generál" amikor kérik, a helyett, hogy előre eltárolná őket.
A generátorobjektum nem tartalmazza „készen” az elemeit, mint például a listák, karakterláncok és a többi konténer típusú objektum, s ezért nem is lehet indexelni, de bejárni igen.
Az elemeket csak kérésre hozza létre, mindig csak egyet, s ez az a tulajdonsága, ami miatt esetenként nagyon hasznos, mert kevés memoria helyet igényel.
# A következő metódus (ez még NEM egy generátor) megduplázza a kapott iterable elemeit,
# és eltárolja őket. Nagy méretű iterable esetén ez nagyon sok helyet foglalhat!
def double_numbers(iterable):
double_arr = []
for i in iterable:
double_arr.append(i + i)
return double_arr
# A következő kód futtatásakor az összes szám kétszeresét kiszámítanánk, és visszaadnánk
# ezt a nagy listát a ciklus vezérléséhez.
for value in double_numbers(range(1000000)): # `test_non_generator`
print (value)
if value > 5:
break
# Használjunk inkább egy generátort, ami "legenerálja" a soron következő elemet,
# amikor azt kérik tőle
def double_numbers_generator(iterable):
for i in iterable:
yield i + i
# A lenti kód mindig csak a soron következő számot generálja a logikai vizsgálat előtt.
# Így amikor az érték eléri a > 5 határt, megszakítjuk a ciklust, és a lista számainak
# nagy részénél megspóroltuk a duplázás műveletet (ez sokkal gyorsabb így!).
for value in double_numbers_generator(range(1000000)): # `test_generator`
print (value)
if value > 5:
break
# csak akkor generálja le a következő számot, amikor kérjük
# - esetünkben a ciklus következő iterációjakor
# A lista képzéshez hasonlóan generátor képzőket is használhatunk ("generator comprehensions").
values = (-x for x in [1, 2, 3, 4, 5])
for x in values:
print(x) # kimenet: -1 -2 -3 -4 -5
# Egy generátor összes generált elemét listaként is elkérhetjük:
values = (-x for x in [1, 2, 3, 4, 5])
gen_to_list = list(values)
print(gen_to_list) # => [-1, -2, -3, -4, -5]
0 2 4 6 0 2 4 6 -1 -2 -3 -4 -5 [-1, -2, -3, -4, -5]
# A lenti egyszerű példában az add_apples dekorátor a dekorált get_fruits függvény
# kimenetébe beszúrja az 'Apple' elemet.
def add_apples(func):
def get_fruits():
fruits = func()
fruits.append('Apple')
return fruits
return get_fruits
@add_apples
def get_fruits():
return ['Banana', 'Mango', 'Orange']
# A kimenet tartalmazza az 'Apple' elemet:
# Banana, Mango, Orange, Apple
print (', '.join(get_fruits()))
print(' ---------------------------------')
# Ebben a példában a beg dekorátorral látjuk el a say függvényt.
# Beg meghívja say-t. Ha a say_please paraméter igaz, akkor
# megváltoztatja az eredmény mondatot.
from functools import wraps
def beg(target_function):
@wraps(target_function)
def wrapper(*args, **kwargs):
msg, say_please = target_function(*args, **kwargs)
if say_please:
return "{} {}".format(msg, "Kérem! Segítsen rajtam:(")
return msg
return wrapper
@beg
def say(say_please=False):
msg = "Kaphatok egy sört?"
return msg, say_please
print (say()) # Kaphatok egy sört?
print (say(say_please=True)) # Kaphatok egy sört? Kérem! Segítsen rajtam:(
Banana, Mango, Orange, Apple --------------------------------- Kaphatok egy sört? Kaphatok egy sört? Kérem! Segítsen rajtam:(