Python tkinter tk.Button és ttk.Button opciók

# Python 3.12

import tkinter  as tk
from tkinter  import ttk



ablak = tk.Tk()

btn1 = ttk.Button(ablak, text="próba")
btn1.pack()


print('ttk.Button')
for i in btn1.configure().keys():
    print(f'{i}=')
# command=
# default=
# takefocus=
# text=
# textvariable=
# underline=
# width=
# image=
# compound=
# padding=
# state=
# cursor=
# style=
# class=

print('\n------------------------------------------------------------------------\n')

btn2 = tk.Button(ablak, text="próba")
btn2.pack()

print('tk.Button')
for i2 in btn2.configure().keys():
    print(f'{i2}=')
# activebackground=
# activeforeground=
# anchor=
# background=
# bd=
# bg=
# bitmap=
# borderwidth=
# command=
# compound=
# cursor=
# default=
# disabledforeground=
# fg=
# font=
# foreground=
# height=
# highlightbackground=
# highlightcolor=
# highlightthickness=
# image=
# justify=
# overrelief=
# padx=
# pady=
# relief=
# repeatdelay=
# repeatinterval=
# state=
# takefocus=
# text=
# textvariable=
# underline=
# width=
# wraplength=

ablak.mainloop() 

Python random list

import random

lista = [10, 15, 20, 25, 30]
index = random.randint(0, len(lista) - 1)
elem = lista[index]
print('Véletlen szám:', elem)

# Véletlen számlista
print(random.choices(range(1, 36), k=7))
# [21, 19, 8, 4, 21, 26, 12] szám ismétlődés!

# A véletlen számok súlyozása
tizszam = range(1, 11)
elemek_valoszinusege = [1, 3, 7, 2, 9, 9, 1, 5, 4, 6]
print(random.choices(tizszam, k=7, weights=elemek_valoszinusege))
# [8, 5, 5, 4, 3, 5, 10] szám ismétlődés!

# Szám ismétlődés nélkül
print(list(set(random.choices(range(1, 36), k=7))))
# [32, 3, 9, 13, 21, 23] 6 vagy 7 darab szám!

# megoldás
print(sorted(random.sample(range(1, 36), 7)))
# [5, 6, 14, 15, 19, 21, 25]
# [4, 16, 21, 24, 29, 30, 32]
# stb....

# megoldás finomítása
kihagyandok = [1, 10, 20, 30]
valasz = [x for x in range(1, 36) if not (x in kihagyandok)]
print(valasz)
# [2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33, 34, 35]

elemek = [x for x in random.sample(valasz, k=7)]
elemek.sort()
print(elemek)
# [11, 14, 15, 18, 22, 33, 35]
# [4, 7, 11, 13, 17, 29, 34]
# stb...

Python 3.12

Layco

Python tkinter verzió

# Python 3.12

import tkinter as tk

# példa 1.
print(tk._test())

# példa 2.
print(tk.Tcl().eval('info patchlevel'))

# példa 3.
print(f'{tk.TkVersion=}')

Layco

Python tkinter font

Betűtípusok kiíratása.

Python 3.12

import tkinter as tk
from tkinter import font
from pprint import pprint

ablak = tk.Tk()

pprint(font.families())

ablak.mainloop()

Egy adott típuson belül.

import tkinter as tk
from tkinter import font


class BetuTipus(tk.Canvas):
    def __init__(self):
        super().__init__()
        self.configure(width=800, height=300, bg='orange')

        # Szövegek hozzáadása különböző variánsokkal
        y_pozicio = 50
        for valtozat in [
            "Bahnschrift SemiBold",
            "Bahnschrift SemiCondensed",
            "Bahnschrift",
            "Bahnschrift Condensed",
            "Bahnschrift Light SemiCondensed"]:
            self.bahnschrift_tipusok(
                370, y_pozicio,
                f"{valtozat}: 'Düh csikarja fenn a felhőt, fintorog.'", valtozat)
            y_pozicio += 40


    def bahnschrift_tipusok(self, x, y, text, font_name):
        font_tipus = font.Font(family=font_name, size=20)
        self.create_text(x, y, text=text, font=font_tipus, fill="black")


