Python Set Vs List: la verdadera diferencia

En el mundo de la programación de Python, a menudo encontrará varias estructuras de datos que sirven para diferentes propósitos. Entre estas estructuras, los conjuntos y las listas se usan comúnmente para almacenar y manipular colecciones de datos.

Si bien pueden parecer similares, existen diferencias notables en sus propiedades y casos de uso.

Tabla de contenido

• Comprensión de conjuntos y listas de Python
  • ¿Qué son los conjuntos de Python?
  • ¿Qué son las listas de Python?
• 3 diferencias clave entre conjuntos y listas
  • 1. Orden e indexación
  • 2. Mutabilidad
  • Singularidad de los Elementos
  • 3. Operaciones admitidas
• ¿Cómo elige la estructura de datos adecuada?
  • Casos de uso para conjuntos
  • Casos de uso para listas
• Comparación de rendimiento entre conjuntos y listas
  • Complejidad del tiempo
  • Uso de memoria
• Operaciones y métodos comunes
  • Establecer método
  • Método de lista
• Nuestra última palabra

Comprensión de conjuntos y listas de Python

Bien, primero expliquemos las cosas.

¿Qué son los conjuntos de Python?

Un conjunto de Python es una estructura de datos incorporada que representa una colección desordenada de elementos distintos, llamados miembros.

Esta poderosa herramienta es particularmente útil en aplicaciones de ciencia de datos y operaciones matemáticas.

Los conjuntos de Python tienen las siguientes propiedades:

1. Están desordenados, lo que significa que los elementos de un conjunto se almacenan independientemente de su índice. Esta colección desordenada de valores únicos admite pruebas de membresía eficientes y comprensiones de conjuntos.

2. No permiten valores duplicados. Esto los hace útiles cuando necesita trabajar con valores únicos, eliminar duplicados de una lista o realizar operaciones de conjuntos como uniones, intersecciones y diferencias simétricas.

Hay dos formas de crear un conjunto en Python:

1. Mediante el uso de llaves ({}), también conocidas como corchetes.

2. Mediante el uso de la función integrada set(), que toma un solo argumento, un iterable que contiene los elementos que desea incluir en el conjunto.

A continuación se proporciona una sintaxis genérica para crear un conjunto de Python usando llaves y la función de conjunto integrada:

my_set = {1, 2, 3}
another_set = set([4, 5, 6])

¿Qué son las listas de Python?

Una lista de Python es una estructura de datos integrada similar a las matrices dinámicas en otros lenguajes de programación.

Se utilizan para almacenar varios elementos en una sola variable, lo que los convierte en una opción versátil para manejar varios tipos de datos, como cadenas, números y valores booleanos.

Las listas de Python tienen las siguientes propiedades:

1. Están ordenados, lo que significa que un elemento en particular tiene una posición única en una lista y se puede acceder a través de su índice. Esta colección ordenada admite el acceso aleatorio, lo que le permite realizar operaciones como división, concatenación y comprensión de listas.

2. Son mutables y sus elementos se pueden cambiar después de crear una lista, lo que ofrece flexibilidad al trabajar con estructuras de datos.

3. Las listas de Python permiten valores duplicados y pueden almacenar una combinación de tipos de datos, incluidas cadenas, números y valores booleanos.

Hay dos formas de crear una lista en Python:

1. Usando corchetes, que denotan los límites de la lista.

2. Mediante el uso de la función list() incorporada, que puede tomar un solo argumento o un iterable que contenga los elementos que desea incluir en la lista.

El siguiente código de Python demuestra la creación de una lista de Python usando corchetes y la función list() integrada:

list1 = [1, 2, 3] 
list2 = list([4, 5, 6])

3 diferencias clave entre conjuntos y listas

Son múltiples diferencias entre un conjunto de Python y una lista. Algunos de los más importantes se enumeran a continuación:

1. Orden e indexación

Orden e indexación en la lista de Python : una lista de Python puede admitir la indexación, lo que significa que puede acceder a los elementos de una lista usando su posición en la lista. Esto proporciona flexibilidad al manipular datos con un orden conocido.

El siguiente código de Python demuestra el orden y la indexación de las listas:

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Accessing elements using their index
first_element = my_list[0]  # This will be 3
third_element = my_list[2]  # This will be 2

# Modifying elements using their index
my_list[1] = 7  # The list becomes [3, 7, 2, 8, 1]

# Iterating over a list maintaining the order
for item in my_list:
    print(item)

