Sakktábla kirajzolása Python nyelven

A sakktábla kirajzolásához a Python nyelv beépített turtle (teknőc) grafikus modulját használjuk. Ez a legegyszerűbb és leglátványosabb módja az alakzatok megjelenítésének.Az alábbi kód megrajzolja a klasszikus, 8 × 8-as sakktáblát, váltakozva fekete és fehér mezőkkel.

----

import turtle

def rajzolj_sakktabla():

    # Ablak beállítása

    ablak = turtle.Screen()

    ablak.title("Sakktábla")

    ablak.bgcolor("white")

    

    # A teknőc beállítása

    rajzolo = turtle.Turtle()

    rajzolo.speed(0)  # A leggyorsabb rajzolási sebesség

    rajzolo.penup()

    

    mez_meret = 50  # Egy mező mérete pixelben

    kezdo_x = -200  # Kezdő X koordináta

    kezdo_y = 200   # Kezdő Y koordináta

    # Tábla rajzolása sorról sorra

    for sor in range(8):

        for oszlop in range(8):

            rajzolo.goto(kezdo_x + oszlop * mez_meret, kezdo_y - sor * mez_meret)

            rajzolo.pendown()

            

            # Színek váltogatása a sor és oszlop paritása alapján

            if (sor + oszlop) % 2 == 0:

                szin = "white"

            else:

                szin = "black"

                

            rajzolo.fillcolor(szin)

            rajzolo.begin_fill()

            

            # Egy négyzet megrajzolása

            for _ in range(4):

                rajzolo.forward(mez_meret)

                rajzolo.right(90)

                

            rajzolo.end_fill()

            rajzolo.penup()

    rajzolo.hideturtle()

    ablak.mainloop()

# Program indítása

rajzolj_sakktabla()

---

Biliárdasztal pythonban

A biliárdasztal megrajzolásához. A program létrehozza az asztal zöld posztóját, a falakat, a lyukakat és a kezdő háromszögben elhelyezett golyókat is.

-----------

import turtle

import math

# Beállítások

ablak = turtle.Screen()

ablak.title("Biliárdasztal Python-nal")

ablak.bgcolor("black")

ablak.setup(width=900, height=550)

# Rajzoló teknőc

t = turtle.Turtle()

t.speed(0)

t.hideturtle()

# Asztal pozíciója és méretei

asztal_szelesseg = 700

asztal_magassag = 350

x_kezdo = -asztal_szelesseg / 2

y_kezdo = asztal_magassag / 2

# 1. Asztal posztó

t.penup()

t.goto(x_kezdo, y_kezdo)

t.pendown()

t.color("#0E5E24") # Sötétzöld posztó szín

t.begin_fill()

for _ in range(2):

    t.forward(asztal_szelesseg)

    t.right(90)

    t.forward(asztal_magassag)

    t.right(90)

t.end_fill()

# 2. Asztal keret és lyukak rajzolása

t.color("#5C3A21") # Fa keret színe

vastagsag = 30

t.penup()

t.goto(x_kezdo - vastagsag, y_kezdo + vastagsag)

t.pendown()

t.begin_fill()

for _ in range(2):

    t.forward(asztal_szelesseg + (2 * vastagsag))

    t.right(90)

    t.forward(asztal_magassag + (2 * vastagsag))

    t.right(90)

t.end_fill()

# Lyukak (fekete körök a 4 sarokban és oldalt)

lyuk_sugar = 20

lyukak_pozicioi = [

    (x_kezdo, y_kezdo), (x_kezdo + asztal_szelesseg/2, y_kezdo), (x_kezdo + asztal_szelesseg, y_kezdo),

    (x_kezdo, y_kezdo - asztal_magassag), (x_kezdo + asztal_szelesseg/2, y_kezdo - asztal_magassag), (x_kezdo + asztal_szelesseg, y_kezdo - asztal_magassag)

]

for x, y in lyukak_pozicioi:

    t.penup()

    t.goto(x, y)

    t.pendown()

    t.color("black")

    t.begin_fill()

    t.circle(lyuk_sugar)

    t.end_fill()

# 3. Golyók lerakása a jobb oldalon

golyo_sugar = 10

golyo_szinek = ["yellow", "blue", "red", "purple", "orange", "green", "brown", "black"]

# Háromszög csúcsának koordinátái

csucs_x = x_kezdo + (asztal_szelesseg * 0.75)

csucs_y = y_kezdo - (asztal_magassag / 2)

sorok = 5

kezdo_tav = 2.5 * golyo_sugar

for sor in range(sorok):

    sor_x = csucs_x + (sor * golyo_sugar * math.sqrt(3))

    sor_kezdo_y = csucs_y - (sor * golyo_sugar)

    for i in range(sor + 1):

        t.penup()

        t.goto(sor_x, sor_kezdo_y + (i * 2 * golyo_sugar))

        t.pendown()

        

        # Véletlenszerű szín választása a golyóknak

        idx = (sor + i) % len(golyo_szinek)

        t.color(golyo_szinek[idx])

        

        t.begin_fill()

        t.circle(golyo_sugar)

        t.end_fill()

# Fehér golyó a bal oldalon (kezdő golyó)

t.penup()

t.goto(x_kezdo + (asztal_szelesseg * 0.25), y_kezdo - (asztal_magassag / 2))

t.pendown()

t.color("white")

t.begin_fill()

t.circle(golyo_sugar)

t.end_fill()

# Az ablak nyitva tartása

turtle.done()

------------

Üstökös pythonban

Az alábbi kód egy ragyogó üstököst hoz létre izzó csóvával, a sötét űr hátterében pedig még csillagokat is elhelyez.

-----------

import turtle

import random

# Ablak beállítása

ablak = turtle.Screen()

ablak.bgcolor("midnightblue")  # Sötétkék űr háttér

ablak.title("Üstökös rajzolása Pythonban")

# A teknőc (rajzoló) beállítása

ustokos = turtle.Turtle()

ustokos.speed(0)  # Maximális rajzolási sebesség

ustokos.hideturtle()  # Ne látszódjon maga a teknőc nyíl

# Csillagok rajzolása a háttérbe

def csillag_rajzolas():

    csillag = turtle.Turtle()

    csillag.speed(0)

    csillag.color("white")

    csillag.hideturtle()

    

    for _ in range(50):

        x = random.randint(-400, 400)

        y = random.randint(-300, 300)

        csillag.penup()

        csillag.goto(x, y)

        csillag.pendown()

        csillag.dot(random.randint(1, 4)) # Véletlen méretű csillagok

# Üstökös csóva rajzolása (színátmenet és sávok)

def csova_rajzolas():

    szinek = ["cyan", "lightblue", "white"]

    ustokos.penup()

    ustokos.goto(-200, 150) # Kezdőpont az űrben

    

    # Csóva szélessége és rétegei

    for i in range(60):

        ustokos.pendown()

        ustokos.pensize(i / 3)

        ustokos.color(szinek[i % len(szinek)])

        ustokos.forward(10)

        ustokos.right(1)

# Mag (üstökös feje) rajzolása

def mag_rajzolas():

    ustokos.penup()

    ustokos.goto(-200, 150)

    ustokos.pendown()

    ustokos.color("yellow")

    ustokos.dot(45, "yellow") # Külső sárga fény

    ustokos.color("white")

    ustokos.dot(25, "white")  # Belső vakító mag

# Program futtatása

csillag_rajzolas()

csova_rajzolas()

mag_rajzolas()

# Az ablak nyitva tartása kattintásig

ablak.exitonclick()

-----------

Pythonban írt program szupernovát rajzol

Véletlenszerűen generálja a csillag sugarát, a robbanás energiasugarainak számát, a színeket és a szétrepülő részecskék pozícióit, így minden futtatáskor egyedi szupernóvát rajzol ki

