Python programozás

User info

Welcome, Guest! Please login or register.


You are here » Python programozás » Test forum » Programozás Pythonban


Programozás Pythonban

Posts 1 to 9 of 9

1

Bevezetés a Python programozási nyelvbe
Ezt a fórumot azért hoztam létre, hogy segítsem a Programozás szakkörre, valamint az emelt szintű érettségi fakultációra járó diákokat abban, hogy a szakkörön/órán Python nyelven megoldott feladatokat otthon, nyugodt körülmények között is ki tudják próbálni. El tudjanak gondolkodni azon, hogy mit, miért csináltunk és mi, mit jelent.
Arra kérek mindenkit, aki ezt a fórumot olvassa, hogy írjon véleményt az egyes feladatokra írt programokkal kapcsolatban: hogyan lehetne másképpen (rövidebben, más ötlet alapján) megírni az egyes programokat.
A Python programot (annak is a legfrissebb verzióját) a python.org oldalról lehet letölteni. Miután letöltöttük a telepítőprogramot egy (mondjuk) Python nevű mappába, el kell indítani. Néhány gombnyomás után fenn lesz a Python a számítógépünkön és már használhatjuk is. Ajánlott a kezdés előtt egy mappát létrehozni a forrásprogramok számára! Célszerű az elején egyszerű programok írásával és futtatásával kezdeni, mint például téglalap területének és kerületének a kiszámítása, hogy mielőbb megismerjük a Python programok szerkezetét.
Mindenkinek sok sikert és örömöt kívánok a Python programozás megismeréséhez!

0

2

