Las 10 Mejores Extensiones de Python para Visual Studio Code

Daniel Morales
Oct 09, 2021

Contents Outline

Las 10 Mejores Extensiones de Python para Visual Studio Code

Oct 09, 2021 9 minutes read

En este nuevo post queremos hablar de las extensiones más útiles de Python para Visual Studio Code. 

Visual Studio Code es un entorno de desarrollo integrado creado por Microsoft para Windows, Linux y macOS. Entre sus características se encuentran la depuración, el resaltado de sintaxis, la finalización inteligente de código, los fragmentos, la refactorización de código y Git integrado. Los usuarios pueden cambiar el tema, los atajos de teclado, las preferencias e instalar extensiones que añaden funcionalidad adicional.

Precisamente vamos a hablar sobre las extensiones que puedes instalar para VS. Aquí una lista de nuestras preferidas

Puedes leer más artículos de Data Science en español aquí 


1- Python




Extensión de Python para Visual Studio Code

Una extensión de Visual Studio Code con un rico soporte para el lenguaje Python (para todas las versiones activamente soportadas del lenguaje: >=3.6), incluyendo características como IntelliSense (Pylance), linting, depuración, navegación de código, formateo de código, refactorización, explorador de variables, explorador de pruebas, ¡y más!

NOTA: El soporte en la web -- por ejemplo, github.dev -- es limitado.

Extensiones instaladas
La extensión Python instalará automáticamente las extensiones Pylance y Jupyter para ofrecerte la mejor experiencia al trabajar con archivos Python y notebooks Jupyter. Sin embargo, Pylance es una dependencia opcional, lo que significa que la extensión de Python seguirá siendo totalmente funcional si no se instala. También puedes desinstalarla a expensas de algunas características si estás usando un servidor de idiomas diferente.

2- Python Indent




Sirve para corregir la sangría de Python en Visual Studio Code. 

Cómo funciona
Cada vez que presione la tecla Enter en un contexto de Python, esta extensión analizará su archivo de Python hasta la ubicación de su cursor, y determinará exactamente cuánto debe sangrar la siguiente línea (o dos en el caso de sangrías colgantes) y cuánto deben desangrarse las líneas cercanas.

Hay tres casos principales a la hora de determinar la sangría correcta. Revisar la documentación aqui: https://github.com/kbrose/vsc-python-indent

3- Python Doctring Generator



Extensión de Visual Studio Code para generar rápidamente docstrings para funciones python.

Características
  • Genera rápidamente un fragmento de docstring que puede ser tabulado.
  • Elija entre varios tipos de formatos de docstrings.
  • Infiere los tipos de parámetros a través de pistas de tipo pep484, valores por defecto y nombres var.
  • Soporte para args, kwargs, decoradores, errores y tipos de parámetros.

Formatos Docstring
  • Google (por defecto)
  • docBlockr
  • Numpy
  • Sphinx
  • PEP0257 (próximamente)

