Búsqueda de sitios web

Comprensiones de conjuntos de Python: cómo y cuándo usarlas

Python Set CompreHensions proporciona una forma concisa de crear y manipular conjuntos en su código. Generan conjuntos con una sintaxis limpia, haciendo que su código sea más legible y pitónico. Con Set Comprensions, puede crear, transformar y filtrar conjuntos, que son excelentes habilidades para agregar a su Kit de herramientas de programación de Python.

Al final de este tutorial, comprenderá que:

  • Python tiene set Comprensions , que le permiten crear conjuntos con una sintaxis concisa .
  • Python tiene cuatro tipos de comprensiones: list , set , diccionario y generador Expresiones.
  • Una comprensión de conjunto se puede escribir como {expresión para elemento en iterable [si condición]}.
  • Los conjuntos no pueden contener duplicados , ya que aseguran que todos sus elementos sean únicos .

Para aprovechar al máximo este tutorial, debe estar familiarizado con los conceptos básicos de Python como for bucles, iterables, comprensiones de listas y comprensiones de diccionario.

Creación y transformación de conjuntos en Python

En la programación de Python, es posible que deba crear, completar y transformar conjuntos. Para hacer esto, puede usar LITERALES SET, el constructor set() y for loops. En las siguientes secciones, verá rápidamente cómo usar estas herramientas. También aprenderá sobre las comprensiones establecidas, que son una forma poderosa de manipular conjuntos en Python.

Creando conjuntos con literales y set()

Para crear nuevos conjuntos, puede usar literales. Un set literal es una serie de elementos encerrados en tirantes rizados. La sintaxis de un set literal se muestra a continuación:

{element_1, element_2,..., element_N}

Los elementos deben ser objetos deshables. Los objetos en el literal pueden duplicarse, pero solo se almacenará una instancia en el conjunto resultante. Los conjuntos no permiten elementos duplicados. Aquí hay un ejemplo rápido de un conjunto:

>>> colors = {"blue", "red", "green", "orange", "green"}
>>> colors
{'red', 'green', 'orange', 'blue'}

>>> colors.add("purple")
>>> colors
{'red', 'green', 'orange', 'purple', 'blue'}

En este ejemplo, creará un conjunto que contiene nombres de colores. Los elementos del conjunto resultante son objetos de cadena únicos. Puede agregar nuevos elementos utilizando el método .add(). Recuerde que los conjuntos son colecciones desordenadas, por lo que el orden de los elementos en el conjunto resultante no coincidirá con el orden de inserción en la mayoría de los casos.

También puede crear un nuevo conjunto usando el constructor set() y un iterable de objetos:

>>> numbers = [2, 2, 1, 4, 2, 3]

>>> set(numbers)
{1, 2, 3, 4}

En este ejemplo, crea un nuevo conjunto usando set() con una lista de valores numéricos. Observe cómo el conjunto resultante no contiene elementos duplicados. En la práctica, el constructor set() es una gran herramienta para eliminar valores duplicados en iterables.

Para crear un conjunto vacío, utiliza el constructor set() sin argumentos:

>>> set()
set()

No puede crear un conjunto vacío con un literal porque un par de llaves {} representa un diccionario vacío, no un conjunto. Para crear un conjunto vacío, debe utilizar el constructor set().

Uso de bucles for para completar conjuntos

A veces, es necesario comenzar con un conjunto vacío y completarlo dinámicamente con elementos. Para hacer esto, puedes usar un bucle for. Por ejemplo, digamos que desea crear un conjunto de palabras únicas a partir de un texto. A continuación se explica cómo hacer esto con un bucle:

>>> unique_words = set()

>>> text = """
... Beautiful is better than ugly
... Explicit is better than implicit
... Simple is better than complex
... Complex is better than complicated
... """.lower()

>>> for word in text.split():
...     unique_words.add(word)
...

>>> unique_words
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

En este ejemplo, primero crea un conjunto vacío usando set() . Aplica minúsculas al texto utilizando el método .lower() para que el caso de extracción de palabras sea insensible. Luego, ejecuta un bucle sobre una lista de palabras extraídas del texto.

Como enfoque rápido, ha utilizado el método .split() para dividir el texto en palabras individuales utilizando el carácter de espacio como separador.

El bucle intenta agregar una palabra al conjunto en cada iteración. Sin embargo, si ya hay una palabra en el conjunto, no se agregará ninguna instancia nueva. Es por eso que el conjunto resultante solo tiene una instancia de better, por ejemplo. El bucle es legible y claro, pero puedes utilizar una comprensión establecida para que tu código sea aún más conciso.

Introducción a las comprensiones de conjuntos

