Objektum felismerés pyrhonnal

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

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

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()

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