Procesos
subprocess.Popen
: Clase que permite crear y controlar procesos en Python.
1 2 3 4 5 6 7 8 9 |
import subprocess def main(): process = subprocess.Popen(["ping", "-c", "4", "google.com"], stdout=subprocess.PIPE) output, _ = process.communicate() print(output.decode()) if __name__ == "__main__": main() |
os.system
: Permite interactuar con el entorno de ejecución y controlar procesos en tiempo de ejecución.
1 2 3 4 5 6 7 |
import os def main(): os.system("ping -c 4 google.com") if __name__ == "__main__": main() |
subprocess.run
: Representa un proceso en ejecución y proporciona métodos para controlarlo.
1 2 3 4 5 6 7 8 |
import subprocess def main(): result = subprocess.run(["echo", "Hello, World!"], capture_output=True, text=True) print(result.stdout) if __name__ == "__main__": main() |
psutil
: Obtener información sobre procesos en ejecución y controlarlos.
1 2 3 4 5 6 7 8 |
import psutil def main(): for proc in psutil.process_iter(['pid', 'name']): print(f"PID: {proc.info['pid']}, Name: {proc.info['name']}") if __name__ == "__main__": main() |
Hilos
threading.Thread
: Clase que permite crear y controlar hilos en Python.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import threading import time class MiThread(threading.Thread): def run(self): for i in range(5): print(f"Hilo ejecutándose: {i}") time.sleep(0.5) def main(): hilo = MiThread() hilo.start() hilo.join() if __name__ == "__main__": main() |
threading.Thread
contarget
: Interfaz funcional que define un hilo de ejecución en Python.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import threading import time def mi_funcion(): for i in range(5): print(f"Hilo ejecutándose desde función: {i}") time.sleep(0.5) def main(): hilo = threading.Thread(target=mi_funcion) hilo.start() hilo.join() if __name__ == "__main__": main() |
asyncio
: Mecanismo de concurrencia que permite realizar tareas asíncronas y no bloqueantes en Python.
1 2 3 4 5 6 7 8 9 10 11 12 |
import asyncio async def mi_corutina(): for i in range(5): print(f"Corutina ejecutándose: {i}") await asyncio.sleep(0.5) def main(): asyncio.run(mi_corutina()) if __name__ == "__main__": main() |
concurrent.futures.ThreadPoolExecutor
: Esta interfaz permite administrar hilos y ejecutar tareas de manera concurrente.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
from concurrent.futures import ThreadPoolExecutor import time def tarea(nombre): for i in range(5): print(f"Tarea {nombre}: {i}") time.sleep(0.5) def main(): with ThreadPoolExecutor(max_workers=2) as executor: executor.submit(tarea, "1") executor.submit(tarea, "2") if __name__ == "__main__": main() |
asyncio.Future
: Clase que facilita la programación asincrónica y la combinación de múltiples futuros en Python.
1 2 3 4 5 6 7 8 9 10 11 12 13 |
import asyncio async def mi_corutina(): await asyncio.sleep(1) return "Resultado de la tarea" async def main(): future = asyncio.create_task(mi_corutina()) resultado = await future print(f"Resultado: {resultado}") if __name__ == "__main__": asyncio.run(main()) |
Red
urllib.request.urlopen
: Clase que permite trabajar con URL y realizar operaciones de red como abrir conexiones HTTP.
1 2 3 4 5 6 7 8 9 |
import urllib.request def main(): with urllib.request.urlopen("http://www.example.com") as response: html = response.read().decode() print(html) if __name__ == "__main__": main() |
http.client.HTTPConnection
: Clase abstracta que establece una conexión a un recurso a través de una URL.
1 2 3 4 5 6 7 8 9 10 |
import http.client def main(): connection = http.client.HTTPConnection("www.example.com") connection.request("GET", "/") response = connection.getresponse() print(response.read().decode()) if __name__ == "__main__": main() |
socket.socket
: Clase que representa un socket de red y permite la comunicación entre procesos a través de la red.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import socket def main(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind(("localhost", 1234)) server_socket.listen(1) print("Esperando conexión...") client_socket, addr = server_socket.accept() print(f"Conexión aceptada de {addr}") client_socket.sendall(b"Hola, cliente!") client_socket.close() server_socket.close() if __name__ == "__main__": main() |
selectors.DefaultSelector
: Una clase para operaciones de socket no bloqueantes en Python.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import selectors import socket def main(): selector = selectors.DefaultSelector() server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind(("localhost", 1234)) server_socket.listen(1) server_socket.setblocking(False) selector.register(server_socket, selectors.EVENT_READ) print("Esperando conexión...") events = selector.select() for key, _ in events: if key.fileobj is server_socket: client_socket, addr = server_socket.accept() print(f"Conexión aceptada de {addr}") data = client_socket.recv(1024) print(f"Mensaje recibido: {data.decode()}") client_socket.close() if __name__ == "__main__": main() |
socket.socket
conSOCK_DGRAM
: Para trabajar con datagramas y sockets UDP en Python.
1 2 3 4 5 6 7 8 9 10 |
import socket def main(): socket_udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) message = b"Hola, UDP!" socket_udp.sendto(message, ("localhost", 1234)) socket_udp.close() if __name__ == "__main__": main() |
Seguridad
cryptography.Fernet
: Clase que proporciona funcionalidad de cifrado y descifrado para encriptar y desencriptar datos.
1 2 3 4 5 6 7 8 9 10 11 12 |
from cryptography.fernet import Fernet def main(): key = Fernet.generate_key() cipher_suite = Fernet(key) encrypted = cipher_suite.encrypt(b"Mensaje secreto") decrypted = cipher_suite.decrypt(encrypted) print(f"Mensaje desencriptado: {decrypted.decode()}") if __name__ == "__main__": main() |
secrets
: Clase que genera números aleatorios criptográficamente seguros.
1 2 3 4 5 6 7 8 9 |
import secrets def main(): secure_random = secrets.SystemRandom() random_number = secure_random.randint(0, 100) print(f"Número aleatorio seguro: {random_number}") if __name__ == "__main__": main() |
cryptography.hazmat.primitives.serialization.load_pem_private_key
: Clase que almacena claves criptográficas y certificados de seguridad.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
from cryptography.hazmat.primitives import serialization from cryptography.hazmat.primitives.asymmetric import rsa def main(): private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048) pem = private_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption() ) print(f"Clave privada PEM:\n{pem.decode()}") if __name__ == "__main__": main() |
cryptography.hazmat.primitives.asymmetric.rsa.RSAPrivateKey
: Para generar pares de claves criptográficas (pública y privada) en Python.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
from cryptography.hazmat.primitives.asymmetric import rsa def main(): private_key = rsa.generate_private_key(public_exponent=65537, key_size=2048) public_key = private_key.public_key() print(f"Clave pública: {public_key.public_bytes( encoding=serialization.Encoding.PEM, format=serialization.PublicFormat.SubjectPublicKeyInfo ).decode()}") print(f"Clave privada: {private_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.PKCS8, encryption_algorithm=serialization.NoEncryption() ).decode()}") if __name__ == "__main__": main() |
hashlib.sha256
: Clase que proporciona funciones de resumen criptográfico, como SHA-256 o MD5, para procesar datos.
1 2 3 4 5 6 7 8 9 |
import hashlib def main(): hash_object = hashlib.sha256(b"Mensaje a hashear") hex_dig = hash_object.hexdigest() print(f"Hash SHA-256: {hex_dig}") if __name__ == "__main__": main() |
ssl.create_default_context
: Para configurar conexiones seguras con el protocolo SSL/TLS en Python.
1 2 3 4 5 6 7 8 9 10 11 |
import ssl import socket def main(): context = ssl.create_default_context() with socket.create_connection(("www.example.com", 443)) as sock: with context.wrap_socket(sock, server_hostname="www.example.com") as ssock: print("Conexión segura establecida") if __name__ == "__main__": main() |