Si me ha estado siguiendo durante algún tiempo, sabrá que publico regularmente fragmentos de código de Python para problemas cotidianos . Bueno, pensé que finalmente agregaría todas esas respuestas en un artículo masivo con enlaces a todos esos recursos.

Problemas cotidianos

En esta sección, veremos varios escenarios comunes que surgen y cómo resolverlos con código Python. Específicamente, compartiré una breve explicación del problema con una lista de soluciones de código Python. Luego, vincularé todos los recursos que tengo.

Inversión de un diccionario

A veces, cuando tenemos un diccionario, queremos poder cambiar sus claves y valores. Por supuesto, existen preocupaciones como "¿cómo manejamos los valores duplicados?" y "¿y si los valores no se pueden utilizar con hash?" Dicho esto, en el caso simple, hay algunas soluciones:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
# Use to invert dictionaries that have unique values
my_inverted_dict = dict(map(reversed, my_dict.items()))
 
# Use to invert dictionaries that have unique values
my_inverted_dict = {value: key for key, value in my_dict.items()}
 
# Use to invert dictionaries that have non-unique values
from collections import defaultdict
my_inverted_dict = defaultdict(list)
{my_inverted_dict[v].append(k) for k, v in my_dict.items()}
 
# Use to invert dictionaries that have non-unique values
my_inverted_dict = dict()
for key, value in my_dict.items():
    my_inverted_dict.setdefault(value, list()).append(key)
 
# Use to invert dictionaries that have lists of values
my_dict = {value: key for key in my_inverted_dict for value in my_map[key]}

Para obtener más explicaciones, consulte mi artículo titulado " Cómo invertir un diccionario en Python ". Incluye un desglose de cada solución, sus métricas de rendimiento y cuándo son aplicables. Asimismo, tengo un video de YouTube que cubre el mismo tema.

Sumar elementos de dos listas

Supongamos que tiene dos listas y desea combinarlas en una sola lista por elemento. En otras palabras, desea agregar el primer elemento de la primera lista al primer elemento de la segunda lista y almacenar el resultado en una nueva lista. Bueno, hay varias formas de hacerlo:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
ethernet_devices = [1, [7], [2], [8374163], [84302738]]
usb_devices = [1, [7], [1], [2314567], [0]]
 
# The long way
all_devices = [
    ethernet_devices[0] + usb_devices[0],
    ethernet_devices[1] + usb_devices[1],
    ethernet_devices[2] + usb_devices[2],
    ethernet_devices[3] + usb_devices[3],
    ethernet_devices[4] + usb_devices[4]
]
 
# Some comprehension magic
all_devices = [x + y for x, y in zip(ethernet_devices, usb_devices)]
 
# Let's use maps
import operator
all_devices = list(map(operator.add, ethernet_devices, usb_devices))
 
# We can't forget our favorite computation library
import numpy as np
all_devices = np.add(ethernet_devices, usb_devices)

Si desea una explicación más profunda, consulte mi artículo titulado " Cómo sumar elementos de dos listas en Python ", que incluso incluye un desafío divertido. Del mismo modo, puede obtener algo de valor de mi video de YouTube sobre el mismo tema .

Comprobación de si existe un archivo

Una de las ventajas asombrosas de Python es lo fácil que es administrar archivos. A diferencia de Java, Python tiene una sintaxis incorporada para leer y escribir archivos. Como resultado, comprobar si existe un archivo es una tarea bastante breve:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
# Brute force with a try-except block (Python 3+)
try:
    with open('/path/to/file', 'r') as fh:
        pass
except FileNotFoundError:
    pass
 
# Leverage the OS package (possible race condition)
import os
exists = os.path.isfile('/path/to/file')
 
# Wrap the path in an object for enhanced functionality
from pathlib import Path
config = Path('/path/to/file')
if config.is_file():
    pass

Como siempre, puede obtener más información sobre estas soluciones en mi artículo titulado " Cómo comprobar si existe un archivo en Python ", que presenta tres soluciones y métricas de rendimiento.

Conversión de dos listas en un diccionario

Anteriormente, hablamos de sumar dos listas en Python. Resulta que podemos hacer mucho con dos listas. Por ejemplo, podríamos intentar mapear uno sobre otro para crear un diccionario.