--------------

import turtle

import random

def random_szin():

    """Véletlenszerű szín generálása RGB formátumban."""

    r = random.random()

    g = random.random()

    b = random.random()

    return (r, g, b)

def szupernova_rajzolo():

    # Ablak beállítása

    ablak = turtle.Screen()

    ablak.bgcolor("black")

    ablak.title("Véletlenszerű Szupernóva Robbanás")

    

    # Teknőc létrehozása

    suci = turtle.Turtle()

    suci.speed(0) # Leggyorsabb rajzolási sebesség

    suci.hideturtle()

    

    # Központi mag (a csillag)

    sugar = random.randint(30, 80)

    suci.color(random_szin())

    suci.begin_fill()

    suci.circle(sugar)

    suci.end_fill()

    

    # Szupernóva kitörés (szétrepülő sugarak és por)

    sugar_szam = random.randint(15, 40)

    suci.width(random.randint(1, 4))

    

    for _ in range(sugar_szam):

        suci.color(random_szin())

        suci.penup()

        suci.goto(0, sugar) # A mag széléről indulunk

        suci.pendown()

        

        # Véletlenszerű irány és hossz

        suci.right(360 / sugar_szam)

        hossz = random.randint(100, 300)

        suci.forward(hossz)

        

        # Csillagpor és törmelék a sugarak végén

        suci.dot(random.randint(5, 15), random_szin())

    

    # Kilépés kattintásra

    ablak.exitonclick()

if __name__ == "__main__":

    szupernova_rajzolo()

---------------

4D Egyenletes eloszlású pontok Monte Carlo módszerrel sztereografikus szimulációs projekcióval pythonban

4D sztereografikus projekció pythonban

-------------

import math

import sys

import numpy as np

import pygame

# Inicializálás

pygame.init()

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Forgó 4D gömb vetület")

clock = pygame.time.Clock()

# Színek

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

# 4D forgató mátrixok generálása az XY és a ZW síkokban

def get_rotation_matrices(angle_xy, angle_zw):

    c_xy, s_xy = np.cos(angle_xy), np.sin(angle_xy)

    c_zw, s_zw = np.cos(angle_zw), np.sin(angle_zw)

    R_xy = np.array(

        [

            [c_xy, -s_xy, 0, 0],

            [s_xy, c_xy, 0, 0],

            [0, 0, 1, 0],

            [0, 0, 0, 1],

        ]

    )

    R_zw = np.array(

        [

            [1, 0, 0, 0],

            [0, 1, 0, 0],

            [0, 0, c_zw, -s_zw],

            [0, 0, s_zw, c_zw],

        ]

    )

    return R_xy, R_zw

# Hiperszféra (4D gömb) pontjainak generálása

def generate_4d_sphere(num_points, radius):

    points = []

    # Egyenletes eloszlású pontok 4D-ben (Monte Carlo módszerrel)

    while len(points) < num_points:

        p = np.random.uniform(-radius, radius, 4)

        norm = np.linalg.norm(p)

        if norm < radius and norm > 0:

            points.append(p / norm * radius)

    return np.array(points)

# Paraméterek

POINTS_COUNT = 800

RADIUS = 200

points_4d = generate_4d_sphere(POINTS_COUNT, RADIUS)

angle_xy = 0.0

angle_zw = 0.0

# Fő ciklus

running = True

while running:

    for event in pygame.event.get():

        if event.type == pygame.QUIT:

            running = False

    screen.fill(BLACK)

    # Forgatási szögek növelése

    angle_xy += 0.01

    angle_zw += 0.015

    R_xy, R_zw = get_rotation_matrices(angle_xy, angle_zw)

    for p in points_4d:

        # 4D forgatás

        p_rot = p @ R_xy @ R_zw

        # 4D -> 3D vetítés (sztereografikus projekció)

        # W = a negyedik dimenzió. A kamera távolsága miatt osztjuk a (W_távolság - W) értékkel

        distance = 3.0

        w_factor = 1 / (distance - p_rot[3])

        p_3d = np.array([p_rot[0] * w_factor, p_rot[1] * w_factor, p_rot[2] * w_factor])

        # 3D -> 2D perspektivikus vetítés

        cam_dist = 500

        x2d = int(WIDTH / 2 + p_3d[0] * cam_dist / (cam_dist + p_3d[2]))

        y2d = int(HEIGHT / 2 + p_3d[1] * cam_dist / (cam_dist + p_3d[2]))

        # Pont kirajzolása

        brightness = int(

            (p_rot[3] + RADIUS) / (2 * RADIUS) * 200 + 55

        )  # Mélység alapján színezve

        color = (brightness, brightness, brightness)

        pygame.draw.circle(screen, color, (x2d, y2d), 2)

    pygame.display.flip()

    clock.tick(60)

pygame.quit()

sys.exit()

------------

Orion csillagkép rajzolása pythonnal

A program kirajzolja a főbb csillagokat (mint a Betelgeuse vagy a Rigel) és összeköti őket az Orion övvel és a vadász többi vonásával.

------------

import turtle

# Ablak beállítása

screen = turtle.Screen()

screen.bgcolor("black")

screen.title("Az Orion csillagkép")

# A rajzoló teknőc beállítása

orion = turtle.Turtle()

orion.speed(2)

orion.hideturtle()

# Csillagok koordinátái (relatív pozíciók)

stars = {

    "Betelgeuse": (-50, 100),

    "Bellatrix": (-100, 80),

    "Alnitak": (-10, 20),

    "Alnilam": (0, 10),

    "Mintaka": (10, 0),

    "Saiph": (-40, -100),

    "Rigel": (50, -120),

    "Kard (M42)": (0, -40)

}

# Segédfüggvény csillagok rajzolásához

def draw_star(x, y, size, color, name=""):

    orion.penup()

    orion.goto(x, y)

    orion.color(color)

    orion.pendown()

    orion.begin_fill()

    for _ in range(5):

        orion.forward(size)

        orion.right(144)

    orion.end_fill()

    

    # Név kiírása

    if name:

        orion.penup()

        orion.color("white")

        orion.goto(x + 10, y - 5)

        orion.write(name, font=("Arial", 10, "normal"))

# Háttér csillagok (pöttyök)

orion.penup()

orion.goto(-150, 150)

orion.dot(3, "white")

orion.goto(150, -150)

orion.dot(2, "white")

orion.goto(80, 150)

orion.dot(4, "white")

orion.goto(-120, -160)

orion.dot(3, "white")

# Fő csillagok kirajzolása

draw_star(-50, 100, 15, "red", "Betelgeuse")

draw_star(-100, 80, 12, "lightblue", "Bellatrix")

draw_star(-10, 20, 8, "white", "Alnitak")

draw_star(0, 10, 8, "white", "Alnilam")

draw_star(10, 0, 8, "white", "Mintaka")

draw_star(-40, -100, 12, "white", "Saiph")

draw_star(50, -120, 20, "blue", "Rigel")

draw_star(0, -40, 6, "pink", "Kard")

# Vonalak meghúzása (Csillagkép formája)

orion.pensize(2)

orion.color("gray")

# Vállak és lábak összekötése

orion.penup()

orion.goto(-100, 80) # Bellatrix

orion.pendown()

orion.goto(-50, 100) # Betelgeuse

orion.goto(50, -120)  # Rigel

orion.goto(-40, -100) # Saiph

orion.goto(-100, 80) # Vissza a Bellatrixhoz

# Vállak összekötése az övvel

orion.penup()

orion.goto(-50, 100)

orion.pendown()

orion.goto(-10, 20)

orion.penup()

orion.goto(-100, 80)

orion.pendown()

orion.goto(-10, 20)

