Kihagyás

1. gyakorlat

A gyakorlat anyaga

  • Ismerkedés, követelmények ismertetése

Szövegek

Listák

Pythonban nincs külön, natív tömb adatszerkezet, helyette van a lista, ami kvázi egy dinamikus tömb, változó mérettel. Egy listába bármit tárolhatunk, de célszerű egyfajta típusú elemet beletenni.

1
2
3
4
5
6
7
8
list1 = []  # Ures lista (tomb) letrehozasa
list2 = list()  # Ures lista (tomb) letrehozasa
list3 = [2, 4, 6, 8, 10]  # Lista letrehozasa elemekkel


# Egy lista barmilyen tipusu elemet tarolhat
valtozo = 99
list4 = [1, 2, 3, 1.1, 'cica', 3, valtozo, 123]

A listák használata teljesen analóg a tanult tömbökével.

1
2
print('A list4 3. eleme:', list4[2])
print(list4)

Az append metódus segítségével szúrhatunk be egy új elemet a listába.

1
2
list4.append(-911)
print('list4', list4)

Listák indexelése lehet negatív is, ilyenkor a végéről ad vissza elemet. Ha túlindexelnénk a listát, kivételt kapunk.

1
2
print('list4 utolso eleme:', list4[-1])
print('list4 utolso elotti eleme:', list4[-2])
1
print(list4[-100])

Ennek kimenete

Kimenet

Traceback (most recent call last):

File "", line 1, in

IndexError: list index out of range

Az in operátor segítségével megvizsgálhatjuk, hogy egy elem benne van-e egy listában. Az index operátort is használhatjuk, azonban egy kivételt dob, ha az adott elem nincs benne a listában.

1
2
3
if 'cica' in list4:
    print('A cica benne van a list4-ben')
    print('A cica helye:', list4.index('cica'))
1
2
3
4
list4 = [2, 3]

print(list4.index(2))
print(list4.index(2341))

Kimenet

0

Traceback (most recent call last):

File "", line 1, in

ValueError: 2341 is not in list

Lista egy részéről készíthetünk másolatot, ha tömbindexek között megadjuk a kezdő- és végértékeket (a kezdő elem benne lesz az eredményben, de a végső indexen lévő elem nem). Ilyen esetben bármennyire is túlindexeljük a tömböt, nem kapunk kivételt.

1
2
3
4
5
6
7
list4 = [1, 2, 3, 1.1, 'cica', 3, valtozo, 123]

print('list4 egy resze:', list4[2:5])  # 2, 3, 4. indexen levo elemek

# Lista egy reszenek kimasolasa (a reszlista uj lista lesz!)
list5 = list4[1:3]
print('list5', list5)

A listák (és egyébként minden) referencia szerint működik

1
2
3
4
5
6
7
8
9
list4 = [1, 2, 3, 1.1, 'cica', 3, valtozo, 123]
# Listak referencia szerint mukodnek
list5 = list4
print('list4', list4)
print('list5', list5)
list5.append(3)
list5.append('kutya')
print('list4', list4)
print('list5', list5)

A listákból többféleképpen is törölhetünk elemet: remove metódus segítségével törölhetünk egy adott értéket, míg a del operátorral törölhetünk egy adott indexen lévő elemet

1
2
3
4
5
6
list5 = [1, 2, 3]
list5.remove(3)
print('list5', list5)

del list5[0]
print('list5', list5)

A listák count metódusa megszámolja, hogy egy adott elem hányszor szerepel a listában.

1
2
while list5.count(3) > 0:
    list5.remove(3)

Listák összefűzésére a + operátor használható, vagy pedig az extend metódus.

1
2
3
4
5
6
list6 = list5 + list5
print('list6', list6)
list6 = list()
list6.extend(list5)
list6.extend(list5)
print('list6', list6)

Listák sokszorozására a * operátor használható.

1
2
list7 = list5 * 5
print('list7', list7)

Lista elemeinek összefűzése egy stringgé, és fordítva

1
2
3
4
5
6
list8 = ['alma', 'korte', 'barack', 'cseresznye']
print(list8)
print(', '.join(list8))

szoveg = "Volt egyszer egy alma, egy körte."
print(szoveg.split())

Listák rendezésére a sorted globális függvény, vagy pedig a lista sort metódusa használható.

1
2
3
4
5
list8 = ['alma', 'korte', 'barack', 'cseresznye']
list9 = sorted(list8)
print(list9)
list8.sort(reverse=True)
print(list8)

Dictionaryk

Kulcs-érték párokból álló halmaz. Mind a kulcs, mind az érték tetszőleges típusú lehet (de kulcsnak célszerű szöveget választani). Létrehozhatjuk az elemek megadásával {} között.

1
2
3
4
5
6
7
8
dict3 = {
    'name': 'Robert Paulson',
    'kor': 30,
    'ferfi': True
}

print("A neve %(name)s, %(kor)d eves es ferfi? %(ferfi)s" % dict3)
print(f"A neve {dict3['name']}, {dict3['kor']} eves es ferfi? {'Igen' if dict3['ferfi'] else 'Nem'}")