class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Bahnschrift Variánsok Tesztje")

        betu_tipus = BetuTipus()
        betu_tipus.pack(side='top')

if __name__ == '__main__':
    app = App()
    app.mainloop()

Python Canvas kép görgetés

 Görgessünk egy képet a határokon túlra!

Nyelv: Python 3.12

Fejlesztő környezet: PyCharm 2025.1.3 (Community Edition)

import tkinter as tk

class KepGorgetes(tk.Canvas):
    def __init__(self):
        super().__init__()
        self.configure(
            width=300,
            height=300,
            bg='gray',
            scrollregion=(0,0,0,0),
            confine=True    # False: minden irányba húzható
        )

        self.kep = tk.PhotoImage(file='bruce_lee.png')
        self.create_image(50, 50, image=self.kep)

        # Egér bal gomb lenyomva
        self.bind("<ButtonPress-1>", self.start_gorgetes)
        # Mozgatás
        self.bind("<B1-Motion>", self.kep_gorgetes)

    def start_gorgetes(self, event=None):
        """Beolvasás megjelölése"""
        self.scan_mark(event.x, event.y)
        print(f'{event.x}, {event.y}')


    def kep_gorgetes(self, event=None):
        """A kép húzás beolvasása."""
        self.scan_dragto(event.x, event.y, gain=1)    # gain=nyereség
        print(f'{event.x}, {event.y}')


class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('320x400+500+10')
        self.configure(bg='green')

        kep_gorgetes = KepGorgetes()
        kep_gorgetes.pack(pady=50)


if __name__ == '__main__':
    app = App()
    app.mainloop()

Layco

Python tkinter kártyajáték

 Szükséges hozzávalók:

1. 1 pakli magyar kártya képek
2. 1 db szmájli kép,  https://pixabay.com/hu/
3. Python 3.12
4. PyCharm 2025.1.3
5. pakli_manager.py
6. kartya_jatek.py 
7. Haladó Python ismeret.

pakli_manager.py

import random

from tkinter import messagebox as msg


class Pakli:
    @staticmethod
    def csomag_keszites():
        lapok = ['m02', 'm03', 'm04', 'm07', 'm08', 'm09', 'm10', 'm11',
                 'p02', 'p03', 'p04', 'p07', 'p08', 'p09', 'p10', 'p11',
                 't02', 't03', 't04', 't07', 't08', 't09', 't10', 't11',
                 'z02', 'z03', 'z04', 'z07', 'z08', 'z09', 'z10', 'z11']
        random.shuffle(lapok)

        return lapok

    @staticmethod
    def manager_metodus_1(gep, pakli):
        """A kapott kártyapakliból leoszt,
         egy darab kártyalap nevet.
         """
        for _ in range(1):
            # gép kéz lista elem darabszáma
            gep_db = len(gep)
            pkl = len(pakli)

            # Ha a kézben 0 db a lap, és
            # vannak lapok a pakliban, legalább 2 db.
            if gep_db < 1 and pkl > 0:
                # Egy lapot pótol
                gep += pakli[0:1]
                # Rögtön törlődik a pakliból kivett lapnév
                del pakli[0:1]

            # Ha a kézlapok darabszáma egy.
            elif len(gep) == 1:
                break

            else:
                msg.showerror('Ellenőrízendő hiba: 41 sor!',
                              f'{len(pakli)=}db, '
                              f'{len(gep)=}db')
                break

        # sorbarendezés
        gep.sort(key=lambda x: x[0:3])

        return gep, pakli

    @staticmethod
    def manager_metodus_2(szemely, pakli):
        """A kapott kártyapakliból leoszt,
         vagy kiegészíti a személy lapjait öt darabra.
         """
        for _ in range(5):
            # Játékos kéz lista elem darabszáma
            jat_db = len(szemely)
            pkl = len(pakli)

            # Ha a kézben ötnél kevesebb a lap, és
            # vannak lapok a pakliban, legalább 2 db.
            if jat_db < 5 and pkl > 1:
                # Egyesével pótol játékosnak lapot
                szemely += pakli[0:1]
                # Rögtön törlődik a pakliból kivett lapnév
                del pakli[0:1]

            # Ha a kézlapok darabszáma öt - öt.
            elif len(szemely) == 5:
                break

            else:
                msg.showerror('Ellenőrzendő hiba!',
                              f'{len(pakli)=}db, '
                              f'{len(szemely)=}db')
                break

        # sorbarendezés
        szemely.sort(key=lambda x: x[0:3])

        return szemely, pakli

