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

Monte Carlo szimuláció

A veszélyes méretű (140 méternél nagyobb) aszteroidák becsapódási esélyét statisztikai gyakorisággal és Monte Carlo szimulációval szokás modellezni. Íme egy egyszerű Python program, amely ezt a statisztikai valószínűséget és a véletlen eseményeket (Monte Carlo módszer) használja fel a kockázat szimulálására a megadott évek száma alapján: Mivel 66 millió éve volt egy becsapódás, ezért a matematikai esély megnőtt kb; 0.000003%

----------

import random

def szimulal_becsapodas(evek_szama):

    eves_valoszinuseg = 4e-9

    becsapodasok = 0

    for _ in range(evek_szama):

        if random.random() <= eves_valoszinuseg:

            becsapodasok += 1

    return becsapodasok

evek = 110000000

azonositott_kraterek = 200

talalatok = szimulal_becsapodas(evek)

szazalek = (talalatok / evek) * 100

krater_szazalek = (azonositott_kraterek / evek) * 100

print(f"--- Aszteroida Becsapódási Szimuláció ---")

print(f"Vizsgált időszak: {evek:,} év")

print(f"Becsapódások száma a szimulációban: {talalatok}")

print(f"Becsapódás aránya a szimulációban: {szazalek:.10f}%")

print(f"Azonosított kráterek száma a Föld történetében: {azonositott_kraterek}")

print(f"Kráterek aránya a vizsgált időszakhoz képest: {krater_szazalek:.10f}%")

if talalatok > 0:

    print("A szimuláció szerint bekövetkezett ütközés ebben az időszakban.")

else:

    print("A szimulációban nem történt ütközés. Ennek az esélye a valós életben is rendkívül alacsony.")

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

--- Aszteroida Becsapódási Szimuláció ---

Vizsgált időszak: 67,000,000 év

Becsapódások száma a szimulációban: 2

Becsapódás aránya: 0.0000029851%

A szimuláció szerint bekövetkezett ütközés ebben az időszakban.

A Föld története során  közel 200 becsapódási krátert azonosítottak, tehát figyelembe kell venni ezt a tényt is. A becsapódások száma a mérettől függ. Az elmúlt 70 millió évben körülbelül 70 darab olyan, legalább 1 km-es aszteroida csapódott a Földbe, amely globális katasztrófát okozott. A kisebb, de helyi pusztítást végző meteorokból ennél jóval több, több ezer hullott a bolygóra. Az élet 4 milliárd éve jelent meg a földön, de a számítógépem nem tud ilyen nagy számokkal számolni.

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

import random

def monte_carlo_asteroid_simulation(years, num_craters, annual_prob):

    impacts = 0

    

    # A szimulációs ciklus a megadott éveken megy végig

    for year in range(years):

        # Generálunk egy véletlen számot (0 és 1 között) az adott évre

        if random.random() < annual_prob:

            impacts += 1

            

    print(f"{years} év szimulálása befejeződött.")

    print(f"Becsült éves becsapódási esély: {annual_prob}")

    print(f"Tapasztalt becsapódások száma a szimulációban: {impacts}")

    

    # Ha 200 kráter van, megbecsüljük a teljes becsapódási valószínűséget

    probability_with_craters = 1 - (1 - annual_prob) ** num_craters

    print(f"Ekkora krátermennyiség (${num_craters}$ db) mellett az ütközés esélye: {probability_with_craters:.6%}")

# Paraméterek beállítása

evek_szama = 100000000

kraterek_szama = 200

eves_valoszinuseg = 4e-9  # 4 x 10^-9

# Futtatás

monte_carlo_asteroid_simulation(evek_szama, kraterek_szama, eves_valoszinuseg)

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

100.000.000 év szimulálása befejeződött.

Becsült éves becsapódási esély: 4e-09

Tapasztalt becsapódások száma a szimulációban: 2

Ekkora krátermennyiség ($200$ db) mellett az ütközés esélye: 0.000080%

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

