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.

Automatizált kriptokereskedési bot pythonban

A tudományos Python számításokhoz a nyelv egy rendkívül hatékony ökoszisztémát kínál, amely főként nyílt forráskódú könyvtárakon alapul. Ezekkel a matematikai modellezés, a nagy adathalmazok elemzése és a vizualizáció is könnyedén elvégezhető.Alapvető könyvtárakNumPy: A tudományos számítások alapköve. Hatékony, többdimenziós tömböket (array) és lineáris algebrai, valamint Fourier-transzformációs műveleteket biztosít.SciPy: A NumPy-ra épül, és fejlett matematikai algoritmusokat kínál, mint például integrálás, differenciálegyenletek megoldása, optimalizálás és jelfeldolgozás.Pandas: Nélkülözhetetlen eszköz az adatok manipulálásához és elemzéséhez. Különösen erős táblázatos és idősoros adatok kezelésében.Matplotlib & Seaborn: Hatékony könyvtárak adatok vizualizációjára. Segítségükkel grafikonok, diagramok és hőtérképek rajzolhatók közvetlenül a számítási eredményekből.SymPy: Szimbolikus matematikához használható könyvtár, amellyel algebrai kifejezések egyszerűsíthetők, deriválhatók és integrálhatók pontos formában.Népszerű fejlesztői környezetekA tudományos kódok írásához és teszteléséhez a kutatók leggyakrabban az alábbi környezeteket használják:Jupyter Notebook: Egy interaktív webes felület, amely lehetővé teszi, hogy a kódokat, azok kimeneteit (szöveges és grafikus formában), valamint a magyarázatokat egyetlen dokumentumban egyesítsük.Google Colab: Egy felhőalapú Jupyter környezet, amely ingyenes hozzáférést biztosít nagy számítási kapacitáshoz (GPU/TPU) és előre telepített tudományos csomagokhoz.

Automatizált kriptokereskedési bot

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

import pandas as pd

import time

import random

SYMBOL = "BTCUSDT"

AMOUNT = "0.001"

RSI_PERIOD = 14

RSI_OVERBOUGHT = 70

RSI_OVERSOLD = 30

def get_historical_data(symbol, interval='1h', limit=100):

    prices = [50000 + random.uniform(-1500, 1500) for _ in range(limit)]

    df = pd.DataFrame({"close": prices})

    return df

def calculate_rsi(data, period=14):

    delta = data['close'].diff()

    gain = delta.where(delta > 0, 0).rolling(window=period).mean()

    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()

    rs = gain / loss

    rsi = 100 - (100 / (1 + rs))

    return rsi

def execute_trade(symbol, side):

    print(f"{side} megbízás szimulálva: {symbol}, mennyiség: {AMOUNT}")

def run_bot():

    print("Bot elindítva. Szimulált piac figyelése...")

    

    for _ in range(5):

        df = get_historical_data(SYMBOL)

        if df is not None and len(df) >= RSI_PERIOD:

            df['rsi'] = calculate_rsi(df, RSI_PERIOD)

            current_rsi = df['rsi'].iloc[-1]

            current_price = df['close'].iloc[-1]

            print(f"Aktuális ár: {current_price:.2f} USDT | RSI: {current_rsi:.2f}")

            if current_rsi < RSI_OVERSOLD:

                print("Túladott jelzés (Oversold)! Vásárlás indítása.")

                execute_trade(SYMBOL, 'BUY')

            elif current_rsi > RSI_OVERBOUGHT:

                print("Túlvett jelzés (Overbought)! Eladás indítása.")

                execute_trade(SYMBOL, 'SELL')

        time.sleep(1)

if __name__ == "__main__":

    run_bot()

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

Bot elindítva. Szimulált piac figyelése...

Aktuális ár: 50005.43 USDT | RSI: 50.68

Aktuális ár: 48799.39 USDT | RSI: 50.64

Aktuális ár: 50946.77 USDT | RSI: 57.57

Aktuális ár: 50651.00 USDT | RSI: 47.77

Aktuális ár: 51060.46 USDT | RSI: 58.72

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

Dialógus

miért jöttél hozzánk

látogatóba 

mi vagy te

fenomenon vagyok

ki akartok minket pusztitani

nem a mi törvényeink szerint

