3000 éves arámi szövegek

  nyugati, galileai tájszólás ősi sémi nyelv, káldeus   Maalula

madhrashtā, iskola

arc Isten

Yeshūaʕ Jézus

Mene tekel ufarsim

„Eli, Eli, lama sabachtani" אֱלֹהִי אֱלֹהִי לֵמָּה שֲׁבַקתָּנִי 

Adiabenei Párthus Jézus,

Abún d’ basmájá.

Netkádás smák!

Téte melkútáh!

Névé cevianná ajkanná

d’ basmájá af bárá!

Haveán láma

d’ szemkanán javmáná!

Vasbvohlán

havbuáin ajkáná

daf hnan sbvokán

I’ haijabaín!

Velá tahlán

lé ineszíuná.

Elá pacán min bisá.

Metul dilakí malkúta

nahailá

Uatesbétá l’ álám alnún.

Ameyu.

Kozmosz Anyja - Atyja, Te teremtettél mindet,

Ami a Fényben mozog.

Gyújtsd egy pontba fényedet Mibennünk!

Teremtsd most meg Egységed uralmát,

Hogy a Te Egy - Vágyad

A miénkkel cselekedjék,

Miképpen minden fényben, aképpen minden alakban is!

Mindennap add meg nekünk,

Amire szükségünk van,

Kenyérben és szellemi látásban!

Oldd ki hibáink szálait,

Melyek kötve tartanak minket,

Amiként mi is eloldozzuk azokat a kötelékeket, melyekkel másokat tartunk!

Egyesítjük a Mennyet és a Földet.

Teljesítjük igazi célunkat:

Az isteni hatalom és az emberi tenni vágyás szeretetét, amely korról korra megújul.

Hittel és bizalommal megpecsételve,

Egész lényünkkel megerősítjük mindezt.

Ámen

Aboon Dbashmayo – Mi Atyánk, aki a mennyekben vagy.Nethcadash shmokh – Szenteltessék meg a Te neved.Teethe malkoothokh – Jöjjön el a Te országod.Nehwe sebyonokh – Legyen meg a Te akaratod.Hab lan lahmo dsoonconan yawmono – Mindennapi kenyerünket add meg nekünk ma.

Kozmosz Anyja - Atyja, Te teremtettél mindet, Ami a Fényben mozog. Gyújtsd egy pontba fényedet Mibennünk! Teremtsd most meg Egységed uralmát, Hogy a Te Egy - Vágyad A miénkkel cselekedjék, Miképpen minden fényben, aképpen minden alakban is!”„Mindennap add meg nekünk, amire szükségünk van kenyérben és szellemi látásban! Oldd ki hibáink szálait, melyek kötve tartanak minket, amiként mi is eloldozzuk azokat a kötelékeket, melyekkel másokat tartunk!”

„Abba” – Atya, Apuci (egy nagyon bensőséges, gyermeki megszólítás Istenre).„Talitha koum!” – Leányka, kelj fel! (Márk evangéliumából, amellyel Jézus feltámasztotta Jairus leányát).„Eloi, Eloi, lema sabachthani?” – Én Istenem, én Istenem, miért hagytál el engem? (A kereszten mondott híres idézet arámi eredetije).„Maranatha!” – Jöjj el, Urunk! (A korai keresztények arámi nyelvű imádsága).

Abún d basmája.

Netkádás smák!

Téte melkútáh!

Névé cevianná ajkanná

d basmájá af bárá!

Havaán láma

d szemkanán javmáná!

Vasbvohlán

havbuáin ajkáná

daf hnan sbvokán

I haijabain

Velá tahlán

lé"

Bachus pályája

 A távolság kiszámítása a polárkoordinátás Kepler-egyenlet alapján

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

import numpy as np

import matplotlib.pyplot as plt

# A 2063 Bacchus pályaadatai

a = 1.078  # fél nagytengely (CsE)

e = 0.349  # excentricitás

# Valódi anomália (szög) 0-tól 2*pi-ig (teljes pálya)

theta = np.linspace(0, 2 * np.pi, 1000)

# A távolság kiszámítása a polárkoordinátás Kepler-egyenlet alapján

r = (a * (1 - e**2)) / (1 + e * np.cos(theta))

# Polárkoordináták átváltása Descartes-féle (x, y) koordinátákra

x = r * np.cos(theta)

y = r * np.sin(theta)

# Pálya kirajzolása

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

plt.plot(x, y, label='2063 Bacchus pályája', color='orange', linewidth=2)

plt.scatter(0, 0, color='yellow', s=100, label='Nap') # Nap a középpontban

# Pálya speciális pontjainak jelölése

perihelion_x = r[0] * np.cos(theta[0])

perihelion_y = r[0] * np.sin(theta[0])

plt.scatter(perihelion_x, perihelion_y, color='red', label='Perihélium (legközelebbi pont)')

# Tengelyek beállítása és formázás

plt.title('A 2063 Bacchus kisbolygó keringési pályája')

plt.xlabel('X távolság (CsE)')

plt.ylabel('Y távolság (CsE)')

plt.axhline(0, color='gray', linestyle='--', linewidth=0.5)

plt.axvline(0, color='gray', linestyle='--', linewidth=0.5)

plt.legend()

plt.grid(color='gray', linestyle=':', linewidth=0.5)

plt.axis('equal')

plt.show()

----------

Epocha 2009. június 18.

(2455000,5 JD)

Aphélium távolsága 217 654 465 km

(1,455 CsE)[1]

Perihélium távolsága 104 919 906 km

(0,701 CsE)[1]

Fél nagytengely 161 287 186 km

(1,078 CsE)[1]

Pálya excentricitása 0,349[1]

Orbitális periódus 408,893 nap

1,12 év[1]

Közepes anomália 351,522°[1]

Inklináció 9,433°[1]

Felszálló csomó hossza 33,144°[1]

Perihélium szöge 55,267°[1]

--------

A 2063 Bacchus nevű kisbolygó átmérője körülbelül 1 kilométer. Ezzel szemben a Föld átmérője átlagosan 12 742 kilométer. A Bacchus csupán elenyésző töredéke, a Föld átmérőjének megközelítőleg \(\frac{1}{12742}\)-ed része . A 2063 Bacchus nem egy hagyományos bolygó, hanem egy Apollo típusú kisbolygó (aszteroida). Nevét a bor római istenéről kapta.  Az Apollo-családba tartozik többek között a Bennu, az Icarus, valamint a magyar vonatkozású 4483 Petofi is.

Pályaadatai és főbb jellemzői a következők:

