Ismerkedés a Pókerrel.

A kódról.
Egy Main osztály dolgozza fel a Játékos és Komputer Canvas osztályokat, valamint egy algoritmusok.py modul, benne az Algoritmusok osztállyal.

Nem egy kész Póker játék, de arra alkalmas, hogy a bemondásokkal ismerkedjünk. A program jó alapot biztosít a tovább fejlesztésre, ez házi feladat a tisztelt olvasónak.

Köszönet a segítségért: https://www.digitalocean.com/community

Ismerkedés a Pókerrel:

https://www.noklapja.hu/aktualis/2023/11/25/francia-kartya-eredete-lapok-nevei/
https://franciakartya.hu/egy-pakli-francia-kartya-lapok-szinek-es-ertekek/
https://pr-cikk.hu/francia-kartya-lapjai-szinei/
https://www.kartya-jatek.hu/poker/ stb...stb..

A lapok rangsora:
2, 3, 4, 5, 6, 7, 8, 9, 10, bubi, dáma, király, ász, joker
A programban jumbó-bubi=11, dáma=12, király=13, ász=14.

Színek rangsora, balról jobbra:
pikk, kőr, káró, treff,
A programozás könnyítése miatt négy betűvel: pikk ♠, szív ♥, káró ♦, tref ♣,

A ♠ ász erősebb, mint a ♥ ász. A teljes csomagot nézve a pakliban a legerősebb lap a pikk ász, és a leggyengébb lap a treff 2.

A lapkombinációk:

Pár: két azonos rangú lap + három semleges kártya. Két pár közül a magasabb rangú
lapokból álló nyer. Két ász  erősebb mint két 2-s.

Két pár: 2 + 2 azonos rangú és egy semleges lap. Két pár + 2 pár összehasonlításnál
az a játékos nyer, akinek a legmagasabb rangú pár van a kezében.
Ezek azonosságánál a második párok rangja dönt. Két 3-as és két király erősebb mint két 4-s és két tízes.

Drill: három azonos rangú és két semleges lap. – Drillek összehasonlításánál a
magasabb rangú lapok birtokosa nyer. Három jumbó  erősebb mint három 9-s.


Sorok, sorozatok; Két sor összehasonlításánál a magasabb rangú kártyákat bemutató játékos nyer.

Kis sor: Kettessel kezdődő rangban egymást követő, különböző színű lapok.
Példa: 2, 3, 4, 5, 6
Sor: Nem kettessel és nem tízessel kezdődő, rangban egymást követő,
különböző színű lapok. 

Példa: 4, 5, 6, 7, 8 vagy 9, 10, jumbó, dáma, király.
Nagy sor: Tízessel kezdődő rangban egymást követő, különböző színű lapok.
Példa: 10, jumbó, dáma, király ász.

Flös, vagy szín: Azonos színű lapok, rangjuk semleges. Két flös összehasonlításnál
az a játékos nyer, akinek kombinációja a legmagasabb rangú kártyát tartalmazza.
Öt ♥ gyengébb mint öt ♠. Azonban öt ♣ és öt ♣ treff összehasonlításánál az győz akinél van egy nagy értékű lap, például az ász.

Full: drill és pár, azaz három azonos rangú és két azonos rangú kártya.
A fullok összehasonlításánál a drillek döntenek, akinek magasabb rangú
lapokat tartalmaznak, megnyeri a játékot. Három 4-s és két ász nagyobb, mint három 3-s és két ász. 

Póker: négy azonos rangú, értékű kártya és egy semleges lap.
Pókerek összehasonlításánál a magasabb rangú kártyák birtokosa nyer.
Példa.: négy 7-s kisebb, mint négy bubi.


Sorok-flös vagy színsorok: Azonos színű lapokból álló sorok, számsorozatok.

Kisflös: Kettessel kezdődő rangban egymást követő, azonos színű lapok.
Flös: Nem kettessel és nem tízessel kezdődő rangban egymást követő, azonos színű lapok.
Nagyflös: Tízessel kezdődő rangban egymást követő, azonos színű lapok.
Két színsor közül az erősebb a magas rangú lapokat bemutató kombináció.