Conjuntos de Python: un conjunto de Python es una colección desordenada sin indexación, lo que significa que no puede acceder a los elementos usando su posición. Esto es útil cuando el orden de los elementos no importa.

El siguiente código de Python demuestra conjuntos de orden e indexación:

# Creating a Python set
my_set = {3, 5, 2, 8, 1}

# Sets are unordered, so you cannot access elements using their position
# This would raise an error: first_element = my_set[0]

# Modifying a set by adding or removing elements
my_set.add(6)       # The set becomes {1, 2, 3, 5, 6, 8}
my_set.discard(5)   # The set becomes {1, 2, 3, 6, 8}

# Iterating over a set (order is not guaranteed)
for item in my_set:
    print(item)

2. Mutabilidad

Lista de Python: una lista de Python es mutable, lo que le permite modificar sus elementos. Pueden contener cualquier tipo de objeto, incluidas las listas anidadas, lo que ofrece más flexibilidad en cuanto al contenido que pueden almacenar.

El siguiente código demuestra la mutabilidad en las listas de Python:

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Modifying the list by appending elements
my_list.append(4)  # The list becomes [3, 5, 2, 8, 1, 4]

# Modifying the list by removing elements
my_list.remove(2)  # The list becomes [3, 5, 8, 1, 4]

# Lists can hold any type of object, including nested lists
nested_list = [1, 2, [3, 4], 5]

Conjunto de Python: al igual que una lista en Python, un conjunto de Python también es mutable y se puede modificar. Sin embargo, los conjuntos en Python solo pueden contener objetos modificables (inmutables), lo que significa que no puede tener un conjunto de conjuntos o un conjunto que contenga objetos mutables como listas.

El siguiente código demuestra la mutabilidad de los conjuntos de Python:

# Creating a Python set
my_set = {3, 5, 2, 8, 1}

# Modifying the set by adding elements
my_set.add(6)       # The set becomes {1, 2, 3, 5, 6, 8}

# Modifying the set by removing elements
my_set.discard(5)   # The set becomes {1, 2, 3, 6, 8}

# Sets can only hold hashable (immutable) objects
valid_set = {1, 2, 3, 4, (5, 6)}

# The following would raise an error because lists are mutable and cannot be stored in sets
# invalid_set = {1, 2, [3, 4]}

Singularidad de los Elementos

Conjuntos de Python: una característica clave de los conjuntos es que solo almacenan elementos únicos. Se ignora la adición de valores duplicados a una lista. Esto hace que un objeto de conjunto sea ideal para diferentes operaciones de conjunto, como eliminar duplicados o verificar la presencia de elementos únicos.

# Creating a Python set with duplicate elements
my_set = {3, 5, 2, 8, 1, 3, 2, 5}
# The duplicate elements are automatically removed: {1, 2, 3, 5, 8}

# Checking for the presence of a unique element
if 5 in my_set:
    print("5 is in the set")
# Output: 5 is in the set

# Removing duplicates from a list using a set
my_list = [3, 5, 2, 8, 1, 3, 2, 5]
unique_list = list(set(my_list))
# The unique_list becomes [1, 2, 3, 5, 8]

• 

  Listas de Python: las listas permiten valores duplicados y mantienen su orden, lo que puede ser esencial en casos de uso donde los duplicados y el orden de los elementos juegan un papel importante.

  # Creating a Python list with duplicate elements
  my_list = [3, 5, 2, 8, 1, 3, 2, 5]
  # The list contains duplicate values: [3, 5, 2, 8, 1, 3, 2, 5]
  
  # Checking for the presence of an element in a list
  if 5 in my_list:
      print("5 is in the list")
  # Output: 5 is in the list
  
  # Counting the occurrences of a value in a list
  count_of_5 = my_list.count(5)
  print("5 appears", count_of_5, "times")
  # Output: 5 appears 2 times

  

3. Operaciones admitidas

Hay diferentes operaciones que se pueden realizar en conjuntos y listas, cada una optimizada para tareas específicas:

Python Lists: Due to their ordered and index-based nature, lists support operations like slicing, concatenation, repetition, and list comprehension. They also provide built-in methods, such as append(), pop(), and sort(), that allow you to manipulate elements of a list.

# Creating a Python list
my_list = [3, 5, 2, 8, 1]

# Slicing a list
sub_list = my_list[1:4]  # The sub_list becomes [5, 2, 8]

# Concatenation of two lists
list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated_list = list1 + list2  # The concatenated_list becomes [1, 2, 3, 4, 5, 6]

# Repetition of a list
repeated_list = list1 * 2  # The repeated_list becomes [1, 2, 3, 1, 2, 3]