Vagy pedig létrehozhatunk üres dictionaryt, a dict() vagy {} paranccsal.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
osztaly_letszamok = {}
dict2 = dict()

osztaly_letszamok['1a'] = 23
osztaly_letszamok['2b'] = 35
osztaly_letszamok['3a'] = 25
osztaly_letszamok['1b'] = 19

print('Osztaly letszamok:', osztaly_letszamok)
print('Jelenleg %d osztalynak tudjuk a letszamat' % len(osztaly_letszamok))
print('Osztalyok, amik letszamat tudjuk:', osztaly_letszamok.keys())
print('A 3.a letszama', osztaly_letszamok['3a'], 'fo')

Ha olyan elemre hivatkozunk, ami nem létezik, akkor kivételt kapunk.

1
print('Az 5.zs letszama', osztaly_letszamok['5zs'], 'fo')

Ha nem vagyunk benne biztosak, hogy adott elem létezik, érdemes a get()metódust használni. Ez visszatér a kért értékkel, ha létezik az elem, különben None-nal. A get metódus kaphat egy alapértelmezett értéket is, amivel visszatérhet, hogyha nem létezik az adott elem.

1
2
print(f'Az 5.zs letszama {osztaly_letszamok.get("5zs")} fo')
print(f"Az 5.zs letszama {osztaly_letszamok.get('5zs', 0)} fo")

Elemek vizsgálatára itt is az in operátor használatos.

1
2
3
4
5
if '1b' in osztaly_letszamok:  # if '1b' in osztaly_letszamok.keys():
    print('Az 1b osztaly letszamat tudjuk!')

if 25 in osztaly_letszamok.values():  # ertekek kozott keres
    print('Van 25 fos osztaly!')

Dictionary szétbontása tuple listává

1
print(osztaly_letszamok.items()) # [('3a', 25), ('2b', 35), ('1a', 23), ('1b', 19)]

Dictionary bejárása már ismert for ciklussal:

1
2
3
4
5
for kulcs, ertek in osztaly_letszamok.items():
    print('A(z)', kulcs, ' osztalyba', ertek, ' fo jar.')

for kulcs in osztaly_letszamok:
    print(kulcs, '=>', osztaly_letszamok[kulcs])

Elemek törlése a dictionaryből

1
2
3
4
5
osztaly_letszamok['7k'] = 50
print(osztaly_letszamok)
# Jaj, a 7k megse letezik! Most mi legyen?
del osztaly_letszamok['7k']
print(osztaly_letszamok)

f-string

A Pythonban egyre gyakrabban találkozhatunk f-string-ekkel. Az f-stringek segítségével a stringekbe tetszőleges Python kódot tehetünk.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
hero = {
    "name": "Batman",
    "gender": "Male",
    "race": "Human",
    "height": [
        "6'2",
        "188 cm"
    ],
    "weight": [
        "210 lb",
        "95 kg"
    ],
    "eye-color": "blue",
    "hair-color": "black"
}

szoveg = f"A hős neve {hero['name']}, a szeme színe {'nem ' if hero.get('eye-color') != 'blue' else ''}kék"
print(szoveg)

Osztályok

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
class Student:
    def __init__(self, name="Nincs nevem", age=12):
        self.name = name  # aktualis objektum vs. parameter neve
        self.age = age
        self._grades = list()  # ures lista (tomb)

    def add_grade(self, grade):
        self._grades.append(int(grade))

    def avg(self):
        sum_grades = 0
        for grade in self._grades:
            sum_grades += grade
        return sum_grades/len(self._grades)
        # return sum(self.grades) / len(self.grades)

    def max_grade(self):
        return max(self._grades)

    def min_grade(self):
        return min(self._grades)

    def __eq__(self, other):
        return self.__dict__ == other.__dict__


class ClassRoom:
    def __init__(self):
        self._students = list()

    def new_student(self, student):
        if isinstance(student, Student):
            self._students.append(student)
        else:
            print("You can't do that")

    def avg(self):
        avgs = [student.avg() for student in self._students]
        return sum(avgs) / len(avgs)

    def __str__(self):
        return ("[Just a class, which consist of "
                "%d student(s).]" % len(self._students))

    def __eq__(self, other):
        return self.__dict__ == other.__dict__

    def __add__(self, other):
        if isinstance(other, ClassRoom):
            returned = ClassRoom()
            returned._students = self._students + other._students
            return returned


def main():
    # Hozzunk letre egy hallgatot
    cn = Student("Chuck Norris", 65)
    cn.add_grade(5)
    # cn.add_grade("sajt")
    cn.add_grade(2)
    print('Avg', cn.avg())
    print('Max. grade', cn.max_grade())
    print('Min. grade', cn.min_grade())

    js = Student('Jon Snow', 30)
    js.add_grade(1)
    js.add_grade(5)

    heroes = ClassRoom()
    heroes.new_student(cn)
    heroes.new_student(js)
    print('ClassRoom avg.', heroes.avg())
    print('Print the class variable', heroes)

    js2 = Student('Jon Snow', 30)
    js2.add_grade(1)
    js2.add_grade(5)

    heroes2 = ClassRoom()
    heroes2.new_student(cn)
    heroes2.new_student(js2)

    if heroes == heroes2:
        print('The 2 teams of heroes are equal.')
    else:
        print('The 2 teams of heroes are NOT equal.')

    heroes3 = heroes + heroes2
    print(heroes3)