kartya_jatek.py

import tkinter as tk
import pakli_manager as pm
from tkinter import font
from tkinter import messagebox as msg
import sys


class LapManager:
    def __init__(self):

        # A 32 lapos kevert pakli elkészítése.
        self.pakli = pm.Pakli.csomag_keszites()
        print(f'Pakli: {len(self.pakli)} db')

        self.jatekos_lapnevek1 = []
        self.jatekos_lapnevek2 = []

    def egy_kartyalapnev(self):
        eredmeny1 = pm.Pakli.manager_metodus_1(self.jatekos_lapnevek1, self.pakli)
        gep_lapnevek1 = eredmeny1[0]
        # Maradék pakli
        self.pakli = eredmeny1[1]

        pakli_darab = len(self.pakli)
        print(f'Gép kártyalapja: {gep_lapnevek1}')
        print(f'Pakli: {pakli_darab} db')

        if pakli_darab == 0:
            msg.showinfo('Figyelem!', 'Utolsó lapja a komputernek.\n'
                                      'Egy jelölés után, "újkör" gomb...!')

        return gep_lapnevek1

    def ot_kartyalapnev(self):
        eredmeny2 = pm.Pakli.manager_metodus_2(self.jatekos_lapnevek2, self.pakli)
        self.jatekos_lapnevek2 = eredmeny2[0]
        # Maradék pakli
        self.pakli = eredmeny2[1]
        print(f'Játékos kártyalapok: {self.jatekos_lapnevek2}')
        print(f'Pakli: {len(self.pakli)} db')

        return self.jatekos_lapnevek2

    @staticmethod
    def felugro_ablak():
        """Toplevel ablak készítés."""
        top = tk.Toplevel()
        top.geometry("300x280+700+100")
        top.configure(bg='#BCC6CC')
        top.title("Szabályzat.")
        top.grab_set()
        top.focus()

        text = tk.Text(top, height=14, bg='#F5F5DC', font=font.Font(size=10))
        text.pack(padx=10, pady=10, expand=True, fill='both')

        text.insert(
            index='1.0',
            chars='\tA játék menete\n'
                  ' Válassz bal egér gombal egy olyan lapot:\n'
                  ' - hogy a szín nagyobb,az érték egyforma,\n'
                  ' - vagy a színek egyeznek, lap érték nagyobb.\n'
                  ' Ha jól választottál kapsz egy pontot.\n'
                  ' Új körhöz nyomd meg az "újkör" gombot!\n'
                  ' Ha elfogyott a pakli "újparti" gomb!\n'
                  ' - Felugró ablakok fognak figyelmeztetni.\n'
                  ' Értéksor; kisebbtől a nagyobb felé haladva:\n'
                  ' - alsó, felső, király, VII, VIII, IX, X, ász.\n'
                  ' Színérték abc: makk, piros, tök, zöld,(m,p,t,z)'
        )

        tk.Button(top,
                   text='Bezár', bg='red', fg='white',
                   command=top.destroy).pack(expand=True)