E már komoly veszélyt jelent, mivel 65.000 éve volt már egy.

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

Ezzel azt szerettem volna diákjaimnak bebizonyíta, hogy egy PC is képes tudományos számításokra, ha az algoritmust jól készítjük el.

A PC-s tudományos számítások hatékonyságát és sebességét több kulcstényező határozza meg:Párhuzamos programozás (Multithreading): A modern processzorok (CPU) több maggal rendelkeznek. A kódnak úgy kell készülnie, hogy a feladatokat szétossza a magok között (pl. OpenMP vagy MPI segítségével).GPU gyorsítás (CUDA / OpenCL): A videokártyák (GPU-k) több ezer apró maggal rendelkeznek, amelyek kiválóan alkalmasak mátrixműveletekre és nagy adathalmazok párhuzamos feldolgozására.

Vektorizáció: A processzorok utasításkészlete (mint az AVX vagy az AVX-512) lehetővé teszi, hogy egyetlen órajel alatt több adattal is végezzenek műveleteket.Memória-kezelés: A gyorsítótár (Cache) okos kihasználása és az adatok megfelelő struktúrája (pl. összefüggő tömbök használata a lassabb RAM helyett) drasztikusan csökkentheti a futásidőt.

A kutatók és fejlesztők gyakran használnak olyan optimalizált matematikai könyvtárakat (pl. Intel MKL, AMD BLIS), amelyek automatikusan a maximumot hozzák ki a hardverből, így a programozónak nem kell minden gépi szintű trükköt manuálisan megírnia.

Objektum felismerés pythonnal

Objektum felismerés pyrhonnal

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

import cv2

from ultralytics import YOLO

# 1. Betöltjük az előre betanított YOLOv8 modellt (COCO adathalmaz, 80 osztállyal)

model = YOLO("yolov8n.pt")

# 2. Megadjuk a kép elérési útját és beolvassuk

kep_utvonal = "utvonal/a/kephez.jpg"  # Cseréld ki a saját képedre

eredeti_kep = cv2.imread(kep_utvonal)

# 3. Objektumfelismerés futtatása a képen

eredmenyek = model(eredeti_kep)

# 4. Eredmények kirajzolása a képre

for eredmeny in eredmenyek:

    # A kereteket és cimkéket tartalmazó kép

    vizualizalt_kep = eredmeny.plot()

# 5. Az eredmény megjelenítése

cv2.imshow("Objektumfelismero - YOLOv8", vizualizalt_kep)

cv2.waitKey(0) # Vár egy gombnyomásra az ablak bezárásához

cv2.destroyAllWindows()

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

YOLOv8 objektumfelismerés emuláció indítása...

Kép betöltése: utvonal/a/kephez.jpg

Kép sikeresen betöltve. [EMULÁCIÓ]

Objektumfelismerés futtatása... [EMULÁCIÓ]

Talált objektumok:

- person (94.0%)

- car (87.0%)

- dog (76.0%)

Eredmény vizualizálása... [EMULÁCIÓ]

Kép megjelenítése nem elérhető, ezért csak szöveges kimenet látható.

Arcfelismerés pythonnal

Arcfelismerés pythonnal

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

import face_recognition

import cv2

import numpy as np

# 1. Ismert személy(ek) betanítása

# Tölts be egy képet a referenciáról, és add meg a nevét.

# Készíts egy "ismert_arcok" mappát, és tegyél bele egy "sajat_kep.jpg" fájlt.

ismert_kep = face_recognition.load_image_file("ismert_arcok/sajat_kep.jpg")

ismert_arc_kodolasa = face_recognition.face_encodings(ismert_kep)[0]

ismert_arc_nevek = [

    "Sajat Neved"

]

# Inicializáljuk a webkamerát (0 a beépített/fő kamera)

video_capture = cv2.VideoCapture(0)

print("Arckeresés indítása... (A program bezárásához nyomd meg a 'q' billentyűt)")

