Ir al contenido principal

30 trucos interesantes de Python para mejorar tu código con ejemplos

Hemos seleccionado 30 trucos interesantes de Python que puedes utilizar para mejorar tu código y desarrollar tus habilidades con Python.
Actualizado 5 sept 2025  · 15 min de lectura

La demanda de conocimientos de programación en Python ha crecido en los últimos años. Para ayudarte a desarrollar tus habilidades de programación en Python, hemos seleccionado 30 trucos interesantes que puedes utilizar para mejorar tu código. Intenta aprender uno cada día durante los próximos 30 días y consulta nuestra publicación sobre las mejores prácticas de Python para asegurarte de que tu código sea el mejor de su clase. 

Si tus conocimientos de Python no están a la altura, también puedes perfeccionarlos con nuestro programa Python Skill Track.

#1 Cortar en rodajas

a = "Hello World!"
print(a[::-1])

"""
!dlroW olleH
"""

El corte es una característica de Python que se basa en la indexación para permitir a los usuarios acceder a un subconjunto de una secuencia. Un índice es simplemente la posición de un elemento en una secuencia. Si el tipo de secuencia es mutable, puedes utilizar el corte para extraer y modificar datos. 

Nota: También podemos utilizar el corte en una secuencia inmutable, pero intentar modificar el corte generará un error TypeError. 

El formato en el que se implementan los segmentos es: secuencia[inicio:fin:paso]. Si no se especifican valores en los parámetros de inicio, fin y paso, la secuencia implementará los valores predeterminados. Los valores predeterminados son: 

  • El valor predeterminado de «start» es 0. 
  • «stop» toma por defecto la longitud de la secuencia.
  • «step» toma el valor predeterminado 1 si no se especifica. 

Cuando se proporciona la secuencia [start:stop], los elementos devueltos serán desde el índice inicial hasta el índice stop-1(el índice stop no está incluido). 

También podemos pasar índices negativos, que pueden utilizarse para invertir la secuencia. Por ejemplo, en una lista de 4 elementos, el índice 0 también es el índice -4, y el último índice también es -1. En el código de ejemplo anterior, este conocimiento se aplicó al parámetro step de la secuencia. En consecuencia, la cadena se imprimió al revés, comenzando desde el final de la secuencia hasta el índice 0.   

#2 Intercambio en el lugar / Asignación simultánea

a = 10
b = 5
print(f"First: {a, b}")

"""
First: (10, 5)
"""

a, b = b, a + 2
print(f"Second: {a, b}")

"""
Second: (5, 12)
"""

Si tu impresión inicial fue que el valor de b sería 7 en lugar de 12, has caído en la trampa del intercambio in situ. 

En Python, podemos desempaquetar iterables en variables en una sola asignación utilizando el desempaquetado automático. Por ejemplo: 

a, b, c = [1, 2, 3]
print(a)
print(b)
print(c)

"""
1
2
3
"""

También podemos recopilar varios valores en una sola variable utilizando *; este truco de Python se denomina empaquetado. A continuación se muestra un ejemplo de embalaje.  

a, *b = 1, 2, 3
print(a, b)
"""
1 [2, 3]
"""

La combinación del empaquetado y desempaquetado automáticos da lugar a una técnica conocida como asignación simultánea. Podemos utilizar la asignación simultánea para asignar una serie de valores a una serie de variables.

#3 Lista frente a Tuplas 

import sys

a = [1, 2, 3, 4, 5]
b = (1, 2, 3, 4, 5)

print(f"List size: {sys.getsizeof(a)} bytes")
print(f"Tuple size: {sys.getsizeof(b)} bytes")

"""
List size: 52 bytes
Tuple size: 40 bytes
"""

La mayoría de los programadores de Python están familiarizados con la estructura de datos de lista. No se puede decir lo mismo de las tuplas. Ambos son iterables, permiten la indexación y el almacenamiento de tipos de datos heterogéneos. Sin embargo, hay situaciones en las que es preferible utilizar una tupla en lugar de una lista. 

En primer lugar, las listas son mutables, lo que significa que podemos modificarlas como queramos: 

a = [1,2,3,4,5]
a[2] = 8
print(a)

"""
[1,2,8,4,5]
"""