# List comprehension
squared_list = [x ** 2 for x in my_list]  # The squared_list becomes [9, 25, 4, 64, 1]

# Using built-in methods
my_list.append(4)  # The list becomes [3, 5, 2, 8, 1, 4]
my_list.pop()      # The list becomes [3, 5, 2, 8, 1]
my_list.sort()     # The list becomes [1, 2, 3, 5, 8]

Python Sets: Sets are optimized for performing set-related operations like union, intersection, difference, and checking membership using hash functions to find elements quickly. Since they are unordered and lack indexing, set operations differ from list-based ones.

# Creating Python sets
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# Union operation
union_set = set1.union(set2)  # The union_set becomes {1, 2, 3, 4, 5, 6, 7, 8}

# Intersection operation
intersection_set = set1.intersection(set2)  # The intersection_set becomes {4, 5}

# Difference operation
difference_set = set1.difference(set2)  # The difference_set becomes {1, 2, 3}

# Checking membership
if 3 in set1:
    print("3 is a member of set1")
# Output: 3 is a member of set1

How Do You Choose The Right Data Structure?

When working with Python, it’s essential to select the most suitable data structure for your specific task. In this section, we will discuss the best scenarios for using sets and lists, along with their unique advantages.

Let’s get into it.

Use Cases for Sets

Sets offer several advantages that make them the ideal choice for certain tasks:

Uniqueness: If you need to store a collection of unique elements, sets are the way to go. Sets automatically eliminate duplicates, ensuring that each element in the set is distinct.

Membership tests: Sets provide faster membership tests compared to lists. Due to their underlying hash table implementation and the use of hash functions, sets allow for highly efficient lookups based on hash values.

Set operations: Sets support operations such as union, intersection, difference, and symmetric difference that can be useful in many algorithms, data processing tasks, and data science applications.

Use Cases for Lists

Lists are better suited for the following scenarios:

Ordered data: Lists maintain the order of elements, making them suitable for tasks that require respecting the sequence of items, such as processing data in the order it was created or when support indexing is needed.

Mutable data: Lists are mutable, allowing you to add, remove, or modify a specific element as needed. This flexibility makes lists suitable for tasks that involve changing the content of the collection or when working with nested data structures, such as lists of lists or dictionaries.

Non-unique elements: Unlike sets, lists can store duplicate elements, making them appropriate for situations where the frequency of items matters, such as counting occurrences or maintaining the order of duplicate values.

Check out the below to show to further your learning.

APerformance Comparison Between Sets and Lists

In this section, we will compare the performance of Python sets and lists in terms of time complexity and memory usage, which is essential when working with large data structures or when optimizing code for efficiency.

Time Complexity

When it comes to time complexity, sets and lists have different strengths and weaknesses depending on the operations you perform due to their underlying implementation.

1. Searching: Sets use hash lookups and hash functions, which makes searching for an item significantly faster compared to lists. For example, searching through 100,000 items takes 49.663 seconds with a list, but only 0.007 seconds with a set, as it takes advantage of the hash value for quick access.

2. Iteración: las listas son un poco más rápidas que los conjuntos cuando se trata de iterar sobre los elementos. Esto se debe a que los conjuntos requieren operaciones adicionales para garantizar la unicidad, mientras que las listas mantienen una colección ordenada simple con indexación directa.

Uso de memoria

Los conjuntos generalmente consumen más memoria que las listas porque necesitan mantener una tabla hash para garantizar la unicidad de los elementos, lo que tiene el costo de un mayor consumo de memoria.

Las listas solo almacenan los elementos secuencialmente, lo que lleva a un menor consumo de memoria, lo que las convierte en una opción más eficiente en cuanto a la memoria cuando se manejan grandes colecciones de datos.

import time
import random

# Generating a large list and set with 100,000 random integers
large_list = [random.randint(1, 1_000_000) for _ in range(100_000)]
large_set = set(large_list)

# Searching for an item in the list and set
search_value = random.randint(1, 1_000_000)

# Measuring the time it takes to search for the item in the list
start_time = time.time()
result = search_value in large_list
end_time = time.time()
list_search_time = end_time - start_time
print(f"List search time: {list_search_time:.6f} seconds")

# Measuring the time it takes to search for the item in the set
start_time = time.time()
result = search_value in large_set
end_time = time.time()
set_search_time = end_time - start_time
print(f"Set search time: {set_search_time:.6f} seconds")

# Iterating over the list and set
# Measuring the time it takes to iterate over the list
start_time = time.time()
for item in large_list:
    pass