while True:

    # Egyetlen képkocka beolvasása a kamerából

    ret, frame = video_capture.read()

    # A OpenCV BGR formátumban dolgozik, a face_recognition RGB-t vár, ezért konvertálunk

    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)

    # Minden arc és azok kódolásainak megkeresése az aktuális képkockán

    arc_helyek = face_recognition.face_locations(rgb_frame)

    arc_kodolasok = face_recognition.face_encodings(rgb_frame, arc_helyek)

    nevek = []

    for arc_kodolas in arc_kodolasok:

        # Ellenőrizzük, hogy az arc egyezik-e az ismert arcokkal

        egyezesek = face_recognition.compare_faces(ismert_arc_kodolasa, arc_kodolas)

        nev = "Ismeretlen"

        # Ha egyezést talál, használhatjuk a legkisebb távolságú (legjobb) egyezést

        arc_tavolsagok = face_recognition.face_distance([ismert_arc_kodolasa], arc_kodolas)

        legjobb_egyezes_index = np.argmin(arc_tavolsagok)

        

        if egyezesek[legjobb_egyezes_index]:

            nev = ismert_arc_nevek[legjobb_egyezes_index]

        nevek.append(nev)

    # Az eredmények kirajzolása a képre

    for (top, right, bottom, left), nev in zip(arc_helyek, nevek):

        # Négyszög rajzolása az arc köré

        cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)

        # Név kiírása az arc alá

        cv2.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255), cv2.FILLED)

        font = cv2.FONT_HERSHEY_DUPLEX

        cv2.putText(frame, nev, (left + 6, bottom - 6), font, 0.5, (255, 255, 255), 1)

    # A képkocka megjelenítése egy ablakban

    cv2.imshow('Arcfelismero', frame)

    # Kilépés a 'q' billentyű lenyomásával

    if cv2.waitKey(1) & 0xFF == ord('q'):

        break

# Kamera és az ablakok felszabadítása

video_capture.release()

cv2.destroyAllWindows()

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

Enulált tesztelés

Arcfelismerés indítása... [EMULÁCIÓ]

Kamera helyett szimulált képkockák feldolgozása...

Képkocka 1

Talált arc: Sajat Neved

Felismert személy: Sajat Neved

Képkocka 2

Talált arc: Ismeretlen

Felismert személy: Ismeretlen

Képkocka 3

Talált arc: Sajat Neved

Felismert személy: Sajat Neved

Az emuláció véget ért.

Riasztó értesítést küld a mobilra

Emulált riasztással tesztelve

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

import time

NTFY_TOPIC = "enyedi_riasztom_1234"

ALERT_MESSAGE = "RIASZTÁS: Illetéktelen behatoló észlelve az ingatlanban!"

def send_push_notification(topic, message):

    print(f"[EMULÁCIÓ] Push értesítés küldése a(z) '{topic}' témára.")

    print(f"[EMULÁCIÓ] Üzenet: {message}")

    print("[EMULÁCIÓ] Értesítés sikeresen elküldve a telefonra.")

def check_for_intruders():

    intrusion_detected = True

    if intrusion_detected:

        print("Behatoló észlelve! Riasztás indítása...")

        send_push_notification(NTFY_TOPIC, ALERT_MESSAGE)

        return True

    return False

if __name__ == "__main__":

    send_push_notification(NTFY_TOPIC, "A riasztó program elindult és figyel.")

    while True:

        if check_for_intruders():

            break

        time.sleep(5)

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

Push értesítés küldése a(z) 'enyedi_riasztom_1234' témára.

 Üzenet: A riasztó program elindult és figyel.

 Értesítés sikeresen elküldve a telefonra.

Behatoló észlelve! Riasztás indítása...

 Push értesítés küldése a(z) 'enyedi_riasztom_1234' témára.

 Üzenet: RIASZTÁS: Illetéktelen behatoló észlelve az ingatlanban!

 Értesítés sikeresen elküldve a telefonra.