Pályatípus: Keresztezi a Föld és a Vénusz pályáját is. Fél nagytengely: 1,078 CsE (kb. 161,2 millió km).Perihélium (a Naphoz legközelebbi pont): 0,701 CsE (kb. 104,9 millió km).Aphélium (a Naptól legtávolabbi pont): 1,455 CsE (kb. 217,6 millió km).Pálya excentricitása: 0,349 (meglehetősen elnyúlt ellipszis pálya).

Pályahajlás (inklináció): 9,43° az ekliptikához képest.Keringési idő: 408,89 nap (kb. 1,12 év).Fizikai méret: Nyújtott formájú égitest, becsült méretei megközelítőleg 1,1 × 2,6 km. Ütközés vele globális katasztrófát okozna. A pusztítás mértéke azonnal letarolna egy kisebb országnyi területet (pl. Magyarországot), az utóhatások pedig évekre megváltoztatnák a Föld klímáját.

Ütközés következménye; Az objektum \(17-20 \text{ km/s}\) sebességgel (kb. \(60 000 \text{ km/h}\)) érkezne a légkörbe. A becsapódás a globális nukleáris arzenál többszörösének megfelelő energiát szabadítana fel (több százezer megatonnányi TNT).Kráter és lökéshullám: Szárazföldi becsapódás esetén egy \(40-60 \text{ km}\) átmérőjű kráter jönne létre, és a becsapódási ponttól számított több száz kilométeres körzetben minden megsemmisülne. A rengések elarnák a 8-9-es magnitúdót, a szuperszonikus lökéshullám pedig egész kontinenseken söpörne végig, ledöntve az épületeket és erdőket.Hősugárzás és tűzviharok: A légkörbe visszahulló izzó törmelék (ejecta) óriási területeken gyújthatna erdőket és városokat.Óceáni becsapódás: Ha vízbe csapódna, az esemény több száz méter magas megacunamikat indítana útjára, amelyek letarolnák a partvidékeket.Globális tél: A sztratoszférába jutó aeroszolok és por hónapokra vagy évekre elsötétítenék az eget. A fotoszintézis leállása és a globális hőmérséklet drasztikus csökkenése miatt összeomlana  flóra és a fauna. Ezért fejlesztenek bolygóvédelmi koncepciókat (például ionnyalábos eltérítést vagy becsapódás-elhárítást) az esetleges veszélyek elkerülésére.

A Naprendszerben jelenleg több mint 2300 a földre potenciálisan veszélyes kisbolygó kering. Ezek mind instabil, kaotikus pályákon mozognak a gravitációs perturbációk miatt. Emellett folyamatos az új objektumok, például a Vénusszal együtt keringő "láthatatlan" aszteroidák felfedezése is.A potenciálisan veszélyes objektumok pontos azonosítására és követésére több globális megfigyelőrendszer is létezik:A pályák ellenőrzéséhez és a lehetséges becslésekhez használd a NASA Center for Near Earth Object Studies (CNEOS) hivatalos adatbázisát.Az aktuális égboltkutatási eredményekért és folyamatos észlelésekért látogass el a Catalina Sky Survey weboldalára.A tudományos konszenzus szerint az elkövetkező évszázadban egyik jelenleg ismert égitest sem jelent közvetlen és valós veszélyt a Földre.  Ezen zavaró erők hatására a pálya alakja (excentricitása), mérete (nagytengelye) és térbeli dőlésszöge is folyamatosan változik.

Veszélyes objektumok

A Föld pályáját több objektum is keresztezi:Kisbolygók és aszteroidák (mint a potenciálisan veszélyes égitestek),Üstökösök melyek törmelékcsóvája miatt hullócsillag-rajok jönnek létre, pl. az Éta Aquaridák vagy a Szigma Hydridák csillagraj,

Ceres

Az alábbi program lekérdezi a Ceres (vagy bármely más aszteroida) oszkuláló pályaelemeit egy megadott dátumra, majd kiíratja a főbb Kepler-féle elemeket és a pillanatnyi térbeli koordinátákat (vektorokat)

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

from astroquery.jplhorizons import Horizons

from astropy.time import Time

import numpy as np

# 1. Az aszteroida azonosítója és a lekérdezni kívánt dátum

# Használhatsz név szerint is azonosítót, pl. 'Ceres', 'Vesta', vagy sorszámot '433' (Eros)

target_asteroid = 'Ceres'

# Add meg a megfigyelés dátumát (UTC időzónában)

observe_date = '2026-06-25 12:00:00'

# A megfigyelés ideje Astropy Time objektummá alakítva

time_jd = Time(observe_date, format='iso', scale='utc')

print(f"Lekérdezés folyamatban: {target_asteroid} ...")

# 2. Kapcsolódás a NASA JPL HORIZONS rendszeréhez

# A 'location' = '@sun' azt jelenti, hogy a heliocentrikus (Nap körüli) pályát számítjuk

obj = Horizons(id=target_asteroid, location='@sun', epochs=time_jd.jd)

# 3. Pályaelemek lekérdezése

# Az 'elements' metódus lekéri a Kepler-elemeket (pályahajlás, excentricitás, stb.)

elements = obj.elements()

print("\n--- Oszkuláló Pályaelemek (Kepler-elemek) ---")

print(f"Fél nagytengely (a): {elements['a'][0]:.4f} AU")

print(f"Excentricitás (e): {elements['e'][0]:.5f}")

print(f"Pályahajlás (i): {elements['incl'][0]:.4f} fok")

print(f"Perihélium argumentuma (w): {elements['w'][0]:.4f} fok")

print(f"Felszálló csomópont hossza (Omega): {elements['Omega'][0]:.4f} fok")

print(f"Közép-anomália (M): {elements['M'][0]:.4f} fok")

# 4. Térbeli helyzet (Állapotvektorok) lekérdezése

# A 'vectors' metódus megadja a x, y, z pozíciót (AU) és sebességet (AU/nap)

vectors = obj.vectors()

pos_x = vectors['x'][0]

pos_y = vectors['y'][0]

pos_z = vectors['z'][0]

print("\n--- Térbeli koordináták (Heliocentrikus ekliptika, ICRS) ---")

print(f"Pozíció X: {pos_x:.6f} AU")

print(f"Pozíció Y: {pos_y:.6f} AU")

print(f"Pozíció Z: {pos_z:.6f} AU")

# Távolság kiszámítása Pitagorasz-tétellel a naptól ($r = \sqrt{x^2 + y^2 + z^2}$)

distance_au = np.sqrt(pos_x**2 + pos_y**2 + pos_z**2)

distance_km = distance_au * 149597870.7  # 1 AU ~ 149 597 870.7 km

print(f"\nTávolság a Naptól: {distance_au:.4f} AU ({distance_km:,.0f} km)")

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

Perihélium (napközel): 2.558 AU

Afélium (naptávol): 2.977 AU

Pályaperiódus: 4.60 year