Por otro lado, las tuplas son inmutables, lo que significa que intentar modificarlas generará un error TypeError

Por este motivo, las tuplas son más eficientes en cuanto a memoria, ya que Python puede asignar el bloque de memoria adecuado que se requiere para los datos. Por el contrario, en una lista, hay que asignar memoria adicional por si acaso la ampliamos, lo que se denomina asignación dinámica de memoria. 

TLDR; En situaciones en las que no deseas que los datos se modifiquen, es preferible utilizar una estructura de datos de tupla en lugar de una lista por motivos de memoria. Las tuplas también son más rápidas que las listas. 

Aprende más sobre las estructuras de datos de Python en este tutorial. 

#4 Generadores

a = [x * 2 for x in range(10)]
b = (x * 2 for x in range(10))

print(a)
print(b)

"""
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
<generator object <genexpr> at 0x7f61f8808b50>
"""

Las comprensiones de listas son la forma pythónica de crear una lista a partir de otro iterable. Es mucho más rápido que utilizar un bucle «Bucle for». Pero, ¿qué ocurre si accidentalmente cambias los corchetes [] por paréntesis ()? Obtienes un objeto generador.

En Python, los corchetes con lógica de comprensión de listas crean lo que se conoce como un objeto generador. Los generadores son un tipo especial de iterable. A diferencia de las listas, no almacenan sus elementos. En su lugar, almacenan instrucciones para generar cada elemento en orden y el estado actual de las iteraciones.

Cada elemento solo se genera bajo demanda utilizando una técnica denominada evaluación perezosa. La principal ventaja de este consejo de Python que utiliza un generador es que consume menos memoria, ya que no se construye toda la secuencia de una sola vez. 

#5 Aliasing 

a = [1, 2, 3, 4 ,5]
b = a

# Change the 4th index in b
b[4] = 7

print(id(a))
print(id(b))
print(a) # Remember we did not explicitly make changes to a.

"""
15136008
15136008
[1, 2, 3, 4, 7]
"""

Python es un lenguaje de programación orientado a objetos: todo es un objeto. Por lo tanto, asignar un objeto a un identificador es crear una referencia al objeto. 

Cuando asignamos un identificador a otro identificador, obtenemos dos identificadores que hacen referencia al mismo objeto. Este es un concepto conocido como aliasing. Los cambios en un alias afectarán al otro. A veces este comportamiento es deseado, pero a menudo nos pilla desprevenidos. 

Una forma de evitarlo es abstenerse de utilizar alias cuando se emplean objetos mutables. Otra solución podría ser crear un clon del objeto original en lugar de una referencia. 

La forma más sencilla de crear un clon es aprovechar el corte: 

b = a[:] 

Esto creará una nueva referencia a un objeto de lista en el identificador b. 

Se podrían idear muchas otras soluciones, como llamar a list(a) al asignar los datos a otro identificador y utilizar el método copy()

#6 El operador «not»

a = []
print(not a)

"""
True
"""

Nuestro siguiente consejo sobre Python es la forma más sencilla de comprobar si tu estructura de datos está vacía utilizando el operador «not». Las funciones integradas de Python not es un operador lógico que devuelve True si la expresión no es verdadera, o False en caso contrario; invierte el valor de verdad de las expresiones y objetos booleanos.  

Otra forma en la que puedes verlo utilizado es en una instrucción if: 

if not a:
    # do something... 

Cuando a es verdadero , entonces el no operador devolverá False, y viceversa. 

Es difícil de entender, así que pruébalo. 

#7 Cuerdas F

first_name = "John"
age = 19

print(f"Hi, I'm {first_name} and I'm {age} years old!")

"""
Hi, I'm John and I'm 19 years old!
"""

En ocasiones, puede que necesitemos dar formato a un objeto de cadena; Python 3.6 introdujo una interesante característica llamada cadenas f para simplificar este proceso. Es útil comprender cómo se formateaban las cadenas antes del nuevo lanzamiento para apreciar mejor el nuevo método. 

Así es como se formateaban las cadenas anteriormente: 

first_name = "John"
age  = 19

print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

"""
Hi, I'm John and I'm 19 years old!
"""

Básicamente, la nueva forma de dar formato es más rápida, más legible, más concisa y más difícil de equivocarse.

