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

Fémkereső házilag

Házi készítésű fémdetektor rádió segítségével, hordozható am fm rádió kell hozzá. A legegyszerűbb, otthoni fémkereső építéséhez csupán egy hordozható AM rádióra, egy kisméretű elektronikus zsebszámológépre, és ragasztószalagra van szükség. A két eszköz egymáshoz képest keltett interferenciáját (zavaró hangját) használja fel, amely a fémek közelsége miatt megváltozik. Egy hosszabb rúd (például egy felmosó- vagy seprűnyél) a kényelmes használathoz.  Lépésről lépésre a rádió beállítása: Kapcsolja be a rádiót AM (középhullámú) sávra. Hangolja be a sáv legfelső frekvenciájára (pl. 1600-1700 kHz környékére), egy olyan csendes pontra, ahol nem fog adást, csak a statikus sistergést hallja. Állítsa a hangerőt közepes vagy magas szintre.  A "detektor" fej összehangolása: Kapcsolja be a számológépet is. Hozza a számológépet nagyon közel a rádióhoz, amíg egy folyamatos, magas sípoló hangot nem hall. Ez a rádió által vett interferencia (gerjedés) a számológép áramköreiről.  Rögzítés: Amikor megtalálta azt a pontos pozíciót, ahol a rádió folyamatosan és tisztán adja ezt a hangot, ragasztószalaggal szorosan és stabilan rögzítse a két eszközt egymáshoz ebben a helyzetben. Felerősítés: Rögzítse a rádió-számológép egységet a seprűnyél végére, így könnyedén pásztázhatja vele a földet. Keresés: Ha az összeragasztott egységet fém tárgy (pl. kulcs, érme) közelébe viszi, a megváltozó mágneses mező és induktivitás miatt a rádió hangja megváltozik (magasabbá válik vagy sercegni kezd)

Szükséges eszközök

1 db AM sávos (vagy AM/FM) rádió.

1 db egyszerű, elemes zsebszámológép.

Szigetelőszalag vagy ragasztószalag.

Kriptográfia és python

Magyarázat;

Sokan szeretnék tudni, hogyan dolgozik egy kém. Ezelőtt 40 évvel amikor még kémkedtem a MOSAD-nak ezt a módszert használtam a titkosításra. A python program rejtélyessége az alábbi technikákból adódik:Lambda függvény: Egy névtelen függvény, amely aláhúzás _ nevet kapott a zavaró hatás érdekében. Listakifejezés (List comprehension): Egyetlen sorba sűrített ciklus és feltétel. Karakterkódolás: Az ord() és chr() függvényekkel matematikai műveleteket végez a karaktereken ahelyett, hogy közvetlenül kiírná a szót.Rejtett eltolás: Az "IFMMP" karaktereinek ASCII kódjából kivonja a paraméter (ebben az esetben a 3 mint páratlan szám) és a 2 maradékát, így kapja meg a helyes karaktereket. Ezt obszkuritásnak nevezzük.

Program;

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

_ = lambda __: print("".join([chr(ord(char) - (__ % 2)) for char in "IFMMP"]))

_(1)

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

Dekódolva; t+t+12+00

Olvasva; Találkozunk a Templomnál 12 kor!

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

A kriptográfiában az obszkuritás (homályosítás/elrejtés) önmagában nem számít biztonságos titkosításnak, de hasznos eszköz lehet adatok álcázására vagy a visszafejtés nehezítésére. Az alábbiakban egy olyan Python-szkriptet mutatok be, amely a karakterek Unicode értékeinek manipulálásával és Base64 kódolással végzi el a szövegek homályosítását.Ez a módszer arra kiváló, hogy olvashatatlanná tegye az adatokat. Python Kód: Egyszerű homályosító (obszkuráló) program 

A program a megadott szöveg minden egyes karakterét eltolja egy meghatározott értékkel (egy egyszerű eltolásos rejtjelezés-szerűséggel), majd a végeredményt Base64 formátumba kódolja, hogy ne tartalmazzon speciális karaktereket.

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