Royal Poker: Négy egyforma lap, + 1 az ötödik a joker.
Példa: Négy 2-s és a joker.
A joker, jokerek bármihez felhasználhatók, de nem használom a programban!

A játék menete:

Az osztó egyesével ad öt-öt kártyát minden résztvevőnek jobbra vagy balra haladva.
Az osztást követően a játékosok felmérik esélyeiket és az alábbi lehetőségek közül
választhatnak:

1, 2 vagy 3 lap cseréje, példa: – Kérek két lapot! De, előtte eldob a kezéből két lapot, és nem veheti vissza.
Auff: 1 lap kérése nyitottan az asztalra, hogy mindenki lássa milyet kapott.
Ebben az esetben nem szükséges előre eldobni az egy lapot. Választhat, felveszi vagy megtartja a kezében lévőket.
All: 5 lap cseréje.


A fenti lehetőségek kihasználása nélkül a kártyák eldobása,
és a játékos csendes szemlélője lehet a további eseményeknek.

A kódok:

algoritmusok.py

from collections import Counter

# Nincs találat
kartyak0 = ['káro10', 'szív08', 'pikk05', 'tref14', 'tref02']       # False

# Darabok, pár, kétpár, drill, full=drill+pár, póker
kartyak1 = ['káró02', 'szív02', 'pikk04', 'tref05', 'tref14']       # Pár
kartyak2 = ['szív03', 'káró03', 'tref04', 'szív04', 'pikk05']       # Két pár
kartyak3 = ['tref14', 'pikk14', 'káró07', 'szív14', 'káró08']       # Drill
kartyak4 = ['tref07', 'szív07', 'pikk07', 'tref09', 'pikk09']       # Full
kartyak5 = ['tref07', 'szív09', 'pikk07', 'tref09', 'pikk09']       # Full
kartyak6 = ['pikk11', 'szív11', 'tref12', 'tref11', 'káró11']       # Póker

# Színsor, azonos színű lapok
kartyak7 = ['káró10', 'káró08', 'káró05', 'káró14', 'káró02']       # Szín

# Számsorozatok, KisSor, Sor, Nagysor
kartyak8a = ['káró03', 'káró04', 'pikk06', 'tref02', 'szív05']   # Kisor
kartyak8b = ['pikk03', 'káró04', 'szív06', 'tref07', 'szív05']   # Sor
kartyak8c = ['káró11', 'szív10', 'pikk13', 'tref14', 'szív12']   # Nagysor


# Fless=színsor+számsor, Kisfless, Fless, Nagyfless
kartyak9a = ['szív10', 'szív11', 'szív12', 'szív13', 'szív14']       # NagyFless
kartyak9b = ['szív05', 'szív07', 'szív06', 'szív04', 'szív08']       # Fless
kartyak9c = ['szív02', 'szív03', 'szív06', 'szív04', 'szív05']       # KisFless