Uso
El cursor debe estar en la línea directamente debajo de la definición para generar un docstring completo auto-poblado
  • Pulsa enter después de abrir el docstring con comillas triples (""" o ''')
  • Atajo de teclado: ctrl+mayús+2 o cmd+mayús+2 para mac
  • Se puede cambiar en Preferencias -> Atajos de teclado -> extension.generateDocstring
  • Comando: Generar Docstring
  • Menú del botón derecho: Generar Docstring


4- Python Extended





Python Extended es un fragmento de vscode que facilita la escritura de códigos en python proporcionando opciones de finalización junto con todos los argumentos.

Uso
Ejecute vscode y en un archivo python, escriba el nombre del método a completar y presione tab o enter en la selección.

Cómo instalar
Abra vscode. Pulse F1, busque "ext install" seguido del nombre de la extensión, en este caso "ext install Python Extended" sin el ">". O si prefieres ">ext install", pulsa enter, busca "Python Extended".

Puedes leer más artículos de Data Science en español aquí 



5- Python Preview





Una extensión de Visual Studio Code con soporte de vista previa de depuración para el lenguaje Python.

Requisitos
  • Instale una versión de Python 3.6 o Python 2.7. Asegúrese de que la ubicación de su intérprete de Python está incluida en su variable de entorno PATH.
  • Es mejor instalar la extensión de Python para el Intellisense de Python


6- AREPL for Python




AREPL evalúa automáticamente el código python en tiempo real mientras usted escribe.

Uso
  • En primer lugar, asegúrese de que tiene instalado python 3.7 o superior.
  • Abra un archivo de python y haga clic en el gato en la barra superior a la derecha para abrir AREPL. Puede hacer clic en el gato de nuevo para cerrar.
  • O ejecute AREPL a través del comando de búsqueda: control-mayúsculas-p
  • o utilizar los atajos: control-mayúsculas-a (documento actual) / control-mayúsculas-q (nuevo documento)

Características
  • Evaluación en tiempo real: no es necesario ejecutar - AREPL evalúa su código automáticamente. Puede controlar esto (o incluso desactivarlo) en los ajustes.
  • Visualización de variables: El estado final de sus variables locales se muestra en un formato JSON colapsable.
  • Visualización de errores: En el momento en que cometes un error se muestra un error con la traza de la pila.
  • Ajustes: AREPL ofrece muchos ajustes para adaptarse a su experiencia de usuario. Personaliza el aspecto, el tiempo de rebote, las opciones de python y mucho más.

7- Python Path




Esta extensión añade un conjunto de herramientas que ayudan a generar sentencias de importación internas en un proyecto python.

Características
"Copy Python Path" es accesible desde:
  • Linea de comando
  • Menú contextual del explorador
  • Menú contextual del editor
  • Menú contextual del título del editor

Puedes leer más artículos de Data Science en español aquí 

8- Python Test Explorer




Esta extensión le permite ejecutar sus pruebas de Python Unittest, Pytest o Testplan con la interfaz de usuario de Test Explorer.

Cómo empezar
  • Instale la extensión
  • Configure Visual Studio Code para que descubra sus pruebas (consulte la sección Configuración y la documentación del marco de pruebas de su elección:
  • Documentación de Unittest
  • Documentación de Pytest
  • Documentación de Testplan
  • Abra la barra lateral de la vista de pruebas
  • Ejecutar sus pruebas mediante el icono Ejecutar en el Explorador de Pruebas

Características
  • Muestra un Explorador de Pruebas en la vista de pruebas en la barra lateral de VS Code con todas las pruebas y suites detectadas y su estado
  • Práctico informe de errores durante la detección de pruebas
  • Depuración de Unittest, Pytest y Testplan
  • Muestra el registro de una prueba fallida cuando se selecciona la prueba en el explorador
  • Reejecución de pruebas al guardarlas
  • Soporta espacios de trabajo multi-root
  • Admite los marcos de pruebas Unittest, Pytest y Testplan y sus complementos

9- Python Snippets




Un paquete de fragmentos para hacer más productivo el trabajo con python Este paquete de fragmentos contiene todos los métodos de python que se indican a continuación
  • todos los fragmentos incorporados de python y contiene al menos un ejemplo para cada método
  • todos los fragmentos de cadenas de python contienen al menos un ejemplo para cada método
  • todos los fragmentos de listas de python contienen al menos un ejemplo para cada método
  • todos los fragmentos de conjuntos de python contienen al menos un ejemplo para cada método
  • todos los fragmentos de tuplas en python contienen al menos un ejemplo para cada método
  • todos los fragmentos de diccionario de python contienen al menos un ejemplo para cada método
  • Y contiene muchos otros fragmentos de código (como if/else, for, while, while/else, try/catch, file process y
  • fragmentos de clases y ejemplos de clases para oop (polimorfismo, encapsulación, herencia, etc.)


Si no usas un método no te preocupes esta extensión contiene un montón de ejemplos de código para cada método de python

Esta extensión no es sólo un fragmento de código, sino que también será útil para aprender el lenguaje de programación python.

Aprenderás todos los métodos de python con un montón de ejemplos de código
Por ejemplo, si usted quiere usar el método de reemplazo de cadena, sólo tiene que utilizar .replace

Pero si usted no sabe cómo utilizar el método de reemplazo a continuación, utilice string.replace =>

10- Jupyter




Una extensión de Visual Studio Code que proporciona soporte básico de notebooks para los kernels de lenguaje que son compatibles con Jupyter Notebooks hoy en día. Muchos kernels de lenguaje funcionarán sin ninguna modificación. Para habilitar características avanzadas, pueden ser necesarias modificaciones en las extensiones de lenguaje de VS Code.

Soporte de notebooks
La Extensión Jupyter utiliza el soporte de cuaderno incorporado de VS code. Esta interfaz ofrece una serie de ventajas a los usuarios de cuadernos:

  • Soporte inmediato de la amplia gama de funciones básicas de edición de código de VS Code, como la salida en caliente, la búsqueda y el reemplazo, y el plegado de código.
  • Extensiones del editor como VIM, coloración de corchetes, linters y muchas más están disponibles mientras se edita una celda.
  • Profunda integración con el banco de trabajo general y con las funciones basadas en archivos de VS Code, como la vista de esquema (tabla de contenidos), las migas de pan y otras operaciones.
  • Tiempos de carga rápidos para los archivos Jupyter notebook (.ipynb). Cualquier archivo de cuaderno se carga y renderiza lo más rápidamente posible, mientras que las operaciones relacionadas con la ejecución se inicializan entre bastidores.
  • Incluye una herramienta de diferencias para cuadernos, que facilita la comparación y la visualización de las diferencias entre las celdas de código, los resultados y los metadatos.
  • Extensibilidad más allá de lo que proporciona la extensión Jupyter. Las extensiones ahora pueden añadir su propio lenguaje o tiempo de ejecución específico a los cuadernos, como los cuadernos interactivos de .NET y Gather
  • Aunque la extensión de Jupyter viene con un amplio conjunto de los renderizadores más utilizados para la salida, el mercado admite renderizadores personalizados instalables para que el trabajo con tus cuadernos sea aún más productivo. Para empezar a escribir los tuyos propios, consulta la documentación de la api de renderizadores de VS Code.


Conclusión


Existen muchas extensiones que puedes usar con tu Visual Studio Code, y decidir cual usar pasará por hacer pruebas, revisar utilidades, casos de uso y demás con el fin de hacer tu trabajo mas sencillo mientras codeas!

Lea también: ¿Por Qué Los Decoradores En Python Son Pura Genialidad?

Related Posts

Entendiendo El Módulo Collections de Python

¿Cómo Usar Correctamente Los Datetimes En Python?

¿Por Qué Los Decoradores En Python Son Pura Genialidad?

Categories

Data Science Machine Learning Deep learning Flask Deployment Big Data Business Python SQL Programming Libraries Jupyter Numpy News Pandas Matplotlib Visualization Datathons

Join Competition

Google Play Store Rating Prediction

Real Estate Price Forecast

Most Related Articles

Python
Programming
¿Por Qué Los Decoradores En Python Son Pura Genialidad?

Analiza, prueba y reutiliza tu código con poco más que un símbolo @Si hay algo que hace que Python sea increíblemente exitoso, eso sería su legibilidad. Todo lo demás depende de eso: si el código es ilegible, es difícil de mantener. Tampoco es fácil para los principiantes: un novato que se aturda con un código ilegible no intentará escribir el suyo propio algún día.Python ya era legible y amigable para los principiantes antes de que aparecieran los decoradores. Pero a medida que el lenguaje comenzó a ser utilizado para más y más cosas, los desarrolladores de Python sintieron la necesidad de más y más características, sin desordenar el paisaje y hacer el código ilegible.Los decoradores son un ejemplo de una característica perfectamente implementada. Lleva un tiempo entenderlos, pero vale la pena. Cuando empieces a usarlos, notarás cómo no complican demasiado las cosas y hacen que tu código sea limpio y elegante.Antes que nada: funciones de orden superiorEn pocas palabras, los decoradores son una forma clara de manejar las funciones de orden superior. Así que vamos a verlos primero.Funciones que devuelven funcionesDigamos que tienes una función, greet() - que saluda a cualquier objeto que le pases. Y digamos que tienes otra función, simon() - que inserta "Simón" donde sea apropiado. ¿Cómo podemos combinar las dos? Piénsalo un momento antes de mirar a continuacióndef greet(name): return f"Hello, {name}!" def simon(func): return func("Simon") simon(greet)La salida es "¡Hola, Simon!". Espero que tenga sentido para ti.Por supuesto, podríamos haber llamado simplemente a greet("Simon"). Sin embargo, la cuestión es que podríamos querer poner "Simón" en muchas funciones diferentes. Y si no usamos "Simón" sino algo más complicado, podemos ahorrar un montón de líneas de código empaquetándolo en una función como simon().Funciones dentro de otras funcionesTambién podemos definir funciones dentro de otras funciones. Esto es importante porque los decoradores también lo hacen. Sin los decoradores se ve así:def respect(maybe): def congrats(): return "Congrats, bro!" def insult(): return "You're silly!" if maybe == "yes": return congrats else: return insultLa función respect() devuelve una función; respect("yes") devuelve la función congrats, respect("brother") (o algún otro argumento en lugar de "brother") devuelve la función insultos. Para llamar a las funciones, introduce respect("sí")() y respect("hermano")(), como una función normal.Lee también:  Python Books You Must Read in 2020¿Lo tienes? ¡Entonces ya tienes todo listo para los decoradores!Code is beautifully nerdy. Image by author.El ABC de los decoradores de PythonFunciones con un símbolo @Probemos una combinación de los dos conceptos anteriores: una función que toma otra función y define una función. ¿Suena alucinante? Considera esto:def startstop(func): def wrapper(): print("Starting...") func() print("Finished!") return wrapper def roll(): print("Rolling on the floor laughing XD") roll = startstop(roll)La última línea asegura que ya no necesitamos llamar a startstop(roll)(); con roll() será suficiente. ¿Sabes cuál es la salida de esa llamada? ¡Pruébalo tú mismo si no estás seguro!Ahora, como una muy buena alternativa, podríamos insertar esto justo después de definir startstop():@startstop def roll(): print("Rolling on the floor laughing XD")Esto hace lo mismo, pero pega roll() a startstop() al principio.Flexibilidad añadida¿Por qué es útil? ¿No consume exactamente las mismas líneas de código que antes?En este caso, sí. Pero una vez que estás tratando con cosas un poco más complicadas, se vuelve realmente útil. Por una vez, puedes mover todos los decoradores (es decir, la parte def startstop() de arriba) a su propio módulo. Es decir, los escribes en un archivo llamado decorators.py y escribes algo como esto en tu archivo principal:from decorators import startstop @startstop def roll(): print("Rolling on the floor laughing XD")En principio, puedes hacerlo sin usar decoradores. Pero de esta manera se hace la vida más fácil porque ya no tienes que lidiar con funciones anidadas y con el interminable conteo de corchetes.También puedes anidar decoradores:from decorators import startstop, exectime @exectime @startstop def roll(): print("Rolling on the floor laughing XD")Ten en cuenta que aún no hemos definido exectime(), pero lo verás en la siguiente sección. Es una función que puede medir el tiempo que tarda un proceso en Python.Este anidamiento equivaldría a una línea como estaroll = exectime(startstop(roll))¡Comienza el conteo de corchetes! Imagina que tienes cinco o seis de esas funciones anidadas unas dentro de otras. ¿No sería la notación del decorador mucho más fácil de leer que este lío anidado?Incluso puedes usar decoradores en funciones que aceptan argumentos. Ahora imagina unos cuantos argumentos en la línea anterior y tu caos estaría completo. Los decoradores lo hacen más limpio y ordenado.Lee también: How to Get a Job With PythonFinalmente, puedes incluso añadir argumentos a tus decoradores - como @mydecorator(argument). Sí, puedes hacer todo esto sin decoradores. Pero entonces te deseo que te diviertas entendiendo tu código sin decoradores cuando lo releas dentro de tres semanas...Decorators make everything easier. Image by author.Aplicaciones: donde los decoradores cortan la nataAhora que espero haberte convencido de que los decoradores te hacen la vida tres veces más fácil, veamos algunos ejemplos clásicos en los que los decoradores son básicamente indispensables.Medir el tiempo de ejecuciónSupongamos que tenemos una función llamada waste time() y queremos saber cuánto tarda. Pues bien, ¡sólo hay que utilizar un decorador!import time def measuretime(func): def wrapper(): starttime = time.perf_counter() func() endtime = time.perf_counter() print(f"Time needed: {endtime - starttime} seconds") return wrapper @measuretime def wastetime(): sum([i**2 for i in range(1000000)]) wastetime()Una docena de líneas de código y ya está. Además, puedes usar measuretime() en tantas funciones como quieras.Ralentizar el códigoA veces no quieres ejecutar el código inmediatamente, sino esperar un tiempo. Ahí es donde un decorador de ralentización resulta útil:import time def sleep(func): def wrapper(): time.sleep(300) return func() return wrapper @sleep def wakeup(): print("Get up! Your break is over.") wakeup()Llamar a wakeup() hace que te tomes un descanso de 5 minutos, tras el cual tu consola te recuerda que debes volver al trabajo.Lee también: Building A Linear Regression Model With Python To Predict Retail Customer SpendingPruebas y depuraciónDigamos que tienes un montón de funciones diferentes que llamas en diferentes etapas, y estás perdiendo la visión general sobre lo que se está llamando cuando. Con un simple decorador para cada definición de función, puedes aportar más claridad. Así:def debug(func): def wrapper(): print(f"Calling {func.__name__}") return wrapper @debug def scare(): print("Boo!") scare()Hay un ejemplo mucho más elaborado aquí. Ten en cuenta, sin embargo, que para entender ese ejemplo, tendrás que comprobar cómo decorar funciones con argumentos. Aun así, ¡vale la pena leerlo!Reutilización de códigoEsto no hace falta decirlo. Si has definido una función decorator(), puedes esparcir @decorator por todo tu código. Para ser honesto, no creo que haya nada más simple que eso.Manejo de los inicios de sesiónSi tienes funcionalidades a las que sólo se puede acceder si un usuario está conectado, también es bastante fácil con los decoradores. Te remitiré al ejemplo completo para que lo consultes, pero el principio es bastante sencillo: primero defines una función como login_required(). Antes de cualquier definición de función que necesite el inicio de sesión, pones @login_required. Bastante simple, diría yo.Azúcar sintáctico - o por qué Python es tan dulceNo es que no sea crítico con Python o que no utilice lenguajes alternativos cuando sea apropiado. Pero hay un gran atractivo en Python: es muy fácil de digerir, incluso cuando no eres un informático de formación y sólo quieres hacer que las cosas funcionen.Si C++ es una naranja, Python es una piña: igualmente nutritiva, pero tres veces más dulce. Los decoradores son sólo un factor en la mezcla.Pero espero que hayas llegado a ver por qué es un factor tan dulce. ¡Azúcar sintáctico para añadir algo de placer a tu vida! Sin riesgos para la salud, salvo tener los ojos pegados a una pantalla.¡Te deseo mucho código dulce!Lee también: How to Use Python Datetimes Correctly?

Python
SQL
Programming
¿Cómo Usar Correctamente Los Datetimes En Python?

Datetime es básicamente un objeto python que representa un punto en el tiempo, como años, días, segundos, milisegundos. Esto es muy útil para crear nuestros programas.El módulo datetime proporciona clases para manipular fechas y horas de forma simple y compleja. Mientras que la aritmética de la fecha y la hora está soportada, la aplicación se centra en la extracción eficiente de atributos para formatear y manipular la salidaVamos a importar el módulo de Python

Python
3 Trucos De Python Que Mejorarán Tu Código

Llevo más de 10 años codificando en Python. Hubo un tiempo en el que pensé que lo sabía todo, lo que era una clara señal de que me estaba volviendo complaciente.Entonces decidí investigar un poco sobre las mejoras de Python. Esas versiones 3.6, 3.7, 3.8 de Python no están ahí por nada, ¿verdad?Después de revisar las notas de la versión, encontré estos trucos que me gustaría compartir con ustedes.Al leer este artículo, aprenderás:Cómo formatear enteros grandes de forma más claraUna mejor manera de trabajar con las rutas de los archivosLa forma correcta de formatear cadenas1. Formateo de big integersUsing Underscores in Numeric Literals. Image by Roman OracA partir de la versión 3.6 de Python se pueden utilizar guiones bajos para facilitar la lectura de los números. Ver PEP 515 para más detalles.Veamos un ejemplo:a = 1000000000 # Is variable a billion or 100 millions? # Let's use underscores to make it easier to read a = 1_000_000_000 # You can group numbers as you like b = 1_0_9_0También funciona con direcciones hexadecimales y bits de agrupación.# grouping hexadecimal addresses by words addr = 0xCAFE_F00D # grouping bits into nibbles in a binary literal flags = 0b_0011_1111_0100_1110Lea también: ¿Por Qué Los Decoradores En Python Son Pura Genialidad?2. PathlibPhoto by Alice Donovan Rouse on UnsplashTrabajar con rutas puede ser un reto, especialmente si tu código necesita ejecutarse en múltiples sistemas operativos.Por suerte para nosotros, la biblioteca estándar de Python tiene pathllib.Veamos un ejemplo:from pathlib import Path path = Path("some_folder") print(path) # output: some_folder # We can add more subfolders in a readable way path = path / "sub_folder" / "sub_sub_folder" print(path) # output: some_folder/sub_folder/sub_sub_folder # make path absolute print(path.resolve()) # output: /Users/r.orac/some_folder/sub_folter/sub_sub_folderA pesar de utilizar el signo / como separador para concatenar rutas, pathlib lo hace agnóstico al sistema operativo, lo que significa que también funcionará en el sistema operativo Windows.Lea también: Usando Python y Pandas Datareader Para Analizar Datos Financieros3. Simplificar el formato de las cadenasFormato de cadenas f en Python. Imagen de Roman OracEstoy acostumbrado a utilizar el formato de cadena de la vieja escuela en Python:person = 'Roman' exercise = 0 print("%d-times %s exercised during corona epidemic" % (exercise, person)) # output # 0-times Roman exercised during corona epidemicHasta hace poco, no sabía que había una forma mejor (más moderna) de formatear cadenas en Python.En Python 3.6, PEP 498 introduce la Interpolación Literal de Cadenas, que simplifica el formato de las cadenas.Podemos reescribir el ejemplo anterior a:person = 'roman' exercise = 0 print(f"{exercise}-times {person} exercised during corona epidemic") # output # 0-times Roman exercised during corona epidemicUna cadena prefijada con f se conoce como fstring.Las cadenas f admiten incluso operaciones matemáticas:print(f"{exercise+1}-times {person} exercised during corona epidemic") # Output # '1-times roman exercised during corona epidemic'Pero no hice el ejercicio durante la epidemia de la corona por lo que añadir +1 en la fstring sería simplemente una mentira 😂¿Qué pasa con el formato de los valores flotantes?f = 0.333333 print(f"this is f={f:.2f} rounded to 2 decimals") # Output this is f=0.33 rounded to 2 decimalsLea también: ¿Cómo Usar Correctamente Los Datetimes En Python?ConclusiónEstos trucos de Python harán que tu código sea más conciso y que la codificación sea más agradable.Muchos desarrolladores de Python no conocen estos trucos - tú ya no eres uno de ellos.Antes de irteSígueme en  Twitter, donde tuiteo regularmente sobre Ciencia de Datos y Aprendizaje Automático.Lea también: Entendiendo El Módulo Collections de Python

Python
Programming
Libraries
Entendiendo El Módulo Collections de Python

El módulo collections de Python tiene diferentes tipos de datos especializados que funcionando como contenedores y que pueden utilizarse para reemplazar los contenedores de propósito general de Python (`dict`, `tuple`, `list` y `set`). Estudiaremos las siguientes partes de este módulo:- `ChainMap`- `defaultdict`- `deque`Existe un submódulo de colecciones llamado abc o Abstract Base Classes. Estas no serán tratadas en este post. ¡Empecemos con el contenedor ChainMap!ChainMapUn ChainMap es una clase que proporciona la capacidad de enlazar múltiples mapeos juntos de tal manera que terminan siendo una sola unidad. Si miras la documentación, te darás cuenta de que acepta `**maps*`, lo que significa que un ChainMap aceptará cualquier número de mapeos o diccionarios y los convertirá en una única vista que podrás actualizar. Veamos un ejemplo para que puedas ver cómo funciona:from collections import ChainMap car_parts = {'hood': 500, 'engine': 5000, 'front_door': 750} car_options = {'A/C': 1000, 'Turbo': 2500, 'rollbar': 300} car_accessories = {'cover': 100, 'hood_ornament': 150, 'seat_cover': 99} car_pricing = ChainMap(car_accessories, car_options, car_parts)car_pricing >> ChainMap({'cover': 100, 'hood_ornament': 150, 'seat_cover': 99}, {'A/C': 1000, 'Turbo': 2500, 'rollbar': 300}, {'hood': 500, 'engine': 5000, 'front_door': 750}) car_pricing['hood'] >> 500Aquí importamos ChainMap de nuestro módulo de colecciones. A continuación creamos tres diccionarios. Luego creamos una instancia de nuestro ChainMap pasándole los tres diccionarios que acabamos de crear.Por último, intentamos acceder a una de las claves de nuestro ChainMap. Cuando hacemos esto, el ChainMap recorrerá cada mapa para ver si esa clave existe y tiene un valor. Si lo tiene, entonces el ChainMap devolverá el primer valor que encuentre que coincida con esa clave.Esto es especialmente útil si quiere establecer valores por defecto. Supongamos que queremos crear una aplicación que tiene algunos valores por defecto. La aplicación también conocerá las variables de entorno del sistema operativo. Si hay una variable de entorno que coincide con una de las claves que tenemos por defecto en nuestra aplicación, el entorno anulará nuestro valor por defecto. Además, vamos a suponer que podemos pasar argumentos a nuestra aplicación. Estos argumentos tienen prioridad sobre el entorno y los valores por defecto. Este es un lugar donde un ChainMap puede realmente ser útil. Veamos un ejemplo sencillo que está basado en uno de la documentación de Python:Nota: no ejecutes este código desde Jupyter Notebook, sino desde tu IDE favorito y llamandolo desde una terminal. de esta mandera `python chain_map.py -u daniel`import argparse import os from collections import ChainMap def main(): app_defaults = {'username':'admin', 'password':'admin'} parser = argparse.ArgumentParser() parser.add_argument('-u', '--username') parser.add_argument('-p', '--password') args = parser.parse_args() command_line_arguments = {key:value for key, value in vars(args).items() if value} chain = ChainMap(command_line_arguments, os.environ, app_defaults) print(chain['username']) if __name__ == '__main__': main() os.environ['username'] = 'test' main()➜ python python3 post.py -u daniel daniel daniel Vamos a desglosar esto un poco. Aquí importamos el módulo `argparse` de Python junto con el módulo `os`. También importamos `ChainMap`.A continuación tenemos una función simple que tiene algunos valores predeterminados. He visto estos valores por defecto utilizados para algunos enrutadores populares. Luego configuramos nuestro analizador de argumentos y le decimos cómo manejar ciertas opciones de la línea de comandos. Notarás que argparse no proporciona una forma de obtener un objeto diccionario de sus argumentos, así que usamos un dict comprehension para extraer lo que necesitamos. La otra pieza interesante aquí es el uso de las vars incorporadas de Python. Si lo llamaras sin un argumento vars se comportaría como los locales incorporados de Python. Pero si le pasas un objeto, entonces vars es el equivalente a la propiedad `__dict__` de object. En otras palabras, vars(args) es igual a `args.__dict__`. Finalmente creamos nuestro ChainMap pasando nuestros argumentos de la línea de comandos (si hay alguno), luego las variables de entorno y finalmente los valores por defecto.Al final del código, intentamos llamar a nuestra función, luego establecer una variable de entorno y llamarla de nuevo. Pruébalo y verás que imprime admin y luego prueba como se esperaba. Ahora vamos a intentar llamar al script con un argumento de línea de comandos:python chain_map.py -u danielCuando yo ejecuto esto en mi maquina, me retorna  el daniel dos veces. Esto se debe a que nuestro argumento de línea de comandos anula todo lo demás. No importa que establezcamos el entorno porque nuestro ChainMap mirará primero los argumentos de la línea de comandos antes que cualquier otra cosa. Si lo intentas sin el `-u daniel` correrán los argumentos reales, en mi caso `"admin" "test"`Ahora que sabes cómo usar ChainMaps, ¡podemos pasar al Counter!Contador (`Counter`)El módulo de colecciones también nos proporciona una pequeña herramienta que permite realizar cómodos y rápidos recuentos. Esta herramienta se llama `Counter`. Puedes ejecutarla con la mayoría de los iterables. Vamos a probarlo con un stringfrom collections import Counter Counter('superfluous') >> Counter({'s': 2, 'u': 3, 'p': 1, 'e': 1, 'r': 1, 'f': 1, 'l': 1, 'o': 1})counter = Counter('superfluous') counter['u'] >> 3En este ejemplo, importamos `Counter` de `collections` y le pasamos una cadena. Esto devuelve un objeto Counter que es una subclase del diccionario de Python. Luego ejecutamos el mismo comando pero lo asignamos a la variable counter para que podamos acceder al diccionario más fácilmente. En este caso, hemos visto que la letra `"u"` aparece tres veces en la cadena de ejemplo.El contador proporciona algunos métodos que pueden interesarle. Por ejemplo, puede llamar a elementos que obtendrá un iterador sobre los elementos que están en el diccionario, pero en un orden arbitrario. Esta función se puede considerar como un "codificador", ya que la salida en este caso es una versión codificada de la cadena.list(counter.elements()) >> ['s', 's', 'u', 'u', 'u', 'p', 'e', 'r', 'f', 'l', 'o']Otro método útil es most_common. Puede preguntarle al Contador cuáles son los elementos más comunes pasando un número que represente cuáles son los elementos `"n"` más recurrentes:counter.most_common(2) [('u', 3), ('s', 2)]Aquí sólo preguntamos a nuestro Counter cuáles fueron los dos elementos más recurrentes. Como puedes ver, se produjo una lista de tuplas que nos dice que `"u"` ocurrió 3 veces y `"s"` ocurrió dos veces.El otro método que quiero cubrir es el método de sustracción. El método `subtract` acepta un iterable o un mapeo y utiliza ese argumento para restar. Es un poco más fácil de explicar si ves algo de código:counter_one = Counter('superfluous') counter_one >> Counter({'s': 2, 'u': 3, 'p': 1, 'e': 1, 'r': 1, 'f': 1, 'l': 1, 'o': 1}) counter_two = Counter('super') counter_one.subtract(counter_two) counter_one >> Counter({'s': 1, 'u': 2, 'p': 0, 'e': 0, 'r': 0, 'f': 1, 'l': 1, 'o': 1})Así que aquí recreamos nuestro primer contador y lo imprimimos para saber qué hay en él. Así creamos nuestro segundo objeto Contador. Finalmente restamos el segundo contador del primero. Si miras con atención en la salida al final, notará que el número de letras de cinco de los elementos ha sido disminuido en uno.Como mencioné al principio de esta sección, puedes usar el Contador contra cualquier iterable o mapeo, por lo que no tienes que usar sólo cadenas. También puedes pasarle tuplas, diccionarios y listas.Pruébalo por tu cuenta para ver cómo funciona con esos otros tipos de datos. ¡Ahora estamos listos para pasar al `defaultdict`!`defaultdict`El módulo de colecciones tiene una práctica herramienta llamada `defaultdict`. El `defaultdict` es una subclase del dict de Python que acepta un `default_factory` como argumento principal. El `default_factory` suele ser un tipo de datos de Python, como int o una lista, pero también puedes usar una función o un lambda. Empecemos por crear un diccionario regular de Python que cuenta el número de veces que se utiliza cada palabra en una frase:sentence = "The red for jumped over the fence and ran to the zoo for food" words = sentence.split(' ') words >> ['The', 'red', 'for', 'jumped', 'over', 'the', 'fence', 'and', 'ran', 'to', 'the', 'zoo', 'for', 'food'] reg_dict = {} for word in words: if word in reg_dict: reg_dict[word] += 1 else: reg_dict[word] = 1 print(reg_dict) >> {'The': 1, 'red': 1, 'for': 2, 'jumped': 1, 'over': 1, 'the': 2, 'fence': 1, 'and': 1, 'ran': 1, 'to': 1, 'zoo': 1, 'food': 1}¡Ahora vamos a intentar hacer lo mismo con defaultdict!from collections import defaultdict sentence = "The red for jumped over the fence and ran to the zoo for food" words = sentence.split(' ') d = defaultdict(int) for word in words: d[word] += 1 print(d) >> defaultdict(<class 'int'>, {'The': 1, 'red': 1, 'for': 2, 'jumped': 1, 'over': 1, 'the': 2, 'fence': 1, 'and': 1, 'ran': 1, 'to': 1, 'zoo': 1, 'food': 1})Notarás enseguida que el código es mucho más sencillo. El defaultdict asignará automáticamente cero como valor a cualquier clave que no tenga ya en él. Nosotros añadimos uno para que tenga más sentido y también se incrementará si la palabra aparece varias veces en la frase.Ahora vamos a intentar utilizar un tipo de lista de Python como nuestro `default_factory`. Empezaremos con un diccionario regular, como antes.my_list = [(1234, 100.23), (345, 10.45), (1234, 75.00), (345, 222.66), (678, 300.25), (1234, 35.67)] reg_dict = {} for acct_num, value in my_list: if acct_num in reg_dict: reg_dict[acct_num].append(value) else: reg_dict[acct_num] = [value]Si ejecuta este código, debería obtener una salida similar a la siguiente:print(reg_dict) >> {1234: [100.23, 75.0, 35.67], 345: [10.45, 222.66], 678: [300.25]}Ahora vamos a reimplementar este código usando defaultdict:from collections import defaultdict my_list = [(1234, 100.23), (345, 10.45), (1234, 75.00), (345, 222.66), (678, 300.25), (1234, 35.67)] d = defaultdict(list) for acct_num, value in my_list: d[acct_num].append(value)Una vez más, esto elimina la lógica condicional if/else y hace que el código sea más fácil de seguir. Aquí está la salida del código anterior:print(d) >> defaultdict(<class 'list'>, {1234: [100.23, 75.0, 35.67], 345: [10.45, 222.66], 678: [300.25]})¡Esto es algo muy bueno! ¡Vamos a probar a usar un `lambda` también como nuestra `default_factory`!from collections import defaultdict animal = defaultdict(lambda: "Monkey") animal >> defaultdict(<function __main__.<lambda>()>, {}) animal['Sam'] = 'Tiger' print (animal['Nick']) >> Monkey animal >> defaultdict(<function __main__.<lambda>()>, {'Sam': 'Tiger', 'Nick': 'Monkey'})Aquí creamos un `defaultdict` que asignará 'Monkey' como valor por defecto a cualquier clave. La primera llave la ponemos como 'Tiger', y la siguiente no la ponemos. Si imprimes la segunda llave, verás que tiene asignado 'Monkey'. En caso de que no lo hayas notado aún, es básicamente imposible causar un KeyError siempre y cuando establezcas el `default_factory` a algo que tenga sentido. La documentación menciona que si usted establece el `default_factory` a `None`, entonces recibirá un KeyError.Veamos cómo funciona eso:from collections import defaultdict x = defaultdict(None) x['Mike'] --------------------------------------------------------------------------- KeyError Traceback (most recent call last) <ipython-input-30-d21c3702d01d> in <module> 1 from collections import defaultdict 2 x = defaultdict(None) ----> 3 x['Mike'] KeyError: 'Mike'En este caso, acabamos de crear un `defaultdict` con un error. Ya no puede asignar un valor por defecto a nuestra llave, así que lanza un `KeyError` en su lugar. Por supuesto, ya que es una subclase de `dict`, podemos simplemente establecer la llave con algún valor y funcionará. Pero eso anula el propósito de `defaultdict`.`deque`Según la documentación de Python, los deques "son una generalización de las pilas y colas (stacks y queues)". Se pronuncia "deck", que es la abreviatura de "double-ended queue". Son un contenedor de reemplazo para la lista de Python. Los deques son seguros para los hilos (threads) y permiten añadir y sacar datos de la memoria de forma eficiente desde cualquier lado del deque. Una lista está optimizada para operaciones rápidas de longitud fija. Puede obtener todos los detalles detalles en la documentación de Python. Un deque acepta un argumento `maxlen` que establece los límites para el deque. En caso contrario, el deque crecerá hasta un tamaño arbitrario. Cuando un deque acotado está lleno, cualquier nuevo elemento que se añada provocará que el mismo número de elementos salga del otro extremo.Como regla general, si necesitas añadir o sacar elementos rápidamente, utiliza un deque. Si necesitas un acceso aleatorio rápido usa una lista. Tomemos un momento para ver cómo se puede crear y utilizar un deque.from collections import deque import string d = deque(string.ascii_lowercase) for letter in d: print(letter) >> a b c d e f g h i j k l m n o p q r s t u v w x y zAquí importamos el deque de nuestro módulo de colecciones y también importamos el módulo de strings. Para crear una instancia de un deque, necesitamos pasarle un iterable. En este caso, le pasamos `string.ascii_lowercase`, que devuelve una lista de todas las letras minúsculas del alfabeto. Finalmente, hacemos un bucle sobre nuestro deque e imprimimos cada elemento. Ahora veamos algunos de los métodos que posee deque.d.append('bye') d >> deque(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'bye']) d.appendleft('hello') d >> deque(['hello', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'bye']) d.rotate(1) d >> deque(['bye', 'hello', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'])Vamos a desglosar esto un poco. Primero añadimos una cadena al extremo derecho del deque. Luego añadimos otra cadena al lado izquierdo del deque. Por último, llamamos a `rotate` en nuestro deque y le pasamos un uno, lo que hace que rote una vez a la derecha. En otras palabras, hace que un elemento gire desde el extremo derecho y en la parte delantera. Puedes pasarle un número negativo para que el deque rote hacia la izquierda en su lugar. Terminemos esta sección con un ejemplo basado en algo de la documentación de Pythonfrom collections import deque def get_last(filename, n=5): """ Returns the last n lines from the file """ try: with open(filename) as f: return deque(f, n) except OSError: print("Error opening file: {}".format(filename)) raiseEste código funciona de forma muy parecida a como lo hace el programa tail de Linux. Aquí pasamos un `filename` a nuestro script junto con el número `n` de líneas que queremos que nos retorne. El deque está limitado a cualquier número que pasemos como `n`. Esto significa que una vez que el deque está lleno, cuando se leen nuevas líneas y se añaden al deque, las líneas más viejas son sacadas del otro extremo y descartadas. También he envuelto la apertura del archivo con un simple manejador de excepciones porque es muy fácil pasar una ruta malformada. Esto atrapará archivos que no existen.ConclusiónHemos cubierto mucho terreno en este post. Has aprendido a utilizar un defaultdict y un Count. También aprendimos sobre una subclase de la lista de Python, el deque. Por último, hemos visto cómo utilizarlas para realizar varias actividades. Espero que hayas encontrado cada una de estas colecciones interesantes. Pueden ser de gran utilidad para ti en tu dia a dia

Join our private community in Discord

Keep up to date by participating in our global community of data scientists and AI enthusiasts. We discuss the latest developments in data science competitions, new techniques for solving complex challenges, AI and machine learning models, and much more!

Join our Discord