Szabó László István író, költő, az informatika tudományok tanára

2026. június 28., vasárnap

Maci rajz

Az alábbi program egy letisztult, kedves kis macifejet rajzol fülekkel, szemekkel és orral.

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

import turtle

# Ablak beállítása

screen = turtle.Screen()

screen.bgcolor("skyblue")

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

maci = turtle.Turtle()

maci.speed(5)

maci.pensize(3)

# Segédfüggvény körök rajzolásához (kitöltéssel)

def draw_circle(color, radius, x, y):

maci.penup()

maci.goto(x, y)

maci.pendown()

maci.fillcolor(color)

maci.begin_fill()

maci.circle(radius)

maci.end_fill()

# 1. Fülek

draw_circle("saddlebrown", 30, -70, 110) # Bal fül

draw_circle("saddlebrown", 30, 70, 110) # Jobb fül

# 2. Fej

draw_circle("saddlebrown", 80, 0, 0)

# 3. Pofazacskó / Orrrész

draw_circle("bisque", 35, 0, -20)

# 4. Orr

draw_circle("black", 10, 0, -10)

# 5. Szemek

draw_circle("black", 10, -35, 40) # Bal szem

draw_circle("black", 10, 35, 40) # Jobb szem

# 6. Száj

maci.penup()

maci.goto(-20, -1)

maci.pendown()

maci.right(90)

maci.circle(20, 180) # Mosoly rajzolása

# Teknőc elrejtése a szebb végeredményért

maci.hideturtle()

turtle.done()

-----------

Mosolygós arcot szemekkel és orral.

Python program kezdőknek

----------

import turtle

# Ablak beállítása

ablak = turtle.Screen()

ablak.bgcolor("white")

# A rajzoló ("teknős") létrehozása

ceruza = turtle.Turtle()

ceruza.speed(5)

ceruza.pensize(3)

# --- FEJ ---

ceruza.penup()

ceruza.goto(0, -100) # A kör középpontjának alja

ceruza.pendown()

ceruza.color("black", "yellow")

ceruza.begin_fill()

ceruza.circle(120)

ceruza.end_fill()

# --- BAL SZEM ---

ceruza.penup()

ceruza.goto(-40, 20)

ceruza.pendown()

ceruza.color("black", "blue")

ceruza.begin_fill()

ceruza.circle(15)

ceruza.end_fill()

# --- JOBB SZEM ---

ceruza.penup()

ceruza.goto(40, 20)

ceruza.pendown()

ceruza.color("black", "blue")

ceruza.begin_fill()

ceruza.circle(15)

ceruza.end_fill()

# --- ORR ---

ceruza.penup()

ceruza.goto(0, 0)

ceruza.pendown()

ceruza.color("black")

ceruza.circle(10)

# --- MOSOLY ---

ceruza.penup()

ceruza.goto(-50, -30)

ceruza.pendown()

ceruza.right(90)

ceruza.circle(50, 180) # Félkör rajzolása

# A rajzoló eltüntetése és az ablak bezárásának megvárása

ceruza.hideturtle()

turtle.done()

-----------

A hold kering a föld körül

-----------

import turtle

import math

# Ablak beállítása

ablak = turtle.Screen()

ablak.bgcolor("black")

# Föld rajzoló objektum (pontként megadva, hogy nagyobb lehessen)

fold = turtle.Turtle()

fold.color("deep sky blue")

fold.penup()

# A goto(1,1) helyett középre tesszük, és nagy pontot rajzolunk

fold.goto(0, 0)

fold.dot(50) # A 50-es szám állítja a Föld méretét

# Hold rajzoló objektum

hold = turtle.Turtle()

hold.shape("circle")

hold.color("light gray")

hold.penup()

# Animáció változók

szog = 0

sugar = 100 # Megnöveltük a távolságot, hogy a Hold elférjen a nagyobb Föld mellett

# A Hold keringése a Föld körül

while True:

hold.color("light gray") # Egyszerűsítve a színváltás

# Keringés kiszámolása (trigonometria)

x = sugar * math.cos(math.radians(szog))

y = sugar * math.sin(math.radians(szog))

hold.goto(x, y)

szog += 1 # Keringési sebesség

if szog >= 360:

szog = 0

# Az ablak bezárásának megakadályozása kattintásig

ablak.exitonclick()

-----------

https://pythonsandbox.com/turtle

Saturnus pythonban

Saturnus

---------

import turtle

import math

import random

ablak = turtle.Screen()

ablak.bgcolor("black")

ablak.setup(600, 600)

ablak.tracer(0)

# csillagok

csillag = turtle.Turtle()

csillag.hideturtle()

csillag.speed(0)

csillag.color("black")

for _ in range(100):

csillag.penup()

csillag.goto(random.randint(-400, 400), random.randint(-400, 400))

csillag.dot(random.randint(1, 3))

# GYŰRŰ (CSAK ALSÓ FÉL)

gyuru = turtle.Turtle()

gyuru.hideturtle()

gyuru.speed(0)

gyuru.pensize(3)

szinek = ["#6A6C73"]

for szin in szinek:

gyuru.pencolor(szin)

for r in range(120, 150):

gyuru.penup()

gyuru.goto(0, -30)

gyuru.pendown()

# CSAK ALSÓ fél (0° → 180° helyett 180° → 360°)

for angle in range(180, 609):

rad = math.radians(angle)

x = r * math.cos(rad)

y = -r * math.sin(rad) * 0.1

gyuru.goto(x, y)

# BOLYGÓ (utoljára, hogy eltakarja a felsőt)

bolygo = turtle.Turtle()

bolygo.hideturtle()

bolygo.speed(0)

sugar = 100

szinek_b = ["blue","green", "white","purple","brown"]

for i in range(sugar, 0, -1):

bolygo.penup()

bolygo.goto(0, -i + (sugar * 0.09))

bolygo.pendown()

idx = int((i / sugar) * len(szinek_b))

bolygo.pencolor(szinek_b[min(idx, len(szinek_b)-5)])

bolygo.circle(i)

ablak.update()

turtle.done()

-----------

https://pythonsandbox.com/turtle

Forgó körök

Egymásba fonódó, forgó körökből álló fraktálminta

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

import turtle

# Alap beállítás (nem Screen objektummal)

rajzolo = turtle.Turtle()

rajzolo.speed(0)

rajzolo.hideturtle()

rajzolo.pensize(2)

lepesek = 150

# Egyszerű színlista (biztosan működik mindenhol)

szinek = [

"red", "orange", "yellow", "green",

"cyan", "blue", "purple", "magenta"

]

for i in range(lepesek):

rajzolo.pencolor(szinek[i % len(szinek)])

rajzolo.circle(150)

rajzolo.right(360 / lepesek + 2)

rajzolo.forward(2)

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

Szivárványos spirál négyzetes

Az alábbi kód egy dinamikusan forgó, szivárványos spirált rajzol négyzetekből, amely lenyűgöző vizuális élményt nyújt.

-----------

import turtle

# Ablak beállítása

ablak = turtle.Screen()

ablak.bgcolor("black")

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

rajzolo = turtle.Turtle()

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

rajzolo.width(2)

szinek = ["red", "purple", "blue", "green", "orange", "yellow"]

# Négyzetspirál rajzolása

for i in range(360):

rajzolo.pencolor(szinek[i % 6]) # Szín váltása a listából

rajzolo.forward(i * 1.2) # Haladás előre

rajzolo.right(89) # Kicsi fordulat, hogy spirál legyen