# Öv csillagai (Alnitak, Alnilam, Mintaka)

orion.goto(10, 0)

# Lábak összekötése az övvel

orion.penup()

orion.goto(-10, 20)

orion.pendown()

orion.goto(-40, -100)

orion.penup()

orion.goto(10, 0)

orion.pendown()

orion.goto(50, -120)

# A kard vonala

orion.penup()

orion.goto(0, 10)

orion.pendown()

orion.goto(0, -40)

# Ablak bezárása kattintásra

screen.exitonclick()

------------

Forma-1-es autót rajzol ki a python program

 Forma-1-es autót rajzol ki a python program

--------------

import turtle

screen = turtle.Screen()

screen.setup(width=900, height=800)

screen.bgcolor("white")

screen.title("Ferrari sportkocsi")

t = turtle.Turtle()

t.speed(0)

t.pensize(3)

def poly(points, fill, outline="black"):

    t.color(outline, fill)

    t.penup()

    t.goto(points[0])

    t.pendown()

    t.begin_fill()

    for p in points[1:]:

        t.goto(p)

    t.goto(points[0])

    t.end_fill()

def wheel(x, y, r=42):

    t.penup()

    t.goto(x, y - r)

    t.pendown()

    t.color("black", "black")

    t.begin_fill()

    t.circle(r)

    t.end_fill()

    t.penup()

    t.goto(x, y - r * 0.45)

    t.pendown()

    t.color("gray", "gray")

    t.begin_fill()

    t.circle(r * 0.45)

    t.end_fill()

def car_body():

    poly([(-360, -70), (-300, -35), (-220, -15), (120, -15), (240, -35), (320, -70), (300, -95), (-340, -95)], "red")

    poly([(-175, -15), (-115, 40), (15, 55), (110, 45), (165, -15)], "red")

    poly([(-150, -10), (-100, 30), (10, 40), (90, 32), (135, -10)], "lightblue")

    poly([(160, -15), (235, -35), (255, -70), (185, -50)], "darkred")

    poly([(-335, -70), (-260, -70), (-255, -95), (-345, -95)], "black")

    poly([(-350, -95), (-290, -95), (-300, -110), (-360, -110)], "darkred")

    poly([(-360, -55), (-305, -55), (-295, -65), (-350, -65)], "black")

    poly([(-365, -68), (-325, -68), (-325, -82), (-365, -82)], "black")

    poly([(300, -68), (350, -60), (345, -80), (295, -85)], "black")

    t.penup()

    t.goto(0, 35)

    t.pendown()

    t.color("black")

    t.pensize(8)

    t.setheading(0)

    t.circle(20, 180)

    t.pensize(3)

wheel(-210, -95, 46)

wheel(185, -95, 46)

car_body()

t.hideturtle()

turtle.done()

-----------

A python program 8D hiperkocka pontjait generálja le

A 8-dimenziós (8D) terek közvetlen vizualizációja emberi szemmel nem lehetséges, mivel a fizikai világunk háromdimenziós. A programozásban azonban a többdimenziós adatokat úgy ábrázoljuk, hogy a magasabb dimenziós koordinátákat (pl. mátrix transzformációkkal) levetítjük (projekcióval 2 vagy 3 dimenzióra), vagy pedig a dimenziókat más tulajdonságokhoz – például színekhez, méretekhez vagy időbeli változásokhoz – rendeljük hozzá.Az alábbi Python program a numpy és a matplotlib könyvtárakat használja. Egy 8D hiperkocka pontjait generálja le, majd egy véletlenszerű mátrix segítségével az 8 dimenziót 2 dimenzióra vetíti, így egy vizuálisan értelmezhető ábrát kapsz. 

-----------

import numpy as np

import matplotlib.pyplot as plt

# 1. 8D hiperkocka csúcsainak generálása

# Egy 8D kocka 2^8 = 256 csúccsal rendelkezik.

dim = 8

vertices = np.array([[x >> i & 1 for i in range(dim)] for x in range(2**dim)])

# Eltoljuk a kockát, hogy a középpontja az origóban (0) legyen

vertices = vertices * 2 - 1

# 2. Véletlenszerű projekciós mátrix (8D -> 2D)

# Létrehozunk egy 8x2-es mátrixot, amivel a 8D adatokat 2D-be vetítjük.

projection_matrix = np.random.rand(dim, 2)

# 3. A 8D pontok vetítése 2D-be

projected_vertices = np.dot(vertices, projection_matrix)

# 4. A 2D pontok kirajzolása

plt.figure(figsize=(8, 8))

plt.scatter(projected_vertices[:, 0], projected_vertices[:, 1], c='blue', alpha=0.7, edgecolors='k')

plt.title("8D hiperkocka 2D vetülete")

plt.xlabel("X tengely (Projekció 1)")

plt.ylabel("Y tengely (Projekció 2)")

plt.grid(True, linestyle='--', alpha=0.6)

plt.show()

-------------

7D Tesseraktot írtam projekcióval python nyelven

A többdimenziós (például 7D) terek közvetlenül nem rajzolhatók ki a fizikai képernyőnkre, de egy matematikai vetítéssel (projekcióval) átalakíthatók 3D-s vagy 2D-s koordinátákká, majd megjeleníthetők.Az alábbi Python program a numpy segítségével hoz létre egy 7 dimenziós kockát (tesseraktot), mátrixműveletekkel 3D-re vetíti, a matplotlib segítségével pedig kirajzolja a térbeli szerkezetet és a tengelyeket.Szükség esetén a szükséges csomagokat a terminálban a pip install numpy matplotlib paranccsal telepítheted.

---------------

import numpy as np

import matplotlib.pyplot as plt

from itertools import product

# 7 dimenziós kocka csúcsainak generálása (-1 és 1 értékekkel)

# A 2^7 az 128 csúcsot jelent.

dimensions = 7

vertices = np.array(list(product([-1, 1], repeat=dimensions)))

# Véletlenszerű vagy fix transzformációs mátrix, amivel 7D-ből 3D-t csinálunk

# A gyakorlatban ez egy 3x7-es mátrix.

np.random.seed(42)

projection_matrix = np.random.rand(3, dimensions)

# A 7D pontok vetítése 3D-be

projected_vertices = np.dot(vertices, projection_matrix.T)

# Kocka éleinek meghatározása (szomszédok, amik csak 1 dimenzióban különböznek)

edges = []

for i, v1 in enumerate(projected_vertices):

    for j, v2 in enumerate(projected_vertices):

        # Hamming-távolság: hány koordinátában térnek el egymástól a 7D-ben?

        if np.sum(np.abs(vertices[i] - vertices[j]) == 2) == 1:

            edges.append((v1, v2))

# 3D ábra inicializálása

fig = plt.figure(figsize=(8, 6))

ax = fig.add_subplot(111, projection='3d')

# Élek kirajzolása

for edge in edges:

    xs = [edge[0][0], edge[1][0]]

    ys = [edge[0][1], edge[1][1]]

    zs = [edge[0][2], edge[1][2]]

    ax.plot(xs, ys, zs, color='b', alpha=0.3)

# Pontok kirajzolása

ax.scatter(projected_vertices[:, 0], projected_vertices[:, 1], projected_vertices[:, 2], color='r')

ax.set_title("7D kocka 3D-s vetülete")

ax.set_xlabel("X tengely")

ax.set_ylabel("Y tengely")

ax.set_zlabel("Z tengely")

plt.show()

--------------

Ortografikus vagy perspektivikus projekcióval pythonban írt forgatható 6D grafika