Las comprensiones de conjuntos le permiten crear conjuntos con un bucle for de una línea. Si está familiarizado con las listas por comprensión, comprenderá rápidamente las comprensiones de conjuntos. Ambas construcciones tienen una sintaxis similar. La principal diferencia es que las comprensiones de conjuntos utilizan llaves en lugar de corchetes.

Aquí está la sintaxis para una comprensión establecida:

{expression for member in iterable [if condition]}

Una comprensión establecida devuelve un nuevo conjunto. Para construir este conjunto, calcula los elementos de los elementos de una entrada iterable. La sintaxis incluye un condicional opcional al final, que puede usar para filtrar las colecciones existentes o generar elementos condicionalmente.

La sintaxis de comprensión de conjuntos consta de cuatro elementos clave:

  1. Los soportes de encerrado: aparatos ortopédicos rizados ( {} ) se utilizan para definir las comprensiones establecidas.
  2. La expresión de comprensión: Una expresión que proporciona un elemento en cada iteración.
  3. El miembro actual : Este es el nombre del elemento o valor actual en el iterable.
  4. El iterable: Puede ser cualquier objeto iterable de Python, incluida una lista, tupla, conjunto, generador o tipos similares.

El siguiente código muestra cómo se puede crear un conjunto de palabras únicas mediante comprensión:

>>> text = """
... Beautiful is better than ugly
... Explicit is better than implicit
... Simple is better than complex
... Complex is better than complicated
... """.lower()

>>> {word for word in text.split()}
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

En este ejemplo, utiliza un conjunto de comprensión para extraer palabras únicas del texto original. La sintaxis es concisa y clara, lo que mejora la legibilidad de su código.

En la práctica, cuando no necesita transformar los datos para generar los elementos de su conjunto, puede reemplazar el bucle desde la sección anterior y la comprensión anterior con el siguiente código:

>>> set(text.split())
{
    'beautiful',
    'ugly',
    'better',
    'implicit',
    'complicated',
    'than',
    'explicit',
    'is',
    'complex',
    'simple'
}

En este ejemplo, pasa el texto dividido directamente al constructor set() y obtiene el mismo resultado que con el bucle o la comprensión. Puede hacer esto porque los elementos establecidos no necesitan ejecutar a través de una transformación.

Las comprensiones también pueden incluir más de una cláusula para . Cuando lo hacen, la izquierda para itera sobre la colección externa, el siguiente para de izquierda a derecha itera sobre el primer nivel de anidación, y así sucesivamente.

Para ilustrar, digamos que tiene una lista de listas. Cada lista anidada contiene números y desea crear un conjunto con sus valores cuadrados. Para hacer esto, puede usar una comprensión con dos cláusulas for como se muestra a continuación:

>>> matrix = [
...     [9, 3, 8, 3],
...     [4, 5, 2, 8],
...     [6, 4, 3, 1],
...     [1, 0, 4, 5],
... ]

>>> {value**2 for row in matrix for value in row}
{64, 1, 0, 4, 36, 9, 16, 81, 25}

En este ejemplo, el primero for bucle itera sobre las filas de su matriz. El segundo para bucle itera sobre el número en cada fila. Como resultado, obtienes un conjunto de valores cuadrados.

Es importante tener en cuenta que en este ejemplo, en lugar de tener 16 elementos, terminas con solo nueve. Esto se debe a que los elementos del conjunto son únicos. Cuando se duplica un elemento, la nueva instancia no se agrega al conjunto final.

Aprovechando la comprensión del conjunto en Python

Con la comprensión de conjuntos, puede crear nuevos conjuntos, transformar los existentes e incluso filtrar elementos mediante condicionales. En las siguientes secciones, aprenderá cómo utilizar la comprensión de conjuntos para abordar estos casos de uso.

Para empezar, aprenderá cómo usar comprensiones para crear nuevos conjuntos de Iterables existentes.

Crear conjuntos a partir de iterables

A veces, tiene una iterable de datos y desea crear un conjunto utilizando los elementos de datos para generar los elementos a través de algunas transformación de datos.

Por ejemplo, digamos que tiene una lista de herramientas y bibliotecas. Debe verificar continuamente si una herramienta determinada está en la lista. Para hacer esto, usa pruebas de membresía. También debe hacer que su caso de código sea insensible, para que decida transformar todas las palabras en letras minúsculas.

Los conjuntos son más eficientes que las listas en las pruebas de membresía. Por lo tanto, también decides convertir tu lista de herramientas en un conjunto de palabras en minúscula:

>>> tools = ["Python", "Django", "Flask", "pandas", "NumPy"]

>>> tools_set = {tool.lower() for tool in tools}
>>> tools_set
{'django', 'numpy', 'flask', 'pandas', 'python'}

