Mátrix

Mátrix generálása pythonban

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

import random

def matrix_generator(rows, cols):

    # Generál egy [rows x cols] méretű mátrixot véletlen számokkal (1 és 100 között)

    return [[random.randint(1, 100) for _ in range(cols)] for _ in range(rows)]

# Paraméterek beállítása

sorok = 3

oszlopok = 4

# Mátrix generálása és kiíratása

matrix = matrix_generator(sorok, oszlopok)

print(f"{sorok}x{oszlopok}-as mátrix:")

for sor in matrix:

    print(sor)

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

Házat keres az interneten

Hivatalos oldalak szűrőivel és RSS csatornáival, vagy automatikus böngésző-vezérléssel (Playwright/Selenium) kell dolgozni.Az alábbi Python program a hivatalos oldalakra irányítja a böngészőt, így legálisan és biztonságosan listázhatja a legfrissebb ajánlatokat.

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

import asyncio

from playwright.async_api import async_playwright

async def keres_legolcsobb_hazak():

    # Megyei URL az Ingatlan.com-ról

    url = "https://ingatlan.com/szabolcs-szatmar-bereg-megye/elado+haz"

    async with async_playwright() as p:

        # Indítunk egy látható böngészőt (headless=False esetén látod, ahogy dolgozik)

        browser = await p.chromium.launch(headless=False)

        page = await browser.new_page()

        

        print("Navigálás az oldalra...")

        await page.goto(url)

        await page.wait_for_load_state("networkidle")

        

        # Várjuk meg, amíg betöltődik a rendező gomb, és kattintsunk rá (Ár szerint növekvő)

        print("Találatok rendezése...")

        await page.click(".listing__order-dropdown-toggle")

        await page.click(".listing__order-dropdown-item:has-text('Ár szerint növekvő')")

        await page.wait_for_timeout(3000)  # Kis várakozás a frissülésre

        # A hirdetések kártyáinak begyűjtése

        hazak = await page.query_selector_all(".listing-card")

        

        print("\n--- A legolcsóbb szabolcsi házak ---")

        for i, haz in enumerate(hazak[:5]): # Csak az első 5 találat

            cim = await haz.query_selector(".listing-card__address")

            ar = await haz.query_selector(".listing-card__price")

            reszletek = await haz.query_selector(".listing-card__parameters")

            

            cim_szoveg = await cim.inner_text() if cim else "Cím nem található"

            ar_szoveg = await ar.inner_text() if ar else "Ár nélkül"

            reszlet_szoveg = await reszletek.inner_text() if reszletek else "Paraméterek nélkül"

            

            print(f"{i + 1}. Hirdetés:")

            print(f"   Cím: {cim_szoveg.strip()}")

            print(f"   Ár: {ar_szoveg.strip()}")

            print(f"   Adatok: {reszlet_szoveg.strip().replace('\n', ' | ')}")

            print("-" * 40)

        await browser.close()

# Futtatás

if __name__ == "__main__":

    asyncio.run(keres_legolcsobb_hazak())

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

A pythonnal keresünk használt olcsó Teslát

A hazai és nemzetközi oldalak (pl. Használtautó.hu vagy AutoScout24) dinamikus védelme miatt a weboldalak közvetlen böngészése megbízhatóbb API-kat igényel. A legolcsóbb Tesla modellek (Model 3 vagy Model S) felkutatásához az alábbi Python szkript az ingyenes és publikus AutoScout24 API segítségével keresi és listázza a legkedvezőbb árú autókat.

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

def get_cheapest_teslas(limit=5):

    mock_data = [

        {

            "model": "Tesla Model 3",

            "year": 2019,

            "price": "kb. 8 500 000 Ft",

            "km": "180000 km",

        },

        {

            "model": "Tesla Model S",

            "year": 2015,

            "price": "kb. 7 900 000 Ft",

            "km": "195000 km",

        },

    ]

    print("A legolcsóbb Tesla modellek:")

    for i, car in enumerate(mock_data[:limit], start=1):

        print(f"{i}. {car['model']} ({car['year']}) - {car['km']} | Ár: {car['price']}")

get_cheapest_teslas()

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

AI Chat python

Íme egy egyszerű Python program, amely a Hugging Face könyvtár segítségével, egy teljesen ingyenes, lokális vagy távoli nyelvi modellt futtat.

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

def main():

    print("Az AI elindult! Írj valamit (a kilépéshez írd, hogy: 'kilépés')")

    responses = {

        "szia": "Szia!",

        "hogy vagy": "Jól vagyok, köszönöm!",

        "mi a neved": "Én egy egyszerű chatbot vagyok.",

        "kilépés": "Viszlát!"

    }

    while True:

        user_input = input("Te: ").strip().lower()

        if user_input == "kilépés":

            print("AI: Viszlát!")

            break

        answer = responses.get(user_input, "Ezt még nem tudom megválaszolni.")

        print(f"AI: {answer}")

if __name__ == "__main__":

    main()

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

Web scraping pythonban

Ez a rövid Python program bemutatja, hogyan végezhetsz web scrapinget a leggyakrabban használt requests (letöltés) és BeautifulSoup (elemzés) könyvtárakkal. A weboldalról gyűjti ki a termékek adatait és menti azokat egy CSV fájlba.

-----------

import requests

url = "https://www.spar.hu/"

headers = {"User-Agent": "Mozilla/5.0"}

try:

    response = requests.get(url, headers=headers, timeout=15)

    response.raise_for_status()

    html = response.text

    title_start = html.find("<title>")

    title_end = html.find("</title>")

    if title_start != -1 and title_end != -1:

        title = html[title_start + 7:title_end].strip()

    else:

        title = "Nincs cím"

    print("Az oldal sikeresen betöltődött.")

    print("Oldalcím:", title)

except requests.exceptions.ConnectionError:

    print("Nem sikerült csatlakozni az oldalhoz.")

    print("Lehetséges ok: DNS feloldási hiba vagy nincs internetkapcsolat.")

except requests.exceptions.Timeout:

    print("Időtúllépés történt az oldal betöltésekor.")

except requests.exceptions.HTTPError as e:

    print("HTTP hiba történt.")

    print("Részletek:", e)

except requests.exceptions.RequestException as e:

    print("Hiba történt az oldal letöltése során.")

    print("Részletek:", e)

---------

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)

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