-----------

Rudloe Manor titkai

A Rudloe Manor (korábbi nevén RAF Rudloe Manor vagy RAF Box) egy történelmi jelentőségű, 17. századi műemlék épület és egykori katonai támaszpont Angliában, Wiltshire megyében, Bath és Corsham között. A helyszín a brit repüléstörténet, a hírszerzés és az ufókutatás egyik legrejtélyesebb központja. A felszín alatt egy hatalmas, megerősített bunkerrendszer található, amelyet úgy terveztek, hogy ellenálljon egy esetleges atomtámadásnak.Az ufó-legenda: A második világháború után a brit kormányzat itt működtette a földönkívüli jelenségekkel és azonosítatlan repülő tárgyakkal kapcsolatos kutatások nem hivatalos központját. A helyi és nemzetközi összeesküvés-elméletek szerint itt tárolhatták azokat az idegen technológiákat vagy dokumentumokat, amelyeket a brit hatóságok gyűjtöttek be. Amerikai megfelelője a roswelli incidens az ufókutatás leghíresebb eseménye, amely 1947 júliusában történt az Egyesült Államokban, Új-Mexikó államban.

A hivatalos álláspont szerint egy meteorológiai ballon zuhant le, a konteók hívei szerint azonban egy földönkívüli űrhajó és annak legénysége ért ott balesetet.A legfontosabb részletek:Időpont: 1947. július eleje.Helyszín: Roswell kisváros, Új-Mexikó, USA.A kezdet: Egy William „Mac” Brazel nevű helyi farmer furcsa törmelékeket talált a birtokán, amiről értesítette a hatóságokat.A katonai bejelentés: A hadsereg kezdetben maga is arról számolt be, hogy egy „repülő csészealj” maradványait gyűjtötték be. Ezt a közleményt gyorsan visszavonták, és kijelentették, hogy csupán egy időjárási szonda (meteorológiai ballon) zuhant le.A rejtély és az elméletekA gyors cáfolat és a szokatlan roncsok (amelyekről a szemtanúk azt állították, hogy különleges, elpusztíthatatlan fémből voltak) táptalajt adtak az összeesküvés-elméleteknek. Az ufóhívők körében elterjedt narratíva szerint:Nem időjárási ballon csapódott be, hanem egy idegen űrhajó.A katonaság titokban földönkívüliek holttesteit (ún. „Szürkéket”) gyűjtötte be, és azokat az azóta elhíresült 51-es körzetbe szállította.Hivatalos vizsgálatokAz amerikai kormány az évtizedek során több alkalommal is vizsgálta az ügyet, hogy eloszlassa a pletykákat:1994: A hadsereg kiadott egy jelentést, amely szerint a roncsok a Mogul projekt részét képezték.

Ez egy szigorúan titkos amerikai katonai projekt volt, amelynek keretében magaslati léggömbökkel a szovjet atomkísérleteket figyelték.1997: Egy újabb jelentésben tisztázták, hogy a földönkívüliekről szóló történetek valószínűleg a korabeli, magasból végzett ejtőernyős tesztekből és katonai dummy (bábu) kísérletekből erednek.

https://www.war.gov/ufo/

Járvány modellezése

   Egy járvány terjedését (vagy más néven exponenciális katasztrófát) szimulálja. A fertőzés egy egyszerű matematikai modellen (SIR) alapul, amely a fogékony (S), fertőzött (R) és gyógyult/elhunyt (I) csoportokat mutatja be.

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

import numpy as np

import matplotlib.pyplot as plt

# Modell paraméterei

N = 1000            # Teljes népesség

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

R0 = 0              # Kezdő gyógyultak száma

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

beta = 0.2          # Fertőzési ráta

gamma = 0.05        # Gyógyulási ráta

days = 160          # Szimulációs napok

# Tömbök inicializálása

t = np.linspace(0, days, days)

S, I, R = np.zeros(days), np.zeros(days), np.zeros(days)

S[0], I[0], R[0] = S0, I0, R0

# Differenciálegyenlet szimuláció (Euler-módszer)

for i in range(1, days):

    dS = -(beta * S[i-1] * I[i-1] / N)

    dI = (beta * S[i-1] * I[i-1] / N) - (gamma * I[i-1])

    dR = gamma * I[i-1]

    

    S[i] = S[i-1] + dS

    I[i] = I[i-1] + dI

    R[i] = R[i-1] + dR

print("A járványterjedési modell lefutott.")

print(f"Maximális fertőzöttség: {int(np.max(I))} fő")

print(f"Végső állapot: S={int(S[-1])}, I={int(I[-1])}, R={int(R[-1])}")

# Eredmények ábrázolása

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

plt.plot(t, S, label='Fogékony (S)', color='blue', linewidth=2)

plt.plot(t, I, label='Fertőzött (I)', color='red', linewidth=2)

plt.plot(t, R, label='Gyógyult/Kiesett (R)', color='green', linewidth=2)

plt.title('Katasztrófa (Járvány) terjedési modellje')

plt.xlabel('Idő (Napok)')

plt.ylabel('Lakosság száma')

plt.legend()

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

plt.tight_layout()

plt.show()

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

A járványterjedési modell lefutott.

Maximális fertőzöttség: 413 fő

Végső állapot: S=18, I=5, R=976

Lottósorsolás szimulálása

Skandináv

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

import random

def skandinav_lotto_sorsolas():

    # 1-től 35-ig terjedő skála, amelyből húzunk

    szamok = list(range(1, 36))

    

    # 7 darab véletlenszerű szám kiválasztása ismétlődés nélkül

    nyeroszamok = random.sample(szamok, 7)

    

    # A számok sorba rendezése az átláthatóság érdekében

    nyeroszamok.sort()

    

    return nyeroszamok

# A szimuláció futtatása és eredmény kiírása

huzott_szamok = skandinav_lotto_sorsolas()

print(f"A skandináv lottó sorsolás nyerőszámai: {huzott_szamok}")

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

A skandináv lottó sorsolás nyerőszámai: [4, 16, 19, 21, 22, 26, 34]

Lineáris regresszió

Ez a program megtanulja a bemeneti adatok (X) és a kimeneti értékek (y) közötti összefüggést, majd megbecsüli egy új adat értékét.

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

import numpy as np

from sklearn.linear_model import LinearRegression

# 1. Adatok előkészítése (Tanító adathalmaz)

# Tegyük fel, hogy a méret (nm) és az ár (millió Ft) közötti összefüggést modellezzük

X = np.array([[50], [60], [70], [80], [90]])   # Alapterület

y = np.array([25, 30, 38, 45, 52])            # Árak

# 2. A modell létrehozása és tanítása

modell = LinearRegression()

modell.fit(X, y)