class Algoritmusok:

    # 1.a. vizsgálat
    @staticmethod
    def egyforma_erteku_lapokat_keres(cards):
        """
        Az egyforma értékű lapokat keresi meg,
        és a gyűjtő listázva adja vissza
        :param cards: Játékos lapjai
        :return: Az egyforma értékü lapokat és jellemzőit
        """
        # Elemekből az értékek kiszelése
        ertek_szelet = [sz[4:6] for sz in cards]
        # Szótár key a lapérték, szótár value a darabszám.
        counts1 = Counter(ertek_szelet)

        gyujto_lista = list()
        # Ha a v = darabszám nagyobb mint 1
        for key, value in counts1.items():
            if value > 1:
                gyujto_lista.append(int(key))
                gyujto_lista.append(value)
                # A több darabos value -hoz megkeresi a színt.
                for elem in cards:
                    if key == elem[4:6]:
                        gyujto_lista.append(elem[0:4])

        # Az Algoritmusok osztály statikus metódus hívása
        return Algoritmusok.egyforma_erteku_lapokat_ad(gyujto_lista)

    # 1.b. vizsgálat
    @staticmethod
    def egyforma_erteku_lapokat_ad(darabok):
        """
        Az egyforma_erteku_lapokat_keres() metódus folytatása
        :return: eredmeny lista
        """
        # üres lista esetén
        if not darabok:
            return f'Darabok: {False}'

        # Ha nem üres a lista, elemek száma szerinti kiértékelés
        if darabok:
            if len(darabok) == 4:
                return (f'Pár: {True}, {darabok[0]}-s {darabok[1]} db, '
                        f'{darabok[2:3][0]}, {darabok[3:4][0]}.')

            elif len(darabok) == 5:
                return (f'Drill: {True}, {darabok[0]}-s {darabok[1]} db, '
                        f'{darabok[2:3][0]}, {darabok[3:4][0]}, '
                        f'{darabok[4:5][0]}')

            elif len(darabok) == 6:
                return (f'Póker: {True}, '
                        f'{darabok[0]}-s {darabok[1]} db, '
                        f'{darabok[2:6]}')

            elif len(darabok) == 8:
                return (f'Két pár: {True}, '
                        f'{darabok[0]}-s {darabok[1]} db, '
                        f'{darabok[2:3][0]}, {darabok[3:4][0]},'
                        f' és {darabok[4]}-s {darabok[5]} db, '
                        f'{darabok[6:7][0]}, {darabok[7:8][0]}')

            # Annak eldöntése, hogy a lista elején, vagy végén van a Pár
            elif len(darabok) == 9:
                # Ha a 2-s a lista elején van
                if darabok[1] == 2:
                    return (f'Full: {True}, '
                            f'{darabok[0]}-s {darabok[1]} db, {darabok[2:4]}, '
                            f'és {darabok[4]}-s {darabok[5]} db, '
                            f'{darabok[6:]}')

                # Ha a lista elején van drill
                elif darabok[1] == 3:
                    return (f'Full: {True}, '
                            f'{darabok[0]}-s {darabok[1]} db, {darabok[2:5]}'
                            f' és {darabok[5]}-s {darabok[6]} db, '
                            f'{darabok[7:]}')
                else:
                    return 'A nem üres lista hibát jelez!'

            else:
                return 'Kiértékelési hiba!'
        # ----------------------------------------------------------

    # 2. vizsgálat
    @staticmethod
    def egyforma_szinu_lapokat_ad(cards):
        """
        A kártyalapok azonos színeinek vizsgálata.
        :param cards: öt játékos kártyalap.
        :return: ha öt azonos True
        """
        szin_szelet = [sz[0:4] for sz in cards]
        # print(f'{szin_szelet=}')

        counts2 = Counter(szin_szelet)
        # print(f'{counts2=}')

        # A counter szótár kibontása
        for k, v in counts2.items():
            if v == 5:
                return ['Színsor:', True, '| Színe:', k]
            else:
                return ['Színsor:', False]

    # 3. vizsgálat
    @staticmethod
    def szamsorozatokat_ad(cards):
        """
        Ellenőrizi, hogy a lista tartalmaz-e egymást követő,
        udvarias, trapéz számokat
        :param cards: Játékos lapok lista
        :return:
        """
        ertek = [int(sz[4:6]) for sz in cards]
        legkisebb = min(ertek)
        eredmeny = [sorted(ertek) == list(range(min(ertek), max(ertek) + 1))]
        # print(f'{eredmeny=}')

        if eredmeny[0] is False:
            return ['Számsor:', False]

        if eredmeny[0] is True:
            if legkisebb == 2:
                return ['Kissor:', eredmeny[0], '| legkisebb szám:', legkisebb]

            elif 2 < legkisebb < 10:
                return ['Sor:', eredmeny[0], '| legkisebb szám:', legkisebb]

            elif legkisebb == 10:
                return ['Nagysor:', eredmeny[0], '| legkisebb szám:', legkisebb]

            else:
                return 'Hiba a számsorozatokban!'

    # ------------------------------------------------------------------