Otro uso de las cadenas f es imprimir un nombre identificador junto con el valor. Esto se introdujo en Python 3.8.

x = 10
y = 20
print(f"{x = }, {y = }")

"""
x = 10, y = 20
"""

Echa un vistazo a este tutorial sobre el formato de cadenas F en Python para obtener más información. 

#8 El parámetro «end» de las funciones de impresión

languages = ["english", "french", "spanish", "german", "twi"]
print(' '.join(languages))

"""
english french spanish german twi
"""

Es bastante común usar un imprimir sin definir ninguno de sus parámetros opcionales. Por consiguiente, muchos usuarios de Python desconocen que es posible controlar la salida hasta cierto punto.

Un parámetro opcional que podemos cambiar es end. El parámetro end especifica lo que debe mostrarse al final de una llamada a un imprimir

El valor predeterminado de end es «\n», que indica a Python que comience una nueva línea. En el código anterior, lo cambiamos por un espacio. Por lo tanto, el resultado devuelto muestra todos los elementos de nuestra lista impresos en la misma línea.

#9 Añadir a tupla

a = (1, 2, [1, 2, 3])
a[2].append(4)
print(a)

"""
(1, 2, [1, 2, 3, 4])
"""

Ya sabemos que las tuplas son inmutables; consulta el truco de Python #3 Lista frente a... Tuplas. Intentar cambiar el estado de una tupla generaría un error TypeError. Sin embargo, si piensas en un objeto tupla como una secuencia de nombres con enlaces a objetos que no se pueden cambiar, es posible que veas las cosas de otra manera.

Los dos primeros elementos de nuestra tupla son números enteros, por lo que son inmutables. El último elemento de nuestra tupla es una lista, un objeto mutable en Python.

Si consideramos que nuestra lista es solo otro nombre en una secuencia vinculada a un objeto que no se puede cambiar, nos daríamos cuenta de que la lista aún se puede modificar desde dentro de la tupla.

¿Recomendaríamos que hicieras esto en la práctica? Probablemente no, ¡pero es una de esas cosas que es bueno saber!

#10 Fusionar diccionarios

a = {"a": 1, "b": 2}
b = {"c": 3, "d": 4}

a_and_b = a | b
print(a_and_b)

"""
{"a": 1, "b": 2, "c": 3, "d": 4}
"""

En Python 3.9 y versiones posteriores, es posible fusionar diccionarios utilizando | (OR bit a bit). No hay mucho más que decir sobre este truco concreto de Python, salvo que es una solución mucho más legible.  

#11 Operador ternario / Expresiones condicionales 

condition = True
name = "John" if condition else "Doe"

print(name)

"""
John
"""

En el código anterior, puedes ver lo que se conoce como operador ternario, también denominado expresión condicional entre nombres. Utilizamos operadores ternarios para evaluar cosas en función de si una condición es verdadera o falsa.

Otra forma en la que podríamos haber escrito el código anterior es la siguiente:

condition = True
if condition:
    name = "John"
else:
    name = "Doe"

print(name)
"""
John
"""

Aunque ambos conjuntos de código dan como resultado la misma salida, fíjate en cómo la condición ternaria nos permite escribir un código mucho más corto y claro. Es lo que los Pythonistas llamarían la forma más «Python» de escribir código. 

#12 Eliminar duplicados de las listas

a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
print(list(set(a)))

"""
[1, 2, 3, 4, 5, 6, 7]
"""

La forma más sencilla de eliminar elementos duplicados de una lista es convertir la lista en un conjunto (y luego volver a convertirla en una lista si lo deseas).

En cuanto a la mutabilidad, los conjuntos y las listas son bastante similares en Python. Podemos añadir y eliminar elementos de ambas estructuras de datos a voluntad, pero siguen siendo extremadamente diferentes.

Las listas están ordenadas, indexadas desde cero y son mutables. Los conjuntos no están ordenados ni indexados. Los elementos de un conjunto deben ser de tipo inmutable, aunque el conjunto en sí sea mutable; si intentas recuperar un elemento mediante un índice o modificar un elemento, se generará un error.

Otra diferencia clave entre conjuntos y listas es que los conjuntos no pueden contener duplicados. Esto es lo que nos ayudó a eliminar los elementos duplicados de nuestra lista.