# 3. Modell paraméterei

print(f"Együttható (meredekség): {modell.coef_[0]:.2f}")

print(f"Tengelymetszet: {modell.intercept_:.2f}")

# 4. Becslés (Predikció)

# Becsüljük meg egy 85 nm-es lakás árát

uj_adat = np.array([[85]])

becsult_ar = modell.predict(uj_adat)

print(f"A(z) {uj_adat[0][0]} nm-es lakás becsült ára: {becsult_ar[0]:.2f} millió Ft")

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

Együttható (meredekség): 0.69

Tengelymetszet: -10.30

A(z) 85 nm-es lakás becsült ára: 48.35 millió Ft

Tudományos kísérlet PI becslésére pythonban

Kísérlet PI értékének meghatározására

----------

import random

import matplotlib.pyplot as plt

def monte_carlo_pi(osszes_pont):

    belso_pont = 0

    x_kint, y_kint = [], []

    x_bent, y_bent = [], []

    for _ in range(osszes_pont):

        # Véletlen koordináták a [-1, 1] intervallumon

        x = random.uniform(-1, 1)

        y = random.uniform(-1, 1)

        

        # Pitagorasz-tétel: x^2 + y^2 <= r^2 (esetünkben 1^2)

        if x**2 + y**2 <= 1.0:

            belso_pont += 1

            x_bent.append(x)

            y_bent.append(y)

        else:

            x_kint.append(x)

            y_kint.append(y)

    # Pi becslése a képlet alapján

    pi_becsles = 4 * belso_pont / osszes_pont

    return pi_becsles, x_kint, y_kint, x_bent, y_bent

# A kísérlet paraméterei

kiserletek_szama = 5000

# Futtatás

becsult_pi, x_out, y_out, x_in, y_in = monte_carlo_pi(kiserletek_szama)

print(f"Generált pontok száma: {kiserletek_szama}")

print(f"A Pi becsült értéke: {becsult_pi}")

print(f"Eltérés a valódi értéktől: {abs(becsult_pi - 3.14159265359):.5f}")

# Grafikon megjelenítése a kísérlet vizualizálásához

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

plt.scatter(x_out, y_out, color='red', s=1, label='Négyzeten belül, körön kívül')

plt.scatter(x_in, y_in, color='blue', s=1, label='Körön belül')

plt.title(f"Monte Carlo Pi szimuláció (Becsült Pi: {becsult_pi})")

plt.xlabel("X koordináta")

plt.ylabel("Y koordináta")

plt.legend(loc='lower right')

plt.axis('equal')

plt.show()

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

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

Generált pontok száma: 5000

A Pi becsült értéke: 3.168

Eltérés a valódi értéktől: 0.02479

Szimulált hipotézis pythonban

Szimulált hipotézis pythonban

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

import numpy as np

import pandas as pd

import scipy.stats as stats

import matplotlib.pyplot as plt

# 1. Adatgenerálás: Szimulált kísérleti adatok (pl. kontroll és kezelt csoport)

np.random.seed(42)

csoport_kontroll = np.random.normal(loc=100, scale=15, size=50) # Átlag=100, Szórás=15

csoport_kezelt = np.random.normal(loc=115, scale=12, size=50)   # Átlag=115, Szórás=12

# 2. Adatrendszerezés (Pandas DataFrame)

df = pd.DataFrame({

    'Csoport': ['Kontroll'] * 50 + ['Kezelt'] * 50,

    'Eredmeny': np.concatenate([csoport_kontroll, csoport_kezelt])

})

# 3. Statisztikai Elemzés: Kétmintás t-próba

stat, p_ertek = stats.ttest_ind(csoport_kontroll, csoport_kezelt)

print(f"Statisztikai próba eredménye: t = {stat:.4f}, p-érték = {p_ertek:.4e}")

if p_ertek < 0.05:

    print("Következtetés: A különbség statisztikailag szignifikáns (elutasítjuk a nullhipotézist).")

else:

    print("Következtetés: Nincs szignifikáns különbség a csoportok között.")

# 4. Vizualizáció: Boxplot éshisztogram

fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 5))

# Boxplot

df.boxplot(column='Eredmeny', by='Csoport', ax=ax1)

ax1.set_title('Csoportok összehasonlítása (Boxplot)')

ax1.set_ylabel('Értékek')

# Hisztogramok

ax2.hist(csoport_kontroll, bins=10, alpha=0.6, label='Kontroll', color='blue')

ax2.hist(csoport_kezelt, bins=10, alpha=0.6, label='Kezelt', color='orange')

ax2.set_title('Eloszlások')

ax2.set_xlabel('Eredmények')

ax2.set_ylabel('Gyakoriság')

ax2.legend()

plt.tight_layout()

plt.show()

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

Statisztikai próba eredménye: t = -7.5141, p-érték = 2.7192e-11

Következtetés: A különbség statisztikailag szignifikáns (elutasítjuk a nullhipotézist).

Angol nyelv oktató program python nyelven

Angol nyelv oktató program

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

import random

# Szótár: Angol kifejezések és a magyar jelentéseik

szotar = {

    "apple": "alma",

    "book": "könyv",

    "cat": "macska",

    "dog": "kutya",

    "sun": "nap",

    "house": "ház",

    "water": "víz",

    "car": "autó",

    "tree": "fa",

    "computer": "számítógép"

}

def angol_tanito():

    print("Üdvözöllek az Angol Tanító Programban!")

    print("Írd be a magyar jelentést, ha megadom az angol szót. (A kilépéshez írd be: 'kilepes')\n")

    

    szavak = list(szotar.items())

    random.shuffle(szavak)  # Keverjük a szavakat a változatos tanulásért

    

    jo_valaszok = 0

    osszes_kerdes = len(szavak)

    

    for angol, magyar in szavak:

        valasz = input(f"Mi a magyar jelentése ennek: '{angol}'? ").strip().lower()

        

        if valasz == "kilepes":

            print("\nKilépés a gyakorlásból.")

            break

        

        if valasz == magyar:

            print("Helyes! 🎉")

            jo_valaszok += 1

        else:

            print(f"Helytelen. A helyes válasz: '{magyar}'.")

            

    # Eredmény kiértékelése

    print("\n--- Gyakorlás vége ---")

    print(f"Eredményed: {jo_valaszok} / {osszes_kerdes} helyes válasz.")

    if osszes_kerdes > 0:

        szazalek = (jo_valaszok / osszes_kerdes) * 100

        print(f"Sikerességi arány: {szazalek:.1f}%")

if __name__ == "__main__":

    angol_tanito()

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

Üdvözöllek az Angol Tanító Programban!

Írd be a magyar jelentést, ha megadom az angol szót. (A kilépéshez írd be: 'kilepes')