class App:
    def __init__(self):
        kartyak = kartyak9c
        self.szam_szin_sorozat(kartyak)

    @staticmethod
    def szam_szin_sorozat(card):
        a = Algoritmusok.egyforma_erteku_lapokat_keres(card)
        print(a)
        b = Algoritmusok.egyforma_szinu_lapokat_ad(card)
        print(*b)
        c = Algoritmusok.szamsorozatokat_ad(card)
        print(*c)

        if b[1] is True and c[1] is True:
            if c[3] == 2:
                print(f'KisFless: {True}')

            elif 10 > c[3] > 2:
                print(f'Fless: {True}')

            elif c[3] == 10:
                print(f'NagyFless: {True}')

            else:
                print(f'Fless: {False}')


if __name__ == '__main__':
    App()

A_Poker.py

import tkinter as tk
import random
import sys
import algoritmusok as al

card_names = [
    'káró02', 'káró03', 'káró04', 'káró05', 'káró06', 'káró07', 'káró08',
    'káró09', 'káró10', 'káró11', 'káró12', 'káró13', 'káró14',
    'szív02', 'szív03', 'szív04', 'szív05', 'szív06', 'szív07', 'szív08',
    'szív09', 'szív10', 'szív11', 'szív12', 'szív13', 'szív14',
    'pikk02', 'pikk03', 'pikk04', 'pikk05', 'pikk06', 'pikk07', 'pikk08',
    'pikk09', 'pikk10', 'pikk11', 'pikk12', 'pikk13', 'pikk14',
    'tref02', 'tref03', 'tref04', 'tref05', 'tref06', 'tref07', 'tref08',
    'tref09', 'tref10', 'tref11', 'tref12', 'tref13', 'tref14']

# összekeveri a lapokat
random.shuffle(card_names)


class PlayerTable(tk.Canvas):
    def __init__(self, container):
        super().__init__(container)
        # A játékos tábla mérete és színe
        self.configure(width=650, height=260, bg='#006400')

        # képobjektum
        self.jat_img = None
        # Játékos képobjektumok listája
        self.jat_img_list = []

        # Kép készítő objektum
        self.jat_create_img_obj = None
        # Canvas create_image objektumok tárolója
        self.jat_canv_obj = []

        # Szöveg a táblán
        self.create_text(325, 15,
                         text="A játékos lapjai",
                         fill="#E3CF57",
                         font='Gabriola 15 bold')

        # Játékos találatok megjelenítője
        self.jtext = None
        self.jtext_lista = []

        self.jatekos_kijelzok()

    def jatekos_kijelzok(self):
        jkijelzo = [f'kijelző 1', f'kijelző 2', f'kijelző 3', f'kijelző 4']
        le = 0
        for i0 in range(4):
            self.jtext = self.create_text(320, 190+le, text=jkijelzo[i0],
                                          fill='white',
                                          font='CambriaMath 12')
            self.jtext_lista.append(self.jtext)
            le += 20

    def player_card(self, jotlap):
        """
        Megjeleníti a játékos kártyáit.
        :param jotlap: Játékos öt lapja.
        :return:
        """
        # Játékos lapjainak a koordinátái
        jat_koordinatak = [(100, 100), (210, 100), (320, 100), (430, 100), (540, 100)]

        # Az öt lapot sorba rendezi a 4-s és 5-s index alapján
        jotlap.sort(key=lambda x: x[4:6])

        # Játékos képobjektumok készítő és listázó
        for i1 in range(5):
            self.jat_img = tk.PhotoImage(file=f'../kepek/{jotlap[i1]}.png')
            self.jat_img_list.append(self.jat_img)

        # Játékos kártyák megmutatása
        for i2 in range(5):
            self.jat_create_img_obj = (
                self.create_image(jat_koordinatak[i2],
                                  image=self.jat_img_list[i2]))

            # Összegyűjti a képkészítő objektumokat
            self.jat_canv_obj.append(self.jat_create_img_obj)

        # A játékos lapneveit elenőrzi
        # print(f'\nJátékos sorbarendezett lapjai: {jotlap}')

    def jat_delete_objects(self):
        """
        Osztály attribútumok törlése
        :return:
        """
        self.jat_img = None
        self.jat_create_img_obj = None

        # print(f'\nTörlés előtt: {self.jat_img_list}, {len(self.jat_img_list)} db')
        self.jat_img_list.clear()
        # print(f'Törlés után: {self.jat_img_list=}, {len(self.jat_img_list)} db')

        for i3 in range(5):
            self.delete(self.jat_canv_obj[i3])

        # self.jtext = None
        # self.jtext_lista.clear()

        for i4 in range(4):
            self.itemconfig(self.jtext_lista[i4], text='')

    def szam_szin_sorozat(self, card):
        # Modul osztály példány
        algorithms = al.Algoritmusok()

        # Az Algoritmusok osztály metódusok hívása
        # Egyforma értékű lapok
        egyforma = algorithms.egyforma_erteku_lapokat_keres(card)
        print(egyforma)
        # Megjelenés a játékos táblán
        self.itemconfig(self.jtext_lista[0], text=egyforma)

        # Azonos színű lapok
        egyszinu = algorithms.egyforma_szinu_lapokat_ad(card)
        print(*egyszinu)
        # Megjelenés a játékos táblán
        self.itemconfig(self.jtext_lista[1], text=egyszinu)

        # Számsorozatok megjelenítése
        sorozat = algorithms.szamsorozatokat_ad(card)
        print(*sorozat)
        # Megjelenés a játékos táblán
        self.itemconfig(self.jtext_lista[2], text=sorozat)

        # Amikor a sorozat azonos színű, vagy nem.
        if egyszinu[1] is True and sorozat[1] is True:
            if sorozat[3] == 2:
                print(f'KisFless: {True}')
                # Megjelenés a játékos táblán
                self.itemconfig(self.jtext_lista[3], text=f'KisFless: {True}')

            elif 10 > sorozat[3] > 2:
                print(f'Fless: {True}')
                # Megjelenés a játékos táblán
                self.itemconfig(self.jtext_lista[3], text=f'Fless: {True}')

            elif sorozat[3] == 10:
                print(f'NagyFless: {True}')
                # Megjelenés a játékos táblán
                self.itemconfig(self.jtext_lista[3], text=f'NagyFless: {True}')
        else:
            print(f'Fless: {False}')
            # Megjelenés a játékos táblán
            self.itemconfig(self.jtext_lista[3], text=f'Fless: {False}')