A matematika nyelvén a hat dimenzió (6D) teljesen értelmezhető, ám a mi fizikai, háromdimenziós világunkban ezt közvetlenül nem tudjuk lerajzolni. A vizualizációhoz a 6D-s koordinátákat le kell képeznünk 2D-s vagy 3D-s térbe. Ezt leggyakrabban dimenziócsökkentéssel (pl. ortografikus vagy perspektivikus projekcióval) érik el.Az alábbi Python program a numpy és a matplotlib segítségével egy 6D-s hiperkockát (tesserakt általánosítása 6 dimenzióra) vetít ki egy képernyőn megjelenő 3D-s ábrára, amelyet az egér segítségével szabadon forgathatsz.

-------------

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

from itertools import product

# 1. Definiáljuk a 6 dimenziós hiperkocka csúcsait (-1 és 1 közötti értékekkel)

vertices_6d = np.array(list(product([-1, 1], repeat=6)))

# 2. Határozzuk meg az éleket a 6D térben

# Két csúcs akkor és csak akkor van összekötve, ha pontosan egy koordinátájukban különböznek

edges = []

for i in range(len(vertices_6d)):

    for j in range(i + 1, len(vertices_6d)):

        if np.sum(np.abs(vertices_6d[i] - vertices_6d[j])) == 2:

            edges.append((i, j))

# 3. Egyszerű ortografikus projekció: a 6D koordinátákat 3D-be képezzük

# (Általánosítva: az első 3 dimenziót vesszük, vagy tetszőleges lineáris transzformációt alkalmazunk)

def project_6d_to_3d(v_6d):

    # Itt az első 3 dimenziót használjuk vizualizációs célra

    return v_6d[:, :3]

# 4. Kirajzoló függvény

def draw_6d_hypercube():

    fig = plt.figure(figsize=(8, 8))

    ax = fig.add_subplot(111, projection='3d')

    ax.set_title("6D hiperkocka 3D-s projekciója")

    # Kezdeti 3D koordináták

    projected_vertices = project_6d_to_3d(vertices_6d)

    # Élek kirajzolása

    for edge in edges:

        p1 = projected_vertices[edge[0]]

        p2 = projected_vertices[edge[1]]

        ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='b', alpha=0.5)

    # Csúcsok megjelölése

    ax.scatter(projected_vertices[:, 0], projected_vertices[:, 1], projected_vertices[:, 2], color='r')

    ax.set_xlabel('X tengely')

    ax.set_ylabel('Y tengely')

    ax.set_zlabel('Z tengely')

    plt.show()

if __name__ == "__main__":

    draw_6d_hypercube()

----------------

5 dimenziós hiperkocka python nyelven

Ez a program egy ötdimenziós kocka (penterakt) csúcsait és éleit generálja, majd egy mátrix transzformáció segítségével elforgatja és kirajzolja a síkra.

-------------

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

import itertools

# 5D kocka csúcsainak generálása (-1 és 1 értékekkel)

points_5d = np.array(list(itertools.product([-1, 1], repeat=5)))

# Élek meghatározása (azok a csúcsok, amelyek pontosan egy koordinátában különböznek)

edges = []

for i in range(len(points_5d)):

    for j in range(i + 1, len(points_5d)):

        if np.sum(np.abs(points_5d[i] - points_5d[j])) == 2:

            edges.append((i, j))

# Egyszerű forgató mátrixok az 5D térben

def rotate_5d(points, angles):

    # Forgatás 5 dimenzióban (egyszerűsített síkok mentén)

    c1, s1 = np.cos(angles[0]), np.sin(angles[0])

    c2, s2 = np.cos(angles[1]), np.sin(angles[1])

    

    rotated = np.copy(points)

    for i in range(len(points)):

        # x-y sík forgatás

        x, y = rotated[i, 0], rotated[i, 1]

        rotated[i, 0] = x * c1 - y * s1

        rotated[i, 1] = x * s1 + y * c1

        

        # z-w sík forgatás

        z, w = rotated[i, 2], rotated[i, 3]

        rotated[i, 2] = z * c2 - w * s2

        rotated[i, 3] = z * s2 + w * c2

    return rotated

# Matplotlib beállítása

fig = plt.figure()

ax = fig.add_subplot(111, projection='3d')

plt.title("5D Hiperkocka (Penterakt) vetülete")

angles = [0.0, 0.0]

try:

    while True:

        # Forgatási szögek növelése

        angles[0] += 0.05

        angles[1] += 0.03

        

        # 5D koordináták forgatása

        rotated_5d = rotate_5d(points_5d, angles)

        

        # Dimenziócsökkentés: az első 3 dimenziót használjuk a 3D-s megjelenítéshez

        projected_3d = rotated_5d[:, :3]

        

        ax.clear()

        ax.set_xlim3d(-2.5, 2.5)

        ax.set_ylim3d(-2.5, 2.5)

        ax.set_zlim3d(-2.5, 2.5)

        ax.axis('off') # Keret kikapcsolása

        

        # Élek kirajzolása

        for edge in edges:

            p1 = projected_3d[edge[0]]

            p2 = projected_3d[edge[1]]

            ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='blue', alpha=0.3)

            

        # Pontok megjelenítése

        ax.scatter(projected_3d[:, 0], projected_3d[:, 1], projected_3d[:, 2], color='red', s=10)

        

        plt.pause(0.01)

except KeyboardInterrupt:

    print("A rajzolás leállítva.")

-------------

4D hiperkocka pythonba

Az alábbi Python kód a numpy és a matplotlib segítségével egy forgó 4D hiperkockát vetít ki.

------------

import numpy as np

import matplotlib.pyplot as plt

from mpl_toolkits.mplot3d import Axes3D

import itertools

import time

# 4D hiperkocka csúcsai

vertices_4d = np.array(list(itertools.product([-1, 1], repeat=4)))

# 4D élek meghatározása (azok a csúcsok, amik pontosan 1 koordinátában különböznek)

edges = []

for i in range(len(vertices_4d)):

    for j in range(i + 1, len(vertices_4d)):

        if np.sum(np.abs(vertices_4d[i] - vertices_4d[j])) == 2:

            edges.append((i, j))

def rotate_4d(vertices, xy_angle, yz_angle, zw_angle):

    # Forgatási mátrixok a 4D térben

    c_xy, s_xy = np.cos(xy_angle), np.sin(xy_angle)

    c_yz, s_yz = np.cos(yz_angle), np.sin(yz_angle)

    c_zw, s_zw = np.cos(zw_angle), np.sin(zw_angle)

    

    rotated = np.zeros_like(vertices)

    for i, v in enumerate(vertices):

        x, y, z, w = v

        

        # xy síkú forgatás

        x1, y1 = x * c_xy - y * s_xy, x * s_xy + y * c_xy

        

        # yz síkú forgatás

        y2, z2 = y1 * c_yz - z * s_yz, y1 * s_yz + z * c_yz

        

        # zw síkú forgatás

        z3, w3 = z2 * c_zw - w * s_zw, z2 * s_zw + w * c_zw

        

        rotated[i] = [x1, y2, z3, w3]

        

    return rotated

def project_4d_to_3d(vertices, distance=3.0):

    # Perspektivikus vetítés 4D-ből 3D-be

    projected = np.zeros((vertices.shape[0], 3))

    for i, v in enumerate(vertices):

        x, y, z, w = v

        w_factor = 1 / (distance - w)

        projected[i] = [x * w_factor, y * w_factor, z * w_factor]

    return projected

# Matplotlib beállítások

fig = plt.figure(figsize=(8, 8))

ax = fig.add_subplot(111, projection='3d')

ax.set_facecolor('black')

# Forgatási szögek

angle_xy, angle_yz, angle_zw = 0.0, 0.0, 0.0