#13 Guion bajo independiente 

>>> print(_)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>

>>> 1 + 2
3

>>> print(_)
3

El guión bajo (_) es un identificador válido en Python, por lo que es posible utilizarlo para hacer referencia a un objeto. Pero underscore también tiene otra responsabilidad: almacenar el resultado de la última evaluación.

La documentación indica que «el intérprete interactivo pone a disposición el resultado de la última evaluación en la variable _. (Se almacena en el módulo builtins, junto con funciones integradas como print).

Como no asignamos un objeto a underscore antes de llamarlo en la primera línea, obtuvimos un error. Sin embargo, cuando calculamos el resultado de 1 + 2, el intérprete interactivo almacenó el resultado en el identificador _ por nosotros. 

#14 Subrayado para ignorar valores

for _ in range(100):
    print("The index doesn't matter")

"""
The index doesn't matter
The index doesn't matter
...
"""

En el consejo n.º 13 de Python, descubrimos que el intérprete interactivo pone a disposición el último resultado de una evaluación en el identificador de guión bajo (_), pero ese no es su único caso de uso.

También podemos utilizarlo para representar objetos que no nos interesan o que no utilizaremos más adelante en el programa. Esto es importante porque usar un identificador en lugar de un guión bajo (_) generará un error F841 cuando intentemos aplicar linting a nuestro programa. Un error F841 simplemente indica que se ha asignado un nombre de variable local, pero que no se ha utilizado en el programa, lo cual es una mala práctica.

N.º 15: Guiones bajos al final

list_ = [0, 1, 2, 3, 4]
global_ = "Hi there" 

Continuando con los dos trucos anteriores, el uso del guión bajo (_) en Python tiene otra finalidad: evitar conflictos con las palabras clave de Python. 

PEP 8 menciona que el guión bajo final (_) debe «utilizarse por convención para evitar conflictos con las palabras clave de Python». También afirma que «por lo general, es mejor añadir un solo guión bajo al final que utilizar una abreviatura o una deformación ortográfica». Por lo tanto, list_ es mejor que lst.

N.º 16: Guiones bajos iniciales

class Example:
    def __init__(self):
        self._internal = 2
        self.external = 20

A menudo verás que los programadores experimentados en Python tienden a anteponer un guión bajo a los identificadores o nombres de métodos, y por una buena razón.

El guión bajo que precede a un identificador o método tiene un significado oculto: esta variable o método solo está destinado al uso interno. Básicamente, se trata de una advertencia para otros programadores que se han definido en PEP 8, pero que Python no obliga a cumplir. Por lo tanto, los subrayados principales son un indicador débil.

A diferencia de Java, Python no establece una distinción clara entre variables privadas y públicas. En otras palabras, solo tiene significado porque la comunidad Python ha acordado que lo tenga. Su inclusión no afecta al comportamiento de tus programas.

#17 Subrayado visual

Aquí tienes el último consejo sobre los guiones bajos. Hasta ahora, hemos visto tres casos de uso diferentes para el guión bajo, pero puedes consultar nuestro tutorial para obtener más información sobre la función del guión bajo (_) en Python

number = 1_500_000
print(number)

"""
15000000
"""

Otra forma en la que podemos utilizar el guión bajo es como separador visual para agrupar dígitos en literales de números enteros, decimales y complejos; esto se introdujo en Python 3.6. 

La idea era facilitar la legibilidad de los literales largos o aquellos cuyo valor debía separarse claramente en partes. Puedes obtener más información al respecto en PEP 515.

#18 __name__ == «__main__» 

if __name__ == "__main__":
    print("Read on to understand what is going on when you do this.")

"""
print("Read on to understand what is going on when you do this.")
"""

Es muy probable que hayas visto esta sintaxis en varios programas de Python; Python utiliza un nombre especial llamado «__main__» y lo establece como identificador llamado __name__ si el archivo Python que se está ejecutando es el programa principal.

Si decidimos importar el módulo que se muestra en la captura de pantalla a otro módulo (archivo Python) y ejecutamos ese archivo, la verdad de la expresión en nuestro código será falsa. Esto se debe a que, cuando importamos desde otro módulo, el identificador __name__ se establece con el nombre del módulo (archivo Python). 