class ComputerTable(tk.Canvas):
    def __init__(self, container):
        super().__init__(container)
        # Az asztal
        self.configure(width=650, height=260, bg='#006400')

        # Kép objektum
        self.gep_img = None
        # A gép kép objektumok tárolója listában
        self.gep_img_list = []
        # Kép készítő objektum
        self.gep_create_img_obj = None
        # Canvas create_image objektumok tárolója
        self.gep_canv_obj = []

        # A kártyák fölötti felirat
        self.create_text(325, 15,
                         text="A számítógép lapjai",
                         fill="#E3CF57",
                         font='Gabriola 15 bold')

        # Játékos találatok megjelenítője
        self.gtext = None
        self.gtext_lista = []

        self.computer_kijelzok()

    def computer_kijelzok(self):
        gkijelzo = ['kijelző 1', 'kijelző 2', 'kijelző 3', 'kijelző 4']
        le = 0
        for i0 in range(4):
            self.gtext = self.create_text(320, 190 + le, text=gkijelzo[i0],
                                          fill='white',
                                          font='CambriaMath 12')
            self.gtext_lista.append(self.gtext)
            le += 20

    def computer_card(self, gotlap):
        # A gép lapok koordinátái
        gep_koordinatak = [(100, 100), (210, 100), (320, 100), (430, 100), (540, 100)]

        # Az öt lapot sorba rendezi a sztring számok alapján
        gotlap.sort(key=lambda x: x[4:6])

        # Kép objektumok készítése listába
        for i in range(5):
            self.gep_img = tk.PhotoImage(file=f'../kepek/{gotlap[i]}.png')
            self.gep_img_list.append(self.gep_img)

        # A gép lapjait jeleníti meg
        for i in range(5):
            self.gep_create_img_obj = (
                self.create_image(gep_koordinatak[i],
                                  image=self.gep_img_list[i]))

            # Összegyűjtjük a kép készítő objektumokat
            self.gep_canv_obj.append(self.gep_create_img_obj)

        # A gép lapok ellenőrzése
        # print(f'Computer sorbarendezett lapjai: {gotlap}')

    def gep_delete_objects(self):
        # Osztály attribútumok törlése
        self.gep_img = None
        self.gep_create_img_obj = None

        # print(f'\nTörlés előtt: {self.gep_img_list}, {len(self.gep_img_list)} db')
        self.gep_img_list.clear()
        # print(f'Törlés után: {self.gep_img_list=}, {len(self.gep_img_list)} db')

        # Kártyák törlése
        for i in range(5):
            self.delete(self.gep_canv_obj[i])

        # Kiértékelés törlése
        for i4 in range(4):
            self.itemconfig(self.gtext_lista[i4], text='')

    def szam_szin_sorozat(self, card):
        # Modul osztály példány
        algorithms = al.Algoritmusok()

        # Az Algoritmusok osztály metódus
        azonosertekek = algorithms.egyforma_erteku_lapokat_keres(card)
        print(azonosertekek)
        # Megjelenés a számítógép táblán
        self.itemconfig(self.gtext_lista[0], text=azonosertekek)

        # Az Algoritmusok osztály metódus
        azonosszinek = algorithms.egyforma_szinu_lapokat_ad(card)
        print(*azonosszinek)
        # Megjelenés a számítógép táblán
        self.itemconfig(self.gtext_lista[1], text=azonosszinek)

        # Az Algoritmusok osztály metódus
        szamsorozat = algorithms.szamsorozatokat_ad(card)
        print(*szamsorozat)
        # Megjelenés a számítógép táblán
        self.itemconfig(self.gtext_lista[2], text=szamsorozat)

        if azonosszinek[1] is True and szamsorozat[1] is True:
            if szamsorozat[3] == 2:
                print(f'KisFless: {True}')
                # Megjelenés a számítógép táblán
                self.itemconfig(self.gtext_lista[3], text=f'kisFless: {True}')

            elif 10 > szamsorozat[3] > 2:
                print(f'Fless: {True}')
                # Megjelenés a számítógép táblán
                self.itemconfig(self.gtext_lista[3], text=f'Fless: {True}')

            elif szamsorozat[3] == 10:
                print(f'NagyFless: {True}')
                # Megjelenés a számítógép táblán
                self.itemconfig(self.gtext_lista[3], text=f'NagyFless: {True}')

        else:
            print(f'Fless: {False}')
            # Megjelenés a számítógép táblán
            self.itemconfig(self.gtext_lista[3], text=f'Fless: {False}')