try:

    while True:

        # Forgatás és vetítés

        rotated_4d = rotate_4d(vertices_4d, angle_xy, angle_yz, angle_zw)

        projected_3d = project_4d_to_3d(rotated_4d)

        

        ax.cla()

        ax.set_xlim3d(-1.5, 1.5)

        ax.set_ylim3d(-1.5, 1.5)

        ax.set_zlim3d(-1.5, 1.5)

        ax.axis('off')

        

        # Élek kirajzolása

        for edge in edges:

            p1 = projected_3d[edge[0]]

            p2 = projected_3d[edge[1]]

            ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='cyan', alpha=0.5)

            

        plt.pause(0.01)

        

        # Szögek növelése a folyamatos animációhoz

        angle_xy += 0.02

        angle_yz += 0.03

        angle_zw += 0.01

        

except KeyboardInterrupt:

    print("Animáció leállítva.")

-------------

3D spirál pythonban

.Az alábbi program egy interaktív, színes 3D spirált rajzol pythonban, 

---------------

import numpy as np

import matplotlib.pyplot as plt

# Adatok generálása a 3D spirálhoz

# t a szög, z a magasság

t = np.linspace(0, 20 * np.pi, 1000)

x = np.sin(t)

y = np.cos(t)

z = t

# 3D ábra inicializálása

fig = plt.figure(figsize=(8, 6))

ax = fig.add_subplot(111, projection='3d')

# Vonal rajzolása színátmenettel

ax.plot(x, y, z, label='3D Spirálicsík')

# Grafikon címe és tengelyfeliratok

ax.set_title("Egyszerű 3D ábra Pythonban")

ax.set_xlabel("X tengely")

ax.set_ylabel("Y tengely")

ax.set_zlabel("Z tengely")

# Jelmagyarázat hozzáadása

ax.legend()

# Megjelenítés

plt.show()

---------------

Fraktál rajzolás pythonnal

A Python nyelv egyik leglátványosabb és legegyszerűbben használható eszköze a teknőcgrafika (Turtle modul), amellyel kiválóan rajzolhatók rekurzív geometriai fraktálok. Az alábbi kód egy klasszikus  Koch-hópelyhet (más néven Koch-görbét) rajzol ki.

-----------

import turtle

def koch_curve(t, length, depth):

    """Rekurzív függvény egyetlen Koch-vonal szakasz megrajzolásához."""

    if depth == 0:

        t.forward(length)

    else:

        length /= 3

        koch_curve(t, length, depth - 1)

        t.left(60)

        koch_curve(t, length, depth - 1)

        t.right(120)

        koch_curve(t, length, depth - 1)

        t.left(60)

        koch_curve(t, length, depth - 1)

def draw_snowflake(t, length, depth):

    """Kirajzolja a három oldalból álló Koch-hópelyhet."""

    for _ in range(3):

        koch_curve(t, length, depth)

        t.right(120)

# Ablak beállítása

screen = turtle.Screen()

screen.bgcolor("black")

screen.title("Koch-hópehely fraktál")

# A teknőc (rajzoló) beállítása

snowflake_turtle = turtle.Turtle()

snowflake_turtle.speed(0) # 0 a leggyorsabb sebesség

snowflake_turtle.color("cyan")

snowflake_turtle.pensize(1)

# Kezdőpozíció beállítása

snowflake_turtle.penup()

snowflake_turtle.backward(150)

snowflake_turtle.pendown()

# Fraktál rajzolása 3-as rekurziós mélységgel

draw_snowflake(snowflake_turtle, 300, 3)

# Ablak bezárásáig nyitva tartása

turtle.done()

----------

Brute force jelszó kereső

Ez a Python program, egy megadott karakterkészletből kiindulva, brute force módszerrel (minden lehetséges kombinációt kipróbálva) megkeresi a jelszót.A hatékonyság érdekében a beépített itertools.product függvényt használtam, amely generátorként működik, így nem használ sok memóriát.

--------------

import string

import time

from itertools import product

def brute_force_password(target_password, max_length=5):

    # Karakterkészlet: kisbetűk, nagybetűk és számok

    # Szükség esetén kiegészíthető írásjelekkel is: + string.punctuation

    chars = string.ascii_letters + string.digits

    attempts = 0

    start_time = time.time()

    print(f"Keresés indítása a következő karakterekkel: {chars}\n")

    # Próbálkozás különböző jelszóhosszúságokkal a megadott maximumig

    for length in range(1, max_length + 1):

        print(f"Próbálkozás {length} karakter hosszúságú kombinációkkal...")

        # Generálja az összes lehetséges kombinációt az adott hosszon

        for combination in product(chars, repeat=length):

            attempts += 1

            # Összeilleszti a karaktereket egy szöveggé

            guess = "".join(combination)

            # Ellenőrzés, hogy egyezik-e a céllal

            if guess == target_password:

                end_time = time.time()

                duration = end_time - start_time

                return {

                    "found": True,

                    "password": guess,

                    "attempts": attempts,

                    "time": round(duration, 4),

                }

    return {"found": False, "attempts": attempts, "time": round(time.time() - start_time, 4)}

# --- Program futtatása ---

if __name__ == "__main__":

    # Adj meg egy teszt jelszót (figyelem: a brute force hosszú jelszavaknál nagyon lassú!)

    # Példák: "a", "Ab3", "pass"

    secret_password = "Ab3"

    # Maximális hossz, ameddig a program keresni fog

    maximum_search_length = 5

    result = brute_force_password(secret_password, maximum_search_length)

    if result["found"]:

        print("\n" + "=" * 40)

        print("SIKER! A jelszó megvan.")

        print(f"Megtalált jelszó: {result['password']}")

        print(f"Próbálkozások száma: {result['attempts']}")

        print(f"Eltelt idő: {result['time']} másodperc")

        print("=" * 40)

    else:

        print("\n" + "=" * 40)

        print("Sikertelen keresés.")

        print(f"A jelszó nem található {maximum_search_length} karakteres hosszig.")

        print(f"Összes próbálkozás: {result['attempts']}")

        print("=" * 40)

----------------

Vírusírtó Python nyelven (Szoftverfejlesztő)

Egy teljes értékű, ipari szintű vírusírtó motor fejlesztése összetett, alacsony szintű programozást (C/C++) és folyamatosan frissülő vírusadatbázist igényel. Grafikus felülettel (GUI) rendelkezik Python programozási nyelven írtam, amely képes kiválasztott mappákat átvizsgálni, és az ismert kártevőket azok fájl-aláírása (hash) alapján kiszűrni.

---------------

import tkinter as tk

from tkinter import filedialog, messagebox

import hashlib

import os

# Oktató jellegű vírusadatbázis (Fájl SHA-256 lenyomatok)

# Valódi vírusírtók sok millió aláírást tartalmaznak

VIIRUS_ADATBAZIS = {

    "d16c5232d67a99bb108253a6ec0407137f8f8b85b28de5d2753a479d479133a8": "EICAR-Test-File (Veszélytelen tesztvírus)",

    # Ide szúrhatsz be további ismert kártevő hash-eket

}

class VirusIrtoApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Python Antivirus - Alap verzió")

        self.root.geometry("500x400")

        self.root.config(bg="#f0f0f0")

        # Cím

        self.label = tk.Label(root, text="Grafikus Víruskereső", font=("Arial", 16), bg="#f0f0f0")

        self.label.pack(pady=15)

        # Gomb: Mappa kiválasztása

        self.btn_browse = tk.Button(root, text="Mappa kiválasztása", font=("Arial", 12), command=self.kivalaszt_mappa, bg="#4CAF50", fg="white", padx=10, pady=5)

        self.btn_browse.pack(pady=10)

        # Kijelölt mappa megjelenítése

        self.path_label = tk.Label(root, text="Nincs mappa kiválasztva", font=("Arial", 10), bg="#f0f0f0", wraplength=400)

        self.path_label.pack(pady=5)

        # Gomb: Vizsgálat indítása

        self.btn_scan = tk.Button(root, text="Vizsgálat indítása", font=("Arial", 12), command=self.indit_vizsgalat, bg="#2196F3", fg="white", padx=10, pady=5, state=tk.DISABLED)

        self.btn_scan.pack(pady=20)

        # Eredmény kijelző doboz

        self.log_text = tk.Text(root, height=10, width=55, state=tk.DISABLED, font=("Consolas", 9))

        self.log_text.pack(pady=10)

        self.kivalasztott_konyvtar = ""

    def kivalaszt_mappa(self):

        self.kivalasztott_konyvtar = filedialog.askdirectory()

        if self.kivalasztott_konyvtar:

            self.path_label.config(text=f"Kiválasztva: {self.kivalasztott_konyvtar}")

            self.btn_scan.config(state=tk.NORMAL)

    def log(self, uzenet):

        self.log_text.config(state=tk.NORMAL)

        self.log_text.insert(tk.END, uzenet + "\n")

        self.log_text.see(tk.END)

        self.log_text.config(state=tk.DISABLED)

    def fajl_hash_szamitas(self, fajl_utvonal):

        haszno = hashlib.sha256()

        try:

            with open(fajl_utvonal, "rb") as f:

                while darab := f.read(8192):

                    haszno.update(darab)

            return haszno.hexdigest()

        except Exception:

            return None

    def indit_vizsgalat(self):

        if not self.kivalasztott_konyvtar:

            return

        self.log_text.config(state=tk.NORMAL)

        self.log_text.delete(1.0, tk.END)

        self.log_text.config(state=tk.DISABLED)

        

        self.log("Vizsgálat megkezdve: " + self.kivalasztott_konyvtar)

        self.root.update()

        talalat_szam = 0

        # Mappa bejárása

        for root, dirs, files in os.walk(self.kivalasztott_konyvtar):

            for file in files:

                fajl_utvonal = os.path.join(root, file)

                self.log(f"Ellenőrzés: {file}")

                self.root.update()

                fajl_hash = self.fajl_hash_szamitas(fajl_utvonal)

                

                if fajl_hash and fajl_hash in VIIRUS_ADATBAZIS:

                    talalat_szam += 1

                    self.log(f"[!] FENYEGETÉS TALÁLVA: {talalat_szam}")

                    self.log(f"    Fájl: {fajl_utvonal}")

                    self.log(f"    Vírus: {VIIRUS_ADATBAZIS[fajl_hash]}")

        self.log("---- Vizsgálat véget ért ----")

        messagebox.showinfo("Kész", f"A vizsgálat befejeződött. Talált fenyegetések száma: {talalat_szam}")

if __name__ == "__main__":

    root = tk.Tk()

    app = VirusIrtoApp(root)

    root.mainloop()

----------------

Képnéző alkalmazás Pythonban. (Szoftverfejlesztő)

Képnéző alkalmazás Pythonban, beépített tkinter grafikus könyvtárát és a Pillow (PIL) képkezelő modult érdemes használni.

---------------

import os

import tkinter as tk

from tkinter import filedialog

from PIL import Image, ImageTk

class KepnezoApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Python Képnéző")

        self.root.geometry("800x600")

        self.kep_lista = []

        self.aktualis_index = 0

        self.kep_objektum = None

        # Gomb a mappa kiválasztásához

        self.mappa_gomb = tk.Button(root, text="Mappa kiválasztása", command=self.mappa_valasztas)

        self.mappa_gomb.pack(pady=10)

        # Kép megjelenítő címke

        self.kep_cimke = tk.Label(root)

        self.kep_cimke.pack(expand=True, fill=tk.BOTH)

        # Navigációs keret

        self.also_keret = tk.Frame(root)

        self.also_keret.pack(side=tk.BOTTOM, pady=10)

        self.elozo_gomb = tk.Button(self.also_keret, text="<< Előző", command=self.elozo_kep)

        self.elozo_gomb.pack(side=tk.LEFT, padx=10)

        self.kovetkezo_gomb = tk.Button(self.also_keret, text="Következő >>", command=self.kovetkezo_kep)

        self.kovetkezo_gomb.pack(side=tk.RIGHT, padx=10)

    def mappa_valasztas(self):

        mappa_utvonal = filedialog.askdirectory()

        if mappa_utvonal:

            tamogatott_form = ('.png', '.jpg', '.jpeg', '.gif', '.bmp')

            self.kep_lista = [

                os.path.join(mappa_utvonal, f) for f in os.listdir(mappa_utvonal)

                if f.lower().endswith(tamogatott_form)

            ]

            

            if self.kep_lista:

                self.aktualis_index = 0

                self.kep_megjelenites()

            else:

                self.kep_cimke.config(text="Nincs kép a mappában!", image="")

    def kep_megjelenites(self):

        if not self.kep_lista:

            return

        kep_path = self.kep_lista[self.aktualis_index]

        

        try:

            # Kép beolvasása a Pillow segítségével

            eredeti_kep = Image.open(kep_path)

            

            # Kép méretezése az ablakhoz (megtartva az arányokat)

            ablak_szelesseg = self.root.winfo_width() or 800

            ablak_magassag = self.root.winfo_height() - 100 or 500

            eredeti_kep.thumbnail((ablak_szelesseg, ablak_magassag))

            

            self.kep_objektum = ImageTk.PhotoImage(eredeti_kep)

            

            # Frissítjük a Label-t az új képpel

            self.kep_cimke.config(image=self.kep_objektum, text="")

            self.root.title(f"Python Képnéző - {os.path.basename(kep_path)}")

        except Exception as e:

            self.kep_cimke.config(text="Hiba a kép betöltésekor!", image="")

    def elozo_kep(self):

        if self.kep_lista:

            self.aktualis_index = (self.aktualis_index - 1) % len(self.kep_lista)

            self.kep_megjelenites()

    def kovetkezo_kep(self):

        if self.kep_lista:

            self.aktualis_index = (self.aktualis_index + 1) % len(self.kep_lista)

            self.kep_megjelenites()

# Alkalmazás indítása

if __name__ == "__main__":

    fo_ablak = tk.Tk()

    app = KepnezoApp(fo_ablak)

    fo_ablak.mainloop()

------------------

MP4 videó lejátszó Python nyelven (Szoftverfejlesztő)

Egy Python program, amely MP4 videókat játszik le a beépített tkinter és pygame könyvtárak segítségével. Nem igényel külső médialejátszó keretrendszereket, és közvetlenül a Python alapkönyvtáraira épül.

---------------

import os

import tkinter as tk

from tkinter import filedialog

from PIL import Image, ImageTk

import pygame