Mi a magyar jelentése ennek: 'sun'? nap

Helyes! 🎉

Mi a magyar jelentése ennek: 'apple'? alma

Helyes! 🎉

Mi a magyar jelentése ennek: 'cat'? macska

Helyes! 🎉

Mi a magyar jelentése ennek: 'book'? könyv

Helyes! 🎉

Mi a magyar jelentése ennek: 'house'? ház

Helyes! 🎉

Mi a magyar jelentése ennek: 'dog'? kutya

Helyes! 🎉

Mi a magyar jelentése ennek: 'tree'? ▌

Ready

Programozás tanítás

Programozás tanítás

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

import time

def bevezetes():

    print("=" * 50)

    print("ÜDVÖZÖLJÜK A PYTHON OKTATÓPROGRAMBAN!")

    print("=" * 50)

    time.sleep(1)

    print("\nA Python egy népszerű, könnyen tanulható programozási nyelv.\n")

def valtozo_lecke():

    print("\n--- 1. LECKE: Változók és adattípusok ---")

    print("A változók olyanok, mint a dobozok: adatokat tárolunk bennük.")

    print("Például: nev = 'Anna' (szöveg) vagy kor = 25 (szám)")

    

    valasz = input("\nHány éves az a Python nevű 'doboz', amiben a 10-es számot tároljuk? ")

    if valasz == "10":

        print("Helyes! A változó pontosan azt az értéket tárolja, amit belehelyeztünk.")

    else:

        print("Nem talált. A válasz 10, mivel a tárolt érték maga a szám.")

def ciklus_lecke():

    print("\n--- 2. LECKE: Ciklusok ---")

    print("A ciklusok arra valók, hogy utasításokat ismételjünk meg újra és újra.")

    print("A 'for ciklus' végigmegy egy listán vagy számsorozaton.")

    print("\nNézzük meg a gyakorlatban! Írd be a következőt:")

    print("for i in range(3):")

    print("    print('Ciklus')")

    

    input("\nNyomj Entert, hogy lásd mi történik, ha ezt lefuttatjuk...")

    for i in range(3):

        print(f"Ciklus {i+1}")

    print("A ciklus 3-szor futott le, mivel a range(3) 0-tól 2-ig számol.")

def fuggveny_lecke():

    print("\n--- 3. LECKE: Függvények ---")

    print("A függvények olyanok, mint a kis miniprogramok: egy adott feladatot végeznek el.")

    print("A 'def' kulcsszóval hozzuk létre őket, például: def koszones():")

    print("\nÍrj be egy sajátot, ami kiírja, hogy 'Szia!'")

    print("Hogyan definiálnád a függvényt? (Csak az első sort írd!)")

    

    helyes_valaszok = ["def koszones():", "def koszones( ):"]

    valasz = input("Írd be a kódot: ")

    

    if valasz in helyes_valaszok:

        print("Gratulálok! Ez a helyes szintaxis.")

    else:

        print("Majdnem! Ügyelj a zárójelekre és a kettőspontra a végén: def koszones():")

def fo_program():

    bevezetes()

    valtozo_lecke()

    time.sleep(1)

    ciklus_lecke()

    time.sleep(1)

    fuggveny_lecke()

    

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

    print("Gratulálunk! Sikeresen teljesítetted az alapozó tanfolyamot!")

    print("=" * 50)

if __name__ == "__main__":

    fo_program()

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

==================================================

ÜDVÖZÖLJÜK A PYTHON OKTATÓPROGRAMBAN!

==================================================

A Python egy népszerű, könnyen tanulható programozási nyelv.

--- 1. LECKE: Változók és adattípusok ---

A változók olyanok, mint a dobozok: adatokat tárolunk bennük.

Például: nev = 'Anna' (szöveg) vagy kor = 25 (szám)

Valutaváltó

Íme egy egyszerű és hatékony Python program, amellyel valós idejű árfolyamok alapján válthatsz valutát. 

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

import requests

def valuta_valto():

    print("--- Egyszerű Valutaváltó ---")

    

    # Felhasználói bemenet kérése

    try:

        osszeg = float(input("Add meg az átváltani kívánt összeget: "))

    except ValueError:

        print("Érvénytelen összeg! Kérlek, számot adj meg.")

        return

    forras = input("Milyen valutából szeretnél váltani? (pl. USD, EUR, HUF): ").upper()

    cel = input("Milyen valutára szeretnél váltani? (pl. EUR, HUF, USD): ").upper()

    # API hívás az aktuális árfolyamok lekéréséhez

    url = f"https://frankfurter.dev{osszeg}&from={forras}&to={cel}"

    

    try:

        valasz = requests.get(url)

        adat = valasz.json()

        

        # Ellenőrizzük, hogy sikeres volt-e a válasz és létezik-e a célvaluta

        if valasz.status_code == 200 and cel in adat['rates']:

            atvaltott_osszeg = adat['rates'][cel]

            print(f"\nEredmény: {osszeg} {forras} = {atvaltott_osszeg:.2f} {cel}")

        else:

            print("Hiba: Érvénytelen valutakód, vagy az átváltás nem lehetséges.")

            

    except Exception as e:

        print(f"Hiba történt a kapcsolat során: {e}")

if __name__ == "__main__":

    valuta_valto()

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

--- Egyszerű Valutaváltó ---

10000.00 HUF = 27.78 USD

Ház költségvetés Készítő Program

Az alábbi Python program segítségével könnyedén kiszámolhatod egy 10 × 10 méteres (100 négyzetméteres) alapterületű ház építési költségvetését. A program bekéri az egységárakat, majd tételesen felsorolja az anyag-, munka- és egyéb költségeket, végül pedig összegzi azokat.

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