class App(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('600x400+700+100')
        self.title('Egyszerű kártyajáték.')
        self._cellak = {}
        self.kivalasztott_keret = None  # Csak egy legyen egyszerre
        self.jatekos_pont = 0
        self.gep_pont = 0
        # Egér kattintási eseményt vezérlő változó.
        self.eger_katt = True

        # példányosítás
        self.lap_manager = LapManager()

        # Fekete hátterű canvas
        self.canvas = tk.Canvas(self, bg='black', width=600, height=370)
        self.canvas.pack(fill="both",expand=True)

        # Eredmény kijelző
        self.pont_label = tk.Label(self,
                              text=f'Személy {self.jatekos_pont} : '
                                   f'{self.gep_pont} Komputer ',
                              bg='#254117', fg='white',
                              font=font.Font(size=12))
        self.pont_label.pack(fill='x', expand=True)



        # App osztály metódus hívások
        self._gombokat_keszit_raccsal()
        self._ujkor()
        self._szmajli_keszites()

        msg.showinfo(
            'Kezdés',
            'Bal egérgomb kattintással\n'
            'válassz egy játékos kártyát.\n'
            'Ezután nyomj "újkör" gombot!')

    def _komputer_kep(self):
        """A computer kártyalapja."""
        self.gep_kep_tk_lista1 = []
        self.gep_lap = self.lap_manager.egy_kartyalapnev()

        for nev1 in self.gep_lap:
            self.gep_kep1 = tk.PhotoImage(file=f'kepek/{nev1}.png')
            self.gep_kep_tk_lista1.append(self.gep_kep1)

        i = 0
        self.szem_kep_id_lista1 = []
        for sor1 in range(230, 1+230, 90):
            self.szem_kep_id1 = self.canvas.create_image(sor1, 90,
                                                       image=self.gep_kep_tk_lista1[i])
            self.szem_kep_id_lista1.append(self.szem_kep_id1)
            i += 1

        self.canvas.create_text(230, 165, text='géplap', fill='white')

    def _szemely_kepek(self):
        self.szem_kep_tk_lista2 = []
        lapnevek2 = self.lap_manager.ot_kartyalapnev()
        for nev2 in lapnevek2:
            self.szem_kep2 = tk.PhotoImage(file=f'kepek/{nev2}.png')

            self.szem_kep_tk_lista2.append(self.szem_kep2)

        i = 0
        self.szem_kep_id_lista2 = []
        for sor2 in range(50, 361+50, 90):
            self.szem_kep_id2 = self.canvas.create_image(
                sor2, 250,
                image=self.szem_kep_tk_lista2[i], tags=lapnevek2[i])

            self.szem_kep_id_lista2.append(self.szem_kep_id2)
            i += 1

        self.canvas.create_text(230, 330, text='játékoslapok', fill='white')

        self.kattintasi_esemenyek = []
        for kep_id in self.szem_kep_id_lista2:
            self.kattintas = self.canvas.tag_bind(kep_id, '<Button-1>',
                                                  self._kattintasi_esemeny)

            self.kattintasi_esemenyek.append(self.kattintas)

    def _kattintasi_esemeny(self, event):
        if self.eger_katt:
            # Az esemény pozíciójából megtaláljuk az elemet
            self.item_id = self.canvas.find_closest(event.x, event.y)[0]

            # Lekérjük az elemhez tartozó tageket (pl. név, kartya_x)
            self.tags = self.canvas.gettags(self.item_id)

            # Korábbi kijelölés törlése, ha van
            if self.kivalasztott_keret:
                self.canvas.delete(self.kivalasztott_keret)

            # Kép pozíciójának lekérése
            x, y = self.canvas.coords(self.item_id)

            # Téglalap kirajzolása (egyszerű piros keret a kép köré)
            self.kivalasztott_keret = self.canvas.create_rectangle(
                x - 41, y - 64, x + 41, y + 64,
                outline='red',
                width=3
            )

            self._elszamolas()
            # Egér kattintás tiltása, egy körön belüli ismétlés kizárás.
            self.eger_katt = False

        else:
            msg.showerror('Kattintottál!', 'Egy körben egy kattintás!')

    def _elszamolas(self):
        """A gép kártya és a kattintott játékos kártya
        összehasonlítása, nagyobb érték megállapítása."""

        print(f'\nGép lapnév: {self.gep_lap[0]},\n'
              f'Játékos lapnév: {self.tags[0]},\n')

        jat_ertek = int(self.tags[0][1:3])
        gep_ertek = int(self.gep_lap[0][1:3])
        jat_szin = self.tags[0][0]
        gep_szin = self.gep_lap[0][0]

        if jat_szin == gep_szin:
            if jat_ertek > gep_ertek:
                self.jatekos_pont += 1
                # Szmájli megjelenítő metódus
                self.start_szmajli()
            elif jat_ertek < gep_ertek:
                self.gep_pont += 1

        # játékos szín betűje abc rendben nagyobb
        elif jat_szin < gep_szin:
            if jat_ertek == gep_ertek:
                self.jatekos_pont += 1
                # Szmájli megjelenítő metódus
                self.start_szmajli()
            elif jat_ertek != gep_ertek:
                self.gep_pont += 1

        # játékos szín betűje abc rendben kisebb
        elif jat_szin > gep_szin:
            if jat_ertek == gep_ertek:
                self.gep_pont += 1
            elif jat_ertek != gep_ertek:
                self.gep_pont += 1

        else:
            print('hiba 230 sor!')

        self.pont_label.configure(text=f'Személy {self.jatekos_pont} : '
                                   f'{self.gep_pont} Komputer ')

        # újkör engedélyezése a választás után
        self._gomb_beallit('újkör', 'normal')

    def _ujkor(self):
        """Metódusok gyűjtőhelye."""
        self._torlesek()
        if len(self.lap_manager.pakli) != 0:
            self._szemely_kepek()
            self._komputer_kep()
            # Új kör gomb újra letiltva, amíg nincs új választás
            self._gomb_beallit('újkör', 'disabled')
            # Egér kattintás engedélyezése
            self.eger_katt = True
        else:
            msg.showinfo('Figyelem!', 'Vége a mérkőzésnek.\n'
                                      'Folytatás: "újparti" gomb!')

    def _torlesek(self):
        """Törli a felhasznált képekhez kapcsolódó változókat
        és a kijelölést, mielőtt két új kártyakép megjelenik.
        Egy a gépnek és egy pótlás a személynek, hogy öt lapja
        legyen. """
        # Korábbi kijelölés törlése.
        if self.kivalasztott_keret:
            self.canvas.delete(self.kivalasztott_keret)
            self.kivalasztott_keret = None

            # Géplapok törlése (teljesen)
        if hasattr(self, 'szem_kep_id_lista1'):
            for kep_id in self.szem_kep_id_lista1:
                self.canvas.delete(kep_id)
            self.szem_kep_id_lista1.clear()
            self.gep_kep_tk_lista1.clear()
            self.gep_lap.clear()

            # Csak a kijelölt játékoslap törlése
        if hasattr(self, 'szem_kep_id_lista2') and hasattr(self, 'tags'):
            try:
                lapnev = self.tags[0]  # pl. 'p08'
                index = self.lap_manager.jatekos_lapnevek2.index(lapnev)

                self.canvas.delete(self.szem_kep_id_lista2[index])

                del self.szem_kep_id_lista2[index]
                del self.szem_kep_tk_lista2[index]
                del self.lap_manager.jatekos_lapnevek2[index]

            except (ValueError, IndexError) as e:
                print(f'Hiba a lap törlésekor: {e}')

            # Eseménykötések törlése a játékos képeknél
        if hasattr(self, 'kattintasi_esemenyek'):
            self.kattintasi_esemenyek.clear()

    def _gombokat_keszit_raccsal(self):
        self.gombok = {}  # új: gombok név szerint tárolva

        racs_keret = tk.Frame(master=self.canvas, bg='black')
        racs_keret.place(x=460, y=10)

        # játékos és gép gomb törölve
        gomb_nevek = ['újkör', 'újparti', 'kilép', 'szabály']
        for sor, nev in enumerate(gomb_nevek):
            self.rowconfigure(sor, weight=1, minsize=5)
            self.columnconfigure(sor, weight=1, minsize=5)

            parancs = None
            if nev == 'újkör':
                parancs = self._ujkor
            elif nev == 'újparti':
                parancs = self._ujparti
            elif nev == 'kilép':
                parancs = sys.exit
            elif nev == 'szabály':
                parancs = self.lap_manager.felugro_ablak

            # Alapszínek a funkciókhoz
            szinek = {
                'újparti': '#1E90FF',  # DodgerBlue
                'újkör': '#228B22',  # ForestGreen
                'kilép': '#B22222',  # FireBrick
                'szabály': '#FFA500'  # Orange
            }
            szin = szinek.get(nev, 'gray')  # fallback

            button = tk.Button(
                master=racs_keret,
                text=nev,
                font=font.Font(size=12),
                bg=szin,
                fg='white',
                width=10,
                height=0,
                command=parancs
            )

            self._cellak[button] = (sor, 0)
            self.gombok[nev] = button  # gomb mentése név alapján

            button.grid(
                row=sor,
                column=0,
                padx=2,
                pady=4,
                sticky="nsew"
            )

        # újkör kezdetben letiltva
        self._gomb_beallit('újkör', 'disabled')

    def _gomb_beallit(self, nev, allapot='normal'):
        """Gomb engedélyezése vagy tiltása név alapján."""
        if nev in self.gombok:
            self.gombok[nev]['state'] = allapot

    def _ujparti(self):
        """Játék teljes újraindítása: változók, képek, pontok."""
        print('Újparti gomb lenyomva!')
        # Egér kattintási esemény engedélyezése
        self.eger_katt = True

        self.canvas.delete("all")
        self.jatekos_pont = 0
        self.gep_pont = 0
        self.kivalasztott_keret = None

        self.lap_manager = LapManager()
        self.pont_label.configure(text='Személy 0 : 0 Komputer')

        for attr in ['szem_kep_tk_lista1', 'szem_kep_tk_lista2',
                     'szem_kep_id_lista1', 'szem_kep_id_lista2']:
            if hasattr(self, attr):
                getattr(self, attr).clear()

        if hasattr(self, 'kattintasi_esemenyek'):
            self.kattintasi_esemenyek.clear()

        # új játékos és géplapok automatikusan
        self._szemely_kepek()
        self._komputer_kep()
        self._szmajli_keszites()

        # újkör most még nem kell, mert lapok már megvannak
        self._gomb_beallit('újkör', 'disabled')

        msg.showinfo('Új játék', 'A játék újraindult.\n'
                                 'Válassz egy lapot a játékhoz!')

    def _szmajli_keszites(self):
        # Szmájli képbetöltés
        self.kep = tk.PhotoImage(file='kepek/szmajli.png')

        # Szmájli kép megjelenítő
        self.szmajli_kep = self.canvas.create_image(85, 60, image="")

    def start_szmajli(self):
        self.canvas.itemconfigure(self.szmajli_kep, image=self.kep)
        # 1 másodperc és eltűnik a kép.
        self.after(1000, lambda _: self.canvas.itemconfigure(
            self.szmajli_kep, image=""), "")


if __name__ == '__main__':
    app = App()
    app.mainloop()

Köszönet a ChatGPT -nek. Sokat segített.

Layco