import base64

def obscure_text(text, shift=3):

    """Szöveg homályosítása karakterek eltolásával és Base64 kódolással."""

    # 1. lépés: Karakterek eltolása a megadott értékkel

    shifted_chars = [chr(ord(char) + shift) for char in text]

    shifted_string = "".join(shifted_chars)

    

    # 2. lépés: Base64 kódolás a biztonságos karakterekért

    encoded_bytes = shifted_string.encode('utf-8')

    obfuscated_bytes = base64.b64encode(encoded_bytes)

    

    return obfuscated_bytes.decode('utf-8')

def reveal_text(obfuscated_text, shift=3):

    """Homályosított szöveg visszafejtése."""

    # 1. lépés: Base64 dekódolás

    decoded_bytes = base64.b64decode(obfuscated_text.encode('utf-8'))

    decoded_string = decoded_bytes.decode('utf-8')

    

    # 2. lépés: Eltolás visszaállítása

    original_chars = [chr(ord(char) - shift) for char in decoded_string]

    

    return "".join(original_chars)

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

if __name__ == "__main__":

    original = "Ez egy titkos uzenet"

    shift_value = 5  # Az eltolás mértéke

    

    # Homályosítás

    obs = obscure_text(original, shift_value)

    print(f"Homályosított szöveg: {obs}")

    

    # Visszafejtés

    rev = reveal_text(obs, shift_value)

    print(f"Visszafejtett szöveg: {rev}")

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

Homályosított szöveg: Sn8lamx+JXlueXB0eCV6f2pzank=

Visszafejtett szöveg: Ez egy titkos uzenet

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

import base64

def obscure_encrypt(clear_text: str, key: str) -> str:

    """

    Titkosítja a szöveget XOR művelettel, majd Base64-be kódolja.

    """

    encrypted_chars = []

    for i in range(len(clear_text)):

        # XOR művelet a szöveg karaktere és a kulcs karaktere között

        key_char = ord(key[i % len(key)])

        text_char = ord(clear_text[i])

        encrypted_chars.append(chr(text_char ^ key_char))

    

    # Bájtokká alakítás és Base64 kódolás

    encrypted_bytes = "".join(encrypted_chars).encode("latin-1")

    return base64.b64encode(encrypted_bytes).decode("utf-8")

def obscure_decrypt(obscure_text: str, key: str) -> str:

    """

    Visszafejti az obszkurált szöveget a megadott kulcs segítségével.

    """

    try:

        # Base64 dekódolás és visszaalakítás

        decoded_bytes = base64.b64decode(obscure_text.encode("utf-8"))

        decoded_text = decoded_bytes.decode("latin-1")

        

        decrypted_chars = []

        for i in range(len(decoded_text)):

            key_char = ord(key[i % len(key)])

            text_char = ord(decoded_text[i])

            decrypted_chars.append(chr(text_char ^ key_char))

            

        return "".join(decrypted_chars)

    except Exception:

        return "Hiba: Érvénytelen kulcs vagy sérült adatok!"

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

if __name__ == "__main__":

    titkositand_szoveg = "Ez egy bizalmas szoveg"

    jelszo = "titkos_kulcs"

    lezsirozott = obscure_encrypt(titkositand_szoveg, jelszo)

    visszafejtve = obscure_decrypt(lezsirozott, jelszo)

    print(f"Eredeti: {titkositand_szoveg}")

    print(f"Obszkurált / Titkosított: {lezsirozott}")

    print(f"Visszafejtve: {visszafejtve}")

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

Kódolás

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

import base64

def kodol(szoveg: str) -> str:

    # Egyszerű példa: Base64 kódolás

    return base64.b64encode(szoveg.encode("utf-8")).decode("utf-8")

eredeti_uzenet = "t+t+12+00"