Como ocurre con muchos de estos problemas, existen algunas preocupaciones. Por ejemplo, ¿qué pasa si las dos listas no son del mismo tamaño? Del mismo modo, ¿qué sucede si las claves no son únicas o se pueden usar con hash? Dicho esto, en el caso simple, existen algunas soluciones sencillas:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
column_names = ['id', 'color', 'style']
column_values = [1, 'red', 'bold']
 
# Convert two lists into a dictionary with zip and the dict constructor
name_to_value_dict = dict(zip(column_names, column_values))
 
# Convert two lists into a dictionary with a dictionary comprehension
name_to_value_dict = {key:value for key, value in zip(column_names, column_values)}
 
# Convert two lists into a dictionary with a loop
name_value_tuples = zip(column_names, column_values)
name_to_value_dict = {}
for key, value in name_value_tuples:
    if key in name_to_value_dict:
        pass # Insert logic for handling duplicate keys
    else:
        name_to_value_dict[key] = value

Una vez más, puede encontrar una explicación para cada una de estas soluciones y más en mi artículo titulado " Cómo convertir dos listas en un diccionario en Python ". Si eres una persona visual, es posible que prefieras mi video de YouTube, que también cubre la asignación de listas a diccionarios .

Comprobación de si una lista está vacía

Si viene de un lenguaje escrito estáticamente como Java o C, es posible que le moleste la falta de tipos estáticos en Python. Claro, no saber el tipo de variable a veces puede ser frustrante, pero también hay ventajas. Por ejemplo, podemos verificar si una lista está vacía por su flexibilidad de tipo, entre otros métodos:

01
02
03
04
05
06
07
08
09
10
11
12
13
my_list = list()
 
# Check if a list is empty by its length
if len(my_list) == 0:
    pass  # the list is empty
 
# Check if a list is empty by direct comparison (only works for lists)
if my_list == []:
    pass  # the list is empty
 
# Check if a list is empty by its type flexibility **preferred method**
if not my_list:
    pass  # the list is empty

Si desea obtener más información sobre estas tres soluciones, consulte mi artículo titulado " Cómo verificar si una lista está vacía en Python ". Si estás en un apuro, mira mi video de YouTube que cubre el mismo tema .

Clonación de una lista

Uno de mis temas favoritos en la programación es copiar tipos de datos. Después de todo, nunca es fácil en este mundo basado en referencias en el que vivimos, y eso también es cierto para Python. Afortunadamente, si queremos copiar una lista, hay algunas formas de hacerlo:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
my_list = [27, 13, -11, 60, 39, 15]
 
# Clone a list by brute force
my_duplicate_list = [item for item in my_list]
 
# Clone a list with a slice
my_duplicate_list = my_list[:]
 
# Clone a list with the list constructor
my_duplicate_list = list(my_list)
 
# Clone a list with the copy function (Python 3.3+)
my_duplicate_list = my_list.copy()  # preferred method
 
# Clone a list with the copy package
import copy
my_duplicate_list = copy.copy(my_list)
my_deep_duplicate_list = copy.deepcopy(my_list)
 
# Clone a list with multiplication?
my_duplicate_list = my_list * 1  # do not do this

Cuando se trata de clonación, es importante tener en cuenta la diferencia entre copias superficiales y profundas. Afortunadamente, tengo un artículo que cubre ese tema .

Finalmente, puede encontrar más información sobre las soluciones enumeradas anteriormente en mi artículo titulado " Cómo clonar una lista en Python ". Además, puede encontrar valor en mi video relacionado de YouTube titulado " 7 formas de copiar una lista en Python con los pingüinos de Pittsburgh ".

Recuperar el último elemento de una lista

Ya que estamos en el tema de las listas, hablemos de cómo obtener el último elemento de una lista. En la mayoría de los lenguajes, esto implica alguna expresión matemática complicada que implica la longitud de la lista. ¿Qué pasa si te digo que hay varias soluciones más interesantes en Python?

01
02
03
04
05
06
07
08
09
10
11
12
13
my_list = ['red', 'blue', 'green']
 
# Get the last item with brute force using len
last_item = my_list[len(my_list) - 1]
 
# Remove the last item from the list using pop
last_item = my_list.pop()
 
# Get the last item using negative indices *preferred & quickest method*
last_item = my_list[-1]
 
# Get the last item using iterable unpacking
*_, last_item = my_list

Como siempre, puede obtener más información sobre estas soluciones en mi artículo titulado " Cómo obtener el último elemento de una lista en Python ", que presenta un desafío, métricas de rendimiento y un video de YouTube .

