Procesos
Subprocess (similar a ProcessBuilder, Runtime, Process y ProcessHandle)
En Python, el módulo subprocess se utiliza para crear y controlar procesos:
|
1 2 3 4 5 6 7 8 9 10 11 |
import subprocess # Crear y ejecutar un proceso process = subprocess.Popen(['ls', '-l'], stdout=subprocess.PIPE, stderr=subprocess.PIPE) # Obtener la salida del proceso stdout, stderr = process.communicate() # Información del proceso print(f"PID: {process.pid}") print(f"Retorno: {process.returncode}") |
Hilos
Thread
Para crear y controlar hilos, se usa la clase Thread en Python:
|
1 2 3 4 5 6 7 8 9 |
import threading def thread_function(name): print(f"Thread {name} ejecutándose") # Crear y empezar un hilo thread = threading.Thread(target=thread_function, args=("1",)) thread.start() thread.join() |
Runnable (similar a Runnable en Kotlin)
En Python, una función puede actuar como Runnable:
|
1 2 3 4 5 6 |
def run(): print("Hilo en ejecución") thread = threading.Thread(target=run) thread.start() thread.join() |
Asyncio (similar a Coroutine y CompletableFuture)
Python utiliza asyncio para tareas asíncronas y no bloqueantes:
|
1 2 3 4 5 6 7 8 9 |
import asyncio async def main(): print('Hola') await asyncio.sleep(1) print('Mundo') # Ejecutar la corrutina asyncio.run(main()) |
ExecutorService (similar a ExecutorService en Kotlin)
En Python, puedes usar concurrent.futures para administrar hilos:
|
1 2 3 4 5 6 7 |
from concurrent.futures import ThreadPoolExecutor def task(name): print(f"Tarea {name} ejecutándose") with ThreadPoolExecutor(max_workers=2) as executor: futures = [executor.submit(task, i) for i in range(5)] |
Red
URL y URLConnection (similar a URL y URLConnection en Kotlin)
En Python, se utiliza urllib para trabajar con URL y conexiones HTTP:
|
1 2 3 4 5 6 |
import urllib.request # Trabajar con URL response = urllib.request.urlopen('http://www.example.com/') html = response.read() print(html) |
Socket y SocketChannel (similar a Socket y SocketChannel en Kotlin)
En Python, se utiliza el módulo socket:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
import socket # Crear un socket TCP/IP sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # Conectar el socket a un puerto server_address = ('localhost', 10000) sock.connect(server_address) try: # Enviar datos message = b'Este es el mensaje. Se repetirá.' sock.sendall(message) # Recibir respuesta data = sock.recv(1024) print(f"Recibido: {data}") finally: sock.close() |
DatagramSocket (similar a DatagramSocket en Kotlin)
Para trabajar con datagramas y sockets UDP:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import socket # Crear un socket UDP sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) server_address = ('localhost', 10000) message = b'Este es el mensaje.' try: # Enviar datos sent = sock.sendto(message, server_address) # Recibir respuesta data, server = sock.recvfrom(4096) print(f"Recibido: {data}") finally: sock.close() |
Seguridad
Cipher (similar a Cipher en Kotlin)
Para cifrado y descifrado, se usa el módulo cryptography:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes from cryptography.hazmat.backends import default_backend # Configuración del cifrado key = b'1234567890123456' iv = b'1234567890123456' cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend()) # Cifrado encryptor = cipher.encryptor() ciphertext = encryptor.update(b"mensaje secreto") + encryptor.finalize() # Descifrado decryptor = cipher.decryptor() plaintext = decryptor.update(ciphertext) + decryptor.finalize() print(plaintext) |
SecureRandom (similar a SecureRandom en Kotlin)
Para generar números aleatorios criptográficamente seguros:
|
1 2 3 4 5 |
import os # Generar un número aleatorio seguro random_bytes = os.urandom(16) print(random_bytes) |
KeyStore (similar a KeyStore en Kotlin)
Para almacenar y gestionar claves criptográficas:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
from cryptography.hazmat.primitives import serialization from cryptography.hazmat.primitives.asymmetric import rsa # Generar un par de claves private_key = rsa.generate_private_key( public_exponent=65537, key_size=2048 ) # Serializar la clave privada pem = private_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.BestAvailableEncryption(b'mypassword') ) print(pem) |
KeyPairGenerator (similar a KeyPairGenerator en Kotlin)
Para generar pares de claves criptográficas:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
from cryptography.hazmat.primitives.asymmetric import rsa # Generar un par de claves private_key = rsa.generate_private_key( public_exponent=65537, key_size=2048 ) public_key = private_key.public_key() # Serializar la clave pública pem_public = public_key.public_bytes( encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo ) print(pem_public) |
MessageDigest (similar a MessageDigest en Kotlin)
Para funciones de resumen criptográfico:
|
1 2 3 4 5 6 7 8 |
import hashlib # Crear un resumen SHA-256 digest = hashlib.sha256() digest.update(b"mensaje") hash_value = digest.hexdigest() print(hash_value) |
SSLContext (similar a SSLContext en Kotlin)
Para configurar conexiones seguras con SSL/TLS:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import ssl import socket # Crear un contexto SSL context = ssl.create_default_context() # Conectar utilizando el contexto SSL conn = context.wrap_socket(socket.socket(socket.AF_INET), server_hostname='www.example.com') conn.connect(('www.example.com', 443)) # Enviar solicitud HTTPS conn.sendall(b"GET / HTTP/1.1\r\nHost: www.example.com\r\n\r\n") # Leer la respuesta response = conn.recv(4096) print(response) |