1-2. óra (09.05) A Python programozási nyelv alapjai
A Python programozási nyelv jellemzői (nagyon magas szintű nyelv, interpreteres, dinamikus adatkezelésű, jól áttekinthetű forrásprogramok írhatók benne, behúzásos technika, ...)
Alapvető matematikai műveletek elvégzése az interpreter segítségével (+, -, *, /, **, //, %)
Kerekítés: round(szám, tizedesjegyek száma)
Kiírás a képernyőre: print() utasítás segítségével
Beolvasás a billentyűzetről: input() utasítással
Számtípusok: int (integer, egész); float (valós)
Egyszerű programok írása Pythonban:
- téglalap területének és kerületének kiszámítása és kiíratása
- téglatest felszínének és térfogatának kiszámítása és kiíratása

0

3

3-4. óra (09.12.) -  Elágazások (kétirányú, töbirányú) és ciklusok (megszámlálásos és elöltesztelő) a Pythonban

Megjegyzések (kommentek) írása. Egy soros, több soros.

Kétirányú elágazás:
if feltétel:
    utasítások
else:
    utasítások2

Feladat: kérjünk be egy egész számot és döntsük el, hogy páros vagy páratlan!
A program:
a = int(input('Kérem az egész számot! '))
if a % 2 == 1:
   print('A szám páratlan.')
else:
   print('A szám páros.')

Többirányú elágazás: amikor egy beolvasott érték több feltételnek felelhet meg.
if feltétel1:
   utasítás1
elif feltétel2:
   utasítás2
elif feltétel3:
   utasítás3
.
.
.
else:
   utasításn

Feladat: olvassunk be egy egész számot (pontszám) 0 és 100 között és mondjuk meg, hogy milyen jegy
tartozik hozzá, ha 0-24 között elégtelen, 25-39 között elégséges, 40-59 között közepes, 60 és 79 között
jó, míg 80-tól jeles az osztályzat.
A program:
n = int(input('Kérem a pontszámot! '))
if n < 25:
   print('elégtelen')
elif n < 40:
   print('elégséges')
elif n < 60:
   print('közepes')
elif n < 80:
   print('jó')
else:
   print('jeles')

Ciklusok a Pythonban:
- megszámlálásos (for i in range(0, n): vagy for szo in mondat:)
- elöltesztelő ciklus (while feltétel: utasítások)

Feladat: adjuk össze a pozitív egész számokat 1-től 50-ig!
A program:
s = 0
for i in range(1, 51):
   s = s + i
print('A számok összege: ', s)

Módosítás: azt, hogy meddig adjuk össze a számokat, kérjük be a billenytűzetről!
A program:
n = int(input('Kérem a felső határt! '))
s = 0
for i in range(1, n+1):
   s = s + i
print('A számok összege: ', s)

Feladat: adjuk össze a páratlan számokat 1-től n-ig!
A program:
n = int(input('Kérem a felső határt! '))
s = 0
for i in range(1, n+1, 2):
   s = s + i
print('A számok összege: ', s)

Értékadás a Pythonban:
a = 1
b = 2
helyett:
a, b = 1, 2

Feladat: írjunk programot, ami kiírja a 200-nál kisebb Fibonacci számokat! (1, 1, 2, 3, 5, 8, 13, 21,...)
A program:
a, b = 1, 1
while b < 200:
   a, b = b, a+b
   print(a)

Feladat: írjunk programot, ami beolvassa egy háromszög 3 oldalát és azokból kiszámolja a háromszög
területét (Héron-képlettel).
A program:
import math
a = float(input('a= '))
b = float(input('b= '))
c = float(input('c= '))
if a>0 and b>0 and c>0 and (a+b>c) and (a+c>b) and (b+c>a):
    s = (a+b+c)/2
    t = math.sqrt(s*(s-a)*(s-b)*(s-c))
    print('A háromszög területe: ', round(t, 2))
else:
    print('Nem létezik a háromszög!')

Házi feladat: írjunk programot a másodfokú egyenlet megoldására!

0

4

5-6. óra (09.19.) Ciklusok a Pythonban. Programozási tételek
I. A házi feladat ellenőrzése
II. Ciklusok a Pythonban
Írassuk ki a 100-nál kisebb, 3-mal osztva 1 maradékot adó pozitív egész számokat!
A program (megszámlálásos):
for i in range(100):
    if i % 3 == 1:
        print(i)

Ugyanennek a feladatnak a megoldása elöl tesztelő ciklussal:
i = 1
while i < 100:
    if i % 3 == 1:
        print(i)
    i += 1

III. Programozási tételek
1. Összegzés tétele: adjunk össze N darab számot, amik egy a() vektorban vannak tárolva!
Az algoritmus mondatszerű leírása:
s = 0
ciklus i = 1-től N-ig
    s = s + a(i)
ciklus vége
Ki: s

2. Eldöntés tétele: adott egy N elemű a() sorozat és a sorozat elemein értelmezett T tulajdonság. Van-e a sorozatban T tulajdonságú elem?
Az algoritmus mondatszerű leírása:
i = 1
ciklus amíg i <= N és a(i) nem T tulajdonságú
i = i + 1
ciklus vége
van = (i <= N)
Ha van, akkor ki: van T tulajdonságú elem; különben ki: nincs T tulajdonságú elem

Példaprogramok a programozási tételek alkalmazására.
1. Olvassunk be egy egész számot a billentyűzetről és döntsük el, hogy a szám osztható-e 2-vel, illetve 3-mal!

x = int(input("Írd be a számot!"))
if x % 2 == 0:
    if x % 3 == 0:
        print("A szám osztható 6-tal.")
    else:
        print("A szám osztható 2-vel, de 3-mal nem.")
else:
    if x % 3 != 0:
        print("A szám nem osztható sem 2-vel, sem 3-mal.")
    else:
        print("A szám nem osztható 2-vel, de 3-mal igen.")

2. Döntsük el, hogy egy N=10 egész számot tartalmazó <a> listában van-e 5-tel osztható szám!
A Python program:
a = [2, 6, 8, 1, 4, 12, 16, 11, 22, 7]
n = len(a)
i = 0
while i <= n-1 and a[i] %5 != 0:
    i = i + 1
van = (i <= n-1)
if van:
    print('Van.')
else:
    print('Nincs.')

3. Olvassunk be a konzolról egy szöveget, majd döntsük el, hogy van-e a szövegben magánhangzó!

x = input('Kérem, írja be a szöveget: ')
valasz = False
for betu in x:
    if betu == 'a' or betu == 'e' or betu == 'i' or betu == 'o' or betu == 'u':
        valasz = True
if valasz:
    print('Van a szövegben magánhangzó.')
else:
    print('Nincs a szövegben magánhangzó.')

A 3. feladat megoldásának javított változata. Az első változatban (for.. ciklus) a program minden egyes betűjét megvizsgálja a szövegnek, amire sok esetben NINCS szükség. Ezért célszerű előltesztelő ciklust alkalmazni. Íme:

x = input('Kérem, írja be a szöveget: ')
n = len(x)   #a szövegben levő karakterek számát adja értékül az N változónak
i = 0       # mert a stringet indexelése is 0-val kezdődik
while i < n and (x[i] != 'a' and x[i] != 'e' and x[i] != 'i' and x[i] != 'o' and x[i] != 'u'):
    i += 1      # i értékét növeljük 1-gyel
valasz = (i < n)
if valasz:
    print("Van a szövegben magánhangzó.")
else:
    print("Nincs a szövegben magánhangzó.")

Házi feladat: írjunk programot, amely bekér egy szöveget és megszámolja, hogy hány darab magánhangzó van a szövegben!

0

5

7-8. óra (09.26)
Továbbképzés miatt elmaradt.

0

6

9-10. óra (10.03.): Feladatok megoldása
1. Feladat: írjunk programot, ami beolvassa egy háromszög 3 oldalát és azokból kiszámolja a háromszög
területét (Héron-képlettel).
A program:
import math
a = float(input('a= '))
b = float(input('b= '))
c = float(input('c= '))
if a>0 and b>0 and c>0 and (a+b>c) and (a+c>b) and (b+c>a):
    s = (a+b+c)/2
    t = math.sqrt(s*(s-a)*(s-b)*(s-c))
    print('A háromszög területe: ', round(t, 2))
else:
    print('Nem létezik a háromszög!')

2. Feladat: OLvassunk be egy szöveget a billentyűzetről egy sztringbe, majd számoljuk meg, hogy hány magánhangzó van a szövegben!
A program:
x = input('Kérem, írja be a szöveget: ')
s = 0 #a szövegben levő magánhangzók számát adja majd eredményül
for betu in x:
    if betu == 'a' or betu == 'e' or betu == 'i' or betu == 'o' or betu == 'u':
        s = s + 1
print('A szövegben levő magánhangzók száma: ', s)

3. Feladat: Olvassunk be egy egész számot a billentyűzetről és döntsük el, hogy a szám osztható-e 2-vel, illetve 3-mal!
A program:
x = int(input("Írd be a számot!"))
if x % 2 == 0:
    if x % 3 == 0:
        print("A szám osztható 6-tal.")
    else:
        print("A szám osztható 2-vel, de 3-mal nem.")
else:
    if x % 3 != 0:
        print("A szám nem osztható sem 2-vel, sem 3-mal.")
    else:
        print("A szám nem osztható 2-vel, de 3-mal igen.")

4. Feladat: Írj egy programot, mely egy beolvasott számról eldönti, hogy a különböző
pénzérmékből/papírcímletekből (5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000) hány darab
szükséges ahhoz, hogy összértékük a beolvasott szám legyen, de a lehető legkevesebb címletet használjuk fel ehhez!
A program:
cimletek = [5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5]
x = int(input('Kérem az összeget! '))
darab = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
i = 0
while x >= 5 and i <= 10:
    db = x // cimletek[i]
    darab[i] = db
    x = x - db * cimletek[i]
    i = i + 1
n = len(cimletek)
for j in range(0, n):
    print(cimletek[j],'Ft-osból ',darab[j],' darab kell.')

5. Feladat: Írj egy programot, mely beolvas egy 10-es számrendszerbeli számot, majd kiírja annak a 2-es és 16-os számrendszerbeli megfelelőjét/alakját!

6. Feladat: Írj egy programot, mely bekéri a billentyűzetről az éjfél óta eltelt másodpercek számát, és kiírja az időpontot óra:perc:másodperc formában!
A program:
x = int(input('Kérem a másodpercek számát! '))
ora = x // 3600
x = x - ora * 3600
perc = x // 60
mperc = x - perc * 60
print(ora,':',perc,':',mperc)

7. Feladat: Olvassunk be a billentyűzetről egy egész számot és írassuk ki az 1-nél nagyobb legkisebb pozitív osztóját!
A program:
n = int(input('Kérem az egész számot! '))
i = 2
while n % i != 0:
    i = i + 1
print('Az 1- nél nagyobb legkisebb osztó: ', i)

8. Feladat: Olvassunk be egy egész számot a billentyűzetről és döntsük el, hogy a szám prím-e!
A program:
n = int(input('Kérem az egész számot! '))
i = 2
while n % i != 0:
    i = i + 1
if i == n:
    print('A szám prím.')
else:
    print('A szám nem prím.')

0

7

11-12. óra: gyakorló feladatok

1. feladat: olvassunk be a billentyűzetről egy szöveget mondjuk az 's' sztringbe, majd számoljuk meg, hogy hány 'a' betű van benne!
megoldás:
s = input('Kérem a szöveget! ')
db = 0
for betu in s:
    if betu == 'a':
        db += 1
print('A szövegben levő "a" betűk száma: ', db)

2. feladat: olvassuk be a billentyűzetről egy egyenes körhenger alapkörének sugarát és a magasságát, majd számítsuk ki a felszínét és a térfogatát!
megoldás:
import math
r = float(input('Kérem az egyenes körhenger alapkörének sugarát! '))
m = float(input('Kérem az egyenes körhenger magasságát! '))
v = r * r * math.pi * m
f = 2 * r * math.pi * (r + m)
print('Az egyenes körhenger felszíne {0}, térfogata {1}'.format(round(f, 2), round(v, 2)))

3. feladat: egy 10 elemű, egész számokat tartalmazó lista elemeit adjuk össze és írjuk ki az összeget! (Összegzés tétele)
megoldás:
lista = [3, 1, 7, 11, 2, 3, -1, -7, -11, -2]
s = 0
for x in lista:
    s += x
print('A lista elemeinek összege: ', s)

4. feladat: adjunk meg 10 darab egész számot egy listában, majd döntsük el, hogy van-e köztük 3-mal osztható, és ha van, írjuk ki, hogy hányadik! (eldöntés tétele)
megoldás:
lista = [6, 1, 5, 4, 7, 14, 11, 17, 20, 22]
n = len(lista)
i = 0
van = False
while (i <= n-1) and (lista[i] % 3 != 0):
    i += 1
van = (i<=n-1)
if van:
    print('Van 3-mal osztható elem, mégpedig a(z) {}-ik'.format(i+1))
else:
    print('Nincs 3-mal osztható elem.')

5. feladat: adjuk össze az 1 és 100 közé eső és 3-mal osztva 2 maradékot adó számokat és írjuk ki az összeget! (Összegzés tétele)
megoldás:
s = 0
for i in range(1, 101):
    if i % 3 == 2:
        s += i
print('A 3-mal osztva 2 maradékot adó számok összege: ', s)

6. feladat: olvassunk be a billentyűzetről egy szöveget mondjuk az 's' sztringbe, majd számoljuk meg, hogy hány 'e' betű van benne!
megoldás:
s = input('Kérem a szöveget! ')
db = 0
for betu in s:
    if betu == 'e':
        db += 1
print('A szövegben található "e" betűk száma: ', db)

7. feladat: adjunk meg 10 darab egész számot egy listában, majd döntsük el, hogy van-e köztük 5-tel osztható, és ha van, írjuk ki, hogy hányadik! (eldöntés tétele)
megoldás:
lista = [2, 6, 8, 13, 14, 24, 26, 12, 18, 23]
n = len(lista)
i = 0
while (i <= n-1) and (lista[i] % 5 != 0):
    i += 1
van = (i <= n-1)
if van:
    print('A listában van 5-tel osztható elem, mégpedig a(z) {}-ik'.format(i+1))
else:
    print('Nincs 5-tel osztható elem.')

8. feladat: olvassuk be a billentyűzetről egy forgáskúp alapkörének sugarát és a magasságát, majd számítsuk ki a felszínét és a térfogatát!
Ez legyen házi feladat!

Még a héten ezen az oldalon közzéteszem azt a 8 darab feladatot, amiből 4-et fogok kiválasztani a jövő heti (október 17-i) dolgozatba!

Íme a feladatok!
1. Írjunk programot, amely bekéri egy kocka oldalélét (a) és kiírja a kocka felszínét és térfogatát! (kocka)
2. Írjunk programot, amely kiírja egy 10 darab egész számot tartalmazó lista elemeinek négyzetösszegét! (négyzetösszeg)
3. Írjunk programot, amely egy egyenes vonalú egyenletesen változó mozgás esetén bekéri a kezdősebességet (v0), gyorsulást (a), az eltelt időt (t) és kiírja a test által megtett utat (s) és a test végsebességét (v)! (mozgás) /matematikai modell: s = (a/2)*t*t + v0*t; v = a*t + v0/
4. Írjunk programot, amely bekér három számot (melyek egy háromszög három oldalát jelentik), majd eldönti, hogy szerkeszthető-e háromszög a három oldalból! (háromszög)
5. Kérjen be a felhasználótól egy szót, és döntse el, hogy van-e benne "i" betű! Amennyiben van, írja ki, hogy „Van benne <i> betű.”! Ha nincs, akkor írja ki, hogy „Nincs benne <i> betű.”! A begépelendő szóról feltételezheti, hogy csak az angol ábécé kisbetűit tartalmazza. (Az angol ábécé magánhangzói: a, e, i, o, u.) (magh)
6. Kérjen be a program a felhasználótól egy szót, majd döntse el, hogy magánhangzóból vagy mássalhangzóból van-e benne több! Az eredményt írja a képernyőre! (mghvsmsg)
7. Kérjen be a program két pozitív számot, majd írja ki a számtani közepüket és a mértani közepüket! (szmk)
8. Kérjen be a program egy pozitív egész számot, majd írja ki a szám legnagyobb pozitív osztóját! (lgnpo)

0

8

13-14. óra: Maximum-kiválasztás tétele, gyakorló feladatok (2019.11.07 és 11.14)

Eddig megismertük az Összegzés tételét és az Eldöntés tételét. Mindkét tételt gyakran kell alkalmazni feladatok megoldásában, így az emelt szintű érettségin is.
Hasonlóan fontos és gyakran előfordul a Maximum-kiválasztás tétele is.
Miről is van itt szó?
Adva van például egy számokból álló sorozat. Az a feladat, hogy mondjuk meg, melyik ezek közül a legnagyobb?
Előfordulhat, hogy a sorozatban több legnagyobb elem van. Ilyenkor általában elég egyet megadni eredményként.
Azt is megkérdezhetjük, hogy hányadik tagja a sorozatnak a legnagyobb elem?
Nézzük az algoritmus mondatszerű leírását:

Eljárás: Be: N, a() 
max = a(1)
ciklus i = 2-től n-ig
   Ha a(i) > max, akkor max = a(i)          (*)
ciklus vége
Ki: max

Most értelmezzük az algoritmust sorról-sorra.
Az első lépésben egy max nevű változónak értéket adunk: legyen egyenlő a sorozat első elemével.
Ezután elindítunk egy megszámlálásos ciklust, ami i=2-tól indul, hiszen az első elem lett a max értéke.
A ciklusmagban egy feltételvizsgálat van: megvizsgáljuk, hogy a sorozat i-edik eleme nagyobb-e a max értékénél.
Ha igen, akkor ez azt jelenti, hogy az addigi legnagyobb elemnél találtunk nagyobbat, tehát erre az értékre kell beállítani a max értékét.
Ha nem, akkor vesszük a sorozat következő elemét.
Amikor vége a ciklusnak, a max nevű változóban lesz a sorozat legnagyobb eleme.
Megjegyzés: ennek a tételnek a párja a minimum-kiválasztás tétele. Ennek az algoritmusában max helyett min van,
továbbá a (*)-gal jelölt sorban a következő szerepel: Ha a(i) < min, akkor min = a(i)

Nézzünk erre egy konkrét feladatot! Legyenek a sorozat elemei egy listában, a neve adatok.
adatok = [2, 1, 9, 6, 7, 3, 4, 11, 5, 8]. Itt az elemek száma: N = 10.
A Python program:

adatok = [2, 1, 9, 6, 7, 3, 4, 11, 5, 8]
n = len(adatok)   #meghatározzuk a sorozat elemszámát
max = adatok[0]   #vigyázat! Már sokszor mondtam, hogy a listában az indexelés 0-val kezdődik!
for i in range(1, n):
   if adatok[i] > max:
      max = adatok[i]
print('A sorozat legnagyobb eleme: ', max)

Ennyi!
Feladatok a maximum-kiválasztás tételére:
1. Adott egy listában N darab szó. Mondjuk meg, hogy melyik a leghosszabb, ez hányadik a sorban és hány karakterből áll?
A Python program:

szoveg = ['alma', 'banan', 'mandarin', 'fuge', 'kelkaposzta', 'dio', 'eper', 'szilva']
maxszo = szoveg[0]
max = len(maxszo)
index = 0
n = len(szoveg)
for i in range(1, n):
    if len(szoveg[i]) > max:
        max = len(szoveg[i])
        maxszo = szoveg[i]
        index = i
print('A leghosszabb szó a(z) {0}, indexe {1}, hossza {2} karakter.'.format(maxszo, index+1, max))

2. Írjunk programot, amely egy N elemet tartalmazó tömbről megmondja, hogy a szomszédos elemek között mekkora a legnagyobb különbség abszolút értékben!
A Python program:

tomb = [2, 1, 5, 4, 11, 6, 8, 20, 14, 7]
n1 = len(tomb)
max = abs(tomb[1] - tomb[0])
for i in range(1, n1-1):
    if abs(tomb[i+1] - tomb[i]) > max:
        max = abs(tomb[i+1] - tomb[i])
print('A legnagyobb különbség abszolut értékben: ', max)

3. Írjunk programot, amely egy N elemet tartalmazó tömbről megmondja, hogy melyik két eleme között legkisebb a különbség!

Fájlkezelés a Pythonban
Legyen a fizikai fájl neve: adat.txt. Ha a logikai fájl neve f, akkor a két fájl egymáshoz rendelése és egyben a fizikai állomány megnyitása történhet például így:
f = open('adat.txt', 'r')    #itt 'open' a fájl megnyitására, 'r' az olvasására (read) utal
És ha már belekezdtünk a fájlkezelésbe, akkor nézzük meg a legújabb (2019. őszi) emelt szintű informatika érettségi első néhány feladatának a megoldását!
A feladat szövege az alábbi volt:
eUtazás
Egyre több országban fordul elő, hogy a közlekedési eszközökön használatos bérleteket és jegyeket valamilyen elektronikus eszközön (például: chipes kártya) tárolják. Egy nagyváros
ilyen rendszert szeretne bevezetni a helyi közlekedésben, amelyet néhány buszjáraton tesztelnek. Ezekre a buszokra csak az első ajtónál lehet felszállni, ahol egy ellenőrző eszközhöz
kell érinteni a kártyát, amelynek chipje tartalmazza a jegy vagy bérlet információkat. A busz ellenőrző eszköze statisztikai és fejlesztési célból rögzíti a felszállók kártyájának
adatait. Az utasadat.txt szóközökkel tagolt állomány egy, a tesztelésben részt vevő busz végállomástól-végállomásig tartó útjának adatait tartalmazza.
Az utasadat.txt állomány legfeljebb 2000 sort tartalmaz és minden sorában 5 adat szerepel. Ezek:
• a megálló sorszáma (0-29; 0 az indulás helye és a 30 a végállomás, ahol már nem lehet felszállni.)
• a felszállás dátuma és időpontja (ééééhhnn-óópp formátumban, kötőjellel elválasztva a dátum és az idő)
• a kártya egyedi azonosítója (hétjegyű szám), egy utas a járaton legfeljebb egyszer utazik
• a jegy vagy bérlet típusa:
Azonosítók és megnevezésük: FEB Felnőtt bérlet; TAB Tanulóbérlet (kedvezményes); NYB Nyugdíjas bérlet (kedvezményes); NYP 65 év feletti bérlet (ingyenes) RVS Rokkant, vak, siket vagy kísérő bérlet (ingyenes); GYK Iskolakezdés előtti gyerekbérlet (ingyenes); JGY Jegy
• a bérlet érvényességi ideje, vagy a felhasználható jegyek száma. A bérlet esetén a dátum [i]ééééhhnn formátumban szerepel, jegy esetén egy 0-10 közötti szám szerepel.
Például:
0 20190326-0700 6572582 RVS 20210101
0 20190326-0700 8808290 JGY 7
0 20190326-0700 1680423 TAB 20190420
12 20190326-0716 3134404 FEB 20190301
12 20190326-0716 9529716 JGY 0
A fenti példában szereplő adatoknál látható, hogy az induló állomáson (0. állomás) 2019. 03. 26-án 7:00-kor a 1680423 kártyaazonosítójú utas tanulóbérlettel szállt fel, amely
2019. 04. 20-ig érvényes. A 12. állomáson 2019. 03. 26-án 7:16-kor a 9529716 kártyaazonosítójú utas jeggyel szállt volna fel, de már elhasználta az összes jegyét (0).
Készítsen programot, amely az utasadat.txt állomány felhasználásával a következő kérdésekre válaszol! A program forráskódját eutazas néven mentse!

1. Olvassa be és tárolja el az utasadat.txt fájl tartalmát!
adat = []
f = open('utasadat.txt', 'r')
for sor in f:
   sor = sor.strip().split()
   adat.append(sor)

2. Adja meg, hogy hány utas szeretett volna felszállni a buszra!
print('2. feladat')
n = len(adatok)                     #egyszerűen lekérdezzük a listában levő elemek számát, majd kiíratjuk a képernyőre a print utasítással
print('A buszra felszállók száma: ', n)

3. A közlekedési társaság szeretné, ha a járművőn csak az érvényes jeggyel vagy bérlettel rendelkezők utaznának. Ezért a jegyeket és bérleteket a buszvezető a felszálláskor ellenőrzi.
(A bérlet még érvényes a lejárat napján.) Adja meg, hogy hány esetben kellett a buszvezetőnek elutasítania az utas felszállását, mert lejárt a bérlete vagy már nem volt jegye!
print('3. feladat')
db3 = 0                             #ebben a változóban számoljuk össze azokat, akik nem szállhattak fel a buszra
for sor3 in adatok:                 #ehhez egy megszámlálásos ciklust szervezünk
    if sor3[4] == '0':              #egyrészt az nem szállhat fel, akinek NINCS jegye
        db3 += 1                    #ekkor megnöveljük a db3 változó értékét 1-gyel
    if len(sor3[4]) == 8:           #másrészt ahol az utolsó adat dátum (8 karakterből áll!)
        if sor3[1][:8] > sor3[4]:  #az sem szállhat fel, akinek bérlete van, de az már lejárt
            db3 += 1                   #ekkor is megnöveljük 1-gyel a db3 változó értékét
print('A buszra {} utas nem szállhatott fel.'.format(db3))

És ha már a mai alkalommal a maximum-kiválasztás tételével foglalkoztunk, akkor oldjuk meg a 4. feladatot is, ami éppen ennek a tételnek az alkalmazását kívánja.

4. Adja meg, hogy melyik megállóban próbált meg felszállni a legtöbb utas! (Több azonos érték esetén a legkisebb sorszámút adja meg!)
print('4. feladat')
darab4 = []                         #létrehozunk egy darab4 nevű listát (üres)
for i in range(30):
    darab4.append(0)                #feltöltjük a listát 30 darab 0-val
for sor4 in adatok:                 #végig iterálunk az adatok nevű listán
    ssz = int(sor4[0])              #lekérdezzük az aktuális allistában a nap sorszámát, majd
    darab4[ssz] += 1                #a darab4 lista adott sorszámú elemét 1-gyel megnöveljük
#print(darab4)
max4 = darab4[0]                    #Most indul egy maximum-kiválasztás, ahol
maxindex = 0                        #meghatározzuk annak a napnak a sorszámát (maxindex) és az előfordulások számát (max4)
for i in range(1, 30):
    if darab4[i] > max4:            #ahol a legtöbb utas próbált felszállni
        max4 = darab4[i]
        maxindex = i
print('A legtöbb utas ({0} fő) a {1}. megállóban próbált felszállni.'.format(max4, maxindex))

5. A közlekedési társaságnak kimutatást kell készítenie, hogy hányszor utaztak valamilyen kedvezménnyel a járművön. Határozza meg, hogy hány kedvezményes és hány ingyenes
utazó szállt fel a buszra! (Csak az érvényes bérlettel rendelkező szállhatott fel a buszra!)
Megoldás: ha megnézzük a sorok értelmezését, láthatjuk, hogy kedvezményesen a tanulóbérletesek (TAB) és a nyugdíjas bérletesek (NYB) utaznak.
Ugyanakkor ingyenesen a 65 év feletti bérletesek (NYP), a rokkant, vak, siket vagy kísérő bérlettel utazók (RVS), valamint az iskolakezdés előtti gyerekbérletesek (GYK) utaznak.
Ennek megfelelően a program:
print('5. feladat')
kedv5, ingy5 = 0, 0                 # két változónak (kedv5 és ingy5) kezdőértéket adunk (0). Ezekben lesz a végén a kedvezményesen, illetve ingyenesen utazók száma.
for sor5 in adatok:                  #végigmegyünk az adatok nevű lista minden elemén (al-listáján).
    if sor5[3] == 'TAB' or sor5[3] == 'NYB':    #ha kedvezményezett az illető, vagyis ha tanuló- vagy nyugdíjas bérlettel rendelkezik,
        kedv5 += 1                              #ekkor a kedv5 értékét megnöveljük 1-gyel
    if sor5[3] == 'RVS' or sor5[3] == 'NYP' or sor5[3] == 'GYK': #ingyen azok utaznak, akik rokkantak vagy 65 év felettiek
        ingy5 += 1                              #vagy gyermekbérlettel rendelkeznek. Ekkor az ingy5 értékét növeljük 1-gyel
print('Ingyenesen utazók száma: {} fő'.format(ingy5))
print('A kedvezményesen utazók száma: {} fő'.format(kedv5)) #a végén kiíratjuk ennek a két változónak az értékét

################################################################

6. Készítsen függvényt napokszama néven az alábbi algoritmus alapján. Az algoritmus a paraméterként megadott két dátumhoz (év, hónap, nap) megadja a közöttük eltelt napok
számát! (A MOD a maradékos osztást, a DIV az egészrészes osztást jelöli.) Az algoritmust a fuggveny.txt fájlban is megtalálja. A függvényt a következő feladat megoldásához
felhasználhatja.
Megoldás: a megadott algoritmust át kell írni Pythonba. A MOD-nak a Pythonban a % felel meg, míg a DIV-nek a //.
Ennek megfelelően a program:
print('6. feladat')
print('Függvény létrehozása...')
def fgv_napoksz(e1,  h1, n1, e2, h2, n2):       #utazás éve, hónapja és napja, valamint a bérlet érvényességének éve, hónapja és napja
    h1 = (h1 + 9) % 12
    e1 = e1 - h1 // 10
    d1 = e1*365 + e1 // 4 -  e1 // 100 + e1 // 400 + (h1*306 + 5) // 10 + n1 - 1
    h2 = (h2 + 9) % 12
    e2 = e2 - h2 // 10
    d2 = e2*365 + e2 // 4 -  e2 // 100 + e2 // 400 + (h2*306 + 5) // 10 + n2 - 1
    napokszama = d2 - d1                        # a két dátum közötti napok száma
    return napokszama                           #ez a függvény kimeneti értéke

######################################################################x

7. A közlekedési társaság azoknak az utasoknak, akiknek még érvényes, de 3 napon belül lejár a bérlete, figyelmeztetést szeretne küldeni e-mailben.
(Például, ha a felszállás időpontja 2019. február 5., és a bérlet érvényessége 2019. február 8., akkor már kap az utas levelet,
ha 2019. február 9. az érvényessége, akkor még nem kap levelet.) Válogassa ki és írja a figyelmeztetes.txt állományba ezen utasok kártyaazonosítóját és a bérlet
érvényességi idejét (éééé-hh-nn formátumban) szóközzel elválasztva!
Az utolsó részfeladat megoldásának programja:
print('7. feladat')
print('Adatok kiírása fájlba.')
g = open('figyelmeztetes.txt', 'w')
for sor7 in adatok:
    if sor7[3] != 'JGY':
        e1 = int(sor7[1][:4])
        h1 = int(sor7[1][4:6])
        n1 = int(sor7[1][6:8])
        e2 = int(sor7[4][:4])
        h2 = int(sor7[4][4:6])
        n2 = int(sor7[4][6:8])
        delta = fgv_napoksz(e1, h1, n1, e2, h2, n2)
        if delta <= 3:
            ki = sor7[2] + ' ' + sor7[4][:4] + '-' + sor7[4][4:6] + '-' + sor7[4][6:8] + '\n'
            g.write(ki)
g.close()

See You Later!

0

9

17 - 18. óra 2019.11.21
Fájlkezelés a Pythonban
1. feladat: a 2016. évi tavaszi emelt szintű feladatsor megoldása (a legalkalmasabb adatszerkezet kialakítása)
A feladat szövege az alábbi volt:
Egy apróságokat árusító boltban minden árucikk darabja 500 Ft. Ha egy vásárlás során valaki egy adott árucikkből több darabot is vesz, a második ára már csak 450 Ft, a harmadik pedig 400 Ft, de a negyedik és további darabok is ennyibe kerülnek, tehát az ár a harmadik ugyanazon cikk vásárlása után már nem csökken tovább.
A pénztárhoz menők kosarában legalább 1 és legfeljebb 20 darab árucikk lehet. A kosarak tartalmát a penztar.txt fájl írja le, amelyben soronként egy-egy árucikk neve vagy az F karakter szerepel. A fájlban legfeljebb 1000 sor lehet. Az F karakter azt jelzi, hogy az adott vásárlónak nincs már újabb árucikk a kosarában, fizetés következik. Az árucikkek neve ékezet nélküli, több szóból is állhat, hossza legfeljebb 30 karakter.
Példa a penztar.txt fájl első néhány sorára:
toll
F
colostok
HB ceruza
HB ceruza
colostok
toll
szatyor
csavarkulcs
doboz
F
A példa alapján az első vásárló összesen 1 tollat vásárolt, ezért összesen 500 Ft-ot kell fizetnie. A második vásárlás során hatféle árucikket vásároltak – a HB ceruzából és a colostokból többet is –, összesen 3900 Ft értékben.
Készítsen programot, amely a penztar.txt állomány adatait felhasználva az alábbi kérdésekre válaszol! A program forráskódját mentse otszaz néven! (A program megírásakor a felhasználó által megadott adatok helyességét, érvényességét nem kell ellenőriznie, és feltételezheti, hogy a rendelkezésre álló adatok a leírtaknak megfelelnek.) A képernyőre írást igénylő részfeladatok eredményének megjelenítése előtt írja a képernyőre a feladat sorszámát (például: 3. feladat:)! Ha a felhasználótól kér be adatot, jelenítse meg a képernyőn, hogy milyen értéket vár! Az ékezetmentes kiírás is elfogadott.
1. Olvassa be és tárolja el a penztar.txt fájl tartalmát!
Olvassuk be az adatokat egy olyan listába, amelyben minden sor egy szövegként (sztring) kerül a listába:
################################################
print('1. feladat: adatok beolvasása egy listába')
adatok = []     #egy üres lista léterhozása "adatok" néven
f = open('penztar.txt', 'r') #fájl megnyitása
for sor in f:
    sor = sor.strip()
    adatok.append(sor)
f.close()    # zárjuk le a fájlt, mert ennek hiányában több kellemetlenségnek néznénk elébe!

################################################
2. Határozza meg, hogy hányszor fizettek a pénztárnál!
Megoldhatjuk ezt a feladatot úgy is, hogy megszámoljuk, hogy hányszor szerepel a listában az 'F' sztring, ami minden esetben egy vásárlást zár le. Íme:
################################################
print('2. feladat')
db2 = 0     #vásárlások száma kezdőértékének a beállítása
for sor2 in adatok:
    if sor2 == 'F':
        db2 += 1
print('A fizetések száma: ', db2)

################################################
3. Írja a képernyőre, hogy az első vásárlónak hány darab árucikk volt a kosarában!
################################################
print('3. feladat: az első vásárlónak hány arucikk volt a kosarában?')
i3 = 0
while adatok[i3]!= 'F':
    i3 += 1
print('Az első vásárlónak {0} darab árucikk volt a kosarában.'.format(i3))

################################################
4. Kérje be a felhasználótól egy vásárlás sorszámát, egy árucikk nevét és egy darabszámot! A következő három feladat megoldásánál ezeket használja fel!
Feltételezheti, hogy a program futtatásakor csak a bemeneti állományban rögzített adatoknak megfelelő vásárlási sorszámot és árucikknevet ad meg a felhasználó.
################################################
print('4. feladat: egy sorszám, áruckk név és darabszám bekérése.')
ssz4 = int(input('Kérem a vásárlás sorszámát! '))
nev4 = input('Kérem az árucikk nevét!')
db4 = int(input('Kérem a darabszámot!'))

###############################################
5. Határozza meg, hogy a bekért árucikkből
a. melyik vásárláskor vettek először, és melyiknél utoljára!
b. összesen hány alkalommal vásároltak!
###############################################
print('\n5. feladat:')
print('5. feladat: a bekért árucikkből mikor és hányszor vettek?')
i50 = 0
db5 = 0
while adatok[i50] != nev4:
    if adatok[i50] == 'F':
        db5 += 1
        i50 += 1
    else:
        i50 += 1
print('A bekért árucikkből a(z) {0}. alkalommal vásároltak először.'.format(db5 + 1))
n = len(adatok)
i51 = n-1
db51 = 0
while adatok[i51] != nev4:
    if adatok[i51] == 'F':
        db51 += 1
        i51 -= 1
    else:
        i51 -= 1
print('A bekért árucikkből a(z) {0}. alkalommal vásároltak utoljára.'.format(d2 - db51 + 1))

###############################################
6. Határozza meg, hogy a bekért darabszámot vásárolva egy termékből mennyi a fizetendő összeg! A feladat megoldásához készítsen
függvényt ertek néven, amely a darabszámhoz a fizetendő összeget rendeli!
###############################################

def ertek (n6):
    if n6 == 1:
        fiz6 = 500
    elif n6 == 2:
        fiz6 = 950
    else:
        fiz6 = 950 + (db4 - 2) * 400
    return fiz6
fizetes6 = ertek(db4)
print(db4, ' darab termék vásárlásakor a fizetendő összeg: ', fizetes6)

###############################################
7. Határozza meg, hogy a bekért sorszámú vásárláskor mely árucikkekből és milyen mennyiségben vásároltak!
Az árucikkek nevét tetszőleges sorrendben megjelenítheti.
Ez az a feladat, aminek a megoldásához nagyon NEM MINDEGY, hogy milyen adatszerkezetet alakítottunk ki az elején!
Itt ugyanis most meg kell határozni az adatok listának azt a részét, ami az adott sorszámú vásárlásra vonatkozik.
Ezt a részt betehetjük egy allistába, majd készítünk ebből egy olyan halmazt, ami minden arucikket csak egyszer tartalmaz.
Ezután végig kell iterálni a halmaz elemein és az allista segítségével meg kell határozni, hogy az egyes árucikkek
hányszor szerepelnek az allistában. Végül ezt ki is kell írni a képenyőre. Lássuk a megoldást! Próbáljátok ki!!!
############################################
print('7. feladat: ')
allista = []
i7, db7 = 0, 0
while db7 < ssz4 - 1:
    if adatok[i7] == 'F':
        db7 += 1
        i7 += 1
    else:
        i7 += 1
while adatok[i7] != 'F':
    allista.append(adatok[i7])
    i7 += 1
alhalmaz = set(allista)
for x in alhalmaz:
    db71 = 0
    for y in allista:
        if y == x:
            db71 += 1
    print(x,':',db71)

#############################################
A 8. feladat megoldásához szintén fájlkezelésre lesz szükség. Ezt majd a következő órán megoldjuk...
Apropó! Ne felejtsük el és gyakoroljuk a halmaz adatszerkezettel kapcsolatban ma tanultakat!
A halmaz az elemek rendezetlen gyűjteménye és minden elem csak egyszer szerepelhet benne.
Egy új halmaz létrehozása:
my_set = {2, 5, 'alma', 8, 'füge', 11}
Adjunk hozzá egy elemet:
my_set.add(3)
Töröljük a halmazból az 5-öt:
my_set.discard(5)
Halmaz törlése:
my_set.clear()
Halmazműveletek: legyen A = {1, 2, 3, 5, 7} és B = {3, 5, 8, 10}
Unió:
C = A | B vagy C = A.union(B)
Metszet:
D = A & B vagy D = A.intersection(B)
Különbség:
E = A - B
Szimmetrikus differencia:
F = A ^ B. Ez megfelel az (A-B) | (B-A) művelettel.
Képezzünk egy listából halmazt! Legyen a lista a következő: lista = ['alma', 'körte', 'banán', 'alma', 'körte', 'füge', 'alma']
A halmaz pedig amit ebből a listából képezünk a fruits lesz:
fruits = set (lista)
A fruits elemei: 'alma', 'banán', 'körte', 'füge' lesznek.
A halmazban minden gyümölcs csak egyszer szerepel.
Kérdés: benne van-e az 'alma' a halmazban?
'alma' in fruits
Válasz: True
Benne van-e a 'málna' a halmazban?
'málna' in fruits
Válasz: False
Fontos! A halmazban az elemek sorrendje NEM kötött!

Last edited by Piroska István (2019-11-21 13:13:47)

0


You are here » Python programozás » Test forum » Programozás Pythonban