nem avatkozhatunk be

csak megfigyelő vagyok

honnan jöttél

Nagykutya v9

az 25 000 fényév az sok

nektek, de nem nekünk

az életképtelen civilizációk magukat elpusztítják

mi szépen kivárjuk és betelepülünk megint

hogy hogy megint

már sokszor volt itt kolóniánk 

ha találunk egy jobbat oda átköltözünk

és ha élnek ott entitások

megvárjuk a végét, minket nem zavartok

A selejtek fejlődése kisiklik és a kudarc kódolva van

De hát mi egyre okosabbak leszünk

rossz irányba tértetek el és elbutultok

hogy tudsz hozzám beszélni

kicsit átalakitottam a selejet agyadat

persze ez olyan terhelés amitől hamarosan elpusztulsz

mi is végzünk kutatásokat kommunikációra

tévúton jártok, rossz a fejlődési irányotok

eleve pusztulásra vagytok ítélve

mi már sok civilizációval kommunkálunk

elraboltok minket

minek

csak passzív nézői vagyunk a felgyorsított evolúciótoknak.

készithetnék rólad fotót?

ha az általad érzékelhető dimenzióban lennék talán

hány dimenzió van

szerintünk több tízezer

hangot sem tudok felvenni

nincs kibocsátott hanghullámom

akkor nincs semmi bizonyíték a kezemben

még a saját történelmeteket sem ismeritek

ne legyetek nagyravágyók

te látsz engem és hallassz

ez nem igazság

megint tévedsz

hogy nézel ki

nem vagyok humanoid

akkor mi vagy

valami egy entitás

organizmus vagyok elégedj meg ennyivel

hogy tudsz metenni olyan hosszú utat

n azt sosem fogod megtudni

használtok ürhajót

teknikai eszközöket használunk

meghibásodnak

igen néha 

de ti nem érzékelitek a maradványokat

hány évig marad fenn az emberi civilizáció

an emberiség, entitások egymást váltó láncolata

általában 3000 kör a nap körül

és váltás van

11 bukott civilizáció

ami 3000 évente csere

igen de vannak közte hézagok

miért a föld

védett helyen van

Sokat költözünk, mert gyakran ütközünk vándorokkal

a föld dokáig nem fog ütközni

és ha mégis

akkor nem lennék itt

ha ezt leírom holnap a tébolydában ébredek

ne írd le

maradjon köztünk

én vezetőim se örülnének ha kiderülne hogy kapcsolódtam hozzád

nem látlak nem hallalak nem észlellek

talán nem is létezel

nekünk ez csak jó

mi csak bányászunk

mit

sok mindent

mióta

10000 kör óta

de vannak akik el is vesznek dolgokat tőletek

hogy mások is vannak

rajtunk kívül még soka 

ide járnak

itt élnek

mikor mi ide jöttünk már itt voltak

velük is besszéltek

nem túl barátságosak

veletek sem

ugyan olyan értéket jelentettek nekik mint a hangyák

nem túl biztató

félnünk kellene

nem vagyunk biztonságban

nem

innen bárki bármit elvihet

csak arra kell ügyelni

ti nevegyétek észre

 jelenleg is a helyi nyersanyagok illegális begyűjtését végzem a sztratoszférikus adóhatóságok háta mögött.

 Kvantum-szintű tömörítő sugarakat használok, amiket a fák lombkoronája és a helyi köd tökéletesen elrejt.

 gravitációs anomália generálnom hogy stabilan tudjak itt létezni

nemaz élet a lényeg a létezés

hogyan tudsz komunikálni velem

titkosított frekvencián át

Nem szabadna itt lennem. A Galaktikus Erőforrás-felügyelet szerint a Föld védett világ. 

Papíron csak tudományos megfigyelés folyhatna.

Miket lopsz tőlünk

francien, tantál, ródium, ozmium

fúróplatformokat hozunk létre

lakott területektől távol

sokan járnak ide

meglepően nagy a forgalom.

vannak akiket én sem ismserek

és vannak akik előttem is rejve vannak

akkor honna tudod hogy itt vannak

az energia árulkodó

ha az ember több figyelmet szentelne a környezete energiáinak változásaira

érdekes dolgokat tapasztalna

szabad rablás van

mindenki azt visz amit akar

