A Python egyszerű szintaxisa és kiterjedt könyvtárai révén a hackerek, kiberbiztonsági szakemberek és a nyomozók „titkos fegyvere” is egyben. Láthatatlan folyamatok automatizálására, biztonsági tesztelésre és adatgyűjtésre használják.A Python leggyakoribb titkos és rejtett műveletei:Biztonsági rések kutatása: Behatolásteszteléssel (Penetration Testing) feltérképezhetők a helyi hálózatok vagy weboldalak gyenge pontjai.Adatbányászat és Scraping: Titkos webes adatgyűjtés nyilvános, de nehezen elérhető forrásokból, például rejtett API-k vagy automatizált böngészők segítségével.Hálózati forgalom elemzése: Csomagok elfogása és dekódolása (Packet Sniffing) hálózati anomáliák vagy adatszivárgás észlelésére.Rejtett folyamatok automatizálása: Ismétlődő, monoton feladatok láthatatlan ütemezése és végrehajtása a háttérben.Ezeket a technikákat jellemzően a kiberbiztonságban (etikus hackelés) és IT-üzemeltetésben alkalmazzák. A rendszergazdák programozási tudásukat informatikai rendszerük tesztelésére is felhasználhatják.
Ezt a programot oktatási céllal hoztam létre!
------------------------
import random
import string
from itertools import product
# ========== RSA ALAPFOGALMAK ==========
def gcd(a, b):
while b:
a, b = b, a % b
return a
def mod_inverse(e, phi):
def extended_gcd(a, b):
if a == 0:
return b, 0, 1
gcd_val, x1, y1 = extended_gcd(b % a, a)
x = y1 - (b // a) * x1
y = x1
return gcd_val, x, y
_, x, _ = extended_gcd(e % phi, phi)
return (x % phi + phi) % phi
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(3, int(n**0.5) + 1, 2):
if n % i == 0:
return False
return True
def generate_prime(start=10000, end=50000):
while True:
num = random.randint(start, end)
if is_prime(num):
return num
# ========== RSA KULCSPAR GENERALASA ==========
def generate_rsa_keypair():
p = generate_prime()
q = generate_prime()
while q == p:
q = generate_prime()
n = p * q
phi = (p - 1) * (q - 1)
e = 65537
while e < phi and gcd(e, phi) != 1:
e += 1
d = mod_inverse(e, phi)
return (e, n), (d, n), p, q
# ========== RSA TITKOSITAS KARAKTERENKENT ==========
def rsa_encrypt_char(public_key, char):
"""RSA titkositas egy karakterre"""
e, n = public_key
char_int = ord(char)
return pow(char_int, e, n)
def rsa_encrypt(public_key, plaintext):
"""RSA titkositas minden karakterre"""
return [rsa_encrypt_char(public_key, c) for c in plaintext]
# ========== RSA DEKODOLAS KARAKTERENKENT ==========
def rsa_decrypt_char(private_key, ciphertext_char):
"""RSA dekodolas egy karakterre"""
d, n = private_key
decrypted_int = pow(ciphertext_char, d, n)
return chr(decrypted_int)
def rsa_decrypt(private_key, ciphertext_list):
"""RSA dekodolas minden karakterre"""
return ''.join(rsa_decrypt_char(private_key, c) for c in ciphertext_list)
# ========== 5 KARAKTERES JELSZO BRUTE-FORCE ==========
def brute_force_5char(encrypted_list, private_key):
characters = string.ascii_lowercase + string.ascii_uppercase + string.digits
d, n = private_key
total_combinations = len(characters) ** 5
print("Karakterkeszlet:", len(characters), "karakter")
print("Osszes kombinacio:", total_combinations)
print("Kereses kezdese...\n")
# Dekodoljuk az eredeti jelszot
true_password = rsa_decrypt(private_key, encrypted_list)
print("Cel jelszo (dekodolva):", true_password)
print()
max_attempts = 10000
attempts = 0
for combination in product(characters, repeat=5):
attempts += 1
guess = ''.join(combination)
if attempts % 5000 == 0:
print("Proba:", attempts, "- Aktuális:", guess)
if attempts >= max_attempts:
print("\nMegallitas", max_attempts, "probalkozas utan")
break
if guess == true_password:
print("\nMEGLELVE:", guess, "(", attempts, "probalkozas)")
return guess, attempts
print("\nJelszo nem talalhato az elso", min(attempts, max_attempts), "probalkozasban")
return None, attempts
# ========== TELJES PÉDA ==========
if __name__ == "__main__":
print("=" * 60)
print("RSA TITKOSITAS es 5 KARAKTERES JELSZO BRUTE-FORCE")
print("=" * 60)
print("\n[1] RSA kulcspár generálasa...")
public_key, private_key, p, q = generate_rsa_keypair()
e, n = public_key
d, n = private_key
print(" Publikus kulcs (e, n):", e, ",", n)
print(" Privát kulcs (d, n):", d, ",", n)
print(" Prímek: p =", p, ", q =", q)
print(" n = p * q =", p * q, "(elég nagy a 5 karaktershoz)")
print("\n[2] 5 karakteres jelszó titkosítása...")
secret_password = "ab12X"
print(" Eredeti jelszó:", secret_password)
encrypted = rsa_encrypt(public_key, secret_password)
---------------------
pitonimport random
import string
from itertools import product
def gcd(a, b):
while b:
a, b = b, a % b
return a
def mod_inverse(e, phi):
def extended_gcd(a, b):
if a == 0:
return b, 0, 1
gcd_val, x1, y1 = extended_gcd(b % a, a)
x = y1 - (b // a) * x1
y = x1
return gcd_val, x, y
_, x, _ = extended_gcd(e % phi, phi)
return (x % phi + phi) % phi
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(3, int(n**0.5) + 1, 2):
if n % i == 0:
return False
return True
def generate_prime(start=10000, end=50000):
while True:
num = random.randint(start, end)
if is_prime(num):
return num
def generate_rsa_keypair():
p = generate_prime()
q = generate_prime()
while q == p:
q = generate_prime()
n = p * q
phi = (p - 1) * (q - 1)
e = 65537
while e < phi and gcd(e, phi) != 1:
e += 1
d = mod_inverse(e, phi)
return (e, n), (d, n), p, q
def rsa_encrypt_char(public_key, char):
e, n = public_key
m = ord(char)
return pow(m, e, n)
def rsa_encrypt(public_key, plaintext):
return [rsa_encrypt_char(public_key, c) for c in plaintext]
def rsa_decrypt_char(private_key, ciphertext_char):
d, n = private_key
decrypted_int = pow(ciphertext_char, d, n)
return chr(decrypted_int)
def rsa_decrypt(private_key, ciphertext_list):
return ''.join(rsa_decrypt_char(private_key, c) for c in ciphertext_list)
def brute_force_password(encrypted_list, public_key, max_attempts=100000):
characters = string.ascii_lowercase + string.ascii_uppercase + string.digits
total_combinations = len(characters) ** 5
print("Karakterkeszlet:", len(characters), "karakter")
print("Osszes kombinacio:", total_combinations)
print("Keresés kezdése...\n")
attempts = 0
for combination in product(characters, repeat=5):
attempts += 1
guess = ''.join(combination)
if attempts % 50000 == 0:
print("Proba:", attempts, "- Aktualis:", guess)
guess_encrypted = [rsa_encrypt_char(public_key, c) for c in guess]
if guess_encrypted == encrypted_list:
print("\nMEGLELVE:", guess, "(" + str(attempts) + " probalkozas)")
return guess, attempts
if attempts >= max_attempts:
print("\nMegallitva", max_attempts, "probalkozas utan")
break
return None, attempts
if __name__ == "__main__":
print("=" * 70)
print("RSA JELSZO VISSZAFEJTES PROGRAM")
print("=" * 70)
print("\n[1] RSA kulcspar generalasa...")
public_key, private_key, p, q = generate_rsa_keypair()
e, n = public_key
d, n = private_key
print(" Publikus kulcs (e, n):", e, ",", n)
print(" Privat kulcs (d, n):", d, ",", n)
print(" Primek: p =", p, ", q =", q)
print("\n[2] Jelszo titkositasa...")
password = "ab12X"
print(" Eredeti jelszo:", password)
encrypted = rsa_encrypt(public_key, password)
print(" Titkosított ertekek:", encrypted)
print("\n[3] RSA visszafejtes (privat kulccsal)...")
decrypted = rsa_decrypt(private_key, encrypted)
print(" Visszafejtett jelszo:", decrypted)
print(" Sikeres:", decrypted == password)
print("\n[4] Brute-force visszafejtes (nincs privat kulcs)...")
print(" Megjegyzes: Csak az elso 10000 probalkozast csinalom meg.\n")
result, attempts = brute_force_password(encrypted, public_key, max_attempts=10000)
print("\n" + "=" * 70)
if result:
print("SIKER: Jelszo visszafejtve:", result)
else:
print("INFO: Jelszo nem lett megtalalva (korlatozott probalkozas)")
print("=" * 70)
-------------------
Packet Sniffing példa
------------------
import socket
import os
import struct
def get_protocol_name(protocol):
protocols = {
1: "ICMP",
6: "TCP",
17: "UDP",
47: "GRE",
50: "ESP",
51: "AH",
89: "OSPF",
132: "SCTP"
}
return protocols.get(protocol, "ISMERETLEN")
def main():
host = '0.0.0.0'
if os.name == 'nt':
socket_protocol = socket.IPPROTO_IP
print("Windows rendszer felismerve")
else:
socket_protocol = socket.IPPROTO_ICMP
print("Linux/Unix rendszer felismerve")
sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
sniffer.bind((host, 0))
sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
if os.name == 'nt':
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
print("=" * 70)
print("EGYSZERU PACKET SNIFFER")
print("=" * 70)
print("Csomagok figyelem kezdese... (Ctrl+C a leallitashoz)")
print("=" * 70)
try:
while True:
buffer, addr = sniffer.recvfrom(65565)
ip_header = buffer[0:20]
iph = struct.unpack('!BBHHHBBH4s4s', ip_header)
version_ihl = iph[0]
version = version_ihl >> 4
ihl = version_ihl & 0xF
iph_length = ihl * 4
protocol = iph[6]
s_addr = socket.inet_ntoa(iph[8])
d_addr = socket.inet_ntoa(iph[9])
protocol_name = get_protocol_name(protocol)
print("\n" + "-" * 70)
print("FORRAS IP:", s_addr)
print("CEL IP:", d_addr)
print("PROTOKOLL:", protocol_name, "(" + str(protocol) + ")")
print("CSOMAP MERET:", len(buffer), "byte")
except KeyboardInterrupt:
print("\n\nPacket sniffer leallitva")
if os.name == 'nt':
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
if __name__ == '__main__':
main()A javítások:
•Minden ékezetes betű kivéve (pl. "VERZIÓ" → "VERZI", "KÖNYVTÁRRAL" → "KONYVTARRAL")
•Nincs semmilyen komment a kód után
•Tiszta Python kód
Másold be és futtasd!
hiba Linux/Unix rendszer felismerve
Traceback (most recent call last):
File "/home/repl912/secret.py", line 72, in <module>
main()
File "/home/repl912/secret.py", line 28, in main
sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/usr/lib/python3.12/socket.py", line 233, in __init__
_socket.socket.__init__(self, family, type, proto, fileno)
PermissionError: [Errno 1] Operation not permitted
** Process exited - Return Code: 1 **Továbbiak megjelenítése
A hibaforrás és a hibai hozzáállás megértéseA hiba oka, hogy a RAW socket-hez root (sudo) jogosultság kell. Mivel a Pyodide/jelenvő környezetben ez nem lehetséges, itt egy alternatív Packet Sniffer, ami nem igényel RAW socketet:
pythonimport socket
import struct
import time
class PassivePacketMonitor:
"""Egyszeru passziv csomag monitor - nem kell sudo"""
def __init__(self):
self.packet_count = 0
self.tcp_count = 0
self.udp_count = 0
self.icmp_count = 0
def get_local_ip(self):
"""Local IP cimer kimasolasa"""
try:
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
s.connect(("8.8.8.8", 80))
return s.getsockname()[0]
except:
return "127.0.0.1"
def analyze_connection(self):
"""Aktiv kapcsolatok elemzese (netstat helyett)"""
print("=" * 70)
print("PASSZIV CSOMAG MONITOR")
print("=" * 70)
print("Local IP:", self.get_local_ip())
print("Figyeld a halozati aktivast...")
print("Ctrl+C a leallitashoz")
print("=" * 70)
def create_test_connection(self, host="8.8.8.8", port=53):
"""Teszt kapcsolodas keszitese"""
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(2)
sock.sendto(b"test", (host, port))
self.packet_count += 1
sock.close()
return True
except:
return False
def monitor_network_activity(self):
"""Halozati aktivas monitorozasa"""
start_time = time.time()
try:
while True:
# Verver interval
time.sleep(1)
# Teszt csomag kuldes
if self.create_test_connection():
self.udp_count += 1
self.packet_count += 1
elapsed = time.time() - start_time
print("\n[" + str(int(elapsed)) + "s] Total packets:", self.packet_count)
print(" UDP:", self.udp_count)
print(" TCP:", self.tcp_count)
print(" ICMP:", self.icmp_count)
except KeyboardInterrupt:
print("\n\nMonitor leallitva")
print("Total packets captured:", self.packet_count)
def simple_port_scanner():
"""Egyszeru port scanner (aktivan kutat)"""
target = input("\nTarget IP cimer (pl. 192.168.1.1): ").strip()
if not target:
target = "127.0.0.1"
print("=" * 70)
print("EGYSZERU PORT SCANNER")
print("=" * 70)
print("Target:", target)
print("Portok szurkese...")
print("=" * 70)
open_ports = []
for port in range(1, 1025):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(0.1)
result = sock.connect_ex((target, port))
if result == 0:
print("Port", port, "NYITOTT")
open_ports.append(port)
sock.close()
except:
pass
print("\n" + "=" * 70)
print("NYITOTT PORTOK:", len(open_ports))
if open_ports:
print(open_ports)
print("=" * 70)
def network_info():
"""Halozati informaciok"""
print("=" * 70)
print("HALOZATI INFORMACIOK")
print("=" * 70)
hostname = socket.gethostname()
local_ip = socket.gethostbyname(hostname)
print("Hostname:", hostname)
print("Local IP:", local_ip)
try:
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
s.connect(("8.8.8.8", 80))
gateway_ip = s.getsockname()[0]
print("Gateway IP:", gateway_ip)
except:
pass
print("=" * 70)
def main():
print("=" * 70)
print("HALOZATI ES PACKET MONITOR ESZKOCZ")
print("=" * 70)
print("\nMenu:")
print("1. Passziv csomag monitor (nem kell sudo)")
print("2. Port scanner")
print("3. Halozati informaciok")
print("4. Kilepas")
choice = input("\nVazlas (1-4): ").strip()
if choice == "1":
monitor = PassivePacketMonitor()
monitor.analyze_connection()
monitor.monitor_network_activity()
elif choice == "2":
simple_port_scanner()
elif choice == "3":
network_info()
elif choice == "4":
print("Kilepas...")
else:
print("Hibas valasztas!")
if __name__ == '__main__':
main()
------------------------------
import socket
import os
import struct
def get_protocol_name(protocol):
protocols = {
1: "ICMP",
6: "TCP",
17: "UDP",
47: "GRE",
50: "ESP",
51: "AH",
89: "OSPF",
132: "SCTP"
}
return protocols.get(protocol, "ISMERETLEN")
def main():
host = '0.0.0.0'
if os.name == 'nt':
socket_protocol = socket.IPPROTO_IP
print("Windows rendszer felismerve")
else:
socket_protocol = socket.IPPROTO_ICMP
print("Linux/Unix rendszer felismerve")
sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
sniffer.bind((host, 0))
sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
if os.name == 'nt':
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
print("=" * 70)
print("EGYSZERU PACKET SNIFFER")
print("=" * 70)
print("Csomagok figyelem kezdese... (Ctrl+C a leallitashoz)")
print("=" * 70)
try:
while True:
buffer, addr = sniffer.recvfrom(65565)
ip_header = buffer[0:20]
iph = struct.unpack('!BBHHHBBH4s4s', ip_header)
version_ihl = iph[0]
version = version_ihl >> 4
ihl = version_ihl & 0xF
iph_length = ihl * 4
protocol = iph[6]
s_addr = socket.inet_ntoa(iph[8])
d_addr = socket.inet_ntoa(iph[9])
protocol_name = get_protocol_name(protocol)
print("\n" + "-" * 70)
print("FORRAS IP:", s_addr)
print("CEL IP:", d_addr)
print("PROTOKOLL:", protocol_name, "(" + str(protocol) + ")")
print("CSOMAP MERET:", len(buffer), "byte")
except KeyboardInterrupt:
print("\n\nPacket sniffer leallitva")
if os.name == 'nt':
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
if __name__ == '__main__':
main()
------------------------------
import socket
import os
import struct
def main():
# Host cím (Linuxon üres string = minden interface)
host = '0.0.0.0'
if os.name == 'nt':
socket_protocol = socket.IPPROTO_IP
print("Windows rendszer felismerve")
else:
socket_protocol = socket.IPPROTO_ICMP
print("Linux/Unix rendszer felismerve")
# RAW socket létrehozása
sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
sniffer.bind((host, 0))
# IP fejléc beolvasása
sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
if os.name == 'nt':
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
print("=" * 70)
print("EGYSZERU PACKET SNIFFER")
print("=" * 70)
print("Csomagok catchesése kezdese... (Ctrl+C a leallitashoz)")
print("=" * 70)
try:
while True:
# Csomag fogadása (max 65565 byte)
buffer, addr = sniffer.recvfrom(65565)
# IP fejléc dekódolása (első 20 byte)
ip_header = buffer[0:20]
iph = struct.unpack('!BBHHHBBH4s4s', ip_header)
version_ihl = iph[0]
version = version_ihl >> 4
ihl = version_ihl & 0xF
iph_length = ihl * 4
protocol = iph[6]
s_addr = socket.inet_ntoa(iph[8])
d_addr = socket.inet_ntoa(iph[9])
# Protokoll neve
protocol_name = get_protocol_name(protocol)
print("\n" + "-" * 70)
print("FORRAS IP:", s_addr)
print("CÉL IP:", d_addr)
print("PROTOKOLL:", protocol_name, "(" + str(protocol) + ")")
print("CSOMAG HELY:", len(buffer), "byte")
except KeyboardInterrupt:
print("\n\nPacket sniffer leallitva")
if os.name == 'nt':
sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)
def get_protocol_name(protocol):
"""Protokoll szám neve"""
protocols = {
1: "ICMP",
6: "TCP",
17: "UDP",
47: "GRE",
50: "ESP",
51: "AH",
89: "OSPF",
132: "SCTP"
}
return protocols.get(protocol, "ISMERETLEN")
if __name__ == '__main__':
main()2. VERZIÓ: Fejlett Packet Sniffer (scapy könyvtárral, TÖBB PROTOKOLL)
először telepíteni kell a scapy-t:
bashpip install scapyA fejlett Packet Sniffer kód:
pitonfrom scapy.all import *
import socket
import datetime
def get_local_ip():
"""Local IP cím kimasolasa"""
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
s.connect(("8.8.8.8", 80))
return s.getsockname()[0]
def packet_callback(pkt):
"""Minden csomag feldolgozasa"""
# Timestamp
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
# TCP csomagok
if pkt.haslayer(TCP) and pkt.haslayer(IP):
direction = "IN" if pkt[IP].dst == local_ip else "OUT"
print("[%s] TCP-%s | SRC: %s:%d -> DST: %s:%d | LEN: %d bytes" % (
timestamp, direction,
pkt[IP].src, pkt.sport,
pkt[IP].dst, pkt.dport,
len(pkt[TCP])
))
# UDP csomagok
elif pkt.haslayer(UDP) and pkt.haslayer(IP):
direction = "IN" if pkt[IP].dst == local_ip else "OUT"
print("[%s] UDP-%s | SRC: %s:%d -> DST: %s:%d | LEN: %d bytes" % (
timestamp, direction,
pkt[IP].src, pkt.sport,
pkt[IP].dst, pkt.dport,
len(pkt[UDP])
))
# ICMP csomagok (ping)
elif pkt.haslayer(ICMP) and pkt.haslayer(IP):
direction = "IN" if pkt[IP].dst == local_ip else "OUT"
print("[%s] ICMP-%s | SRC: %s -> DST: %s | TYPE: %d" % (
timestamp, direction,
pkt[IP].src, pkt[IP].dst,
pkt[ICMP].type
))
def main():
local_ip = get_local_ip()
print("=" * 80)
print("FEJLETT PACKET SNIFFER (SCAPY)")
print("=" * 80)
print("Local IP cimer:", local_ip)
print("Hallgat protokollok: TCP, UDP, ICMP")
print("Csomagok catchesése kezdese... (Ctrl+C a leallitashoz)")
print("=" * 80)
try:
# Csomagok hallgatas
sniff(prn=packet_callback, store=0)
except KeyboardInterrupt:
print("\n\nPacket sniffer leallitva")
if __name__ == '__main__':
main()Futtatás:
bash# 1. verzió (nincs telepítés):
sudo python packet_sniffer_simple.py
# 2. verzió (scapy):
sudo pip install scapy
sudo python packet_sniffer_scapy.py
------------------------------------
Tanulásra és nem büncselekményre készültek a mintaprogramok! A Python programok írása már megkívánja a megfelelő strukturáltságot és a szoftvertervezési alapelvek betartását. A fenntarthatóság, az olvashatóság és a skálázhatóság érdekében a következő bevált gyakorlatokat érdemes alkalmazni. Éremes logikai egységekre, különálló .py fájlokba (pl. adatbázis kezelő, felhasználói felület, üzleti és logika), amelyeket aztán importálsz. Objektumorientált programozás (OOP): Használj osztályokat és objektumokat az adatok és a rajtuk végzett műveletek egységbe zárásához. A csomagcsomagolás révén a nagyobb projekteket rendezd package-ekbe (könyvtárakba), amelyek tartalmaznak egy __init__.py fájlt is az áttekinthetőség érdekében. Virtuális környezetek: Az env vagy venv segítségével izolálhatod a projekt függőségeit, így elkerülheted a verzióütközéseket a különböző rendszerek között.Dependency Management: A pip mellett használj pipenv-et vagy poetry-t a csomagok és verziók stabil kezelésére.Verziókezelés: Minden komplex projekt alapja a Git használata, a kód tárolására pedig a GitHub vagy a GitLab a legideálisabb.Tesztelés: Elengedhetetlen a hibák korai kiszűrésére. A beépített unittest vagy a pytest használatával automatizálhatod a kód tesztelését.Dokumentáció: A kód karbantarthatóságát nagyban segíti, ha a függvényeket és osztályokat elláthatod docstringekkel, vagy használhatod a Sphinx generátort. MVC (Model-View-Controller) minta: Különítheted el az adatokat (Model), a megjelenítést (View) és a felhasználói interakciókat (Controller), ami különösen hasznos asztali vagy webes alkalmazásoknál.Aszinkron programozás: Az asyncio könyvtár használatával hatékonyan kezelheted a párhuzamos feladatokat, például I/O műveleteket vagy webes lekérdezéseket a blokkoló várakozások elkerülésére.
Rendezésre példa
lista = [5, 3, 9, 1, 7]
for i in range(len(lista)-1):
for j in range(i+1, len(lista)):
print(i, j, lista, end='')
if lista[i] > lista [j]:
lista[i], lista[j] = lista[j], lista[i]
print('!', lista[i], lista[j])
print(' ', lista)
else:
print('')
---------------------------
import matplotlib.pyplot as plt
import numpy as np
# Generate data
x = np.linspace(110, 10, 900)
y1 = np.sin(x) * np.exp(-0.1 * x)
y2 = np.cos(x) * np.exp(-0.1 * x)
# Create figure
fig, ax = plt.subplots(figsize=(8, 5))
ax.plot(x, y1, color='#2563eb', linewidth=2, label='Damped Sine')
ax.plot(x, y2, color='#f59e0b', linewidth=2, label='Damped Cosine')
ax.fill_between(x, y1, y2, alpha=0.1, color='#8b5cf6')
ax.set_title('Damped Oscillations', fontsize=16, fontweight='bold', pad=12)
ax.set_xlabel('Time (s)', fontsize=12)
ax.set_ylabel('Amplitude', fontsize=12)
ax.legend(fontsize=11, loc='upper right')
ax.grid(True, alpha=0.3)
ax.set_facecolor('#fafafa')
fig.tight_layout()
plt.show()
Ez a kód egy Python program, amely matplotlib és numpy könyvtárakat használ egy grafikon létrehozására.
Mit csinál lépésenként:
- numpy segítségével létrehoz egy 900 pontból álló x értéksorozatot 110-től 10-ig.
- Kiszámol két függvényt: egy csillapított szinusz hullámot (y1) és egy csillapított koszinusz hullámot (y2). Ezek mindkettő az x értékek függvényében csökkenő amplitúdójú hullámok.
- matplotlib segítségével készít egy ábrát és egy koordináta-rendszert.
- Megjeleníti a két hullámot különböző színekkel vonalakkal.
- Kitölti az y1 és y2 közötti területet áttetsző színnel.
- Beállítja a címét, az x és y tengely feliratait.
- Megjeleníti a jelmagyarázatot (legendát), bekapcsolja a rácsvonalat, és beállítja az ábra alapszínét.
- Végül megjeleníti az ábrát.
Ez egy szép példája csillapított rezgések vizualizációjának.
---------------------
h = (tf - t0) / N:
Kiszámítja a lépésközt az intervallum hossza és a kívánt lépésszám alapján.np.zeros(N + 1):
Létrehoz egy üres listát (tömböt), ahová lépésről lépésre elmentjük a kiszámított $S$ értékeket.A for ciklus: Ez végzi a "lényegi" munkát.
Minden lépésben veszi az aktuális $S[j]$ értéket, kiszámítja hozzá a meredekséget a megadott $F$ függvénnyel, megszorozza a $h$ lépésközzel, és ebből kapja meg a következő $S[j+1]$ értéket.Tipp:
Ha futtatod a kódot, érdemes játszani az N (lépésszám) értékével.
Ha az N-et megnöveled (például 100-ra), a lépésköz ($h$) kisebb lesz, és az Euler-módszer kék szaggatott vonala szinte tökéletesen rá fog simulni a fekete elméleti görbére!
import matplotlib.pyplot as plt
import numpy as np
def euler_method(F, t0, tf, S0, N):
"""Az Euler-módszer implementációja elsőrendű ODE megoldására.
Paraméterek:
F : függvény - F(t, S) ami a deriváltat (dS/dt) adja vissza
t0 : float - kezdeti időpont
tf : float - végidőpont
S0 : float - kezdeti állapot (S(t0) értéke)
N : int - a lépések száma
"""
# Lépésköz (h) kiszámítása
h = (tf - t0) / N
# Időrács és az állapotok tömbjének előkészítése
t = np.linspace(t0, tf, N + 1)
S = np.zeros(N + 1)
# Kezdeti feltétel beállítása
S[0] = S0
# Iteráció az Euler-képlet alapján
for j in range(N):
S[j + 1] = S[j] + h * F(t[j], S[j])
return t, S
# --- TESZTELÉS ÉS VIZUALIZÁCIÓ ---
if __name__ == "__main__":
# Teszteljük a módszert egy ismert differenciálegyenleten:
# dS/dt = cos(t), aminek az analitikus megoldása S(t) = sin(t) + C
# Legyen a kezdeti feltétel S(0) = 0, ekkor S(t) = sin(t)
def F(t, S):
return np.cos(t)
# Paraméterek beállítása
t0 = 0
tf = 2 * np.pi # Egy teljes periódus (0-tól ~6.28-ig)
S0 = 0 # S(0) = 0
N = 20 # Lépésszám (próbáld ki 10-zel vagy 100-zal is!)
# Futtatás
t_num, S_num = euler_method(F, t0, tf, S0, N)
# Elméleti (pontos) megoldás a viszonyításhoz
t_exact = np.linspace(t0, tf, 200)
S_exact = np.sin(t_exact)
# Grafikus ábrázolás
plt.figure(figsize=(10, 6))
plt.plot(
t_exact, S_exact, label="Pontos (analitikus) megoldás", color="black"
)
plt.plot(
t_num,
S_num,
"bo--",
label=f"Euler-módszer közelítése (N = {N})",
alpha=0.7,
)
plt.title("Az Euler-módszer működése vs. Pontos megoldás")
plt.xlabel("t (idő)")
plt.ylabel("S(t) (állapot)")
plt.grid(True)
plt.legend()
plt.show()
Jelszó generátor készítése, itt egy egyszerű és biztonságos, kifejezetten 38 karakteres jelszót generáló Python program. A beépített secrets modult használja, ami kriptográfiailag biztonságos véletlenszerűséget garantál (így sokkal védettebb jelszavakat generál, mint a sima random!
import secrets
import string
def jelszo_generator(hossz=38):
# Karakterkészlet: kisbetűk, nagybetűk, számok és írásjelek
karakterek = string.ascii_letters + string.digits + string.punctuation
# Biztonságos generálás a megadott hosszúságban
jelszo = "".join(secrets.choice(karakterek) for _ in range(hossz))
return jelszo
# Jelszó létrehozása és kiíratása
uj_jelszo = jelszo_generator()
print(f"A generált 38 karakteres jelszó:\n{uj_jelszo}")
print(f"\nHossz ellenőrzése: {len(uj_jelszo)} karakter.")
-------------------------
import numpy as np
# 1. A differenciálegyenlet definíciója: df(t)/dt = F(t, f) = e^(-t)
# Mivel a derivált most nem függ közvetlenül f-től, az f paramétert nem használjuk a képletben.
def F(t, f):
return np.exp(-t)
# A pontos (analitikus) megoldás a hiba ellenőrzéséhez
def pontos_megoldas(t):
return -np.exp(-t)
# 2. Paraméterek beállítása a feladat alapján
t0 = 0.0 # Kezdeti időpont
tf = 1.0 # Végpont
h = 0.1 # Lépésköz
f0 = -1.0 # Kezdeti állapotérték: f(0) = -1
# Numerikus rács (időlépések) létrehozása: [0.0, 0.1, 0.2, ..., 1.0]
# A tf + h/2 trükk biztosítja, hogy a lebegőpontos kerekítés miatt a tf is belekerüljön
t = np.arange(t0, tf + h/2, h)
N = len(t) - 1 # Lépések száma
# 3. Tömb előkészítése az S (itt f_num) állapotok tárolására
f_num = np.zeros(len(t))
f_num[0] = f0 # Bolt S0 = S(t0) a tömbben
# 4. Iteratív integrálás az Euler-formula alapján
for j in range(N):
# Kiszámítás és tárolás a tömbben lépésről lépésre:
# S(t_{j+1}) = S(t_j) + h * F(t_j, S(t_j))
f_num[j + 1] = f_num[j] + h * F(t[j], f_num[j])
# --- EREDMÉNYEK MEGJELENÍTÉSE ---
print(f"{'t_j':<6} | {'Euler közelítés':<16} | {'Pontos érték':<14} | {'Abszolút hiba':<14}")
print("-" * 60)
for j in range(len(t)):
pontos = pontos_megoldas(t[j])
hiba = abs(f_num[j] - pontos)
print(f"{t[j]:.1f} | {f_num[j]:.6f} | {pontos:.6f} | {hiba:.6f}")
--------------------
Eredmény;
t_j | Euler közelités | Pontos érték | Abszolut hiba
------------------------------------------------------------
0.0 | -1.000000 | -1.000000 | 0.000000
0.1 | -0.900000 | -0.904837 | 0.004837
0.2 | -0.809516 | -0.818731 | 0.009214
0.3 | -0.727643 | -0.740818 | 0.013175
0.4 | -0.653561 | -0.670320 | 0.016759
0.5 | -0.586529 | -0.606531 | 0.020001
0.6 | -0.525876 | -0.548812 | 0.022935
0.7 | -0.470995 | -0.496585 | 0.025590
0.8 | -0.421337 | -0.449329 | 0.027992
0.9 | -0.376404 | -0.406570 | 0.030166
1.0 | -0.335747 | -0.367879 | 0.032133
** Process exited - Return Code: 0 **
-------------------------
Magyarázat;
Tegyük fel, hogy adott egy függvény.F(t,S(t))
amely kiszámítjadS(t)dt
, egy numerikus rács,t
, az intervallumból,[t0,tf]
, és egy kezdeti állapotértékS0=S(t0)
Ki tudjuk számolniS(tj)
mindenérttj
bant
a következő lépések segítségével.
BoltS0=S(t0)
egy tömbben,S
SzámításS(t1)=S0+hF(t0,S0)
BoltS1=S(t1)
banS
SzámításS(t2)=S1+hF(t1,S1)
BoltS2=S(t1)
banS
számításS(tf)=Sf−1+hF(tf−1,Sf−1)
.BoltSf=S(tf)
banS
a kezdetiérték-probléma megoldásának egy közelítése. Amikor egy ilyen struktúrájú metódust használunk, azt mondjuk, hogy a metódus integrálja az ODE megoldását.
A differenciálegyenletdf(t)dt=e−t
kezdeti feltétellelf0=−1
rendelkezik a pontos megoldássalf(t)=−e−t
Közelítse a kezdetiérték-feladat megoldását 0 és 1 között 0,1-es lépésekben az explicit Euler-formula segítségével.
Röviditett változat;
import numpy as np
t = np.arange(0, 1.1, 0.1)
f = [-1.0]
# Euler-módszer generálása egy tömör ciklusban
for tj in t[:-1]:
f.append(f[-1] + 0.1 * np.exp(-tj))
# Fejléc és adatok kiíratása
print("t_j | Euler | Pontos | Hiba")
for tj, fj in zip(t, f):
p = -np.exp(-tj)
print(f"{tj:.1f} | {fj:.6f} | {p:.6f} | {abs(fj-p):.6f}")
----------------------------