class Main(tk.Tk):
    def __init__(self, lapnevek):
        super().__init__()
        self.geometry('+700+100')

        # inicializálás
        # A pakli lapok nevei
        self.lapnevek = lapnevek

        self.jat_otlap = None
        self.gep_otlap = None
        # A pakli darabszáma
        # print(f'Tele pakli: {len(self.lapnevek)}')

        # Játékos tábla példány
        self.player_table = PlayerTable(self)
        self.player_table.grid(row=0, column=0, padx=2, pady=2)

        # Gép tábla példány
        self.computer_table = ComputerTable(self)
        self.computer_table.grid(row=1, column=0, padx=2, pady=(0, 2))

        # A táblák alatti gomb és cimkék kerete
        self.frame = tk.Frame(self, bg='#006400')
        self.frame.grid(row=2, column=0, sticky="nsew",
                        padx=2, pady=(0, 2))

        # Osztás gomb
        self.oszt_gomb = tk.Button(self.frame, width=8,
                                   text='Osztás',
                                   font='CambriaMath 12',
                                   bg='#8B5A2B',
                                   state='normal',
                                   command=self.new_cards)
        self.oszt_gomb.pack(side=tk.LEFT, padx=5, pady=5)

        # A cimke követi a pakli darabszámát
        self.pakli_db = tk.Label(self.frame, width=8,
                                 background='#E3CF57',
                                 text=f' Pakli: {0} ',
                                 font='CambriaMath 12')
        self.pakli_db.pack(side=tk.LEFT, ipady=3)

        # Törlés gomb
        self.delete_gomb = tk.Button(self.frame, width=8,
                                     text='Delete',
                                     font='CambriaMath 12',
                                     bg='#8B3626',
                                     state='disabled',
                                     command=self.delete)
        self.delete_gomb.pack(side=tk.LEFT, padx=5, pady=5)

        # Értékelő gomb
        self.ertekel_gomb = tk.Button(self.frame, width=8,
                                      text='Kiértékel',
                                      font='CambriaMath 12',
                                      bg='#FF6103',
                                      state='disabled',
                                      command=self.evaluation)
        self.ertekel_gomb.pack(side=tk.LEFT, padx=5, pady=5)

        # exit gomb
        self.exit_gomb = tk.Button(self.frame, width=8,
                                   text='Exit',
                                   font='CambriaMath 12',
                                   bg='#FF3030',
                                   state='normal',
                                   command=sys.exit)
        self.exit_gomb.pack(side=tk.LEFT, padx=5, pady=5)

        self.szin_sor = tk.PhotoImage(file='../kepek/szin_sorren.png')

        # A cimke képpel
        self.image_label = tk.Label(self.frame, image=self.szin_sor)
        self.image_label.pack(side=tk.RIGHT, padx=5)

    def new_cards(self):
        """
        A pakliból kiszeli a mérkőzők kéz öt lapjait.
        A pakliból törli a kiszeléseket, majd megjeleníti.
        A pakli maradék lapjainak számát frissíti.
        :return: Images cards
        """
        if len(self.lapnevek) > 9:
            self.oszt_gomb.configure(state='disabled')
            self.delete_gomb.configure(state='disabled')
            self.ertekel_gomb.configure(state='normal')
            # A teljes pakli osztások előtt
            # print(f'\nA teljes pakli: {self.lapnevek}')

            # Osztás a játékosnak
            self.jat_otlap = self.lapnevek[0:5]
            # print(f'Játékos ötlapja: {self.jat_otlap}')

            # A leosztott lapok törlése a pakliból
            del self.lapnevek[0:5]
            # print(f'\nOsztás után pakli: {self.lapnevek}')

            # ------------------------------------------

            # Osztás a gépnek
            self.gep_otlap = self.lapnevek[0:5]
            # print(f'Computer ötlapja: {self.gep_otlap}')

            # A leosztott lapok törlése a pakliból
            del self.lapnevek[0:5]
            # print(f'\nOsztás után pakli: {self.lapnevek}')

            # ------------------------------------------------

            # Játékos metódus hívás
            self.player_table.player_card(self.jat_otlap)

            # Computer metódus hívás
            self.computer_table.computer_card(self.gep_otlap)

            # A pakli lapok darabszám megjelenítője
            self.pakli_db.configure(text=f' Pakli: {len(self.lapnevek)} ')
        else:
            self.pakli_db.configure(text=f'Nincs lap!', bg='#FF82AB')

    def delete(self):
        """
        A két Canvas osztály metódusainak a hívása
        :return: Törli a táblán lévő kártyákat és attribútumaikat.
        """
        # buttons configure
        self.oszt_gomb.configure(state='normal')
        self.delete_gomb.configure(state='disabled')
        self.ertekel_gomb.configure(state='disabled')

        # Példány metódusok hívása
        self.player_table.jat_delete_objects()
        self.computer_table.gep_delete_objects()

    def evaluation(self):
        """
        Kiértékelő függvény. A Canvas osztályok metódusait futtatja.
        :return:
        """
        self.oszt_gomb.configure(state='disabled')
        self.delete_gomb.configure(state='normal')
        self.ertekel_gomb.configure(state='disabled')

        # Modul osztály példány
        # algorithms = al.Algoritmusok()

        # Példány metódusok hívása
        print(f'\n\tPlayer datas:')
        self.player_table.szam_szin_sorozat(self.jat_otlap)

        print(f'\n\tComputer datas:')
        self.computer_table.szam_szin_sorozat(self.gep_otlap)


# indító hivatkozás
if __name__ == '__main__':
    main = Main(card_names)
    main.mainloop()