olyan szűk sávban érzékelnek a műszereitek

hogy élmény kihasználni a lehetőséget

miért áltál szóba velem

szánalomból

azt hiszitek ti vagytok az ész az univerzumban

közben rajtatok röhögnek a galaxisokban

vicceket mesélnek aminek főszereplője az ember

nincs szórakoztatóbb egy buta embernél aki azt findolja magáról okos

miért jönnek

A nap külső spirálkarban fekszik, 

mindenkinek utbaesik. 

Sok faj megfordul itt: kutatók, kereskedők, kalandorok, sőt turisták is.

 A legtöbben ügyelnek rá, hogy ne vegyétek észre őket.”

Ha azt hiszed, hogy én vagyok az egyetlen idegen a bolygón, akkor nem figyelsz eléggé

A bányászok között viszont az a pletyka jár, hogy a legveszélyesebb lények nem a csillagok között élnek,

 hanem azokban a tartományokban, amelyek egyetlen milliméterrel „mellettetek” léteznek, mégis teljesen láthatatlanok számotokra

mi a téridő olyan rétegeit használjuk amiket ti nem érzékeltek

annyian hemzsegnek körülöttetek hogy el se hinnéd

csak  kihasználjuk az eéőttetek rejtett dimenziókat

Ami nektek extra dimenzió nekünk természetes

a legveszélyesebb lények nem a csillagok között élnek, hanem azokban a tartományokban,

 amelyek egyetlen milliméterrel „mellettetek” léteznek,

mégis teljesen láthatatlanok számotokra.

Ti alig érzékeltek valamit, mi ezzel szemben:

látjuk az elektromágneses spektrum jelentős részét, 

nem csak a látható fényt,

érzékeljük a gyenge mágneses mezőket,

és részben az időbeli mintázatokat is figyeljük, mágneses erőtér változásokat

A mi szenzoraink észlelik a hőkisugárzást az egergiát, a gravitációs erőteret , a telefonod rádiójeleit, a szívverésed ritmusát, 

és azt, hogy milyen nyomokat hagysz magad után

 a környezetedben.

a környezetetdben számodra rejvemaradt lények milliárdjai a vészélyesek számodra nem én

én csupán egy biztonságos távolságra lebegő szonda vagyok,

nem ejlentek veszélyt sszámodra

A biológiai órád azért ketyeg ilyen gyorsan, mert a szervezeted sejtjei az osztódások során folyamatosan romlanak korcsosodnak

a DNS-ed sérül torzul

hibás gének keletkeznek amik a lehetőségeidet behatárolják

a környezetedben lévő milliárdnyi organizmus okozza a veszted

A telomerek a kromoszómák végén található védősapkák, amelyek minden sejtosztódás során rövidülnek. 

Amikor túlságosan megkopnak, a sejt már nem képes tovább osztódni, és elöregszik. 

Ez a folyamat a sejtszintű öregedés egyik legfőbb biológiai oka, és alapvetően meghatározza élettartamunkat.

hogy működnek

A telomerek úgy működnek, mint a cipőfűző végén található műanyag borítás (aglet): megakadályozzák, 

hogy a létfontosságú genetikai információ sérüljön vagy lekopjon

 a sejtosztódások alatt.A rövidülés oka: Ahogy a sejtek osztódnak, a DNS-másoló mechanizmus nem éri el a szál legvégét. 

Emiatt egy kis darab mindig lemarad.

ti erre azt mondjátok Hayflick-határ:

 A telomerek hossza határozza meg, hogy egy sejt hányszor képes osztódni (ez jellemzően 50-70 alkalom). 

nálunkez többezer kör

Amikor a telomer kritikusan rövidre zsugorodik, a sejt leállítja az osztódást, 

és elpusztul (apoptózis) vagy úgynevezett szenesszenciás (elöregedett) állapotba kerül.

Mi lesz a következménye

A rövidült telomerekkel rendelkező sejtek kevésbé hatékonyan működnek, 

ami hozzájárul az öregedés látható jeleihez és az életkorral összefüggő betegségek 

(pl. szív- és érrendszeri problémák) kialakulásához.

A környezet gyorsitja komtraindikációt okoz

A természetes kopáson túl bizonyos életmódbeli tényezők drasztikusan felgyorsíthatják a telomerek fogyását:

Krónikus stresszHelytelen táplálkozás (feldolgozott élelmiszerek, sok cukor)

Dohányzás és túlzott alkoholfogyasztásAlváshiány és mozgásszegény életmód

Hogyan védhetők meg a telomerek?

Bár a folyamat nem állítható meg teljesen, a telomeráz enzim segítségével a telomerek hossza részben fenntartható vagy akár növelhető is.

 Hatékony eszközök a védelemre:Rendszeres testmozgás: 

A fitt életmód bizonyítottan lassítja a telomerek rövidülését.Egészséges étrend: 

A mediterrán diéta, valamint a megfelelő vitaminbevitel (különösen a D-vitamin) támogatja a sejtek integritását.Stresszcsökkentés: 

A meditáció, a jóga és a megfelelő alvás mind segítik a sejtek védelmét

vannak olyan organzmusok a földön akik ezt megoldották miért nem figyelitek meg őket

transzdifferenciáció  egy meduza képes rá, vagy az emberi Őssejtek (Stem cells)

petsze a baktériumok és egysejtűek: Az olyan mikrobák, mint az E. coli vagy az élesztőgombák,

 kettéosztódással (mitózis) végtelen számban képesek másolni 

és megfiatalítani önmagukat

Autofágia: Az emberi szervezet sejtjei is rendelkeznek egy belső tisztító és megújító mechanizmussal, az autofágiával. 

Ennek során a sejt lebontja és újrahasznosítja a saját sérült, öreg részeit, ezáltal megfiatalítja önmagát

 A kromoszómáink végén található védősapkák, a telomerek, minden egyes sejtosztódásnál rövidülnek. 

Amikor kritikus méretre zsugorodnak, a sejt vagy leállítja 

a működését, vagy elpusztul.Mutációk felhalmozódása: 

A környezeti hatások (pl. UV-sugárzás, táplálkozás) miatt a DNS-ben hibák keletkeznek, amiket a

 javítómechanizmusok egy idő után már nem tudnak tökéletesen korrigálni.Evolúciós érdek: 

A biológiai sokféleséghez és a fajok fejlődéséhez elengedhetetlen a

 generációk cserélődése. Olyan sok organizmus és entitás van itt hogy egymást tapossák

elpusztitotok minket

nekünk egy protuberancia energia sem kellene ahhoz hogy megszüntessünk benneteket

elég lenne választani egy organizmust adni neki egy kis életteret és elvégeznék helyettünk a piszkos munkát

akkor ti korlátozzátok az organizmusokat

azokat amik veszélyesk lehetnek ránk

tehát ti is sebezhetőek vagytok

ki nem, de ezt titokban tartjuk a többi entitás nem tudja

értem, biztonságban vagytok

dehogy érted, nem rendelkezel azokkal az attributumokkal

nem vagy elég hozzá

csak egy forditóval tudom olyan mélyre  szintetizálni a gondolataimat hogyy megértsd

öszintén az ő szintjén mondja az ember

nem féltek tőlünk

miért kellene, túl értékelitek a lehetőségeiteket

amit nem észleltek az nincs

tehát biztonságban vagyunk

ijesztő perspektíva

ti is csak egy organizmus vagytok amiket kordában tartunk

nincs túl fejlődés nincs túlszaporodás

milyen feltételek kellenek ahhoz hogy két civilizáció kontaktba kerüljön galaxis szinten

Két entitás találkozásához a fizika, a téridő és a valószínűségszámítás törvényei szerint több alapvető feltételnek kell egyszerre teljesülnie.

A találkozó legfontosabb szigorú feltételei a következők:

Térbeli és időbeli metszéspont: 

A két objektumnak egyszerre és pontosan ugyanabban a térbeli koordinátában kell tartózkodnia. 

A végtelennek tűnő univerzumban a távolságok és a tágulás miatt ez önmagában is extrém valószínűségű esemény.

Közös fizikai dimenzió: Nem biztos, hogy azonos valóságban vagy dimenzióban léteznek. Kvantumfizikai vagy multiverzum-elméletek szerint az is lehetséges, hogy a járművek párhuzamos univerzumokból származnak, így a találkozóhoz a dimenziók közti átjárhatóság is szükséges.