>>> "python".lower() in tools_set
True
>>> "Pandas".lower() in tools_set
True
>>> "Numpy".lower() in tools_set
True

En la línea resaltada, utiliza una comprensión establecida mientras normaliza todos los valores a minúsculas para garantizar comparaciones consistentes. Luego, utiliza el operador in para ejecutar pruebas de membresía y determinar si una herramienta determinada está en su lista original.

Nuevamente, si no necesita aplicar ninguna transformación de datos a los elementos de la entrada ITerable, entonces no tiene que usar una comprensión establecida. Puede usar set (iterable) en su lugar. En el ejemplo anterior, la transformación consiste en convertir los nombres de herramientas en minúsculas.

Transformando los conjuntos existentes

También puede usar Set Comprensions para transformar rápidamente los conjuntos existentes. Digamos que tiene un conjunto de direcciones de correo electrónico enviadas por el usuario. Has notado que algunas direcciones incluyen espacios líderes y finales, así como letras mayúsculas, y desea solucionar esto. Más importante, has notado que hay una dirección de correo electrónico duplicada.

Decides limpiar esto con una comprensión:

>>> emails = {
...     " alice@example.org ",
...     "BOB@example.com",
...     "charlie@EXAMPLE.com",
...     "David@example.net",
...     " bob@example.com",
...     "JohnDoe@example.com",
... }

>>> {email.strip().lower() for email in emails}
{
    'alice@example.org',
    'bob@example.com',
    'johndoe@example.com',
    'charlie@example.com',
    'david@example.net'
}

En la línea resaltada, tiene un conjunto de comprensión que elimina los espacios iniciales y finales de cada dirección usando el método .strip(). Luego, aplica minúsculas a todas las direcciones usando .lower(). Como resultado de la limpieza, la dirección duplicada se elimina porque los conjuntos solo pueden contener elementos únicos.

Filtrando elementos de conjuntos

A veces, es necesario filtrar un conjunto existente y crear uno nuevo con elementos que cumplan un requisito o condición determinada. Por ejemplo, supongamos que desea filtrar sus direcciones de correo electrónico configuradas para extraer solo los correos electrónicos .com. Para hacer esto, puede utilizar la siguiente comprensión:

>>> emails_set = {
...     "alice@example.org",
...     "bob@example.com",
...     "johndoe@example.com",
...     "charlie@example.com",
...     "david@example.net",
... }

>>> {email for email in emails_set if email.endswith(".com")}
{'bob@example.com', 'charlie@example.com', 'johndoe@example.com'}

En este ejemplo, utiliza un condicional para crear un conjunto que solo incluya las direcciones de correo electrónico en el dominio .com .

Decidir cuándo utilizar conjuntos de comprensión

Al decidir si utilizar una comprensión de conjuntos en lugar de un bucle normal o una combinación de llamadas a funciones, debe considerar los siguientes factores:

  • Concisión: las comprensiones de conjuntos reducen la cantidad de código en comparación con los bucles for equivalentes.
  • Legibilidad: establecer comprensiones puede hacer que su código sea más explícito y legible.

En la práctica, puede usar Set Comprensions cuando necesite realizar las siguientes operaciones:

  • Cree conjuntos a partir de iterables existentes aplicando transformaciones de datos.
  • Transformar los elementos de un conjunto existente
  • Filtrar los elementos de un conjunto existente

Hasta ahora, has aprendido cómo realizar todas estas operaciones utilizando conjuntos por comprensión. Aún así, puede encontrar otros buenos casos de uso para la comprensión de conjuntos durante su experiencia de codificación en Python.

Además, hay situaciones en las que el uso de comprensiones establecidas puede no ser necesaria. Por ejemplo, si necesita eliminar elementos duplicados de un iterable, simplemente puede usar la siguiente sintaxis:

>>> set([2, 2, 1, 4, 2, 3])
{1, 2, 3, 4}

Si no necesita transformar los datos de entrada para generar los elementos del conjunto, puede usar el constructor set(). Esta es una excelente manera de eliminar elementos duplicados de un iterable. Sin embargo, es importante tener en cuenta que los objetos en el iterable de entrada deben ser hash y no se conservará el orden original de los elementos.

Explorando malas prácticas comunes

Hay algunas prácticas malas que querrá evitar cuando trabaje con CompreHensions Set en su código Python. Algunos de los más comunes incluyen:

  • Usando expresiones complejas en comprensiones
  • Escribir comprensiones anidadas con varias cláusulas for o condicionales
  • Intentar acceder a variables de comprensión desde el exterior
  • Ejecutando transformaciones costosas Al construir los elementos establecidos

A veces, puede tener una comprensión establecida donde la expresión de comprensión es demasiado complicada.