def koltsegvetes_szamitas():

    # Alapadatok (10x10 méteres ház, 100 m2 alapterület)

    alapterulet = 100  # m2

    

    print("--- 10x10-es Ház Építési Költségvetés ---")

    

    # Felhasználói bemenetek bekérése egységárakra

    try:

        ar_alap = float(input("Kérjük, adja meg az alapozás m2 árát (Ft): "))

        ar_fal = float(input("Kérjük, adja meg a falazat m2 árát (Ft): "))

        ar_teto = float(input("Kérjük, adja meg a tetőszerkezet m2 árát (Ft): "))

        ar_burkolat = float(input("Kérjük, adja meg a burkolás m2 árát (Ft): "))

        ar_gepeszet = float(input("Kérjük, adja meg a gépészet m2 árát (Ft): "))

        egyeb_koltseg = float(input("Kérjük, adja meg az egyéb (engedélyek, tervek) fix költségét (Ft): "))

    except ValueError:

        print("Hibás adat! Kérjük, számokat adjon meg.")

        return

    # Költségek számítása

    k_alap = alapterulet * ar_alap

    k_fal = alapterulet * ar_fal

    k_teto = alapterulet * ar_teto

    k_burkolat = alapterulet * ar_burkolat

    k_gepeszet = alapterulet * ar_gepeszet

    

    # Összesítés

    anyag_es_munka = k_alap + k_fal + k_teto + k_burkolat + k_gepeszet

    brutto_koltseg = anyag_es_munka + egyeb_koltseg

    # Eredmények kiírása

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

    print("KÖLTSÉGVETÉS ÖSSZESÍTŐ")

    print("="*40)

    print(f"Alapterület: {alapterulet} m2")

    print("-" * 40)

    print(f"Alapozás költsége:       {k_alap:,.0f} Ft".replace(',', ' '))

    print(f"Falazat költsége:        {k_fal:,.0f} Ft".replace(',', ' '))

    print(f"Tetőszerkezet költsége:  {k_teto:,.0f} Ft".replace(',', ' '))

    print(f"Burkolás költsége:       {k_burkolat:,.0f} Ft".replace(',', ' '))

    print(f"Gépészet költsége:       {k_gepeszet:,.0f} Ft".replace(',', ' '))

    print("-" * 40)

    print(f"Egyéb költségek:         {egyeb_koltseg:,.0f} Ft".replace(',', ' '))

    print("="*40)

    print(f"TELJES KÖLTSÉG:          {brutto_koltseg:,.0f} Ft".replace(',', ' '))

    print("="*40)

# Program futtatása

koltsegvetes_szamitas()

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

--- 10x10-es Ház Építési Költségvetés ---

Kérjük, adja meg az alapozás m2 árát (Ft): 20000

Kérjük, adja meg a falazat m2 árát (Ft): 30000

Kérjük, adja meg a tetőszerkezet m2 árát (Ft): 12000

Kérjük, adja meg a burkolás m2 árát (Ft): 3000

Kérjük, adja meg a gépészet m2 árát (Ft): 4000

Kérjük, adja meg az egyéb (engedélyek, tervek) fix költségét (Ft): 800000

========================================

KÖLTSÉGVETÉS ÖSSZESÍTŐ

========================================

Alapterület: 100 m2

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

Alapozás költsége:       2 000 000 Ft

Falazat költsége:        3 000 000 Ft

Tetőszerkezet költsége:  1 200 000 Ft

Burkolás költsége:       300 000 Ft

Gépészet költsége:       400 000 Ft

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

Egyéb költségek:         800 000 Ft

========================================

TELJES KÖLTSÉG:          7 700 000 Ft

========================================

Ready

Burkolás anyagköltség

Előzetes kalkuláció

-----------

# Helyiségek adatainak tárolása (szélesség, hosszúság méterben)

helyisegek = {

    "Nappali": {"szelesseg": 5.0, "hosszusag": 6.0, "burkolat": "parketta"},

    "Hálószoba": {"szelesseg": 4.0, "hosszusag": 4.0, "burkolat": "parketta"},

    "Konyha": {"szelesseg": 3.0, "hosszusag": 4.0, "burkolat": "csempe"},

    "Fürdőszoba": {"szelesseg": 2.5, "hosszusag": 2.0, "burkolat": "csempe"},

    "Előszoba": {"szelesseg": 1.5, "hosszusag": 3.0, "burkolat": "csempe"}

}

teljes_terulet = 0

anyag_szukseglet = {}

print("--- HELYISÉGEK LISTÁJA ÉS ALAPTERÜLETE ---")

for nev, adatok in helyisegek.items():

    terulet = adatok["szelesseg"] * adatok["hosszusag"]

    teljes_terulet += terulet

    print(f"{nev}: {terulet} m² ({adatok['burkolat']})")

    

    # Anyagigény számítás (pl. + 10% vágási veszteség)

    szukseges_anyag = terulet * 1.1 

    

    if adatok["burkolat"] not in anyag_szukseglet:

        anyag_szukseglet[adatok["burkolat"]] = 0

    anyag_szukseglet[adatok["burkolat"]] += szukseges_anyag

print("\n--- ÖSSZESÍTŐ KIMUTATÁS ---")

print(f"A lakás teljes alapterülete: {teljes_terulet} m²")

print("\n--- ANYAGSZÜKSÉGLET (10% ráhagyással) ---")

for anyag, mennyiseg in anyag_szukseglet.items():

    print(f"{anyag.capitalize()}: {mennyiseg:.2f} m²")

.....................

--- HELYISÉGEK LISTÁJA ÉS ALAPTERÜLETE ---

Nappali: 30.0 m² (parketta)

Hálószoba: 16.0 m² (parketta)

Konyha: 12.0 m² (csempe)

Fürdőszoba: 5.0 m² (csempe)

Előszoba: 4.5 m² (csempe)

--- ÖSSZESÍTŐ KIMUTATÁS ---

A lakás teljes alapterülete: 67.5 m²

--- ANYAGSZÜKSÉGLET (10% ráhagyással) ---

Parketta: 50.60 m²

Csempe: 23.65 m²

Mérnökinformatikai Rendszer Tervezése és Implementációja

Egy projekt tervezése

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

class Feladat:

    def __init__(self, nev, becsult_ora, kesz_szazalek=0):

        self.nev = nev

        self.becsult_ora = becsult_ora

        self.kesz_szazalek = kesz_szazalek

    def allapot_frissites(self, uj_szazalek):

        self.kesz_szazalek = max(0, min(100, uj_szazalek))

    def __str__(self):

        return f"{self.nev:<30} | Becsült idő: {self.becsult_ora} óra | Készültség: {self.kesz_szazalek}%"

class ProjektTerv:

    def __init__(self, projekt_nev):

        self.projekt_nev = projekt_nev

        self.feladatok = []

    def feladat_hozzaadas(self, feladat):

        self.feladatok.append(feladat)

        print(f"Hozzáadva: {feladat.nev}")

    def ossz_munkaora(self):

        return sum(f.becsult_ora for f in self.feladatok)

    def projekt_keszultseg(self):

        if not self.feladatok:

            return 0.0

        osszegzett_suly = sum(f.becsult_ora for f in self.feladatok)

        if osszegzett_suly == 0:

            return 0.0

        aktualis_munka = sum(f.becsult_ora * (f.kesz_szazalek / 100) for f in self.feladatok)

        return (aktualis_munka / osszegzett_suly) * 100

    def jelentes(self):

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

        print(f" PROJEKT TERV: {self.projekt_nev.upper()}")

        print("="*50)

        for feladat in self.feladatok:

            print(feladat)

        print("-"*50)

        print(f"Összes becsült idő: {self.ossz_munkaora()} óra")

        print(f"Projekt teljes készültsége: {self.projekt_keszultseg():.2f}%")

        print("="*50)