Hacer un atajo de secuencia de comandos de Python

A veces, cuando crea un script, desea poder ejecutarlo cómodamente con solo hacer clic en un botón. Afortunadamente, hay varias formas de hacerlo.

Primero, podemos crear un acceso directo de Windows con la siguiente configuración:

1
\path\to\trc-image-titler.py -o \path\to\output

Asimismo, también podemos crear un archivo por lotes con el siguiente código:

1
2
@echo off
\path\to\trc-image-titler.py -o \path\to\output

Finalmente, podemos crear un script bash con el siguiente código:

1
2
#!/bin/sh
python /path/to/trc-image-titler.py -o /path/to/output

Si está buscando más explicaciones, consulte el artículo titulado " Cómo hacer un acceso directo de secuencia de comandos de Python con argumentos ".

Ordenar una lista de cadenas

La clasificación es una tarea común que se espera que sepa cómo implementar en Ciencias de la Computación. A pesar del intenso enfoque en los algoritmos de clasificación en la mayoría de los planes de estudios, nadie le dice realmente lo complicado que puede ser la clasificación. Por ejemplo, ordenar números es sencillo, pero ¿qué pasa con ordenar cadenas? ¿Cómo decidimos un pedido adecuado? Afortunadamente, hay muchas opciones en Python:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
my_list = ["leaf", "cherry", "fish"]
 
# Brute force method using bubble sort
my_list = ["leaf", "cherry", "fish"]
size = len(my_list)
for i in range(size):
    for j in range(size):
        if my_list[i] < my_list[j]:
            temp = my_list[i]
            my_list[i] = my_list[j]
            my_list[j] = temp
 
# Generic list sort *fastest*
my_list.sort()
 
# Casefold list sort
my_list.sort(key=str.casefold)
 
# Generic list sorted
my_list = sorted(my_list)
 
# Custom list sort using casefold (>= Python 3.3)
my_list = sorted(my_list, key=str.casefold)
 
# Custom list sort using current locale
import locale
from functools import cmp_to_key
my_list = sorted(my_list, key=cmp_to_key(locale.strcoll))
  
# Custom reverse list sort using casefold (>= Python 3.3)
my_list = sorted(my_list, key=str.casefold, reverse=True)

Si tiene curiosidad acerca de cómo funcionan algunas de estas soluciones, o simplemente desea saber cuáles son algunos de los riesgos potenciales, consulte mi artículo titulado " Cómo ordenar una lista de cadenas en Python ".

Analizar una hoja de cálculo

Uno de los casos de uso más interesantes de Python es la ciencia de datos. Sin embargo, desafortunadamente, eso significa manejar una gran cantidad de datos sin procesar en varios formatos, como archivos de texto y hojas de cálculo. Afortunadamente, Python tiene muchas utilidades integradas para leer diferentes formatos de archivo. Por ejemplo, podemos analizar una hoja de cálculo con facilidad:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# Brute force solution
csv_mapping_list = []
with open("/path/to/data.csv") as my_data:
  line_count = 0
  for line in my_data:
    row_list = [val.strip() for val in line.split(",")]
    if line_count == 0:
      header = row_list
    else:
      row_dict = {key: value for key, value in zip(header, row_list)}
      csv_mapping_list.append(row_dict)
    line_count += 1
 
# CSV reader solution
import csv
csv_mapping_list = []
with open("/path/to/data.csv") as my_data:
    csv_reader = csv.reader(my_data, delimiter=",")
    line_count = 0
    for line in csv_reader:
        if line_count == 0:
            header = line
        else:
            row_dict = {key: value for key, value in zip(header, line)}
            csv_mapping_list.append(row_dict)
        line_count += 1
 
# CSV DictReader solution
import csv
with open("/path/to/dict.csv") as my_data:
    csv_mapping_list = list(csv.DictReader(my_data))

En este caso, intentamos obtener nuestro resultado en una lista de diccionarios. Si desea saber más sobre cómo funciona esto, consulte el artículo completo titulado " Cómo analizar una hoja de cálculo en Python ".

Ordenar una lista de diccionarios

Una vez que tenga una lista de diccionarios, es posible que desee organizarlos en un orden específico. Por ejemplo, si los diccionarios tienen una clave para la fecha, podemos intentar ordenarlos en orden cronológico. Afortunadamente, la clasificación es otra tarea relativamente indolora:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
csv_mapping_list = [