class VideoPlayer:

    def __init__(self, root):

        self.root = root

        self.root.title("Egyszerű MP4 Lejátszó")

        self.root.geometry("800x600")

        self.root.configure(bg="black")

        # Inicializáljuk a pygame-ot a hanghoz és időzítéshez

        pygame.init()

        pygame.mixer.init()

        # GUI elemek

        self.canvas = tk.Canvas(root, bg="black", highlightthickness=0)

        self.canvas.pack(fill=tk.BOTH, expand=True)

        self.control_frame = tk.Frame(root, bg="#333")

        self.control_frame.pack(side=tk.BOTTOM, fill=tk.X)

        self.btn_load = tk.Button(self.control_frame, text="Videó megnyitása", command=self.load_video)

        self.btn_load.pack(side=tk.LEFT, padx=10, pady=10)

        self.btn_play = tk.Button(self.control_frame, text="Lejátszás", command=self.toggle_play)

        self.btn_play.pack(side=tk.LEFT, padx=5, pady=10)

        self.btn_play.config(state=tk.DISABLED)

        # Videó változók

        self.video = None

        self.playing = False

        self.video_event_id = None

    def load_video(self):

        file_path = filedialog.askopenfilename(filetypes=[("MP4 Files", "*.mp4")])

        if file_path:

            # Ha már megy egy videó, állítsuk le

            if self.playing:

                self.stop_video()

            try:

                # Ezzel a `pygame.movie`-t hívjuk meg (Movie osztály Python 3-ban pygame.math-hoz köthető,

                # de belsőleg ffpyplayer-t vagy natív támogatást használ).

                self.video = pygame.movie.Movie(file_path)

                

                # Átméretezzük a canvas-t a videó méretére

                self.canvas.config(width=self.video.get_size()[0], height=self.video.get_size()[1])

                

                # Beállítjuk a hangot

                pygame.mixer.music.load(file_path)

                

                self.btn_play.config(state=tk.NORMAL)

                self.root.title(f"Most játszva: {os.path.basename(file_path)}")

            except Exception as e:

                print(f"Hiba a videó betöltésekor: {e}")

    def toggle_play(self):

        if not self.video:

            return

        if self.playing:

            self.playing = False

            self.video.pause()

            pygame.mixer.music.pause()

            self.btn_play.config(text="Lejátszás")

            if self.video_event_id:

                self.root.after_cancel(self.video_event_id)

        else:

            self.playing = True

            self.video.play()

            pygame.mixer.music.play()

            self.btn_play.config(text="Szünet")

            self.render_frame()

    def render_frame(self):

        if not self.playing:

            return

        # Lekérjük a következő képkockát (surface-t) a pygame-ból

        frame_surface = self.video.get_surface()

        if frame_surface:

            # Konvertáljuk a pygame felületet PIL képpé

            raw_str = pygame.image.tostring(frame_surface, "RGBA", False)

            image = Image.frombytes("RGBA", frame_surface.get_size(), raw_str)

            

            # Méretezés a canvas méretéhez

            width, height = self.canvas.winfo_width(), self.canvas.winfo_height()

            if width > 1 and height > 1:

                image = image.resize((width, height), Image.Resampling.LANCZOS)

            self.photo = ImageTk.PhotoImage(image)

            self.canvas.create_image(0, 0, image=self.photo, anchor=tk.NW)

        # Következő képkocka időzítése (FPS alapú)

        delay = int(1000 / self.video.get_fps())

        self.video_event_id = self.root.after(delay, self.render_frame)

    def stop_video(self):

        self.playing = False

        if self.video:

            self.video.stop()

        pygame.mixer.music.stop()

        if self.video_event_id:

            self.root.after_cancel(self.video_event_id)

        self.video = None

    def on_closing(self):

        self.stop_video()

        self.root.destroy()

if __name__ == "__main__":

    root = tk.Tk()

    app = VideoPlayer(root)

    root.protocol("WM_DELETE_WINDOW", app.on_closing)

    root.mainloop()

-----------------

Grafikus felülettel (GUI) MP3-lejátszót készítettem Python nyelven (Szoftverfejlesztő)

Az alábbiakban egy egyszerű és látványos, grafikus felülettel (GUI) rendelkező MP3-lejátszó programot készíthetünk el Python segítségével. A zenelejátszáshoz a pygame modult, a grafikus felülethez pedig a beépített tkinter könyvtárat használtam.

------------

import os

import tkinter as tk

from tkinter import filedialog, messagebox

from pygame import mixer

class ZeneLejatszo:

    def __init__(self, root):

        self.root = root

        self.root.title("Python MP3 Lejátszó")

        self.root.geometry("400x400")

        self.root.configure(bg="#2c3e50")

        # Pygame mixer inicializálása

        mixer.init()

        # Változók

        self.aktualis_zene = ""

        self.szuneteltetve = False

        # Felhasználói felület létrehozása

        self.letrehozo_gui()

    def letrehozo_gui(self):

        # Címke

        self.cim_label = tk.Label(self.root, text="Nincs kiválasztva zene", bg="#2c3e50", fg="#ecf0f1", font=("Arial", 12))

        self.cim_label.pack(pady=30)

        # Gombok kerete

        gomb_keret = tk.Frame(self.root, bg="#2c3e50")

        gomb_keret.pack(pady=10)

        # Gombok

        self.megnyitas_btn = tk.Button(gomb_keret, text="Megnyitás", width=7, command=self.zene_betoltes)

        self.megnyitas_btn.grid(row=0, column=0, padx=5, pady=5)

        self.lejatszas_btn = tk.Button(gomb_keret, text="Lejátszás", width=7, command=self.zene_lejatszas)

        self.lejatszas_btn.grid(row=0, column=1, padx=5, pady=5)

        self.szunet_btn = tk.Button(gomb_keret, text="Szünet", width=7, command=self.zene_szunet)

        self.szunet_btn.grid(row=0, column=2, padx=5, pady=5)

        self.leallitas_btn = tk.Button(gomb_keret, text="Leállítás", width=7, command=self.zene_leallitas)

        self.leallitas_btn.grid(row=0, column=3, padx=5, pady=5)

    def zene_betoltes(self):

        fajl = filedialog.askopenfilename(initialdir="/", title="Válassz egy MP3 fájlt", filetypes=(("MP3 Files", "*.mp3"), ("All Files", "*.*")))

        if fajl:

            self.aktualis_zene = fajl

            fajl_nev = os.path.basename(self.aktualis_zene)

            self.cim_label.config(text=f"Kiválasztva: {fajl_nev}")

    def zene_lejatszas(self):

        if self.aktualis_zene:

            try:

                mixer.music.load(self.aktualis_zene)

                mixer.music.play()

                self.cim_label.config(text=f"Most szól: {os.path.basename(self.aktualis_zene)}")

                self.szuneteltetve = False

            except Exception as e:

                messagebox.showerror("Hiba", "Nem sikerült lejátszani a zenét.")

        else:

            messagebox.showwarning("Figyelmeztetés", "Kérlek, először válassz ki egy zenét!")

    def zene_szunet(self):

        if self.aktualis_zene:

            if not self.szuneteltetve:

                mixer.music.pause()

                self.szuneteltetve = True

                self.szunet_btn.config(text="Folytatás")

            else:

                mixer.music.unpause()

                self.szuneteltetve = False

                self.szunet_btn.config(text="Szünet")

    def zene_leallitas(self):

        if self.aktualis_zene:

            mixer.music.stop()

            self.cim_label.config(text="Zene leállítva")

            self.szunet_btn.config(text="Szünet")

# Futtatás

if __name__ == "__main__":

    ablak = tk.Tk()

    app = ZeneLejatszo(ablak)

    ablak.mainloop()

--------------

Jegyzettömb készítése Pythonban (Szoftverfejlesztő)

Ez egy egyszerű Jegyzettömb alkalmazás Pythonban, tkinter segítségével. a program a szöveget fixen a jegyzet.txt nevű fájlba menti a szöveget.

-------------

import tkinter as tk

def mentes():

    with open("jegyzet.txt", "w", encoding="utf-8") as f:

        f.write(szoveg_doboz.get("1.0", tk.END))

def megnyitas():

    try:

        with open("jegyzet.txt", "r", encoding="utf-8") as f:

            szoveg_doboz.delete("1.0", tk.END)

            szoveg_doboz.insert(tk.END, f.read())

    except FileNotFoundError:

        pass # Ha még nincs mentve fájl, nem csinál semmit

# Ablak létrehozása

ablak = tk.Tk()

ablak.title("Mini Jegyzettömb")

ablak.geometry("500x400")

# Szövegmező és görgetősáv

gorgeto = tk.Scrollbar(ablak)

gorgeto.pack(side=tk.RIGHT, fill=tk.Y)

szoveg_doboz = tk.Text(ablak, wrap=tk.WORD, yscrollcommand=gorgeto.set)