if __name__ == '__main__':
    main()

Bővebben az osztályokról

Feladatok

Próba

Próbáljuk ki az alábbi kódot:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
import turtle


def draw_head(t):
    # draw head
    for i in range(36):
        t.forward(30)
        t.left(10)


def draw_eyes(t):
    # draw eyes
    t.penup()
    t.goto(-80, 90)
    t.pendown()

    t.left(90)
    for i in range(45):
        t.forward(2)
        t.right(4)

    t.penup()
    t.goto(50, 90)
    t.pendown()

    t.left(-180)
    for i in range(45):
        t.forward(2)
        t.right(4)


def draw_nose(t):
    # draw nose
    t.penup()
    t.goto(0, 50)
    t.pendown()

    t.setheading(0)

    for i in range(5):
        t.forward(25)
        t.right(120)


def draw_mouth(t):
    # draw mouth
    starting_nose_x = t.xcor()
    starting_nose_y = t.ycor()

    t.left(120)
    t.forward(10)
    for i in range(4):
        t.right(16)
        t.forward(17)

    t.penup()
    t.goto(starting_nose_x, starting_nose_y)
    t.pendown()
    t.setheading(-60)

    t.forward(10)
    for i in range(4):
        t.left(16)
        t.forward(17)

    t.penup()
    t.goto(-19, -.10)
    t.pendown()
    t.right(100)
    for i in range(10):
        t.forward(12)
        t.left(21)

def draw_ears(t):
    t.penup()
    t.goto(114, 212)
    t.pendown()
    t.forward(100)
    t.left(120)
    t.forward(75)

    t.penup()
    t.goto(-107, 193)
    t.pendown()
    t.setheading(75)
    t.forward(100)
    t.right(120)
    t.forward(75)
    t.ht()


def draw_something():
    _turtle = turtle.Turtle()
    _turtle.speed(0)
    _turtle.pensize(8)
    _turtle.penup()
    _turtle.goto(0, -100)
    _turtle.pendown()

    draw_head(_turtle)
    draw_eyes(_turtle)
    draw_nose(_turtle)
    draw_mouth(_turtle)
    draw_ears(_turtle)
    turtle.done()


if __name__ == '__main__':
    draw_something()

Házi feladat: Egy hasonló rajz készítése a turtle modullal, tetszőlegesen, bármilyen állat lehet.

Osztályokkal kapcsolatos feladatok

Téglalap

Írj egy osztályt, amely téglalapot reprezentál, annak oldalhosszait tárolja. Készíts neki konstruktort, amely az oldalakat inicializálja, lehessen négyzetet is létrehozni. Készíts metódusokat a kerület és terület kiszámítására. Készíts hozzá main függvényt. Tárold a téglalapokat egy listában. A listában lévő téglalapok területének és kerületének átlagát számítsd ki.

Receptkönyv

Készítsünk receptkönyvet. Ehhez szükségünk lesz egy Hozzávaló, Recept, Receptkönyv osztályra. A receptek egy adott mennyiségre szólnak (pl. 4 főre). Legyen egy olyan függvény, amely segítségével viszont tetszőleges számú emberre alakítható a recept. Ezt a hozzávalók okos letárolásával érhetjük el. A receptnek legyen egy hozzávalók tömbje, amiben tároljuk a recepteket. Ezen kívül tároljuk az elkészítési módot, időt, azt, és azt, hogy hány főre szól a recept

Műsorújság

Készítsünk egy műsorújságot. Kell hozzá egy Műsor osztály, valamint a Műsorújság is. Egy műsornak van neve, korhatár-besorolása (ezek a beérkező adattól függetlenül csak 12, 16, 18 lehet (tehát, ha 8 jön, akkor Műsor objektumban a korhatár-besorolás 12 lesz)), kezdési és befejezési ideje.

A műsorújság osztályon belül legyen a csatorna neve és egy dictionary, amelynek kulcsai a hét napjai, értéke pedig egy lista a műsorokról. Ezek inicializálódjanak a műsorújság létrehozásakor. Legyen egy új_műsor metódusa, ami egy napot, és egy műsort vár paraméterül. Csak akkor lehessen hozzáadni a műsorújsághoz, ha az adott napon a már bent lévő műsorok közül az utolsó után kezdődik (tehát időrendben jönnek, és nincs átfedés). Lehessen kérni statisztikát egy függvény segítségével, ami írjon ki mindenféle izgalmas dolgot a műsorújságról.

Kapcsolódó linkek


Utolsó frissítés: 2021-02-24 17:24:53