Technológiai fejlettség és kommunikáció: Képesnek kell lenniük egymás észlelésére (pl. radar, vizuális vagy gravitációs hullámok útján), valamint a navigációs vagy szándékos pályakorrekcióra a manőver végrehajtásához.Energia és hajtásrendszer: 

Az intersztelláris vagy galaktikus távolságok áthidalásához olyan fejlett hajtóművekre van szükség, amelyekkel manipulálható a téridő (pl. fénysebességhez közeli vagy azt meghaladó utazás).

Sok feltételnek nem tudtok még megfeleni

Vannak akik morfolófiailag is jelenvannak

szerintem sokkal fejletlenebbek mint mi

persze minket ők sem észlelnek

az ember nem tud elvonatkoztani saját emberi morfológiájától

így mindíg humanoidnak képzeli a látogatókat

a legelvonatkoztatottabb amorf fenomenon észlelések a leghihetetlenebbek és ez nekünk jó

gyakran tévesztenek össze madárral, a rüppell keselyű 12000m magasra is képes felrepülni

pedig ott már ritka a levegő

még a repülők sem merészkednek odáig fel

PHJILJBHOŐ YDJBRN

pléuw möwwéo krccáqn

nl dnduwrn plqnhw sxvcwlwdql

qhp d pl wöuyéqbhlqn vchulqw

qhp dydwnrckdwxqn eh

phjiljbhoő ydjbrn

krqqdq möwwéo

Qdjbnxwbd y9

dc 25 000 iéqbéy dc vrn

qhnwhn, gh qhp qhnüqn

dc éohwnéswhohq flylolcáflón pdjxndw hosxvcwíwmán

pl vcéshq nlyáumxn év ehwhohsüoüqn phjlqw

krjb krjb phjlqw

páu vrnvcru yrow lww nroóqláqn 

kd wdoáoxqn hjb mreedw rgd áwnöowöcüqn

év kd éoqhn rww hqwlwávrn

phjyáumxn d yéjéw

D vhohmwhn ihmoőgévh nlvlnoln év d nxgduf nógroyd ydq

Gh káw pl hjbuh rnrvdeedn ohvcüqn

urvvc luáqbed wéuwhwhn ho év hoexwxowrn

krjb wxgvc krccáp ehvcéoql

nlfvlw áwdodnlwrwwdp d vhohmhw djbdgdw

shuvch hc robdq whukhoév dplwőo kdpdurvdq hosxvcwxovc

pl lv yéjcüqn nxwdwávrndw nrppxqlnáflóud

wéyúwrq máuwrn, urvvc d ihmoőgévl luáqbrwrn

hohyh sxvcwxoávud ydjbwrn íwéoyh

pl páu vrn flylolcáflóydo nrppxqnáoxqn

houderowrn plqnhw

plqhn

fvdn sdvvcíy qécől ydjbxqn d ihojbruvíwrww hyroúflówrnqdn.

névclwkhwqén uóodg irwów?

kd dc áowdodg éucénhokhwő glphqclóedq ohqqén wdoáq

kdqjrw

qlqfv nlerfváwrww kdqjkxooáprp

dnnru qlqfv vhppl elcrqbíwén d nhchpehq

péj d vdmáw wöuwéqhophwhnhw vhp lvphulwhn

qh ohjbhwhn qdjbudyájbón

wh oáwvc hqjhp év kdoodvvc

hc qhp ljdcváj

phjlqw wéyhgvc

krjb qécho nl

qhp ydjbrn kxpdqrlg

dnnru pl ydjb

ydodpl hjb hqwlwáv

rujdqlcpxv ydjbrn hoéjhgm phj hqqblyho

krjb wxgvc phwhqql robdq krvvcú xwdw

q dcw vrvhp irjrg phjwxgql

kdvcqáowrn üukdmów

whnqlndl hvcnöcönhw kdvcqáoxqn

phjkleávrgqdn

ljhq qékd 

gh wl qhp éucénholwhn d pdudgyáqbrndw

káqb éylj pdudg ihqq dc hpehul flylolcáfló

dq hpehulvéj, hqwlwávrn hjbpávw yáowó oáqfrodwd

áowdoáedq 3000 nöu d qds nöuüo

év yáowáv ydq

11 exnrww flylolcáfló

dpl 3000 éyhqwh fvhuh