# A rajz végén az ablak kattintásra záródik be

ablak.exitonclick()

-----------

Íme egy színes hópehely fraktál

-----------

import turtle

rajzolo = turtle.Turtle()

rajzolo.speed(0)

rajzolo.pensize(2)

rajzolo.hideturtle()

rajzolo.color("cyan")

def koch(hossz, szint):

if szint == 0:

rajzolo.forward(hossz)

else:

hossz /= 3.0

koch(hossz, szint - 1)

rajzolo.left(60)

koch(hossz, szint - 1)

rajzolo.right(120)

koch(hossz, szint - 1)

rajzolo.left(60)

koch(hossz, szint - 1)

def hopehely(hossz, szint):

for _ in range(3):

koch(hossz, szint)

rajzolo.right(120)

rajzolo.penup()

rajzolo.goto(-200, 100)

rajzolo.pendown()

hopehely(400, 4)

turtle.done()

-----------

Python grafika1

Egy színváltós, harmonikus fraktál-spirált rajzol.

-----------

import turtle

# Ablak beállítása

ablak = turtle.Screen()

ablak.bgcolor("black") # Fekete háttér a szebb kontrasztért

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

rajzolo = turtle.Turtle()

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

rajzolo.width(2) # Vonalvastagság

# Színek a látványos hatásért

szinek = ["red", "purple", "blue", "green", "orange", "yellow"]

# A spirál megrajzolása

for i in range(360):

rajzolo.pencolor(szinek[i % 6]) # Szín váltása minden lépésben

rajzolo.forward(i) # Egyre hosszabb vonal

rajzolo.right(59) # Határozza meg a spirál formáját

# Ablak bezárásához kattintás szükséges

turtle.done()

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

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

https://pythonsandbox.com/turtle

2026. június 27., szombat

Valószínüség

Valószínüség számítás Python-szkript bemutatja, hogy a csillagászok szerint mely égitestek rendelkeznek a legfőbb feltételekkel (folyékony víz, hőforrások), és lekérdezi azokat

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

# A Naprendszer legfőbb égitestjei, amelyeknél a jégpáncél alatt folyékony óceán rejtőzhet,

# és potenciálisan alkalmasak lehetnek az élet (mikrobák) fenntartására.