# --- Példa a használatra ---

if __name__ == "__main__":

    # Mérnökinformatikai projekt terv inicializálása

    mernok_projekt = ProjektTerv("Mérnökinformatikai Rendszer Tervezése és Implementációja")

    # Fázisok és mérföldkövek felvétele (név, becsült óraszám, készültség)

    mernok_projekt.feladat_hozzaadas(Feladat("Követelményanalízis és specifikáció", 20, 100))

    mernok_projekt.feladat_hozzaadas(Feladat("Adatbázis és architektúra tervezés", 35, 80))

    mernok_projekt.feladat_hozzaadas(Feladat("Backend és API fejlesztés", 60, 45))

    mernok_projekt.feladat_hozzaadas(Feladat("Frontend implementáció", 40, 10))

    mernok_projekt.feladat_hozzaadas(Feladat("Tesztelés és dokumentáció", 25, 0))

    # Állapot frissítése pl. haladás miatt

    mernok_projekt.feladatok[2].allapot_frissites(60) # Backend fejlesztés most 60%-on áll

    # Projekt státusz lekérdezése

    mernok_projekt.jelentes()

................................

Hozzáadva: Követelményanalízis és specifikáció

Hozzáadva: Adatbázis és architektúra tervezés

Hozzáadva: Backend és API fejlesztés

Hozzáadva: Frontend implementáció

Hozzáadva: Tesztelés és dokumentáció

==================================================

 PROJEKT TERV: MÉRNÖKINFORMATIKAI RENDSZER TERVEZÉSE ÉS IMPLEMENTÁCIÓJA

==================================================

Követelményanalízis és specifikáció | Becsült idő: 20 óra | Készültség: 100%

Adatbázis és architektúra tervezés | Becsült idő: 35 óra | Készültség: 80%

Backend és API fejlesztés      | Becsült idő: 60 óra | Készültség: 60%

Frontend implementáció         | Becsült idő: 40 óra | Készültség: 10%

Tesztelés és dokumentáció      | Becsült idő: 25 óra | Készültség: 0%

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

Összes becsült idő: 180 óra

Projekt teljes készültsége: 48.89%

==================================================

Ready

Vegyészetben elemzés

Kiszámolja az oldat koncentrációját 

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

import math

class KemiaiOldat:

    """Kémiai oldatokat reprezentáló osztály mérnöki számításokhoz."""

    

    def __init__(self, anyagmennyiseg_mol: float, terfogat_liter: float, savas_e: bool = True):

        self.mol = anyagmennyiseg_mol

        self.liter = terfogat_liter

        self.savas_e = savas_e

        

    def molaritas(self) -> float:

        """Kiszámolja az oldat koncentrációját (mol/dm^3)."""

        if self.liter <= 0:

            raise ValueError("A térfogatnak nagyobbnak kell lennie 0-nál!")

        return self.mol / self.liter

        

    def pH_ertek(self) -> float:

        """Becsült pH érték számítása erős savakra vagy bázisokra."""

        c = self.molaritas()

        if c <= 0:

            return 0.0

        

        # pH = -log10(c) erős sav esetén, pOH erős bázisnál

        ertek = -math.log10(c)

        

        if self.savas_e:

            return ertek

        else:

            return 14.0 - ertek

# Példa az objektum használatára:

# Készítsünk egy 0.1 mol/dm^3-es sósav (savas) oldatot

sosav = KemiaiOldat(anyagmennyiseg_mol=0.1, terfogat_liter=1.0, savas_e=True)

print(f"Koncentráció: {sosav.molaritas():.3f} mol/l")

print(f"Becsült pH: {sosav.pH_ertek():.2f}")

...............

Koncentráció: 0.100 mol/l

Becsült pH: 1.00

Villanyszerelés pythonnal

Számoltssuk ki a soros eredő ellenállás, a párhuzamos eredő ellenállást és a teljesítményt soros kapcsolásnál.

-----------

class AramkorKalkulator:

    def __init__(self, feszultseg: float):

        self.feszultseg = feszultseg

    def soros_eredo(self, ellenallasok: list[float]) -> float:

        """Kiszámolja a sorosan kapcsolt ellenállások eredőjét."""

        return sum(ellenallasok)

    def párhuzamos_eredo(self, ellenallasok: list[float]) -> float:

        """Kiszámolja a párhuzamosan kapcsolt ellenállások eredőjét."""

        if any(r == 0 for r in ellenallasok):

            raise ValueError("Az ellenállás értéke nem lehet nulla párhuzamos kapcsolásnál!")

        reciprocal_sum = sum(1 / r for r in ellenallasok)

        return 1 / reciprocal_sum

    def teljesitmeny(self, ered_ellenallas: float) -> float:

        """Kiszámolja a teljesítményt Watt-ban P = U^2 / R alapján."""

        if ered_ellenallas == 0:

            raise ValueError("Az ellenállás nem lehet nulla!")

        return (self.feszultseg ** 2) / ered_ellenallas

if __name__ == "__main__":

    try:

        U = 12.0

        ellenallas_lista = [100.0, 220.0, 470.0]

        kalkulator = AramkorKalkulator(U)

        soros_R = kalkulator.soros_eredo(ellenallas_lista)

        parhuzamos_R = kalkulator.párhuzamos_eredo(ellenallas_lista)

        teljesitmeny_soros = kalkulator.teljesitmeny(soros_R)

        print(f"Soros eredő ellenállás: {soros_R:.2f} Ohm")

        print(f"Párhuzamos eredő ellenállás: {parhuzamos_R:.2f} Ohm")

        print(f"Teljesítmény soros kapcsolásnál: {teljesitmeny_soros:.4f} W")

    except ValueError as e:

        print(f"Hiba történt a számítás során: {e}")

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

Soros eredő ellenállás: 790.00 Ohm

Párhuzamos eredő ellenállás: 59.98 Ohm

Teljesítmény soros kapcsolásnál: 0.1823 W

Atomreaktor szimuláció

 Egy reaktor-kinetikai modellt (PRKE) valósít meg, a maghasadás láncreakciójának időbeli alakulását, a hőmérséklet-visszacsatolást és a szabályzórudak hatását modellezi.

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

import numpy as np

import matplotlib.pyplot as plt

# 1. Állandók és kezdeti paraméterek

k_eff = 1.05              # Hatásos szorzási tényező (kissé szuperkritikus)

beta = 0.0065             # Késleltetett neutronok hányada (urán üzemanyag)

lambda_n = 0.08           # Késleltetett neutronok bomlási állandója (1/s)

Prompt_gen = 0.00001      # Neutron generációs idő (s)