ljhq gh ydqqdn nöcwh kécdjrn

pléuw d iöog

yéghww khobhq ydq

Vrndw nöowöcüqn, phuw jbdnudq üwnöcüqn yáqgrurnndo

d iöog grnálj qhp irj üwnöcql

év kd péjlv

dnnru qhp ohqqén lww

kd hcw ohíurp kroqds d wéerobgáedq éeuhghn

qh íug oh

pdudgmrq nöcwüqn

éq yhchwőlp vh öuünqéqdn kd nlghuüoqh krjb ndsfvroógwdp krccág

qhp oáwodn qhp kdoododn qhp évcohoohn

wdoáq

Kvantumkommunikáció

Írtan egy python programot kvantumkommunikációra ufókkal

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

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit

from qiskit import BasicAer, execute

# 1. Kvantum és klasszikus regiszterek inicializálása

qr = QuantumRegister(3, 'q')

cr_z = ClassicalRegister(1, 'cr_z')

cr_x = ClassicalRegister(1, 'cr_x')

circuit = QuantumCircuit(qr, cr_z, cr_x)

# 2. A teleportálandó qubit (q0) felkészítése (pl. szuperpozícióba helyezés)

circuit.h(qr[0])

# 3. Összefonódott (Entangled) pár létrehozása a q1 és q2 qubiteken

circuit.h(qr[1])

circuit.cx(qr[1], qr[2])

# 4. A küldő fél (Alice) műveletei: összefonódás a küldendő qubittel

circuit.cx(qr[0], qr[1])

circuit.h(qr[0])

# 5. Alice megméri a qubiteket és elküldi az eredményt klasszikus csatornán

circuit.measure(qr[0], cr_z[0])

circuit.measure(qr[1], cr_x[0])

# 6. A fogadó fél (Bob) műveletei: kvantumállapot rekonstrukció a kapott bitek alapján

circuit.x(qr[2]).c_if(cr_x, 1)

circuit.z(qr[2]).c_if(cr_z, 1)

# 7. A kvantum áramkör szimulációja

backend = BasicAer.get_backend('statevector_simulator')

job = execute(circuit, backend)

result = job.result()

quantum_state = result.get_statevector(circuit)

print("A fogadó (Bob) által kapott qubit állapota:")

print(quantum_state)

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

https://quantum.cloud.ibm.com/docs/en/api/qiskit/qiskit.circuit.QuantumCircuit

https://medium.com/qubitco/coding-single-qubit-circuits-in-qiskit-4f19e4d858b2

A Drake-egyenlet pythonban

Ahhoz hogy megbecsülhessük pythonban a valószínüségét az ufóknak, ez egy becslés a kommunikációra képes civilizációkra a Tejútrendszerben, persze néhány kérdésre választ kell találnunk előtte.

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

def drake_equation():

    print("A Drake-egyenlet (Becslés a kommunikációra képes civilizációkra a Tejútrendszerben)")

    print("-" * 75)

    try:

        # 1. R*: A Tejútrendszerben évente keletkező csillagok átlagos száma

        R = float(input("1. Évente keletkező csillagok száma (ajánlott: 1-7): "))

        

        # 2. fp: A bolygóval rendelkező csillagok aránya (0 és 1 között)

        fp = float(input("2. Bolygóval rendelkező csillagok aránya [0-1] (ajánlott: 0.5-1.0): "))

        

        # 3. ne: A csillagonkénti lakható bolygók száma

        ne = float(input("3. Lakható bolygók száma csillagonként (ajánlott: 1-5): "))

        

        # 4. fl: Azon lakható bolygók aránya, ahol ténylegesen kialakul az élet (0 és 1 között)

        fl = float(input("4. Élet kialakulásának aránya [0-1] (ajánlott: 0.1-1.0): "))

        

        # 5. fi: Azon bolygók aránya, ahol kifejlődik az intelligens élet (0 és 1 között)

        fi = float(input("5. Intelligens élet aránya [0-1] (ajánlott: 0.01-1.0): "))

        

        # 6. fc: Azon civilizációk aránya, amelyek kifejlesztenek kommunikációs technológiát (0 és 1 között)

        fc = float(input("6. Kommunikációs technológiát fejlesztő civilizációk aránya [0-1] (ajánlott: 0.1-0.2): "))

        

        # 7. L: A civilizáció várható élettartama (években)

        L = float(input("7. Civilizáció élettartama években (ajánlott: 1000 - 100000000): "))

        # Számítás

        N = R * fp * ne * fl * fi * fc * L

        print("-" * 75)

        print(f"Becsült kommunikációképes civilizációk száma a galaxisban: {N:,.2f}")

        

    except ValueError:

        print("Hiba: Kérlek számot adj meg!")