potencialis_holdak = {

"Europa": {

"bolygo": "Jupiter",

"jellemzo": "Globális sós óceán, amely közvetlenül érintkezik a sziklás maggal (hidrotermális aktivitás lehetősége).",

"elet_eselye": "Kiemelkedően magas"

"Enceladus": {

"bolygo": "Szaturnusz",

"jellemzo": "A déli póluson gejzírek lövellik az űrbe az óceán vizét, amely szerves molekulákat és foszfort is tartalmaz.",

"elet_eselye": "Kiemelkedően magas"

"Ganymede": {

"bolygo": "Jupiter",

"jellemzo": "A Naprendszer legnagyobb holdja, amelynek jégpáncélja alatt rétegzett óceánok találhatók.",

"elet_eselye": "Mérsékelt / Magas"

"Callisto": {

"bolygo": "Jupiter",

"jellemzo": "Hatalmas, de valószínűleg kevésbé aktív felszín alatti óceán, vastag jégréteggel.",

"elet_eselye": "Mérsékelt"

"Titan": {

"bolygo": "Szaturnusz",

"jellemzo": "Felszínén folyékony szénhidrogén tavak vannak, de a jégkérge alatt szintén hatalmas vízóceán rejtőzik.",

"elet_eselye": "Ismeretlen / Feltételes"

}

def hold_informacio(hold_nev):

"""Lekérdezi az adott hold adatait az adatbázisból."""

hold = potencialis_holdak.get(hold_nev.capitalize())

if hold:

print(f"--- {hold_nev.capitalize()} ---")

print(f"Gazdabolygó: {hold['bolygo']}")

print(f"Jellemző: {hold['jellemzo']}")

print(f"Élet esélye: {hold['elet_eselye']}\n")

else:

print(f"A(z) {hold_nev} nem szerepel a kiemelt óceán-holdak listáján, vagy nincs rá bizonyíték.\n")

# Példa a használatra: az összes lehetséges égitest kiíratása

print("Potenciális élethelyek a jég alatt a Naprendszerben:\n")

for hold in potencialis_holdak.keys():

hold_informacio(hold)

# Egy adott hold részletes keresése:

print("Keresés egy konkrét holdra (pl. Europa):")

hold_informacio("Europa")

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

Potenciális élethelyek a jég alatt a Naprendszerben:

--- Europa ---

Gazdabolygó: Jupiter

Jellemző: Globális sós óceán, amely közvetlenül érintkezik a sziklás maggal (hidrotermális aktivitás lehetősége).

Élet esélye: Kiemelkedően magas

--- Enceladus ---

Gazdabolygó: Szaturnusz

Jellemző: A déli póluson gejzírek lövellik az űrbe az óceán vizét, amely szerves molekulákat és foszfort is tartalmaz.

Élet esélye: Kiemelkedően magas

--- Ganymede ---

Gazdabolygó: Jupiter

Jellemző: A Naprendszer legnagyobb holdja, amelynek jégpáncélja alatt rétegzett óceánok találhatók.

Élet esélye: Mérsékelt / Magas

--- Callisto ---

Gazdabolygó: Jupiter

Jellemző: Hatalmas, de valószínűleg kevésbé aktív felszín alatti óceán, vastag jégréteggel.

Élet esélye: Mérsékelt

--- Titan ---

Gazdabolygó: Szaturnusz

Jellemző: Felszínén folyékony szénhidrogén tavak vannak, de a jégkérge alatt szintén hatalmas vízóceán rejtőzik.

Élet esélye: Ismeretlen / Feltételes

Keresés egy konkrét holdra (pl. Europa):

--- Europa ---

Gazdabolygó: Jupiter

Jellemző: Globális sós óceán, amely közvetlenül érintkezik a sziklás maggal (hidrotermális aktivitás lehetősége).

Élet esélye: Kiemelkedően magas

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

# A jég alatti óceánnal rendelkező holdak és lakhatósági pontszámuk (1-10)

# A pontozás a víz, az energiaforrások és a szerves vegyületek jelenléte alapján történt.

holdak = [

{"nev": "Europa (Jupiter)", "esely": 9, "jellemzo": "Globális óceán, vulkanikus aktivitás a tengerfenéken."},

{"nev": "Enceladus (Szaturnusz)", "esely": 9, "jellemzo": "Gejzírek, szerves molekulák, hidrotermális aktivitás."},

{"nev": "Ganymedes (Jupiter)", "esely": 7, "jellemzo": "Nagy méret, többrétegű jég és víz óceánok."},

{"nev": "Callisto (Jupiter)", "esely": 6, "jellemzo": "Stabil óceán, de kevesebb energiát kaphat a magból."},

{"nev": "Titan (Szaturnusz)", "esely": 5, "jellemzo": "Felszíni szénhidrogén tavak, belső vízóceán lehetősége."}

]

print("A legvalószínűbb holdak a jég alatti életre:\n")

legvaloszinubb = max(holdak, key=lambda x: x['esely'])

for hold in holdak:

if hold["esely"] == legvaloszinubb["esely"]:

print(f"** {hold['nev']} (Legesélyesebb) ** - {hold['jellemzo']}")

else:

print(f" {hold['nev']} - {hold['jellemzo']}")

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

A legvalószínűbb holdak a jég alatti életre:

** Europa (Jupiter) (Legesélyesebb) ** - Globális óceán, vulkanikus aktivitás a tengerfenéken.

** Enceladus (Szaturnusz) (Legesélyesebb) ** - Gejzírek, szerves molekulák, hidrotermális aktivitás.

Ganymedes (Jupiter) - Nagy méret, többrétegű jég és víz óceánok.

Callisto (Jupiter) - Stabil óceán, de kevesebb energiát kaphat a magból.

Titan (Szaturnusz) - Felszíni szénhidrogén tavak, belső vízóceán lehetősége.

2026. június 26., péntek

Tokaji vulkán kitörés modellezése

Egy vulkáni kitörés összetett fizikai folyamat (magma áramlása, gázok terjedése), így a modellezéséhez a Python nyelvben leggyakrabban a numpy és matplotlib csomagokat alkalmazzák a numerikus számításokhoz és az eredmények vizualizációjához.Az alábbi Python szkript egy Tokajhoz hasonló rétegvulkán kitörését szimulálja: lemodellezi a láva terjedését a gravitáció és a domborzat hatására, valamint a vulkáni hamu szélirány szerinti szóródását.

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

import numpy as np

import matplotlib.pyplot as plt

def simulacio_vulkan(grid_size=100, kitoresi_intenzitas=500):

# 1. Alapvető paraméterek és domborzat (Magassági mátrix)

# A kráter a mátrix közepén helyezkedik el

domborzat = np.zeros((grid_size, grid_size))

for i in range(grid_size):

for j in range(grid_size):

tav_kozponttol = np.sqrt((i - grid_size/2)**2 + (j - grid_size/2)**2)

# Egy kúp alakú hegy létrehozása (Tokaji-hegyek jellege)

domborzat[i, j] = 500 - tav_kozponttol * 10

if domborzat[i, j] < 0: domborzat[i, j] = 0

# 2. Láva szimuláció (egyszerűsített celluláris automata)

lava = np.zeros((grid_size, grid_size))

krat_x, krat_y = grid_size // 2, grid_size // 2

lava[krat_x, krat_y] = kitoresi_intenzitas

# Láva terjedése a lejtőn lefelé

for _ in range(20): # Szimulációs lépések

uj_lava = lava.copy()

for x in range(1, grid_size-1):

for y in range(1, grid_size-1):

if lava[x, y] > 0:

szomszedok = [

(x+1, y), (x-1, y), (x, y+1), (x, y-1)

]

for sx, sy in szomszedok:

if domborzat[sx, sy] < domborzat[x, y]:

atadas = lava[x, y] * 0.1

uj_lava[x, y] -= atadas

uj_lava[sx, sy] += atadas

lava = uj_lava

# 3. Hamuszórás szimuláció (Gauss-eloszlás a szélirány alapján)

# Tegyük fel, hogy a szél észak-keleti irányba fúj (Tokaj felé)

hamu = np.zeros((grid_size, grid_size))

szel_irany_x = 5

szel_irany_y = 5

for x in range(grid_size):

for y in range(grid_size):

# Távolság a krátertől szélirányban

dx = x - (krat_x + szel_irany_x)

dy = y - (krat_y + szel_irany_y)

tavolsag = np.sqrt(dx**2 + dy**2)

# Hamu vastagságának csökkenése távolsággal

hamu[x, y] = max(0, 1000 - tavolsag * 20)

# 4. Eredmények vizualizációja

fig, ax = plt.subplots(1, 2, figsize=(12, 6))

# Láva megjelenítése

im1 = ax[0].imshow(lava, cmap='hot', origin='lower')

ax[0].set_title("Láva terjedési modell")

ax[0].set_xlabel("X koordináta (km)")

ax[0].set_ylabel("Y koordináta (km)")

fig.colorbar(im1, ax=ax[0], label='Láva vastagság (m)')

# Hamu szóródás megjelenítése

im2 = ax[1].imshow(hamu, cmap='Greys', origin='lower')

ax[1].set_title("Vulkáni hamu lerakódás (Szélirány: ÉK)")

ax[1].set_xlabel("X koordináta (km)")

ax[1].set_ylabel("Y koordináta (km)")

fig.colorbar(im2, ax=ax[1], label='Hamu vastagság (mm)')

plt.tight_layout()

plt.show()

simulacio_vulkan()

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

Mit csinál a program?

A simulacio_vulkan() függvény 4 fő lépést hajt végre:

Domborzat létrehozása

Láva terjedésének szimulálása

Hamu lerakódásának modellezése

Eredmények vizualizálása

A végén meghívja:

simulacio_vulkan()

1) Domborzat létrehozása

domborzat = np.zeros((grid_size, grid_size))

Ez egy grid_size x grid_size méretű mátrix, alapból 0-val feltöltve.

Ezután minden cellára kiszámolja a középponttól való távolságot:

tav_kozponttol = np.sqrt((i - grid_size/2)**2 + (j - grid_size/2)**2)

Majd ehhez rendeli a magasságot:

domborzat[i, j] = 500 - tav_kozponttol * 10

Tehát:

középen magas

kifelé haladva egyre alacsonyabb

ha negatív lenne, 0-ra állítja

Ez gyakorlatilag egy kúpszerű hegyet készít.

Megjegyzés

A komment szerint „Tokaji-hegyek jellege”, de valójában ez csak egy általános kúpmodell, nem valós topográfia.

2) Láva szimuláció

lava = np.zeros((grid_size, grid_size))

krat_x, krat_y = grid_size // 2, grid_size // 2

lava[krat_x, krat_y] = kitoresi_intenzitas

A kráter a rács közepére kerül, és oda kerül a kezdeti lávamennyiség.

Terjedési logika

A program 20 lépésen keresztül szimulálja a terjedést:

for _ in range(20):

Minden aktív cellánál megvizsgálja a 4 szomszédot:

szomszedok = [(x+1, y), (x-1, y), (x, y+1), (x, y-1)]

Ha a szomszéd alacsonyabban van, mint az aktuális cella:

if domborzat[sx, sy] < domborzat[x, y]:

akkor a láva 10%-át átadja:

atadas = lava[x, y] * 0.1

uj_lava[x, y] -= atadas

uj_lava[sx, sy] += atadas

Fontos viselkedés

Ez azt modellezi, hogy a láva lefelé folyik a lejtőn.

Probléma

A modell egyszerűsége miatt:

egy cella több szomszédnak is adhat ugyanabban a körben

a láva gyorsan eloszlik

nem szerepel viszkozitás, hűlés, megszilárdulás

Ez inkább demonstrációs modell, nem fizikai szimuláció.

3) Hamu szóródás

hamu = np.zeros((grid_size, grid_size))

szel_irany_x = 5

szel_irany_y = 5

Itt feltételezi, hogy a szél észak-keleti irányba fúj.

Ezután minden cellára kiszámolja a krátertől való távolságot a szélirány eltolásával:

dx = x - (krat_x + szel_irany_x)

dy = y - (krat_y + szel_irany_y)

tavolsag = np.sqrt(dx**2 + dy**2)

hamu[x, y] = max(0, 1000 - tavolsag * 20)

Mit jelent ez?

a középponthoz közeli területeken vastagabb hamu

távolabb vékonyabb

a szélirány miatt az eloszlás eltolódik

Megjegyzés

Ez nem valódi légköri modell, hanem egy egyszerű Gauss-szerű lecsengés.

4) Vizualizáció

A program két ábrát rajzol:

Láva

im1 = ax[0].imshow(lava, cmap='hot', origin='lower')

hot színskála

alulról induló koordináta-rendszer

Hamu

im2 = ax[1].imshow(hamu, cmap='Greys', origin='lower')

szürke színskála

világosabb/sötétebb területek mutatják a vastagságot

A colorbar segít az értékek értelmezésében.

Erősségek

Egyszerűen érthető

Jól szemlélteti a rácsalapú modellezést

Szép vizualizációt ad

Jó demonstráció arra, hogyan lehet természeti jelenséget modellezni

Gyengeségek

1. Nem fizikai pontosságú

A láva terjedése túl egyszerű:

nincs hőmérséklet

nincs viszkozitás

nincs megszilárdulás

nincs térfogatmegmaradás

2. A hamu szóródás mesterséges

A szélirány csak egy eltolás:

nincs turbulencia

nincs légköri rétegződés

nincs valós terjedési modell

3. A domborzat statikus

A vulkán kitörése nem változtatja meg érdemben a hegy formáját.

4. A kód lassú lehet nagy rácsnál

Két egymásba ágyazott ciklus van több helyen, ami nagyobb grid_size esetén lassú.

Technikai megfigyelések

Importok

import numpy as np

import matplotlib.pyplot as plt

Ezek megfelelőek, nincs hiányzó import.

Paraméterek

A függvény paraméterei:

def simulacio_vulkan(grid_size=100, kitoresi_intenzitas=500):

Ez jó, mert könnyen állítható.

Szintaxis

A kód alapvetően szintaktikailag helyes.

Összegzés

Ez egy szemléltető, oktatási célú vulkánmodell, generál egy kúpszerű domborzatot,

indít egy láva-terjedést a középpontból, létrehoz egy egyszerű hamu-lerakódási mintát,

A Vesta és a Pallas kisbolygók ütközését modellezük python segítségével

Az alábbi Python program a 4 Vesta és a 2 Pallas kisbolygók feltételezett ütközését modellezi a fizikai törvényszerűségek (pl. kinetikus energia, kráterképződés) alapján. A számításokhoz a NumPy könyvtárat használjuk.

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

import numpy as np

import matplotlib.pyplot as plt

# --- 1. Alapadatok (Vesta és Pallas) ---

# Tömeg (kg)

m_vesta = 2.59e20

m_pallas = 2.11e20

# Átmérő (km)

d_vesta = 525.4

d_pallas = 512.0

# Ütközési sebesség km/s-ban (tipikus érték a kisbolygóövben)

v_impact_kms = 5.5

v_impact = v_impact_kms * 1000 # m/s

# --- 2. Ütközés modellezése ---

# Kinetikus energia kiszámítása (Joule)

# E = 0.5 * m * v^2

E_k = 0.5 * m_vesta * (v_impact**2)

def calculate_crater_diameter(energy_J, target_diameter_km):

# Egyszerűsített kráterbecslő képlet (skálázási törvények alapján)

# D_c ~ C * E^(1/3.4)

# Referenciaértékek becslése: Vesta kb. 500 km-es krátere (Rheasilvia) alapján

return (energy_J / 1e18)**0.28 * 0.1 * target_diameter_km

# Elemzés eredményei

D_crater = calculate_crater_diameter(E_k, d_vesta)

print("--- Ütközés és Elemzés Eredményei ---")

print(f"Becsült becsapódási energia: {E_k:.3e} Joule")

print(f"Várható kráter átmérő a Vestán: {D_crater:.2f} km")

print(f"Tömegvesztési becslés: A Vesta tömegének kb. 1%-a szabadulhat fel törmelékként.")

# --- 3. Eredmények Vizualizációja (Matplotlib) ---

labels = ['Vesta', 'Pallas', 'Ütközési törmelék (becsült)']

masses = [m_vesta, m_pallas, m_vesta * 0.01]

colors = ['#c79f45', '#5599cc', '#e25c5c']

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))