#19 El método «setdefault» 

import pprint

text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"

counts = {}
for word in text.split():
    counts.setdefault(word, 0)
    counts[word] += 1

pprint.pprint(counts)

"""
{'April.': 1,
'But': 1,
"I'm": 1,
"It's": 2,
'UK.': 1,
'a': 1,
'be': 1,
'cold': 1,
'day': 1,
'first': 1,
'going': 1,
'in': 1,
'it': 1,
'museum': 1,
'of': 1,
'should': 1,
'so': 1,
'still': 1,
'the': 3,
'to': 1,
'wonderful': 1}
"""

Es posible que desees establecer un valor para varias claves en un diccionario. Por ejemplo, cuando se programa el recuento de palabras en un corpus. La forma habitual de hacerlo es la siguiente: 

  1. Comprueba si la clave existe en el diccionario.
  2. Si es así, incrementa el valor en 1.
  3. Si no es así, añádelo y establece el valor en 1.

Así es como se ve en el código:

counts = {}
for word in text.split():
    if word in counts:
        counts[word] += 1
    else:
      counts[word] = 1

Una forma más concisa de hacerlo es utilizar el método setdefault() en tu objeto diccionario.

El primer argumento que se pasa al método es la clave que queremos comprobar. El segundo argumento pasado es el valor que se establecerá para la clave si esta aún no existe en el diccionario; si la clave existe, el método devolverá el valor de la clave. Por lo tanto, no se modificaría.

#20 Expresión regular coincidente

import re

number = re.compile(r"(0)?(\+44)?\d{10}")
num_1 = number.search("My number is +447999999999")
num_2 = number.search("My number is 07999999999")

print(num_1.group())
print(num_2.group())

"""
'+447999999999'
'07999999999'
"""

Las expresiones regulares te permiten especificar un patrón de texto para buscar. La mayoría de la gente sabe que podemos buscar cosas utilizando CTRL + F (Windows), pero si no sabes exactamente lo que estás buscando, ¿cómo podrías encontrarlo? La respuesta es buscar patrones.  

Por ejemplo, los números del Reino Unido siguen un patrón similar: tendrán un cero al principio más diez números o +44 en lugar de cero y diez números; el segundo caso indica que se trata de un número en formato internacional. 

Las expresiones regulares ahorran mucho tiempo. Si codificáramos reglas para detectar las instancias en nuestra imagen en lugar de expresiones regulares, podrían ser necesarias más de 10 líneas de código. 

Aprender cómo funcionan las expresiones regulares es fundamental, incluso si no escribes código. La mayoría de los editores de texto y procesadores de texto modernos te permiten utilizar expresiones regulares para buscar y reemplazar elementos.

#21 Regex Pipe

import re

heros = re.compile(r"Super(man|woman|human)")

h1 = heros.search("This will find Superman")
h2 =  heros.search("This will find Superwoman")
h3 = heros.search("This will find Superhuman")

print(h1.group())
print(h2.group())
print(h3.group())

"""
Superman
Superwoman
Superhuman
"""

Las expresiones regulares tienen un carácter especial llamado barra vertical (|) que permite hacer coincidir una de muchas expresiones, y se pueden utilizar en cualquier lugar. Esto resulta muy útil cuando tienes varios patrones similares.

Por ejemplo, «Superman», «Superwoman» y «Superhuman» tienen todos el mismo prefijo. De este modo, podrías aprovechar el canal para conservar la parte del patrón que se repite y cambiar las partes que necesitas que sean diferentes. Una vez más, te ahorramos un tiempo valioso.

Ten en cuenta lo siguiente: si todas las expresiones que deseas buscar aparecen en el mismo texto, se mostrará la primera aparición del texto buscado, es decir, «Un texto de ejemplo que contenga Superwoman, Superman, Superhuman» mostraría Superwoman.

#22 El parámetro «sep» de la función de impresión

day = "04"
month = "10"
year = "2022"

print(day, month, year)
print(day, month, year, sep = "")
print(day, month, year, sep = ".")

"""
04 10 2022
04/10/2022
04.10.2022
"""