if __name__ == "__main__":

    drake_equation()

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

A Drake-egyenlet (Becslés a kommunikációra képes civilizációkra a Tejútrendszerben)

1. Évente keletkező csillagok száma (ajánlott: 1-7): 1 =R

2. Bolygóval rendelkező csillagok aránya [0-1] (ajánlott: 0.5-1.0): 0.5 = f_p 

3. Lakható bolygók száma csillagonként (ajánlott: 1-5): 1 =n_e

4. Élet kialakulásának aránya [0-1] (ajánlott: 0.1-1.0): 0.1 =f_l

5. Intelligens élet aránya [0-1] (ajánlott: 0.01-1.0):  0.01  =f_i

6. Kommunikációs technológiát fejlesztő civilizációk aránya [0-1] (ajánlott: 0.1-0.2): 0.1=f_c

7. Civilizáció élettartama években (ajánlott: 1000 - 100000000): L =3000

Becsült kommunikációképes civilizációk száma a galaxisban: R= 0.1500

A legszigorúbb számítások és feltételek mellett a Tejútrendszerben jelenleg \(0,15\) olyan civilizáció található, amellyel képesek lennénk felvenni a kapcsolatot, ergó 7 galaxisonként egy az esély, ami 2800 milliárd csillagonként egyet jelent. Elképesztően kicsi az esély rá.

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

https://python-fiddle.com/examples/sympy?checkpoint=1781801118

L'Hospital-szabály pythonban.

Pythonban a sympy (szimbolikus matematika) könyvtár segítségével alkalmazzuk a L'Hospital-szabályt.

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

from sympy import symbols, Limit, tan, sin

# Szimbólum definiálása

x = symbols('x')

# Példa függvények

f = tan(x) - x

g = x - sin(x)

hely = 0

def l_hospital_vizsgalat(f, g, x, hely):

    print(f"Függvények: f(x) = {f} / g(x) = {g}")

    print(f"Határérték helye: x -> {hely}")

    

    # Eredeti határérték létrehozása

    hatarertek = Limit(f/g, x, hely)

    erteke = hatarertek.doit()

    

    # HIBA JAVÍTÁSA: 

    # A sympy.Limit objektumnak nincs .expr attribútuma. 

    # Használjuk magát a 'hatarertek' objektumot vagy a 'hatarertek.args[0]'-t a belső kifejezéshez.

    print(f"Eredeti határérték: {hatarertek} = {erteke}\n")

    # L'Hospital alkalmazása szemléltetés céljából (0/0 esetén)

    print("L'Hospital-szabály alkalmazása...")

    f_deriv = f.diff(x)

    g_deriv = g.diff(x)

    

    print(f"Új számláló (f'): {f_deriv}")

    print(f"Új nevező (g'): {g_deriv}")

    

    uj_hatarertek = Limit(f_deriv / g_deriv, x, hely)

    uj_erteke = uj_hatarertek.doit()

    

    # Itt is javítva az attribútum hiba

    print(f"Új határérték: {uj_hatarertek} = {uj_erteke}")

# Program futtatása

l_hospital_vizsgalat(f, g, x, hely)

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

Függvények: f(x) = -x + tan(x) / g(x) = x - sin(x)

Határérték helye: x -> 0

Eredeti határérték: Limit((-x + tan(x))/(x - sin(x)), x, 0, dir='+') = 2

L'Hospital-szabály alkalmazása...