# Tömeg összehasonlítás

ax1.bar(labels, masses, color=colors)

ax1.set_title('Testek tömegének összehasonlítása (kg)')

ax1.set_ylabel('Tömeg (kg)')

ax1.set_yscale('log')

# Becsapódási energia vizualizáció

energies = [0.5 * m_vesta * v_impact**2, 0.5 * m_pallas * v_impact**2]

ax2.bar(['Vesta által kapott', 'Pallas által kapott'], energies, color=['#c79f45', '#5599cc'])

ax2.set_title('Becsapódási kinetikus energia (Joule)')

ax2.set_ylabel('Energia (J)')

ax2.set_yscale('log')

plt.tight_layout()

plt.show()

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

--- Ütközés és Elemzés Eredményei ---

Becsült becsapódási energia: 3.917e+27 Joule

Várható kráter átmérő a Vestán: 25499.33 km

Tömegvesztési becslés: A Vesta tömegének kb. 1%-a szabadulhat fel törmelékként.

A nagy hadron ütköztető

Ez a program Monte-Carlo szimulációt valósít meg, amely modellezi a részecskék (pl. protonok) gyorsítását, majd azok szembekapcsolását és ütközését a hadron ütköztetőben.

--------

import random

import math

import matplotlib.pyplot as plt

class HadronUtkozteto:

def __init__(self, nev: str, kor_sugar_m: float, max_energia_tev: float):

self.nev = nev

self.sugar = kor_sugar_m # Gyorsító gyűrű sugara (méterben)

self.max_energia = max_energia_tev # Maximális elérhető energia TeV-ben

self.nyalabok = []

def nyalab_feltoltes(self, reszecske_szam: int, energia_tev: float):

"""Feltölti a gyorsítót proton nyalábokkal."""

energia = min(energia_tev, self.max_energia)

self.nyalabok.append({

"resztvevok": reszecske_szam,

"energia": energia,

"vektor": 1 # 1 = óramutató járása szerint, -1 = ellenkezőleg

})

print(f"{self.nev} feltöltve: {reszecske_szam} részecske, egyenként {energia} TeV energiával.")

def utkozes(self):

"""Modellezi a két nyaláb frontális ütközését."""

if len(self.nyalabok) < 2:

print("Hiba: Az ütközéshez két ellentétes irányú nyaláb szükséges!")

return

nyalab1 = self.nyalabok[0]

nyalab2 = self.nyalabok[1]

# Összenergia a tömegközépponti rendszerben sqrt(s)

sqrt_s = 2 * nyalab1["energia"]

print(f"Ütközés történt! Összenergia: {sqrt_s:.2f} TeV")

# Egyszerűsített Monte-Carlo részecske generálás az ütközéshez

utkozesi_termekek = []

# Tömegközépponti energia konvertálása GeV-re (1 TeV = 1000 GeV)

hatar_energiak = [random.uniform(0.1, sqrt_s * 1000 / 2) for _ in range(500)]

for e in hatar_energiak:

# Statisztikai eloszlás az új részecskékre

if e < 500: utkozesi_termekek.append("Pion")

elif e < 800: utkozesi_termekek.append("Kaon")

elif e < 950: utkozesi_termekek.append("Proton")

else: utkozesi_termekek.append("Higgs / Z / W bozon")

return utkozesi_termekek

# --- Szimuláció futtatása ---

# 1. Ütköztető létrehozása (pl. LHC paramétereihez hasonlóan)

lhc = HadronUtkozteto(nev="Nagy Hadronütközztető (LHC)", kor_sugar_m=4267, max_energia_tev=7.0)

# 2. Nyalábok indítása