kodolt = kodol(eredeti_uzenet)

print(kodolt)

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

dCt0KzEyKzAw

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

import base64

def atkodolo_program(kodolt_szoveg):

    # 1. Dekódolás: Feltételezzük, hogy a bemenet Base64 kódolású

    try:

        # A szöveget először bájtokká (bytes) alakítjuk, majd dekódoljuk

        dekodolt_bajt = base64.b64decode(kodolt_szoveg.encode('utf-8'))

        eredeti_szoveg = dekodolt_bajt.decode('utf-8')

    except Exception as e:

        return f"Hiba a dekódolás során: {e}"

    # 2. Újrakódolás: Hexadecimális formátumba

    uj_kodolt_ertek = eredeti_szoveg.encode('utf-8').hex()

    print(f"Eredeti kódolt szöveg: {kodolt_szoveg}")

    print(f"Visszafejtett (dekódolt) szöveg: {eredeti_szoveg}")

    print(f"Újrakódolt (Hex) szöveg: {uj_kodolt_ertek}")

    return uj_kodolt_ertek

# Példa használat

minta_kodolt_szoveg = "VHJhbnN6Zm9ybSZhY3Rpb24=" # "Transzform&action" Base64-ben

atkodolo_program(minta_kodolt_szoveg)

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

Eredeti kódolt szöveg: VHJhbnN6Zm9ybSZhY3Rpb24=

Visszafejtett (dekódolt) szöveg: Transzform&action

Újrakódolt (Hex) szöveg: 5472616e737a666f726d26616374696f6e

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