c_initial = beta / Prompt_gen  # Kezdeti késleltetett neutron prekurzor koncentráció

P_0 = 100.0               # Kezdeti termikus teljesítmény (MW)

# Hőmérsékleti visszacsatolási együttható és hűtési paraméter

alpha_temp = -0.002       # Reaktivitási hőmérsékleti együttható (1/K)

T_0 = 300.0               # Hűtőközeg kezdeti hőmérséklete (K)

heat_capacity = 0.5       # Hőkapacitás paraméter

cooling_rate = 0.1        # Hűtési ráta

# 2. Időbeli paraméterek

t_start = 0.0

t_end = 60.0

dt = 0.1

time_steps = int((t_end - t_start) / dt)

# Adattárolók a vizualizációhoz

time_array = np.zeros(time_steps)

power_array = np.zeros(time_steps)

temp_array = np.zeros(time_steps)

# Kezdeti értékek beállítása

P = P_0

C = c_initial

T = T_0

# 3. Szimulációs ciklus (Euler-módszer)

for i in range(time_steps):

    time_array[i] = t_start + i * dt

    power_array[i] = P

    temp_array[i] = T

    rho = (k_eff - 1.0) / k_eff

    rho_total = rho + alpha_temp * (T - T_0)

    dPdt = ((rho_total - beta) / Prompt_gen) * P + lambda_n * C

    dCdt = (beta / Prompt_gen) * P - lambda_n * C

    dTdt = heat_capacity * P - cooling_rate * (T - T_0)

    P += dPdt * dt

    C += dCdt * dt

    T += dTdt * dt

# 4. Eredmény kiírása

print("Szimuláció végeredménye:")

print(f"Végső teljesítmény: {P:.3f} MW")

print(f"Végső hőmérséklet: {T:.3f} K")

print(f"Végső prekurzor koncentráció: {C:.3f}")

print(f"Maximális teljesítmény: {np.max(power_array):.3f} MW")

print(f"Maximális hőmérséklet: {np.max(temp_array):.3f} K")

# 5. Vizualizáció

fig, ax1 = plt.subplots(figsize=(10, 6))

color = 'tab:red'

ax1.set_xlabel('Idő (s)')

ax1.set_ylabel('Reaktor Teljesítmény (MW)', color=color)

ax1.plot(time_array, power_array, color=color, linewidth=2)

ax1.tick_params(axis='y', labelcolor=color)

ax2 = ax1.twinx()

color = 'tab:blue'

ax2.set_ylabel('Hűtőközeg Hőmérséklet (K)', color=color)

ax2.plot(time_array, temp_array, color=color, linestyle='--', linewidth=2)

ax2.tick_params(axis='y', labelcolor=color)

plt.title('Atomreaktor tranziens szimuláció (Teljesítmény és Hőmérséklet)')

fig.tight_layout()

plt.grid(True)

plt.show()

......................

Szimuláció végeredménye:

Végső teljesítmény: nan MW

Végső hőmérséklet: nan K

Végső prekurzor koncentráció: nan

Maximális teljesítmény: nan MW

Maximális hőmérséklet: nan K

Függvény átalakítás mérnöki és grafikai fejlesztés

Függvény átalakítás

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

import numpy as np

class GeometriaiTranszformaciok:

    def __init__(self, pontok):

        """

        Inicializálja a pontokat homogén koordinátákban.

        A pontok egy (N, 2) alakú mátrix vagy lista.

        """

        N = len(pontok)

        # Hozzáadjuk az 1-et a homogén koordinátákhoz (shape: N x 3)

        self.pontok = np.hstack((pontok, np.ones((N, 1))))

    def eltolas(self, tx, ty):

        """Eltolás vektor megadása szerint"""

        matrix = np.array([

            [1, 0, tx],

            [0, 1, ty],

            [0, 0, 1]

        ])

        return self._transzformacio(matrix)

    def forgatas(self, szog_fok):

        """Forgatás az origó körül fokban megadva"""

        radiant = np.radians(szog_fok)

        c = np.cos(radiant)

        s = np.sin(radiant)

        

        matrix = np.array([

            [c, -s, 0],

            [s,  c, 0],

            [0,  0, 1]

        ])

        return self._transzformacio(matrix)

    def skalazas(self, sx, sy):

        """Skálázás (nyújtás/zsugorítás) az x és y tengelyek mentén"""

        matrix = np.array([

            [sx, 0,  0],

            [0,  sy, 0],

            [0,  0,  1]

        ])

        return self._transzformacio(matrix)

    def tukrozes(self, x_tengelyre=False, y_tengelyre=False):

        """Tükrözés a tengelyekre"""

        mx = -1 if x_tengelyre else 1

        my = -1 if y_tengelyre else 1

        

        matrix = np.array([

            [mx, 0,  0],

            [0,  my, 0],

            [0,  0,  1]

        ])

        return self._transzformacio(matrix)

    def _transzformacio(self, transzformacios_matrix):

        """Privát metódus a transzformáció végrehajtására mátrix szorzással"""

        # A pontok (N x 3) mátrixát szorozzuk a (3 x 3) transzformációs mátrix transzponáltjával

        uj_pontok = np.dot(self.pontok, transzformacios_matrix.T)

        # Visszaadjuk az eredményt a homogén komponens levágásával (shape: N x 2)

        return uj_pontok[:, :2]

# --- Példa a használatra ---

if __name__ == "__main__":

    # Kezdeti alakzat csúcspontjai (pl. egy háromszög)

    eredeti_haromszog = np.array([

        [0.0, 0.0],

        [5.0, 0.0],

        [0.0, 5.0]

    ])

    

    # Példányosítás

    transzformator = GeometriaiTranszformaciok(eredeti_haromszog)

    

    # Művelet 1: Eltolás x=2, y=3 irányba

    eltolva = transzformator.eltolas(2, 3)

    print("Eltolt pontok:\n", eltolva)

    

    # Művelet 2: Forgatás 90 fokkal az origó körül

    forgatva = transzformator.forgatas(90)

    print("\n90 fokkal elforgatott pontok:\n", forgatva)

    

    # Művelet 3: Tükrözés az Y tengelyre

    tukrozve = transzformator.tukrozes(y_tengelyre=True)

    print("\nY tengelyre tükrözött pontok:\n", tukrozve)

...........................

Eltolt pontok:

 [[2. 3.]

 [7. 3.]

 [2. 8.]]

90 fokkal elforgatott pontok:

 [[ 0.000000e+00  0.000000e+00]

 [ 3.061617e-16  5.000000e+00]

 [-5.000000e+00  3.061617e-16]]

Y tengelyre tükrözött pontok:

 [[ 0.  0.]

 [ 5.  0.]

 [ 0. -5.]]