Por ejemplo, digamos que ha creado un conjunto a partir de una lista de números. Si el número es par, entonces quieres su cuadrado. De lo contrario, querrás su cubo. Para hacer esto, puede utilizar la siguiente comprensión:

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> {number**2 if number % 2 == 0 else number**3 for number in numbers}
{64, 1, 4, 36, 100, 16, 343, 729, 27, 125}

En esta comprensión, se utiliza una expresión relativamente compleja para generar los elementos del conjunto. Puede resultar difícil leer esta comprensión y descifrar lo que hace. Cuando una expresión complicada hace que su código sea difícil de leer, puede beneficiarse del uso de un bucle for normal:

>>> result_set = set()

>>> for number in numbers:
...     if number % 2 == 0:
...         value = number**2
...     else:
...         value = number**3
...     result_set.add(value)
...

>>> result_set
{64, 1, 4, 36, 100, 16, 343, 729, 27, 125}

Este bucle produce el mismo resultado que la comprensión, pero puede ser más explícito, lo que hace que su código sea más legible.

Las comprensiones anidadas con varias cláusulas o condicionales para pueden hacer que su código sea menos legible. Por lo tanto, generalmente debe evitarlos y usar construcciones más legibles como un bucle regular.

No es posible usar las variables que define en una comprensión fuera de la comprensión en sí misma:

>>> {number**3 for number in range(1, 11)}
{64, 1, 512, 8, 1000, 343, 216, 729, 27, 125}

>>> number
Traceback (most recent call last):
    ...
NameError: name 'number' is not defined

La variable Number solo es visible dentro de la comprensión. Si intenta usarlo fuera de la comprensión, obtiene una excepción nameError .

A veces, cuando se trabaja con CompreHensions SET, es posible que deba ejecutar transformaciones de datos costosas para generar elementos establecidos. En estas situaciones, debe tener en cuenta que construir el conjunto final puede tomar un tiempo considerable. Una posible solución es usar un generador que produce los elementos a pedido.

Conclusión

Has aprendido sobre Python set Comprensions en detalle. Son una herramienta poderosa para crear, transformar y filtrar conjuntos utilizando sintaxis concisa y limpia. También ha aprendido sobre algunas malas prácticas que debe evitar cuando trabaje con comprensiones establecidas.

Las comprensiones establecidas son una excelente herramienta para los desarrolladores de Python. Proporcionan una forma pitónica y simplificada de manipular conjuntos en Python.

En este tutorial, usted:

  • Creado nuevos conjuntos con una sintaxis concisa.
  • Conjuntos existentes transformados con comprensiones
  • Elementos no deseados filtrados de conjuntos existentes
  • decidió cuándo usar las comprensiones establecidas en su código

Con estas habilidades, puede escribir un código más legible y pitónico para procesar conjuntos. A medida que continúe utilizando las comprensiones establecidas, las encontrará como una herramienta invaluable.

Preguntas frecuentes

Ahora que tiene algo de experiencia con la comprensión de conjuntos en Python, puede utilizar las preguntas y respuestas siguientes para comprobar su comprensión y resumir lo que ha aprendido.

Estas preguntas frecuentes están relacionadas con los conceptos más importantes que ha cubierto en este tutorial. Haga clic en el show/oculta alternar junto a cada pregunta para revelar la respuesta:

La comprensión de conjuntos es una forma concisa de crear conjuntos en Python utilizando una sintaxis similar a la comprensión de listas. La principal diferencia es que una comprensión de conjunto usa llaves {}, mientras que una lista de comprensión usa corchetes []. El resultado es un conjunto, que es una colección desordenada de elementos únicos.

Puede crear un conjunto a partir de un iterable utilizando la sintaxis de comprensión de conjuntos: {expresión para miembro en iterable}. Esto evaluará la expresión de cada miembro del iterable y agregará el resultado al conjunto, asegurando que todos los elementos sean únicos.

Debería considerar el uso de conjuntos por comprensión en lugar de bucles regulares cuando desee crear conjuntos de manera concisa y mejorar la legibilidad del código. Son especialmente útiles al transformar o filtrar datos de un iterable para generar elementos de conjunto únicos.

Las prácticas malas comunes incluyen el uso de expresiones demasiado complejas dentro de las comprensiones, la redacción de comprensiones anidadas con múltiples para cláusulas o condicionales, intentando acceder a variables de comprensión fuera de la comprensión y realizar transformaciones costosas que podrían degradar el rendimiento.

Sí, puede usar SET Comprensions para filtrar elementos agregando un condicional al final de la comprensión: {expresión para miembro en iterable if condición} . Esto incluirá solo aquellos elementos para los cuales la condición se evalúa a true .