lhc.nyalab_feltoltes(reszecske_szam=10000, energia_tev=6.5)

# 3. Ütközés modellezése és az eredmények statisztikája

termekek = lhc.utkozes()

# 4. Vizualizáció (Eredmények összesítése tortadiagrammon)

if termekek:

kategoriak = {}

for t in termekek:

kategoriak[t] = kategoriak.get(t, 0) + 1

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

plt.pie(kategoriak.values(), labels=kategoriak.keys(), autopct='%1.1f%%', startangle=140)

plt.title("Ütközés során keletkezett részecskék eloszlása")

plt.axis('equal')

plt.show()

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

Nagy Hadronütközztető (LHC) feltöltve: 10000 részecske, egyenként 6.5 TeV energiával.

Ütközés történt! Összenergia: 13.00 TeV

Járványok terjedésének modellezése

A járványok terjedésének modellezésére a legelterjedtebb matematikai eszköz az úgynevezett SIR (Fogékony, Fertőző, Gyógyult) modell. Ezzel a dinamikus rendszerrel szimulálható a betegség terjedése, a csúcspontok elérése és a lefolyás időtartama.A kipusztulás (amikor mindenki megfertőződik és belehal) egy speciális, végzetes forgatókönyv, ami akkor következik be, ha a betegség halálozási rátája \(100\%\)

-----------

import numpy as np

import matplotlib.pyplot as plt

from scipy.integrate import odeint

# 1. A modell paraméterei

N = 8000000000 # Kezdeti összlakosság (pl. 8 milliárd)

I0 = 1 # Kezdeti fertőzöttek száma

R0 = 0 # Kezdeti gyógyultak/halottak száma

S0 = N - I0 - R0 # Kezdeti fogékonyak száma

beta = 0.4 # Fertőzési ráta (kontaktusok száma * fertőzési esély)

gamma = 0.1 # Átlagos gyógyulási ráta (itt: 1/10 nap)

mortality_rate = 1.0 # Halálozási ráta (1.0 = minden fertőzött meghal)

# 2. A differenciálegyenlet-rendszer (SIR modell)

def sir_model(y, t, N, beta, gamma, mortality):

S, I, R = y

# Fogékonyak számának változása

dSdt = -beta * S * I / N

# Fertőzöttek számának változása

dIdt = (beta * S * I / N) - (gamma * I)

# Gyógyultak és halottak számának változása

dRdt = gamma * I * mortality

return dSdt, dIdt, dRdt

# 3. Időtartomány meghatározása (pl. 300 nap)

t = np.linspace(0, 300, 301)

# 4. A szimuláció futtatása

y0 = S0, I0, R0

ret = odeint(sir_model, y0, t, args=(N, beta, gamma, mortality_rate))

S, I, R = ret.T

# 5. Eredmények vizualizációja

plt.figure(figsize=(10, 6))

plt.plot(t, S, 'b', alpha=0.7, linewidth=2, label='Fogékony (Susceptible)')

plt.plot(t, I, 'r', alpha=0.7, linewidth=2, label='Fertőzött (Infected)')

plt.plot(t, R, 'k', alpha=0.7, linewidth=2, label='Elhunyt (Dead/Removed)')

plt.title('Járvány terjedése és az emberiség kipusztulása', fontsize=14)

plt.xlabel('Idő (nap)', fontsize=12)

plt.ylabel('Népesség', fontsize=12)

plt.ylim(0, N + N*0.1)

plt.legend(loc='best')

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

plt.show()

# 6. Mennyi ideig tart?

# Megkeressük azt a napot, amikor a fertőzöttek száma 0 alá csökken

infection_days = np.where(I < 1)[0]

if len(infection_days) > 0:

end_day = np.max(infection_days)

print(f"A szimuláció szerint a járvány lefolyása: {end_day} nap.")

else:

print("A járvány nem ért véget a vizsgált időszakon belül.")

---------

A járvány 5 év alatt teljesen kiírtja az emberi fajt.

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

Könyvek

https://mek.oszk.hu/08400/08435/08435.pdf

https://mtmi.unideb.hu/pluginfile.php/554/mod_resource/content/3/thinkcspy3.pdf

Atomtámadás hatásának modellezése

Az alábbi Python program a nukleáris fegyverek hatásait (hőhatás, lökéshullám, kezdeti sugárzás) modellezi a cube-root scalingot alkalmazva. A program kiszámítja az egyes pusztítási zónák sugarait egy megadott robbanási energia alapján:

---------

import math

class NuclearExplosionModel:

def __init__(self, yield_ktons):

"""

:param yield_ktons: A robbanás ereje kilotonnában (pl. 15 = Hiroshima)

"""

self.yield_ktons = yield_ktons

# Skálázási tényező (cube-root scaling)

self.scale_factor = math.pow(self.yield_ktons, 1/3)

def calculate_fireball_radius(self):

"""Tűzgömb sugara (hőhatás kezdete) méterben."""

return 670 * self.scale_factor

def calculate_blast_overpressure_radius(self, psi=5):

"""

Lökéshullám hatótávolsága méterben.

Alapértelmezetten az 5 PSI (súlyos épületkárok és emberi sérülések) zónát számolja.

"""

if psi == 20: # 20 PSI: Vasbeton épületek megsemmisülése

return 370 * self.scale_factor

elif psi == 5: # 5 PSI: Átlagos épületek összeomlása

return 740 * self.scale_factor

elif psi == 1: # 1 PSI: Ablaküvegek betörése

return 2130 * self.scale_factor

return 0

def calculate_radiation_radius(self, dose_Sv=5):

"""

Kezdeti ionizáló sugárzás hatótávolsága méterben (5 Sv halálos dózis).

"""

if dose_Sv == 5:

return 1100 * self.scale_factor

return 0

def print_report(self):

print(f"--- Atomcsapás Modell: {self.yield_ktons} kt TNT ---")

print(f"1. Tűzgömb sugara: ~{self.calculate_fireball_radius():.2f} m")

print(f"2. Lökéshullám (20 PSI - Teljes pusztulás): ~{self.calculate_blast_overpressure_radius(20):.2f} m")

print(f"3. Lökéshullám (5 PSI - Épületek dőlnek): ~{self.calculate_blast_overpressure_radius(5):.2f} m")

print(f"4. Lökéshullám (1 PSI - Ablakok törnek): ~{self.calculate_blast_overpressure_radius(1):.2f} m")

print(f"5. Ionizáló sugárzás (5 Sv - Halálos): ~{self.calculate_radiation_radius(5):.2f} m")

# Modell futtatása példa adattal (pl. 50 kilotonnás robbanás)

if __name__ == "__main__":

nuke = NuclearExplosionModel(yield_ktons=50)

nuke.print_report()

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

--- Atomcsapás Modell: 50 kt TNT ---

1. Tűzgömb sugara: ~2468.30 m

2. Lökéshullám (20 PSI - Teljes pusztulás): ~1363.09 m

3. Lökéshullám (5 PSI - Épületek dőlnek): ~2726.18 m

4. Lökéshullám (1 PSI - Ablakok törnek): ~7846.99 m

5. Ionizáló sugárzás (5 Sv - Halálos): ~4052.43 m

----------

import numpy as np

import matplotlib.pyplot as plt

def nuklearis_modell(hatohato_kt, robbanasi_magassag_m=0):

"""

Atomeffektusok számítása (egyszerűsített skálázási törvények alapján).

hatohato_kt: Robbanóerő kilotonnában

robbanasi_magassag_m: Felszíni robbanás esetén 0

"""

