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.]]

Fourier-transzformáció

Az alábbi kód bemutatja, hogyan generálhatunk egy 

összetett jelet, majd végezhetünk rajta Fourier-transzformációt.

-----------

import numpy as np

import matplotlib.pyplot as plt

# 1. Időtartomány beállítása

mintavetelezesi_frekvencia = 1000  # Hz

T = 1.0  # Teljes időtartam (másodperc)

t = np.linspace(0, T, int(mintavetelezesi_frekvencia * T), endpoint=False)

# 2. Összetett jel generálása

frekvencia1 = 50

frekvencia2 = 120

jel = np.sin(2 * np.pi * frekvencia1 * t) + 0.5 * np.sin(2 * np.pi * frekvencia2 * t)

# 3. Fourier-transzformáció végrehajtása

jel_fft = np.fft.fft(jel)

frekvenciak = np.fft.fftfreq(len(jel), 1 / mintavetelezesi_frekvencia)

# 4. Csak a pozitív frekvenciák megtartása

pozitiv_frekvenciak = frekvenciak[:len(frekvenciak)//2]

amplitudok = 2.0 / len(jel) * np.abs(jel_fft[:len(jel_fft)//2])

# 5. Eredmény kiírása

top_indexek = np.argsort(amplitudok)[-5:][::-1]

print("Legnagyobb FFT csúcsok:")

for i in top_indexek:

    print(f"{pozitiv_frekvenciak[i]:.1f} Hz -> {amplitudok[i]:.3f}")

# 6. Ábrázolás

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

plt.subplot(2, 1, 1)

plt.plot(t[:200], jel[:200])

plt.title("Eredeti jel az időtartományban")

plt.xlabel("Idő (s)")

plt.ylabel("Amplitúdó")

plt.subplot(2, 1, 2)

plt.plot(pozitiv_frekvenciak, amplitudok)

plt.title("Frekvenciaspektrum (FFT)")

plt.xlabel("Frekvencia (Hz)")

plt.ylabel("Amplitúdó")

plt.grid(True)

plt.tight_layout()

plt.show()

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

Legnagyobb FFT csúcsok:

50.0 Hz -> 1.000

120.0 Hz -> 0.500

119.0 Hz -> 0.000

121.0 Hz -> 0.000

128.0 Hz -> 0.000