szoveg_doboz.pack(expand=True, fill=tk.BOTH)

gorgeto.config(command=szoveg_doboz.yview)

# Gombok

also_frame = tk.Frame(ablak)

also_frame.pack(fill=tk.X, pady=5)

btn_mentes = tk.Button(also_frame, text="Mentés", command=mentes)

btn_mentes.pack(side=tk.LEFT, padx=10, expand=True)

btn_megnyitas = tk.Button(also_frame, text="Betöltés", command=megnyitas)

btn_megnyitas.pack(side=tk.RIGHT, padx=10, expand=True)

ablak.mainloop()

---------------

Webböngésző Pythonban (Szoftverfejlesztő)

Hatékony webböngésző Pythonban, amely külső böngészőmotor vagy PyQt (pl. PyQt5, PyQt6) helyett a Python beépített tkinter és webbrowser modulszerkezetét használja.

-------------------

import tkinter as tk

import webbrowser

def megnyitas():

    url = url_mezo.get()

    if not url.startswith("http://") and not url.startswith("https://"):

        url = "https://" + url

    webbrowser.open(url)

# Főablak beállítása

ablak = tk.Tk()

ablak.title("Python Mini Böngésző")

ablak.geometry("400x150")

ablak.config(padx=20, pady=20)

# Címke és URL beviteli mező

cimke = tk.Label(ablak, text="Írd be a webcímet vagy keress rá:", font=("Arial", 11))

cimke.pack(pady=(0, 10))

url_mezo = tk.Entry(ablak, width=45, font=("Arial", 12))

url_mezo.insert(0, "www.google.com")

url_mezo.pack(pady=(0, 15))

# Gomb, amivel megnyitjuk az alapértelmezett külső böngészőt

gomb = tk.Button(ablak, text="Keresés / Megnyitás", command=megnyitas, font=("Arial", 11, "bold"), bg="#4CAF50", fg="white")

gomb.pack()

# Ablak futtatása

ablak.mainloop()

--------------

Sszámológép szoftver készítése pythonban (Szoftverfejlesztő)

Az alábbiakban egy egyszerű, grafikus felülettel (GUI) rendelkező számológép szoftver kódját találod, amely a Python beépített tkinter könyvtárát használja. Ez a program kezeli az összeadást, kivonást, szorzást, osztást, és tartalmaz egy "C" (törlés) gombot is.

-----------------------------------

import tkinter as tk

def kattintas(ertek):

    aktualis = kijelzo.get()

    kijelzo.set(aktualis + str(ertek))

def torles():

    kijelzo.set("")

def eredmeny():

    try:

        eredm = eval(kijelzo.get())

        kijelzo.set(str(eredm))

    except:

        kijelzo.set("Hiba")

# Ablak létrehozása

ablak = tk.Tk()

ablak.title("Számológép")

ablak.geometry("300x400")

ablak.configure(bg="#333333")

kijelzo = tk.StringVar()

# Kijelző mező

kijelzo_mezo = tk.Entry(ablak, textvariable=kijelzo, font=("Arial", 20), bd=10, insertwidth=4, width=14, borderwidth=0, justify="right")

kijelzo_mezo.grid(columnspan=4, ipady=15, padx=10, pady=10)

# Gombok elrendezése

gombok = [

    ('7', 1, 0), ('8', 1, 1), ('9', 1, 2), ('/', 1, 3),

    ('4', 2, 0), ('5', 2, 1), ('6', 2, 2), ('*', 2, 3),

    ('1', 3, 0), ('2', 3, 1), ('3', 3, 2), ('-', 3, 3),

    ('C', 4, 0), ('0', 4, 1), ('+', 4, 2), ('=', 4, 3)

]

for (szoveg, sor, oszlop) in gombok:

    if szoveg == 'C':

        action = torles

        hatszin = "#d9534f"

    elif szoveg == '=':

        action = eredmeny

        hatszin = "#5cb85c"

    else:

        action = lambda x=szoveg: kattintas(x)

        hatszin = "#f0ad4e" if szoveg in ['/', '*', '-', '+'] else "#e7e7e7"

    btn = tk.Button(ablak, text=szoveg, font=("Arial", 14), bg=hatszin, command=action, height=1, width=3)

    btn.grid(row=sor, column=oszlop, padx=5, pady=5)

ablak.mainloop()

----------------

Paint-szerű program készítése Pythonban (Szoftverfejlesztő)

Egy Paint-szerű program készítéséhez a Python beépített tkinter grafikus könyvtára a legmegfelelőbb választás. Az alábbi kód egy alapvető rajzolófelületet hoz létre, amelyen szabadkézzel rajzolhatsz, változtathatod a ceruza színét, és törölheted a vásznat.

------------------

import tkinter as tk

from tkinter import colorchooser

class PaintApp:

    def __init__(self, root):

        self.root = root

        self.root.title("Egyszerű Python Paint")

        self.root.geometry("800x600")

        # Alapértelmezett beállítások

        self.pen_color = "black"

        self.pen_size = 5

        self.old_x = None

        self.old_y = None

        # Rajzvászon (Canvas) létrehozása

        self.canvas = tk.Canvas(self.root, bg="white")

        self.canvas.pack(fill=tk.BOTH, expand=True)

        # Események összerendelése az egérrel

        self.canvas.bind('<B1-Motion>', self.draw)

        self.canvas.bind('<ButtonRelease-1>', self.reset)

        # Kezelőpanel (Frame) a gomboknak

        self.control_frame = tk.Frame(self.root)

        self.control_frame.pack(fill=tk.X)

        # Színválasztó gomb

        self.color_button = tk.Button(self.control_frame, text="Szín választása", command=self.choose_color)

        self.color_button.pack(side=tk.LEFT, padx=5, pady=5)

        # Radír gomb

        self.eraser_button = tk.Button(self.control_frame, text="Radír", command=self.use_eraser)

        self.eraser_button.pack(side=tk.LEFT, padx=5, pady=5)

        # Méret növelése és csökkentése

        self.plus_button = tk.Button(self.control_frame, text="Vastagítás (+)", command=self.increase_size)

        self.plus_button.pack(side=tk.LEFT, padx=5, pady=5)

        self.minus_button = tk.Button(self.control_frame, text="Vékonyítás (-)", command=self.decrease_size)

        self.minus_button.pack(side=tk.LEFT, padx=5, pady=5)

        # Törlés gomb

        self.clear_button = tk.Button(self.control_frame, text="Mindent töröl", command=self.clear_canvas)

        self.clear_button.pack(side=tk.LEFT, padx=5, pady=5)

    def choose_color(self):

        # Megnyitja a színválasztó ablakot

        color_code = colorchooser.askcolor(title="Válassz színt!")[1]

        if color_code:

            self.pen_color = color_code

    def use_eraser(self):

        # A radír lényegében egy fehér színű "ceruza"

        self.pen_color = "white"

    def increase_size(self):

        self.pen_size += 2

    def decrease_size(self):

        if self.pen_size > 2:

            self.pen_size -= 2

    def clear_canvas(self):

        self.canvas.delete("all")

    def draw(self, event):

        # Rajzolás a vászonra

        if self.old_x and self.old_y:

            self.canvas.create_line(self.old_x, self.old_y, event.x, event.y,

                                    width=self.pen_size, fill=self.pen_color,

                                    capstyle=tk.ROUND, smooth=tk.TRUE)

        self.old_x = event.x

        self.old_y = event.y

    def reset(self, event):

        # Reseteli a koordinátákat, mikor elengedjük az egeret

        self.old_x = None

        self.old_y = None

if __name__ == "__main__":

    root = tk.Tk()

    app = PaintApp(root)

    root.mainloop()

--------------