# Hatósugarak számítása (közelítő empirikus képletek)

# Tűzgolyó sugara (km)

tuzgolyo = 0.16 * (hatohato_kt ** 0.38)

# 20 psi (súlyos épületkárok, zóna közepe)

psi_20 = 0.45 * (hatohato_kt ** 0.33)

# 5 psi (közepes épületkárok, légnyomás)

psi_5 = 0.98 * (hatohato_kt ** 0.33)

# 1 psi (ablaküveg törések, könnyű sérülések)

psi_1 = 2.45 * (hatohato_kt ** 0.33)

# Hősugárzás (3. fokozatú égési sérülések)

ho_sugar = 1.0 * (hatohato_kt ** 0.41)

return {

'tuzgolyo': tuzgolyo,

'psi_20': psi_20,

'psi_5': psi_5,

'psi_1': psi_1,

'ho_sugar': ho_sugar

}

def szimulacio_megjelenites(hatohato_kt):

adatok = nuklearis_modell(hatohato_kt)

# Vizuális körök beállítása

sugarak = [

('Tűzgolyó (minden elpárolog)', adatok['tuzgolyo'], 'darkred'),

('20 psi Túlnyomás (pusztító)', adatok['psi_20'], 'red'),

('5 psi Túlnyomás (súlyos kár)', adatok['psi_5'], 'orange'),

('Hősugárzás (3. fokú égés)', adatok['ho_sugar'], 'gold'),

('1 psi Túlnyomás (ablakok törnek)', adatok['psi_1'], 'yellow')

]

fig, ax = plt.subplots(figsize=(8, 8))

ax.set_facecolor('lightgray')

# Körök rajzolása

for nev, sugar, szin in reversed(sugarak):

circle = plt.Circle((0, 0), sugar, color=szin, alpha=0.5, label=f"{nev} ({sugar:.2f} km)")

ax.add_patch(circle)

# Célpont (epicentrum)

ax.plot(0, 0, 'kX', markersize=10, label="Epicentrum (becsapódási pont)")

# Grafikon beállítások

max_sugar = adatok['psi_1'] * 1.2

ax.set_xlim(-max_sugar, max_sugar)

ax.set_ylim(-max_sugar, max_sugar)

ax.set_aspect('equal')

ax.set_title(f"Atomcsapás szimulációja ({hatohato_kt} kt robbanóerő)\n Hatósugarak kilométerben", fontsize=14)

ax.set_xlabel("X távolság (km)")

ax.set_ylabel("Y távolság (km)")

# Jelmagyarázat és rács

ax.legend(loc='upper right', bbox_to_anchor=(1.35, 1))

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

plt.tight_layout()

plt.show()

# --- Szimuláció futtatása ---

# Példa egy tipikus kisebb taktikai atomfegyverre (pl. 15 kilotonna - Hirosima méret)

valasztott_kt = 15

print(f"{valasztott_kt} kilotonnás nukleáris robbanás hatásainak vizualizációja...")

szimulacio_megjelenites(valasztott_kt)

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

15 kilotonnás nukleáris robbanás hatásainak vizualizációja...

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

Könyvek

https://mek.oszk.hu/08400/08435/08435.pdf

https://mtmi.unideb.hu/pluginfile.php/554/mod_resource/content/3/thinkcspy3.pdf

A mohácsi csata sztochasztikus determinisztikus harcászati szimulációja

A mohácsi csata (1526. augusztus 29.) modellezése kiváló példa a sztochasztikus (véletlen faktorokat is tartalmazó) események és a determinisztikus harcászati szabályok kombinálására objektumorientált (OOP) Python programozásban. Az alábbi komplex, mégis átlátható mintakód a csata főbb fázisait (tüzérségi támadás, lovasroham, gyalogsági harc) szimulálja le, figyelembe véve a létszámot, a terepviszonyokat és a véletlenszerű harci eseményeket (morál, taktikai döntések). A szimuláció főbb lépései (OOP megközelítésben):Egység (Unit): Osztály a seregek (magyar és oszmán) csapatainak (gyalogság, lovasság, tüzérség) reprezentálására.Hadsereg (Army): Kezeli az egységeket, összesíti a morált és a létszámot.Csata (Battle): Szimulálja a fázisokat (köröket), ahol a sebzés a létszám, a fegyverzet és a szerencsefaktor alapján kerül kiszámításra. A mohácsi csata taktikai modellezését Pythonban legkönnyebben egy objektumorientált szimulációval (OOP) vagy egy ügynökalapú modellező keretrendszerrel (pl. Mesa) valósíthatjuk meg. Az alábbiakban egy olyan leegyszerűsített, de harcászatilag szemléletes Python-példát mutatok be, amely az alapvető tényezőket (létszám, fegyverzet, terep, morál) veszi alapul.Koncepcionális modell. A harcászati szimuláció az alábbi főbb paramétereket veszi figyelembe:Egységek (Units): Név, létszám, morál, sebzés (tűzerő/közelharc) és védelem.Interakció: A csata körökre (turn) van osztva. Minden körben a szembenálló felek támadást indítanak egymás ellen, figyelembe véve a veszteségeket és a morál csökkenését.A csata legfőbb taktikai elemei – mint a magyar lovasság elsöprő erejű rohama vagy a török janicsárok tűzfegyvereinek hatékonysága és a tüzérség – a megfelelő statisztikai értékekkel modellezhetők .

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

import random

class Egyseg:

def __init__(self, nev, letszam, tamadas_ero, vedelem, tipus):

self.nev = nev

self.letszam = letszam

self.alap_letszam = letszam

self.tamadas_ero = tamadas_ero

self.vedelem = vedelem

self.tipus = tipus # 'gyalogsag', 'lovas', 'tuzerseg'

self.moral = 1.0 # 0.0 és 1.0 között

def tamad(self, celpont):

if self.letszam <= 0:

return 0

# Alapsebzés

sebzes = int(self.letszam * self.tamadas_ero * random.uniform(0.8, 1.2))

# Taktikai módosítók (pl. lovasroham gyalogság ellen)

if self.tipus == 'lovas' and celpont.tipus == 'gyalogsag':

sebzes = int(sebzes * 1.5)

elif self.tipus == 'tuzerseg':

sebzes = int(sebzes * 1.8)

# Védelem és morál levonása

elszivott_sebzes = max(0, sebzes - int(celpont.vedelem * 0.5))

elszivott_sebzes = int(elszivott_sebzes * self.moral)

# Sebzés alkalmazása a célponton

celpont.letszam = max(0, celpont.letszam - elszivott_sebzes)

return elszivott_sebzes

def serules(self, mertek):

self.letszam = max(0, self.letszam - mertek)

# Morál csökkenése a veszteségek arányában

self.moral = max(0.2, self.letszam / self.alap_letszam)

class Hadsereg:

def __init__(self, nev):

self.nev = nev

self.egysegek = []

def hozzaad_egyseg(self, egyseg):

self.egysegek.append(egyseg)

def elo_egysegek(self):

return [e for e in self.egysegek if e.letszam > 0]

def ossz_letszam(self):

return sum(e.letszam for e in self.egysegek)

class MohacsiCsataSzimulacio:

def __init__(self):

# Magyar sereg adatai (becslések alapján)

self.magyarok = Hadsereg("Magyar Királyi Sereg")

self.magyarok.hozzaad_egyseg(Egyseg("Könnyűlovasság", 4000, 1.2, 10, 'lovas'))