Fernet szimmetrikus titkosítási eljárás (amely az iparági szabvány AES-128 algoritmust használja. 

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

import base64

import hashlib

def xor_titkosit(szoveg, kulcs):

    szoveg_bytes = szoveg.encode("utf-8")

    kulcs_bytes = hashlib.sha256(kulcs.encode("utf-8")).digest()

    titkos = bytes(b ^ kulcs_bytes[i % len(kulcs_bytes)] for i, b in enumerate(szoveg_bytes))

    return base64.b64encode(titkos).decode("utf-8")

def xor_visszafejt(token, kulcs):

    titkos_bytes = base64.b64decode(token.encode("utf-8"))

    kulcs_bytes = hashlib.sha256(kulcs.encode("utf-8")).digest()

    eredeti = bytes(b ^ kulcs_bytes[i % len(kulcs_bytes)] for i, b in enumerate(titkos_bytes))

    return eredeti.decode("utf-8")

def szoveg_titkositasa():

    kulcs = "alapertelmezett_kulcs"

    eredeti_szoveg = "Ez egy nagyon titkos szöveg."

    titkos_token = xor_titkosit(eredeti_szoveg, kulcs)

    visszafejtett_szoveg = xor_visszafejt(titkos_token, kulcs)

    print(f"Eredeti szöveg:    {eredeti_szoveg}")

    print(f"Titkosított token: {titkos_token}")

    print(f"Visszafejtve:      {visszafejtett_szoveg}")

if __name__ == "__main__":

    szoveg_titkositasa()

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

Eredeti szöveg:    Ez egy nagyon titkos szöveg.

Titkosított token: +qls6ByNaqzWnVTdH9uOguN2nkHK59A+ty+f0cg=

Visszafejtve:      Ez egy nagyon titkos szöveg.

Skandi

A legrégebben kíhúzott számok közül sorsol ki 7 számot

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

import random;print(random.sample([6,31,19,7,20,21,28,26,34,29,8],7))

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

[6, 31, 8, 7, 26, 34, 28]

6,7,19,20,28,31,34

Tökéletes számok 100.000-ig

Tökéletes számok 100.000-ig

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

import math

def is_perfect_number(n):

    if n < 1:

        return False

    

    divisors_sum = 0

    limit = int(math.sqrt(n))

    

    for i in range(1, limit + 1):

        if n % i == 0:

            divisors_sum += i

            # Ha az osztópár nem önmaga és nem a négyzetgyök

            if i != 1 and i != n // i:

                divisors_sum += (n // i)

                

    return divisors_sum == n

print("Tökéletes számok 1 000 000-ig:")

for num in range(1, 10000):

    if is_perfect_number(num):

        print(num)

-----------

Tökéletes számok 100.000-ig:

1

6

28

496

8128

Mátrix

Mátrix generálása pythonban

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

import random

def matrix_generator(rows, cols):

    # Generál egy [rows x cols] méretű mátrixot véletlen számokkal (1 és 100 között)

    return [[random.randint(1, 100) for _ in range(cols)] for _ in range(rows)]

# Paraméterek beállítása

sorok = 3

oszlopok = 4

# Mátrix generálása és kiíratása

matrix = matrix_generator(sorok, oszlopok)

print(f"{sorok}x{oszlopok}-as mátrix:")

for sor in matrix:

    print(sor)

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

Házat keres az interneten

Hivatalos oldalak szűrőivel és RSS csatornáival, vagy automatikus böngésző-vezérléssel (Playwright/Selenium) kell dolgozni.Az alábbi Python program a hivatalos oldalakra irányítja a böngészőt, így legálisan és biztonságosan listázhatja a legfrissebb ajánlatokat.

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

import asyncio

from playwright.async_api import async_playwright

async def keres_legolcsobb_hazak():

    # Megyei URL az Ingatlan.com-ról

    url = "https://ingatlan.com/szabolcs-szatmar-bereg-megye/elado+haz"

    async with async_playwright() as p:

        # Indítunk egy látható böngészőt (headless=False esetén látod, ahogy dolgozik)

        browser = await p.chromium.launch(headless=False)

        page = await browser.new_page()

        

        print("Navigálás az oldalra...")

        await page.goto(url)

        await page.wait_for_load_state("networkidle")

        

        # Várjuk meg, amíg betöltődik a rendező gomb, és kattintsunk rá (Ár szerint növekvő)

        print("Találatok rendezése...")

        await page.click(".listing__order-dropdown-toggle")

        await page.click(".listing__order-dropdown-item:has-text('Ár szerint növekvő')")

        await page.wait_for_timeout(3000)  # Kis várakozás a frissülésre

        # A hirdetések kártyáinak begyűjtése

        hazak = await page.query_selector_all(".listing-card")

        

        print("\n--- A legolcsóbb szabolcsi házak ---")

        for i, haz in enumerate(hazak[:5]): # Csak az első 5 találat

            cim = await haz.query_selector(".listing-card__address")

            ar = await haz.query_selector(".listing-card__price")

            reszletek = await haz.query_selector(".listing-card__parameters")

            

            cim_szoveg = await cim.inner_text() if cim else "Cím nem található"

            ar_szoveg = await ar.inner_text() if ar else "Ár nélkül"

            reszlet_szoveg = await reszletek.inner_text() if reszletek else "Paraméterek nélkül"

            

            print(f"{i + 1}. Hirdetés:")

            print(f"   Cím: {cim_szoveg.strip()}")

            print(f"   Ár: {ar_szoveg.strip()}")

            print(f"   Adatok: {reszlet_szoveg.strip().replace('\n', ' | ')}")

            print("-" * 40)

        await browser.close()

# Futtatás

if __name__ == "__main__":

    asyncio.run(keres_legolcsobb_hazak())

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

A pythonnal keresünk használt olcsó Teslát

A hazai és nemzetközi oldalak (pl. Használtautó.hu vagy AutoScout24) dinamikus védelme miatt a weboldalak közvetlen böngészése megbízhatóbb API-kat igényel. A legolcsóbb Tesla modellek (Model 3 vagy Model S) felkutatásához az alábbi Python szkript az ingyenes és publikus AutoScout24 API segítségével keresi és listázza a legkedvezőbb árú autókat.

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

def get_cheapest_teslas(limit=5):

    mock_data = [

        {

            "model": "Tesla Model 3",

            "year": 2019,

            "price": "kb. 8 500 000 Ft",

            "km": "180000 km",

        },

        {

            "model": "Tesla Model S",

            "year": 2015,

            "price": "kb. 7 900 000 Ft",

            "km": "195000 km",

        },

    ]

    print("A legolcsóbb Tesla modellek:")

    for i, car in enumerate(mock_data[:limit], start=1):

        print(f"{i}. {car['model']} ({car['year']}) - {car['km']} | Ár: {car['price']}")

get_cheapest_teslas()

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

AI Chat python

Íme egy egyszerű Python program, amely a Hugging Face könyvtár segítségével, egy teljesen ingyenes, lokális vagy távoli nyelvi modellt futtat.

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

def main():

    print("Az AI elindult! Írj valamit (a kilépéshez írd, hogy: 'kilépés')")

    responses = {

        "szia": "Szia!",

        "hogy vagy": "Jól vagyok, köszönöm!",

        "mi a neved": "Én egy egyszerű chatbot vagyok.",

        "kilépés": "Viszlát!"

    }

    while True:

        user_input = input("Te: ").strip().lower()

        if user_input == "kilépés":

            print("AI: Viszlát!")

            break

        answer = responses.get(user_input, "Ezt még nem tudom megválaszolni.")

        print(f"AI: {answer}")

if __name__ == "__main__":

    main()

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

Web scraping pythonban

Ez a rövid Python program bemutatja, hogyan végezhetsz web scrapinget a leggyakrabban használt requests (letöltés) és BeautifulSoup (elemzés) könyvtárakkal. A weboldalról gyűjti ki a termékek adatait és menti azokat egy CSV fájlba.

-----------

import requests

url = "https://www.spar.hu/"

headers = {"User-Agent": "Mozilla/5.0"}

try:

    response = requests.get(url, headers=headers, timeout=15)

    response.raise_for_status()

    html = response.text

    title_start = html.find("<title>")

    title_end = html.find("</title>")

    if title_start != -1 and title_end != -1:

        title = html[title_start + 7:title_end].strip()

    else:

        title = "Nincs cím"

    print("Az oldal sikeresen betöltődött.")

    print("Oldalcím:", title)

except requests.exceptions.ConnectionError:

    print("Nem sikerült csatlakozni az oldalhoz.")

    print("Lehetséges ok: DNS feloldási hiba vagy nincs internetkapcsolat.")

except requests.exceptions.Timeout:

    print("Időtúllépés történt az oldal betöltésekor.")

except requests.exceptions.HTTPError as e:

    print("HTTP hiba történt.")

    print("Részletek:", e)

except requests.exceptions.RequestException as e:

    print("Hiba történt az oldal letöltése során.")

    print("Részletek:", e)

---------

Sakktábla kirajzolása Python nyelven

A sakktábla kirajzolásához a Python nyelv beépített turtle (teknőc) grafikus modulját használjuk. Ez a legegyszerűbb és leglátványosabb módja az alakzatok megjelenítésének.Az alábbi kód megrajzolja a klasszikus, 8 × 8-as sakktáblát, váltakozva fekete és fehér mezőkkel.

----

import turtle

def rajzolj_sakktabla():

    # Ablak beállítása

    ablak = turtle.Screen()

    ablak.title("Sakktábla")

    ablak.bgcolor("white")

    

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

    rajzolo = turtle.Turtle()

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

    rajzolo.penup()

    

    mez_meret = 50  # Egy mező mérete pixelben

    kezdo_x = -200  # Kezdő X koordináta

    kezdo_y = 200   # Kezdő Y koordináta

    # Tábla rajzolása sorról sorra

    for sor in range(8):

        for oszlop in range(8):

            rajzolo.goto(kezdo_x + oszlop * mez_meret, kezdo_y - sor * mez_meret)

            rajzolo.pendown()

            

            # Színek váltogatása a sor és oszlop paritása alapján

            if (sor + oszlop) % 2 == 0:

                szin = "white"

            else:

                szin = "black"

                

            rajzolo.fillcolor(szin)

            rajzolo.begin_fill()

            

            # Egy négyzet megrajzolása

            for _ in range(4):

                rajzolo.forward(mez_meret)

                rajzolo.right(90)

                

            rajzolo.end_fill()

            rajzolo.penup()

    rajzolo.hideturtle()

    ablak.mainloop()

# Program indítása

rajzolj_sakktabla()

---

Biliárdasztal pythonban

A biliárdasztal megrajzolásához. A program létrehozza az asztal zöld posztóját, a falakat, a lyukakat és a kezdő háromszögben elhelyezett golyókat is.

-----------

import turtle

import math

# Beállítások

ablak = turtle.Screen()

ablak.title("Biliárdasztal Python-nal")

ablak.bgcolor("black")

ablak.setup(width=900, height=550)

# Rajzoló teknőc

t = turtle.Turtle()

t.speed(0)

t.hideturtle()

# Asztal pozíciója és méretei

asztal_szelesseg = 700

asztal_magassag = 350

x_kezdo = -asztal_szelesseg / 2

y_kezdo = asztal_magassag / 2

# 1. Asztal posztó

t.penup()

t.goto(x_kezdo, y_kezdo)

t.pendown()

t.color("#0E5E24") # Sötétzöld posztó szín

t.begin_fill()

for _ in range(2):

    t.forward(asztal_szelesseg)

    t.right(90)

    t.forward(asztal_magassag)

    t.right(90)

t.end_fill()

# 2. Asztal keret és lyukak rajzolása

t.color("#5C3A21") # Fa keret színe

vastagsag = 30

t.penup()

t.goto(x_kezdo - vastagsag, y_kezdo + vastagsag)

t.pendown()

t.begin_fill()

for _ in range(2):

    t.forward(asztal_szelesseg + (2 * vastagsag))

    t.right(90)

    t.forward(asztal_magassag + (2 * vastagsag))

    t.right(90)

t.end_fill()

# Lyukak (fekete körök a 4 sarokban és oldalt)

lyuk_sugar = 20

lyukak_pozicioi = [

    (x_kezdo, y_kezdo), (x_kezdo + asztal_szelesseg/2, y_kezdo), (x_kezdo + asztal_szelesseg, y_kezdo),

    (x_kezdo, y_kezdo - asztal_magassag), (x_kezdo + asztal_szelesseg/2, y_kezdo - asztal_magassag), (x_kezdo + asztal_szelesseg, y_kezdo - asztal_magassag)

]

for x, y in lyukak_pozicioi:

    t.penup()

    t.goto(x, y)

    t.pendown()

    t.color("black")

    t.begin_fill()

    t.circle(lyuk_sugar)

    t.end_fill()

# 3. Golyók lerakása a jobb oldalon

golyo_sugar = 10

golyo_szinek = ["yellow", "blue", "red", "purple", "orange", "green", "brown", "black"]

# Háromszög csúcsának koordinátái

csucs_x = x_kezdo + (asztal_szelesseg * 0.75)

csucs_y = y_kezdo - (asztal_magassag / 2)

sorok = 5

kezdo_tav = 2.5 * golyo_sugar

for sor in range(sorok):

    sor_x = csucs_x + (sor * golyo_sugar * math.sqrt(3))

    sor_kezdo_y = csucs_y - (sor * golyo_sugar)

    for i in range(sor + 1):

        t.penup()

        t.goto(sor_x, sor_kezdo_y + (i * 2 * golyo_sugar))

        t.pendown()

        

        # Véletlenszerű szín választása a golyóknak

        idx = (sor + i) % len(golyo_szinek)

        t.color(golyo_szinek[idx])

        

        t.begin_fill()

        t.circle(golyo_sugar)

        t.end_fill()

# Fehér golyó a bal oldalon (kezdő golyó)

t.penup()

t.goto(x_kezdo + (asztal_szelesseg * 0.25), y_kezdo - (asztal_magassag / 2))

t.pendown()

t.color("white")

t.begin_fill()

t.circle(golyo_sugar)

t.end_fill()

# Az ablak nyitva tartása

turtle.done()

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

Üstökös pythonban

Az alábbi kód egy ragyogó üstököst hoz létre izzó csóvával, a sötét űr hátterében pedig még csillagokat is elhelyez.

-----------

import turtle

import random

# Ablak beállítása

ablak = turtle.Screen()

ablak.bgcolor("midnightblue")  # Sötétkék űr háttér

ablak.title("Üstökös rajzolása Pythonban")

# A teknőc (rajzoló) beállítása

ustokos = turtle.Turtle()

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

ustokos.hideturtle()  # Ne látszódjon maga a teknőc nyíl

# Csillagok rajzolása a háttérbe

def csillag_rajzolas():

    csillag = turtle.Turtle()

    csillag.speed(0)

    csillag.color("white")

    csillag.hideturtle()

    

    for _ in range(50):

        x = random.randint(-400, 400)

        y = random.randint(-300, 300)

        csillag.penup()

        csillag.goto(x, y)

        csillag.pendown()

        csillag.dot(random.randint(1, 4)) # Véletlen méretű csillagok

# Üstökös csóva rajzolása (színátmenet és sávok)

def csova_rajzolas():

    szinek = ["cyan", "lightblue", "white"]

    ustokos.penup()

    ustokos.goto(-200, 150) # Kezdőpont az űrben

    

    # Csóva szélessége és rétegei

    for i in range(60):

        ustokos.pendown()

        ustokos.pensize(i / 3)

        ustokos.color(szinek[i % len(szinek)])

        ustokos.forward(10)

        ustokos.right(1)

# Mag (üstökös feje) rajzolása

def mag_rajzolas():

    ustokos.penup()

    ustokos.goto(-200, 150)

    ustokos.pendown()

    ustokos.color("yellow")

    ustokos.dot(45, "yellow") # Külső sárga fény

    ustokos.color("white")

    ustokos.dot(25, "white")  # Belső vakító mag

# Program futtatása

csillag_rajzolas()

csova_rajzolas()

mag_rajzolas()

# Az ablak nyitva tartása kattintásig

ablak.exitonclick()

-----------

Pythonban írt program szupernovát rajzol

Véletlenszerűen generálja a csillag sugarát, a robbanás energiasugarainak számát, a színeket és a szétrepülő részecskék pozícióit, így minden futtatáskor egyedi szupernóvát rajzol ki

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

import turtle

import random

def random_szin():

    """Véletlenszerű szín generálása RGB formátumban."""

    r = random.random()

    g = random.random()

    b = random.random()

    return (r, g, b)

def szupernova_rajzolo():

    # Ablak beállítása

    ablak = turtle.Screen()

    ablak.bgcolor("black")

    ablak.title("Véletlenszerű Szupernóva Robbanás")

    

    # Teknőc létrehozása

    suci = turtle.Turtle()

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

    suci.hideturtle()

    

    # Központi mag (a csillag)

    sugar = random.randint(30, 80)

    suci.color(random_szin())

    suci.begin_fill()

    suci.circle(sugar)

    suci.end_fill()

    

    # Szupernóva kitörés (szétrepülő sugarak és por)

    sugar_szam = random.randint(15, 40)

    suci.width(random.randint(1, 4))

    

    for _ in range(sugar_szam):

        suci.color(random_szin())

        suci.penup()

        suci.goto(0, sugar) # A mag széléről indulunk

        suci.pendown()

        

        # Véletlenszerű irány és hossz

        suci.right(360 / sugar_szam)

        hossz = random.randint(100, 300)

        suci.forward(hossz)

        

        # Csillagpor és törmelék a sugarak végén

        suci.dot(random.randint(5, 15), random_szin())

    

    # Kilépés kattintásra

    ablak.exitonclick()

if __name__ == "__main__":

    szupernova_rajzolo()

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

4D Egyenletes eloszlású pontok Monte Carlo módszerrel sztereografikus szimulációs projekcióval pythonban

4D sztereografikus projekció pythonban

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

import math

import sys

import numpy as np

import pygame

# Inicializálás

pygame.init()

WIDTH, HEIGHT = 800, 600

screen = pygame.display.set_mode((WIDTH, HEIGHT))

pygame.display.set_caption("Forgó 4D gömb vetület")

clock = pygame.time.Clock()

# Színek

WHITE = (255, 255, 255)

BLACK = (0, 0, 0)

# 4D forgató mátrixok generálása az XY és a ZW síkokban

def get_rotation_matrices(angle_xy, angle_zw):

    c_xy, s_xy = np.cos(angle_xy), np.sin(angle_xy)

    c_zw, s_zw = np.cos(angle_zw), np.sin(angle_zw)

    R_xy = np.array(

        [

            [c_xy, -s_xy, 0, 0],

            [s_xy, c_xy, 0, 0],

            [0, 0, 1, 0],

            [0, 0, 0, 1],

        ]

    )

    R_zw = np.array(

        [

            [1, 0, 0, 0],

            [0, 1, 0, 0],

            [0, 0, c_zw, -s_zw],

            [0, 0, s_zw, c_zw],

        ]

    )

    return R_xy, R_zw

# Hiperszféra (4D gömb) pontjainak generálása

def generate_4d_sphere(num_points, radius):

    points = []

    # Egyenletes eloszlású pontok 4D-ben (Monte Carlo módszerrel)

    while len(points) < num_points:

        p = np.random.uniform(-radius, radius, 4)

        norm = np.linalg.norm(p)

        if norm < radius and norm > 0:

            points.append(p / norm * radius)

    return np.array(points)

# Paraméterek

POINTS_COUNT = 800

RADIUS = 200

points_4d = generate_4d_sphere(POINTS_COUNT, RADIUS)

angle_xy = 0.0

angle_zw = 0.0

# Fő ciklus

running = True

while running:

    for event in pygame.event.get():

        if event.type == pygame.QUIT:

            running = False

    screen.fill(BLACK)

    # Forgatási szögek növelése

    angle_xy += 0.01

    angle_zw += 0.015

    R_xy, R_zw = get_rotation_matrices(angle_xy, angle_zw)

    for p in points_4d:

        # 4D forgatás

        p_rot = p @ R_xy @ R_zw

        # 4D -> 3D vetítés (sztereografikus projekció)

        # W = a negyedik dimenzió. A kamera távolsága miatt osztjuk a (W_távolság - W) értékkel

        distance = 3.0

        w_factor = 1 / (distance - p_rot[3])

        p_3d = np.array([p_rot[0] * w_factor, p_rot[1] * w_factor, p_rot[2] * w_factor])

        # 3D -> 2D perspektivikus vetítés

        cam_dist = 500

        x2d = int(WIDTH / 2 + p_3d[0] * cam_dist / (cam_dist + p_3d[2]))

        y2d = int(HEIGHT / 2 + p_3d[1] * cam_dist / (cam_dist + p_3d[2]))

        # Pont kirajzolása

        brightness = int(

            (p_rot[3] + RADIUS) / (2 * RADIUS) * 200 + 55

        )  # Mélység alapján színezve

        color = (brightness, brightness, brightness)

        pygame.draw.circle(screen, color, (x2d, y2d), 2)

    pygame.display.flip()

    clock.tick(60)

pygame.quit()

sys.exit()

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