Es alarmante la cantidad de programadores de Python que desconocen todas las capacidades de la función print(). Si «Hello World» fue tu primer programa, probablemente la función print() fue una de las primeras funciones integradas que aprendiste al estudiar Python. Utilizamos print() para mostrar mensajes formateados en la pantalla, pero la función print() ofrece muchas más posibilidades. 

En el código anterior, hemos mostrado diferentes formas de mostrar nuestro mensaje formateado. El parámetro sep es un argumento opcional de la función print() que nos permite especificar cómo se deben separar los objetos si incluimos más de uno. 

El valor predeterminado es separarlos con un espacio, pero hemos cambiado esta funcionalidad con nuestras instrucciones de impresión: una en la que sep se establece en «» y otra en la que sep se establece en «.».

#23 Funciones lambda 

def square(num:int) -> int:
    return num ** 2

print(f"Function call: {square(4)}")
"""
Function call: 16
"""

square_lambda = lambda x: x**2
print(f"Lambda function: {square_lambda(4)}")
"""
Lambda functional: 16
"""

Las funciones Lambda te llevan a un nivel más intermedio-avanzado de lo que puedes hacer con Python. Aprende Python intermedio con este curso. A primera vista parecen complicados, pero son bastante sencillos.

En nuestro código de ejemplo, solo hemos utilizado un argumento, pero podríamos haber utilizado varios si hubiéramos querido:

square = lambda a, b: a ** b
print(f"Lambda function: {square(4, 2)}")
"""
16
"""

En esencia, la palabra clave lambda nos permite crear funciones pequeñas, restringidas y anónimas en una sola línea. Se comportan como una función normal declarada con la palabra clave def, excepto que estas funciones no tienen nombre.

#24 El método «swapcase»

string = "SoMe RaNDoM sTriNg"
print(string.swapcase())

"""
sOmE rAndOm StRInG
"""

El método swapcase() se aplica a un objeto de cadena para permitirnos cambiar las letras mayúsculas a minúsculas y viceversa en una sola línea de código. No hay muchos casos de uso para el método swapcase(), pero es bueno saberlo.

#25 El método «isalnum»

password = "ABCabc123"
print(password.isalnum())

"""
True
"""

Supongamos que estamos creando un programa que requiere que los usuarios introduzcan una contraseña, pero esta debe contener una combinación de números y letras. Podemos hacerlo en una sola línea de código llamando a la función isalnum() en la instancia de cadena.

El método comprueba si todos los caracteres forman parte del alfabeto (A-Za-z) y son numéricos (0-9). Un espacio o símbolo (!#%$&amp;? etc.) devolverá False.

#26 Manejo de excepciones

def get_ration(x:int, y:int) -> int:
    try:
        ratio = x/y
    except ZeroDivisionError:
        y = y + 1
        ratio = x/y
    return ratio

print(get_ration(x=400, y=0))

"""
400.0
"""

Los programas Python se cierran cuando encuentran un error.

A veces, no queremos este comportamiento, como cuando un usuario final interactúa con nuestro código. ¿Qué tan grave sería si nuestro código terminara prematuramente en tal caso?

Hay varias formas de abordar este caso excepcional. La mayoría de los programadores de Python suelen aceptar la idea de que es más fácil pedir perdón que obtener permiso. Esto significa que prefieren detectar un error generado proporcionando un contexto circundante capaz de gestionar una excepción. La idea detrás de este pensamiento es que no tiene sentido perder el tiempo tratando de protegerse contra todos los casos excepcionales.

Pero esto solo es válido cuando existe un mecanismo para hacer frente al problema una vez que se ha producido.

#27 Identificar las diferencias en las listas

list_1 = [1, 3, 5, 7, 8]
list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]

solution_1 = list(set(list_2) - set(list_1))
solution_2 = list(set(list_1) ^ set(list_2))
solution_3 = list(set(list_1).symmetric_difference(set(list_2)))

print(f"Solution 1: {solution_1}")
print(f"Solution 2: {solution_2}")
print(f"Solution 3: {solution_3}")

"""
Solution 1: [9, 2, 4, 6]
Solution 2: [2, 4, 6, 9]
Solution 3: [2, 4, 6, 9]
"""

Aquí hay tres métodos diferentes para comparar la diferencia entre dos listas en Python. 

Nota: A menos que sepas con certeza que list_1 es un subconjunto de list_2, la solución 1 no es igual que las otras dos soluciones.