self.magyarok.hozzaad_egyseg(Egyseg("Nehézlovasság", 5000, 2.0, 30, 'lovas'))

self.magyarok.hozzaad_egyseg(Egyseg("Gyalogság", 15000, 0.8, 15, 'gyalogsag'))

self.magyarok.hozzaad_egyseg(Egyseg("Tüzérség (Ágyúk)", 85, 3.0, 5, 'tuzerseg'))

# Oszmán sereg adatai (becslések alapján)

self.torokok = Hadsereg("Oszmán Birodalmi Sereg")

self.torokok.hozzaad_egyseg(Egyseg("Akıncı (Könnyűlovasság)", 7000, 1.1, 12, 'lovas'))

self.torokok.hozzaad_egyseg(Egyseg("Szpáhi (Nehézlovasság)", 8000, 2.2, 35, 'lovas'))

self.torokok.hozzaad_egyseg(Egyseg("Janicsárok (Gyalogság)", 12000, 1.6, 25, 'gyalogsag'))

self.torokok.hozzaad_egyseg(Egyseg("Szultáni Gárda és Tüzérség", 8000, 2.5, 40, 'tuzerseg'))

def inditas(self):

print("=== A MOHÁCSI CSATA (1526. augusztus 29.) MODELLEZÉSE ===\n")

# 1. Fázis: Tüzérségi párbaj

print("--- 1. FÁZIS: Tüzérségi tűzváltás ---")

self.csata_faze("Tüzérség")

# 2. Fázis: Lovasrohamok

print("\n--- 2. FÁZIS: Lovasroham és összecsapás ---")

self.csata_faze("lovas")

# 3. Fázis: Általános gyalogsági harc és visszavonulás

print("\n--- 3. FÁZIS: Gyalogsági harc és a csata vége ---")

self.csata_faze("gyalogsag")

# Eredmény hirdetése

self.eredmeny_hirdetes()

def csata_faze(self, fegyvernem_szures):

for m_egyseg in self.magyarok.elo_egysegek():

if fegyvernem_szures == "Tüzérség" and m_egyseg.tipus != "tuzerseg": continue

if fegyvernem_szures == "lovas" and m_egyseg.tipus != "lovas": continue

if fegyvernem_szures == "gyalogsag" and m_egyseg.tipus != "gyalogsag": continue

for t_egyseg in self.torokok.elo_egysegek():

if fegyvernem_szures == "Tüzérség" and t_egyseg.tipus != "tuzerseg": continue

if fegyvernem_szures == "lovas" and t_egyseg.tipus != "lovas": continue

sebzes = m_egyseg.tamad(t_egyseg)

print(f"{m_egyseg.nev} támadja a(z) {t_egyseg.nev} egységet. Oszmán veszteség: {sebzes} fő.")

# Visszacsapás

for t_egyseg in self.torokok.elo_egysegek():

for m_egyseg in self.magyarok.elo_egysegek():

sebzes = t_egyseg.tamad(m_egyseg)

print(f"{t_egyseg.nev} támadja a(z) {m_egyseg.nev} egységet. Magyar veszteség: {sebzes} fő.")

print(f"Állás - Magyarok: {self.magyarok.ossz_letszam()} fő | Oszmánok: {self.torokok.ossz_letszam()} fő")

def eredmeny_hirdetes(self):

print("\n=== CSATA VÉGE ===")

m_maradek = self.magyarok.ossz_letszam()

t_maradek = self.torokok.ossz_letszam()

print(f"Magyar seregek túlélői: {m_maradek} harcos.")

print(f"Oszmán seregek túlélői: {t_maradek} harcos.")

if m_maradek > t_maradek:

print("GYŐZELEM: A magyar sereg nyerte a csatát!")

elif m_maradek < t_maradek:

print("VERESÉG: Az oszmán sereg győzedelmeskedett (történelmi hűség).")

else:

print("Döntetlen! A csatatér vértől ázva elhagyatott.")

# A szimuláció futtatása

if __name__ == "__main__":

szim = MohacsiCsataSzimulacio()

szim.inditas()

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

=== A MOHÁCSI CSATA (1526. augusztus 29.) MODELLEZÉSE ===

--- 1. FÁZIS: Tüzérségi tűzváltás ---

Tüzérség (Ágyúk) támadja a(z) Szultáni Gárda és Tüzérség egységet. Oszmán veszteség: 469 fő.

Akıncı (Könnyűlovasság) támadja a(z) Könnyűlovasság egységet. Magyar veszteség: 8324 fő.

Akıncı (Könnyűlovasság) támadja a(z) Nehézlovasság egységet. Magyar veszteség: 6282 fő.

Akıncı (Könnyűlovasság) támadja a(z) Gyalogság egységet. Magyar veszteség: 10298 fő.

Akıncı (Könnyűlovasság) támadja a(z) Tüzérség (Ágyúk) egységet. Magyar veszteség: 7419 fő.

Szpáhi (Nehézlovasság) támadja a(z) Gyalogság egységet. Magyar veszteség: 22574 fő.

Állás - Magyarok: 0 fő | Oszmánok: 34531 fő

--- 2. FÁZIS: Lovasroham és összecsapás ---

Állás - Magyarok: 0 fő | Oszmánok: 34531 fő

--- 3. FÁZIS: Gyalogsági harc és a csata vége ---

Állás - Magyarok: 0 fő | Oszmánok: 34531 fő

=== CSATA VÉGE ===

Magyar seregek túlélői: 0 harcos.

Oszmán seregek túlélői: 34531 harcos.

VERESÉG: Az oszmán sereg győzedelmeskedett (történelmi hűség).

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

import random

class Hadsereg:

def __init__(self, nev, gyalogsag, lovassag, agyuk):

self.nev = nev

self.gyalogsag = gyalogsag

self.lovassag = lovassag

self.agyuk = agyuk

self.moral = 1.0 # Kezdeti morál

@property

def ossz_ero(self):

return self.gyalogsag + (self.lovassag * 1.5) + (self.agyuk * 10)

def veszteseg(self, szazalek):

self.gyalogsag = int(self.gyalogsag * (1 - szazalek))

self.lovassag = int(self.lovassag * (1 - szazalek))

self.agyuk = int(self.agyuk * (1 - szazalek))

class MohacsiCsataSzimulacio:

def __init__(self):

# Történelmi adatok alapján meghatározott kezdeti létszámok

self.magyarok = Hadsereg("Magyar Királyság", 13000, 13000, 85)

self.torokok = Hadsereg("Oszmán Birodalom", 45000, 20000, 300)

def csata_inditasa(self):

print("--- MOHÁCSI CSATA SZIMULÁCIÓ (1526. AUGUSZTUS 29.) ---")

# 1. FÁZIS: Tomori taktikája - Magyar lovasroham a ruméliai hadtest ellen

self.fzis_1_tamadas()

# 2. FÁZIS: Janicsárok puskatüze és török ellentámadás

self.fzis_2_janicsar_vedelem()

# 3. FÁZIS: Végső felmorzsolódás

self.fzis_3_befejezes()

def fzis_1_tamadas(self):

print("\n[1. Fázis] A magyar hadsereg (Tomori Pál) támadást indít a ruméliai seregek ellen.")

# A magyarok kezdeményeznek, előnyben a lovasság

esely = min(0.85, self.magyarok.ossz_ero / self.torokok.ossz_ero)

if random.random() < esely:

print("-> A magyar lovasroham áttöri a ruméliaiak első vonalát!")

self.torokok.veszteseg(0.15)

else:

print("-> A török védvonalak tartanak.")

def fzis_2_janicsar_vedelem(self):

print("\n[2. Fázis] Az oszmán janicsárok megkezdik a puskatüzet, az anatóliai erők bekerítenek.")

# A török tüzérség és a janicsárok túlereje érvényesül

esely = min(0.9, self.torokok.ossz_ero / self.magyarok.ossz_ero)

if random.random() < esely:

print("-> A janicsárok puskatüze megakasztja a magyar rohamot, a törökök ellentámadásba lendülnek.")

self.magyarok.veszteseg(0.40)

else:

print("-> A magyarok hősiesen tartják pozícióikat.")

def fzis_3_befejezes(self):

print("\n[3. Fázis] A csata lezárása és a menekülés.")

self.magyarok.veszteseg(0.60) # Történelmi megsemmisülés

self.torokok.veszteseg(0.10)

print("\n--- CSATA VÉGE ---")

print(f"Magyar seregek megmaradt harcosai: {self.magyarok.gyalogsag + self.magyarok.lovassag} fő.")

print(f"Oszmán seregek megmaradt harcosai: {self.torokok.gyalogsag + self.torokok.lovassag} fő.")

print("\nEredmény: Döntő oszmán győzelem. Magyarország hadereje megsemmisült, II. Lajos király a Csele-patakba fulladt.")

# A szimulacio futtatasa

szim = MohacsiCsataSzimulacio()

szim.csata_inditasa()

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

--- MOHÁCSI CSATA SZIMULÁCIÓ (1526. AUGUSZTUS 29.) ---

[1. Fázis] A magyar hadsereg (Tomori Pál) támadást indít a ruméliai seregek ellen.

-> A magyar lovasroham áttöri a ruméliaiak első vonalát!

[2. Fázis] Az oszmán janicsárok megkezdik a puskatüzet, az anatóliai erők bekerítenek.

-> A magyarok hősiesen tartják pozícióikat.

[3. Fázis] A csata lezárása és a menekülés.

--- CSATA VÉGE ---

Magyar seregek megmaradt harcosai: 10400 fő.

Oszmán seregek megmaradt harcosai: 49725 fő.

Eredmény: Döntő oszmán győzelem. Magyarország hadereje megsemmisült, II. Lajos király a Csele-patakba fulladt.

-----------

import random

class Egyseg:

def __init__(self, nev, letszam, tamadas, vedelem, moral):

self.nev = nev

self.letszam = letszam

self.alap_letszam = letszam

self.tamadas = tamadas

self.vedelem = vedelem

self.moral = moral

self.allapot = "Harcol"

def tamad(self, celpont):

if self.allapot == "Futás" or self.allapot == "Megsemmisült":

return 0

sebzes = int(self.tamadas * self.letszam * (self.moral / 100))

elszenvedett_sebzes = max(0, sebzes - celpont.vedelem)

celpont.veszit(elszenvedett_sebzes)

return elszenvedett_sebzes

def veszit(self, veszteseg):

if veszteseg > 0:

self.letszam = max(0, self.letszam - veszteseg)

veszteseg_szazalek = (veszteseg / self.alap_letszam) * 100

self.moral = max(10, self.moral - veszteseg_szazalek)

if self.letszam == 0:

self.allapot = "Megsemmisült"

elif self.moral < 30:

self.allapot = "Futás"

@property

def veszteseg(self):

return self.alap_letszam - self.letszam

magyar_tuzerseg = Egyseg("Magyar tüzérség és gyalogság", 4000, tamadas=120, vedelem=20, moral=80)

magyar_lovas = Egyseg("Magyar nehézlovasság", 10000, tamadas=250, vedelem=50, moral=90)

magyar_zaszlok = [magyar_tuzerseg, magyar_lovas]

torok_elcsapat = Egyseg("Török előhad (Ruméliaiak)", 15000, tamadas=100, vedelem=30, moral=70)

torok_janicsar = Egyseg("Janicsárok (Tűzfegyverek)", 12000, tamadas=220, vedelem=40, moral=95)

torok_szuzerseg = Egyseg("Oszmán tüzérség", 3000, tamadas=150, vedelem=10, moral=85)

torok_zaszlok = [torok_elcsapat, torok_janicsar, torok_szuzerseg]

print("--- A mohácsi csata szimulációja indul ---\n")

for kor in range(1, 10):

print(f"--- {kor}. Kör ---")

for mg_egyseg in magyar_zaszlok:

for tr_egyseg in torok_zaszlok:

sebzes = mg_egyseg.tamad(tr_egyseg)

print(f"{mg_egyseg.nev} támadja a következőt: {tr_egyseg.nev}. Okozat: {sebzes} veszteség.")

for tr_egyseg in torok_zaszlok:

for mg_egyseg in magyar_zaszlok:

sebzes = tr_egyseg.tamad(mg_egyseg)

print(f"{tr_egyseg.nev} támadja a következőt: {mg_egyseg.nev}. Okozat: {sebzes} veszteség.")

print("\n--- Állapotok a kör végén ---")

for egyseg in magyar_zaszlok + torok_zaszlok:

print(f"{egyseg.nev} | Létszám: {egyseg.letszam} | Morál: {int(egyseg.moral)} | Státusz: {egyseg.allapot}")

print("\n")

print("--- Szimuláció vége ---")

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

--- A mohácsi csata szimulációja indul ---

--- 1. Kör ---

Magyar tüzérség és gyalogság támadja a következőt: Török előhad (Ruméliaiak). Okozat: 383970 veszteség.

Magyar tüzérség és gyalogság támadja a következőt: Janicsárok (Tűzfegyverek). Okozat: 383960 veszteség.

Magyar tüzérség és gyalogság támadja a következőt: Oszmán tüzérség. Okozat: 383990 veszteség.

Magyar nehézlovasság támadja a következőt: Török előhad (Ruméliaiak). Okozat: 2249970 veszteség.

Magyar nehézlovasság támadja a következőt: Janicsárok (Tűzfegyverek). Okozat: 2249960 veszteség.

Magyar nehézlovasság támadja a következőt: Oszmán tüzérség. Okozat: 2249990 veszteség.

Török előhad (Ruméliaiak) támadja a következőt: Magyar tüzérség és gyalogság. Okozat: 0 veszteség.

Török előhad (Ruméliaiak) támadja a következőt: Magyar nehézlovasság. Okozat: 0 veszteség.

Janicsárok (Tűzfegyverek) támadja a következőt: Magyar tüzérség és gyalogság. Okozat: 0 veszteség.

Janicsárok (Tűzfegyverek) támadja a következőt: Magyar nehézlovasság. Okozat: 0 veszteség.

Oszmán tüzérség támadja a következőt: Magyar tüzérség és gyalogság. Okozat: 0 veszteség.

Oszmán tüzérség támadja a következőt: Magyar nehézlovasság. Okozat: 0 veszteség.

--- Állapotok a kör végén ---

Magyar tüzérség és gyalogság | Létszám: 4000 | Morál: 80 | Státusz: Harcol

Magyar nehézlovasság | Létszám: 10000 | Morál: 90 | Státusz: Harcol

Török előhad (Ruméliaiak) | Létszám: 0 | Morál: 10 | Státusz: Megsemmisült

Janicsárok (Tűzfegyverek) | Létszám: 0 | Morál: 10 | Státusz: Megsemmisült

Oszmán tüzérség | Létszám: 0 | Morál: 10 | Státusz: Megsemmisült

--- 2. Kör ---