Librería estándar de Python
Módulo argparse
Sinopsis
- Facilita la creación de interfaces de línea de comandos.
- Es el módulo recomendado para el análisis de la línea de comandos.
Uso
- Crear un objeto
ArgumentParser
(e.g.parser
). - Configurar la sintaxis de la línea de comandos (e.g.
add_argument
). - Utilizar el objeto
parser
para la creación de un objetoNamespace
(e.g.args
), haciendo una llamada al métodoparse_args()
. - Utilizar el objeto
args
para consultar los valores obtenidos de los parámetros.
Ejemplos
Código mínimo
from argparse import ArgumentParser
parser = ArgumentParser()
args = parser.parse_args()
Añadiendo argumentos posicionales
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("foo")
parser.add_argument("bar")
args = parser.parse_args()
Añadiendo textos de ayuda a los argumentos
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("foo", help="one argument")
parser.add_argument("bar", help="other argument")
args = parser.parse_args()
Fuentes
Módulo asyncio
Sinopsis
- Librería para la implantación de código concurrente, usando la nueva sintaxis
async/await
. - Suele ser utilizada para tareas limitadas a E/S (IO-bound), y para desarrollar código de red estructurado y de alto nivel.
- Expone dos niveles de abstracción diferenciados, tanto un alto como un bajo nivel.
APIs de alto nivel
Las APIs de alto nivel proporcionan mecanismos para:
- Ejecutar corrutinas de manera concurrente y sincronizarlas.
- Facilitar la ejecución de E/S de red y comunicación entre procesos (IPC).
- Controlar subprocesos y tareas en colas distribuidas.
APIs de bajo nivel
Las APIs de bajo nivel proporcionan mecanismos para:
- Gestionar bucles de eventos (event loops).
- Facilitar la implementación eficiente de protocolos de trasporte.
- Envolver retrollamadas (callbacks) y atenderlas mediante primitivas async/await.
Ejemplos
Esperar un segundo antes de terminar una tarea
import asyncio
async def main():
print("Hello...")
await asyncio.sleep(1)
print("...world!")
if __name__ == "__main__":
asyncio.run(main())
Recuperar el bucle de eventos actualmente en uso
import asyncio
loop = asyncio.get_event_loop()
Fuentes
Módulo cmd
Sinopsis
- Proporciona un armazón (framework) simple para la creación de intérpretes de comandos interactivos.
Uso
- Crear una subclase de
Cmd
. - Las instancias de las subclases de
Cmd
actuarán como framework para el intérprete. - Los parámetros opcionales del constructor, sirven para controlar la E/S y el soporte a las facilidades de
readline
.
Ejemplos
Creación de la subclase de Cmd
import cmd
class MyCmd(cmd.Cmd):
def do_hello(self, arg):
if arg:
print("Hello, {}!".format(arg))
else:
print("Hello, world!")
Instanciación de la subclase de Cmd
if __name__ == "__main__":
MyCmd().cmdloop()
Fuentes
Módulo ctypes
Sinopsis
- Proporciona una interfaz de funciones foráneas (foreign function interface) para Python.
- Incluye tipos de datos compatibles con los del lenguaje C y la posibilidad de cargar librerías dinámicas (e.g. DLL, so, etc.) en memoria.
- Permite construir emboltorios (wrappers) en Python de manera nativa.
Uso
Carga de librerías de enlace dinámico
- El paquete
ctypes
exporta los objetoscdll
y, ―en Windows―windll
yoledll
, con los que se puede cargar las librerías de enlace dinámico.
Ejemplos
Importar la librería kernel32.dll
de Windows
import ctypes as ct
print(ct.windll.kernel32)
Fuentes
Módulo pathlib
Sinopsis
- Analiza, construye y prueba nombres de fichero y rutas usando una interfaz orientada a objetos, en lugar de la API de bajo nivel de Python.
- Proporciona la semantica necesaria para representar un sistema de ficheros de manera más o menos independiente del sistema operativo.
- Opera directamente sobre rutas puras (pure paths) sin realizar operaciones de E/S, o a través de rutas concretas (concrete paths) en caso contrario.
Uso
Ante la duda, podremos utilizar la clase Path
que permite abstraernos de la implementación concreta subyacente.
Crear una instancia de una ruta o nombre de fichero a partir de una cadena de caracteres
El constructor de la clase Path
puede recibir una o más cadenas de caracteres, que sirvan para especificar el valor inicial de cada objeto de la clase:
from pathlib import Path
p = Path("/some/place", "to/find")
Ejemplos
Inicialización común para todos los ejemplos de esta sección:
> from pathlib import Path
> p1 = Path(r"C:\Windows\System\..\System32\Drivers\etc\hosts.ics")
Obtener la ruta como una cadena de caracteres
> str(p1)
Similar a os.path.normpath
> p1.absolute()
Similar que os.path.abspath
> p1.resolve()
Emular os.path.basename
> p1.name
Emular os.path.dirname
> p1.parent
Fuentes
Módulo shelve
Sinopsis
-
Implementa un almacenamiento persistente (persistent storage) con una interfaz similar a la de un diccionario.
-
Se diferencia del módulo
dbm
en que los valores (values) del diccionario pueden tener un tipo de dato distinto a la cadena de caracteres (string) o la secuencia de octetos (bytes). -
Se asemeja con
dbm
, en que las claves (keys) sí deben ser del tipo cadena de caracteres y/o secuencia de octetos. -
Internamente, los valores se almacenan serializándolos mediante
pickle
, y almacenándolos en una base de datos con interfazdbm
.
Uso
Simplemente se abre la base de datos dbm
subyacente; posiblemente, utilizando para ello un gestor de contexto (context manager). Y se utiliza como un diccionario cualquiera. También podremos sincronizar la escritura de los cambios al disco.
Ejemplos
Crear un almacenamiento persistente y escribir un valor
import shelve
with shelve.open("cached.db") as cached:
cached["joe"] = {
"name": "Joe Herrera",
"age": 19
"mantra": "Uh, la la la, ..."
}
Abrir un almacenamiento persistente y leer un valor
import shelve
with shelve.open("cached.db") as cached:
value = cached["joe"]
print(value)
Abrir un almacenamiento persistente con soporte a retroescritura (writeback)
La retroescritura se utilizará cuando hagamos cambios sobre los valores insertados, y queramos que dichos cambios se actualicen en el disco. Dicho modo está desactivado por omisión.
import shelve
with shelve.open("cached.db", writeback=True) as cached:
cached["joe"]["age"] += 1
Fuentes
Módulo smtplib
Sinopsis
-
Implementa un cliente SMTP que puede ser usado para enviar correos-e a cualquier máquina con un demonio SMTP o ESMTP instalado.
-
Las conexiones desde nuestro cliente SMTP al servidor utilizado, pueden hacerse de dos (2) maneras: mediante una conexión insegura haciendo uso de la clase
SMTP
o, através de una conexión segura que se crea desde una instancia de la claseSMTP_SSL
.
Uso
El módulo smtplib
define la clase SMTP
(aparte de varias otras excepciones y funciones de utilidad) que implementa un cliente SMTP. Para enviar un correo-e a través de un servidor SMTP no seguro, se debe ejecutar la siguiente secuencia de pasos:
- Crear una instancia de la clase
SMTP
. - Invocar el método
sendmail
con los parámetros necesarios para enviar el mensaje. - Invocar el método
quit
antes de finalizar la conversación.
La clase SMTP_SSL
permite abrir conexiones seguras desde el comienzo, mientras que para el caso de la SMTP, las conexiones se abren en modo inseguro para después ser actualizadas (upgraded) a modo seguro mediante la llamada al método starttls()
.
Ejemplos
Abrir una conexión insegura y enviar un mensaje simple
import smtplib
from_addr = "my_address@example.com"
to_addr = "your_address@example.com"
msg_text = "Hello, world!"
try:
smtp = smtplib.SMTP("smtp.gmail.com", 587)
smtp.sendmail(from_addr, to_addr, msg_text)
smtp.quit()
except:
print("Oops: something is wrong")
Abrir una conexión insegura y actualizarla a modo seguro
import smtplib
try:
smtp = smtplib.SMTP("smtp.gmail.com", 587)
smtp.ehlo()
smtp.starttls()
smtp.quit()
except:
print("Oops: something is wrong")
Abrir una conexión segura desde el inicio
import smtplib
try:
smtp = smtplib.SMTP_SSL("smtp.gmail.com", 587)
smtp.ehlo()
smtp.quit()
except:
print("Oops: something is wrong")
Fuentes
- https://docs.python.org/3/library/smtplib.html
- https://tools.ietf.org/html/rfc821.html
- https://tools.ietf.org/html/rfc1869.html
Módulo subprocess
Sinopsis
- Permite la creación de procesos, la conexión con los flujos de entrada, error y salida, y la recuperación de los códigos de retorno de dichos subprocesos.
- Sustituye a las funciones disponibles en
os.system
yos.spawn*
.
Uso
Interfaz básica
A partir de la versión 3.5
de Python, se puede trabajar en modo simplificado usando la función run
, que funcionará en la mayoría de los casos.
Nota: Para los casos no contemplados por
run
, existe una interfaz avanzada basada en el constructorPopen
.
- Invocar la función
run
- TODO
Ejemplos
TODO
Fuentes
Módulo tempfile
Sinopsis
- Crea ficheros y directorios temporales.
- Funciona en todas las plataformas soportadas.
- Proporciona interfaces de alto nivel con gestión automática de recursos (vía gestores de contexto).
- Proporciona interfaces de bajo nivel sin gestión manual de recursos (e.g.
mkstemp()
ymkdtemp()
). - Se pueden controlar el nombre y la localización de los ficheros, así como sus parámetros de apertura.
Uso
Con gestión automática de recursos
- Crear una instancia de una de las clases
TemporaryFile
,NamedTemporaryFile
oSpooledTemporaryFile
. - Utilizar los métodos tipo fichero asociados a las clases anteriores.
- Cerrar el objeto mediante su método
close()
o encerrar dentro de un gestor de contexto.
Ejemplos
TODO
Fuentes
Módulo zipfile
Sinopsis
- Proporciona herramientas para la creación, lectura, escritura, agregado y listado de objetos en un archivo en formato ZIP (i.e. según lo especificado en PKZIP Application Note).
- Actualmente, el módulo no soporta archivos ZIP multi-disco, pero soporta las extensiones ZIP64.
- Si bien puede descifrar archivos ZIP encriptados, no puede crearlos y los desencripta de forma muy lenta.
Uso
- Crear una instancia de la clase
ZipFile
. - Usar los métodos de la clase
ZipFile
para:- Obtener una lista con la información de los miembros del archivo.
- Recuperar la información de un miembro de nuestro archivo.
- Acceder a los miembros del archivo de manera individual.
- Leer, escribir o extraer miembros del archivo.
- Cerrar el archivo o utilizar un gestor de contexto para esto.
Ejemplos
Leer los nombres de los miembros de un archivo .ZIP
from zipfile import ZipFile
with ZipFile("example.zip") as zip:
for name in zip.namelist():
print(name)
Obtener un objeto tipo fichero de un miembro dado del archivo
from zipfile import ZipFile
with ZipFile("example.zip") as zip:
with zip.open("example1.txt") as input:
for line in input:
print(line.decode())
Leer todo el contenido de un miembro dado del archivo
from zipfile import ZipFile
with ZipFile("example.zip") as zip:
buffer = zip.read("spanish/example2.txt")
print(buffer.decode())
Leer un miembro dado del archivo en modo texto (con una codificación dada)
from io import TextIOWrapper
from zipfile import ZipFile
with ZipFile("example.zip") as zip:
with TextIOWrapper(zip.open("data.csv"), encoding="utf-8-sig") as input:
for line in input:
print(line)
Fuentes