end_time = time.time()
list_iter_time = end_time - start_time
print(f"List iteration time: {list_iter_time:.6f} seconds")

# Measuring the time it takes to iterate over the set
start_time = time.time()
for item in large_set:
    pass
end_time = time.time()
set_iter_time = end_time - start_time
print(f"Set iteration time: {set_iter_time:.6f} seconds")

El código proporcionado muestra la comparación de rendimiento entre conjuntos y listas de Python en términos de complejidad de tiempo para la búsqueda y la iteración.

Genera una gran lista y un conjunto de números enteros aleatorios, encerrados entre corchetes (también llamados llaves).

Luego mide el tiempo que se tarda en buscar un elemento específico, utilizando un solo argumento tanto en la lista como en el conjunto, y mide el tiempo que se tarda en recorrer todos los elementos de la lista y el conjunto.

El resultado ilustra las diferencias de rendimiento entre las listas y los conjuntos de Python para la búsqueda y la iteración, que se derivan de su implementación subyacente.

La operación de búsqueda es más rápida en conjuntos (0,000000 segundos) que en listas (0,002999 segundos) debido al uso de funciones hash para calcular valores hash para búsquedas eficientes. Sin embargo, iterar sobre una lista (0,007995 segundos) es un poco más rápido que iterar sobre un conjunto (0,017989 segundos), ya que los conjuntos requieren operaciones adicionales para garantizar la unicidad.

Operaciones y métodos comunes

Tanto los conjuntos como las listas en Python tienen varias operaciones y métodos, cada uno optimizado para tareas específicas y manipulación de datos. Algunos de estos métodos se enumeran a continuación:

Establecer método

Los métodos de conjunto realizan operaciones que son similares a las operaciones matemáticas y son herramientas poderosas para manejar valores únicos en una colección.

• add(elemento): agrega un elemento al conjunto si aún no está presente.

• remove(elemento): Elimina el elemento especificado del conjunto; genera un error si no se encuentra el elemento.

• descartar (elemento): elimina el elemento especificado del conjunto si está presente. No se genera ningún error si no se encuentra el elemento.

• union(set2): Devuelve un nuevo conjunto que contiene todos los elementos del conjunto original y del conjunto2, realizando efectivamente una operación de conjunto.

• intersección(conjunto2): Devuelve un nuevo conjunto que contiene elementos comunes tanto al conjunto original como al conjunto2.

• diferencia(conjunto2): Devuelve un nuevo conjunto que contiene elementos del conjunto original pero no del conjunto2.

• diferencia_simétrica(conjunto2): Devuelve un nuevo conjunto que contiene elementos en el conjunto original o en el conjunto2, pero no en ambos.

Método de lista

Los métodos de lista proporcionan varias formas de manipular datos.

• append(element): Agrega un elemento al final de la lista.

• extender (iterable): agrega todos los elementos del iterable (por ejemplo, otra lista) al final de la lista.

• insert(índice, elemento): Inserta un elemento en el índice especificado.

• remove(elemento): Elimina la primera aparición del elemento especificado en la lista; genera un error si el elemento no está presente.

• pop(índice): elimina y devuelve el elemento en el índice especificado. Si no se proporciona un índice, elimina el último elemento.

• índice(elemento): Devuelve el índice de la primera aparición del elemento especificado en la lista.

• count(elemento): Devuelve el número de ocurrencias del elemento especificado en la lista.

• sort(): Ordena la lista en orden ascendente por defecto; para el orden descendente, use el parámetro reverse=True.

• reverse(): Invierte el orden de los elementos en la lista.

Al usar estos métodos de configuración y lista de Python, puede manipular de manera efectiva sus datos y resolver varios problemas en la programación de Python, la ciencia de datos y otras aplicaciones.

Nuestra última palabra

Al elegir entre listas y conjuntos de Python para su estructura de datos, considere usar listas cuando necesite una colección ordenada de elementos, desee conservar elementos duplicados y requiera la capacidad de acceder a elementos por índice.

Opte por conjuntos cuando la singularidad de los elementos sea esencial, el orden de los elementos no sea importante y se prefieran pruebas de pertenencia más rápidas. Si bien las listas sobresalen en la iteración, los conjuntos brindan controles de contención más eficientes.

Su elección depende en última instancia de los requisitos de su proyecto, ya que cada estructura de datos ofrece su propio conjunto de beneficios y limitaciones, lo que las convierte en herramientas poderosas para abordar diversas tareas en la programación de Python. ¡Disfrutar!