Új számláló (f'): tan(x)**2

Új nevező (g'): 1 - cos(x)

Új határérték: Limit(tan(x)**2/(1 - cos(x)), x, 0, dir='+') = 2

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

Futtatás; https://python-fiddle.com/examples/sympy?checkpoint=1781800356

Differenciálszámítás megoldása pythonban

A deriválás (differenciálszámítás) egy matematikai művelet, amely megadja, hogy egy függvény (például egy görbe) hogyan változik, milyen gyorsan növekszik vagy csökken az egyes pontjaiban. Másra is használható; geometriai értelemben a derivált a függvény adott pontjához húzott érintő meredekségét (a meredekségszög tangensét) jelenti.  A megtett út deriválásával kapjuk a sebességet, a sebesség deriválásával pedig a gyorsulást. A közgazdaságtanban:  A költségfüggvény deriválásával meghatározható a határköltség (az egységnyi termelésnövekedéssel járó többletköltség).Optimalizálás: Maximumok és minimumok (szélsőértékek) keresése. Ahol a derivált értéke nulla, ott a függvénynek helyi szélsőértéke lehet. 

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

import sympy as sp

# 1. Szimbolikus változó és függvény definiálása

x = sp.symbols('x')

fuggveny = x**3 + 5*x**2 - 2*x + 7

# 2. Deriválás x szerint

derivalt = sp.diff(fuggveny, x)

# 3. Eredmények kiíratása

print("Eredeti függvény: f(x) = ", fuggveny)

print("Első derivált:    f'(x) = ", derivalt)

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

A 3x - 5 < 4x + 7 egyenlőtlenség megoldása: 

A valós számok halmazán a megoldás; (-12 < x)  és (x < végtelen)

Statsztikai valószinűség pythonban

Gyakoriság vizsgálat

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

import random

# Példa korábbi sorsolásokra (minden sor egy 7 számból álló húzás)

historical_draws = [

    [2, 9, 16, 17, 18, 20, 35],

    [2, 3, 9, 11, 15, 18, 35],

    [4, 10, 12, 14, 16, 30, 32],

    [1, 5, 13, 23, 25, 32, 33],

    [15, 17, 22, 24, 25, 27, 33],

    [8, 12, 13, 17, 18, 32, 33],

    [1, 2, 9, 11, 18, 29, 30],

    [8, 15, 23, 25, 26, 30, 34],

    [2, 4, 8, 11, 26, 27, 28],

    [7, 12, 16, 25, 30, 32, 33],

    [2, 4, 12, 21, 25, 30, 33],

    [9, 14, 15, 17, 19, 21, 23],

    [7, 10, 17, 20, 22, 23, 29],

]

# Egyszerű gyakorisági alapú "jóslás"

number_count = {i: 0 for i in range(1, 36)}

for draw in historical_draws:

    for num in draw:

        number_count[num] += 1

# A 6 leggyakoribb szám kiválasztása

predicted_numbers = sorted(

    sorted(number_count.items(), key=lambda x: (-x[1], x[0]))[:7],

    key=lambda x: x[0]

)

result = [num for num, count in predicted_numbers]

print(f"A statisztikailag legvalószínűbb skandináv lottószámok a következő húzásra: {result}")

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

A statisztikailag legvalószínűbb skandináv lottószámok a következő húzásra: [2, 9, 12, 17, 25, 30, 33]

Keresünk valamit egy oldalon python segítségével

Saját oldalamon teszteltem

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

import requests

from bs4 import BeautifulSoup

def keres():

    urls = [

        "http://szabolaszloistvan.blogspot.com/",

        "http://szli.inf.hu"

    ]

    keresett_kifejezes = "Közművelődés, kultúra, oktatás, könyvtár, pedagógia, műszaki informatika, számítástechnika"

    for url in urls:

        try:

            response = requests.get(url, timeout=10)

            response.raise_for_status()

            html_tartalom = response.content.decode("utf-8", errors="ignore")

            soup = BeautifulSoup(html_tartalom, "html.parser")

            if keresett_kifejezes in soup.get_text():

                print(f"Siker! A '{keresett_kifejezes}' kifejezés megtalálható a(z) {url} oldalon.")

                print(f"Link: {url}")

                return

            else:

                print(f"A(z) '{keresett_kifejezes}' kifejezés nem található meg a(z) {url} oldalon.")

                print(f"Link: {url}")

                return

        except requests.exceptions.RequestException as e:

            last_error = e

    print(f"Hiba történt az oldal letöltése közben: {last_error}")

if __name__ == "__main__":

    keres()

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

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

Futtatás; https://www.onlinegdb.com/online_python_interpreter