#28 Args y Kwargs

def some_function(*args, **kwargs):
    print(f"Args: {args}")
    print(f"Kwargs: {kwargs}")

some_function(1, 2, 3,  a=4, b=5, c=6)

"""
Args: (1, 2, 3)
Kwargs: {'a': 4, 'b': 5, 'c': 6}
"""

Usamos *args y **kwargs como parámetros de una función cuando no sabemos el número de variables que debe esperar nuestra función. 

El parámetro *args nos permite pasar un número variable de parámetros a una función cuando no se utiliza con palabras clave (es decir, los parámetros que pasamos no requieren un nombre asociado). Por otro lado, el parámetro **kwargs nos permite pasar un número arbitrario de parámetros con palabras clave a una función.

En realidad, las palabras *args y **kwargs no son tan mágicas: la verdadera magia está en los asteriscos (*). Esto significa que podríamos haber utilizado cualquier palabra después de los asteriscos, pero el uso de args y kwargs es una práctica habitual y se aplica entre los programadores de Python. 

#29 Los puntos suspensivos

print(...)

"""
Ellipsis
"""

def some_function():
    ...

# Alternative solution
def another_function():
    pass

Ellipsis es un objeto Python que se puede invocar proporcionando una secuencia de tres puntos (...) o invocando al propio objeto (Ellipsis).

Su uso más notable es para acceder y dividir arreglos multidimensionales en NumPy, por ejemplo:

import numpy as np

arr = np.array([[2,3], [1,2], [9,8]])

print(arr[...,0])
"""
[2 1 9]
"""
print(arr[...])

"""
[[2 3]
[1 2]
[9 8]]
"""

Pero otro uso de Ellipsis es como marcador de posición en una función no implementada. 

Esto significa que podrías pasar Ellipsis, ..., o pasar, y todos ellos seguirían siendo válidos.

#30 Comprensión de listas

even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
print(even_numbers)

"""
[2, 4, 6, 8]
"""

Nuestro último truco de Python son las comprensiones de listas, una forma elegante de crear una lista a partir de otra secuencia. Te permiten realizar operaciones lógicas y de filtrado sofisticadas, como hemos hecho en el código anterior.

Hay otras formas de lograr el mismo objetivo; por ejemplo, podríamos haber utilizado una función lambda de la siguiente manera:

even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
print(even_numbers)
"""
[0, 2, 4, 6, 8]
"""

Sin embargo, varios Pythonistas dirían que esta solución es mucho menos legible que la comprensión de listas.

Echa un vistazo a este tutorial para obtener más información sobre las comprensiones de listas en Python.   

Temas

Los mejores cursos de Python

Curso

Python intermedio

4 h
1.3M
Mejora tus conocimientos de ciencia de datos creando visualizaciones con Matplotlib y manipulando DataFrames con pandas.
Ver detallesRight Arrow
Comienza el curso
Ver másRight Arrow
Relacionado

blog

Las 23 mejores preguntas y respuestas de entrevistas sobre Python

Preguntas esenciales de una entrevista sobre Python con ejemplos para solicitantes de empleo, estudiantes de último curso y profesionales de los datos.
Abid Ali Awan's photo

Abid Ali Awan

15 min

Python snake

blog

¿Para qué se utiliza Python? 8 usos reales de Python

¿Te has preguntado alguna vez para qué se utiliza Python en el mundo real? Echa un vistazo a 8 usos prácticos de este potente lenguaje de programación.
Elena Kosourova's photo

Elena Kosourova

10 min

Tutorial

21 herramientas esenciales de Python

Conozca las herramientas esenciales de Python para el desarrollo de software, raspado y desarrollo web, análisis y visualización de datos y aprendizaje automático.
Abid Ali Awan's photo

Abid Ali Awan

Tutorial

Tutorial sobre cómo concatenar cadenas en Python

Aprende varios métodos para concatenar cadenas en Python, con ejemplos que ilustran cada técnica.
DataCamp Team's photo

DataCamp Team

Tutorial

Arreglos en Python

Arreglos de Python con ejemplos de código. ¡Aprende hoy mismo a crear e imprimir arreglos con Python NumPy!
DataCamp Team's photo

DataCamp Team

Ver másVer más