Python Set Vs List – A verdadeira diferença

No mundo da programação Python, você frequentemente encontrará várias estruturas de dados que atendem a propósitos diferentes. Entre essas estruturas, conjuntos e listas são comumente usados ​​para armazenar e manipular coleções de dados.

Embora possam parecer semelhantes, existem diferenças notáveis ​​em suas propriedades e casos de uso.

Índice

• Compreendendo conjuntos e listas do Python
  • O que são conjuntos Python?
  • O que são listas Python
• 3 principais diferenças entre conjuntos e listas
  • 1. Ordem e indexação
  • 2. Mutabilidade
  • Unicidade dos Elementos
  • 3. Operações Suportadas
• Como você escolhe a estrutura de dados correta?
  • Casos de uso para conjuntos
  • Casos de uso para listas
• AComparação de desempenho entre conjuntos e listas
  • Complexidade de tempo
  • Uso de memória
• Operações e métodos comuns
  • Definir método
  • Método de lista
• Nossa última palavra

Compreendendo conjuntos e listas do Python

Ok, então vamos explicar as coisas primeiro.

O que são conjuntos Python?

Um conjunto Python é uma estrutura de dados integrada que representa uma coleção não ordenada de elementos distintos, chamados membros.

Esta poderosa ferramenta é particularmente útil em aplicações de ciência de dados e operações matemáticas.

Os conjuntos Python têm as seguintes propriedades:

1. Eles são desordenados, o que significa que os elementos de um conjunto são armazenados independentemente de seu índice. Essa coleção não ordenada de valores exclusivos oferece suporte a testes de associação eficientes e compreensões de conjuntos.

2. Eles não permitem valores duplicados. Isso os torna úteis quando você precisa trabalhar com valores exclusivos, remover duplicatas de uma lista ou realizar operações de conjunto como uniões, interseções e diferenças simétricas.

Existem duas maneiras de criar um conjunto em Python:

1. Usando chaves ({}), também conhecidas como chaves.

2. Usando a função interna set(), que recebe um único argumento, um iterável contendo os elementos que você deseja incluir no conjunto.

Uma sintaxe genérica para criar um conjunto Python usando chaves e a função de conjunto integrada é fornecida abaixo:

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

O que são listas Python

Uma lista Python é uma estrutura de dados integrada semelhante a arrays dinâmicos em outras linguagens de programação.

Eles são usados ​​para armazenar vários itens em uma única variável, tornando-os uma opção versátil para lidar com vários tipos de dados, como strings, números e booleanos.

As listas do Python têm as seguintes propriedades:

1. Eles são ordenados, o que significa que um determinado elemento possui uma posição única em uma lista e pode ser acessado por meio de seu índice. Essa coleção ordenada suporta acesso aleatório, permitindo que você execute operações como divisão, concatenação e compreensão de lista.

2. Eles são mutáveis ​​e seus elementos podem ser alterados após a criação de uma lista, oferecendo flexibilidade ao trabalhar com estruturas de dados.

3. As listas Python permitem valores duplicados e podem armazenar uma mistura de tipos de dados, incluindo strings, números e booleanos.

Existem duas maneiras de criar uma lista em Python:

1. Usando colchetes, que denotam os limites da lista.

2. Usando a função interna list(), que pode receber um único argumento ou um iterável contendo os elementos que você deseja incluir na lista.

O código Python a seguir demonstra a criação de uma lista Python usando colchetes e a função interna list():

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

3 principais diferenças entre conjuntos e listas

São várias diferenças entre um conjunto Python e uma lista. Alguns dos mais importantes estão listados abaixo:

1. Ordem e indexação

Ordem e indexação na lista Python : Uma lista Python pode suportar indexação, o que significa que você pode acessar elementos em uma lista usando sua posição na lista. Isso fornece flexibilidade ao manipular dados com uma ordem conhecida.

O código Python a seguir demonstra a ordem e a indexação das 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 Python: Um conjunto Python é uma coleção desordenada sem indexação, o que significa que você não pode acessar elementos usando sua posição. Isso é útil quando a ordem dos elementos não importa.

O código Python a seguir demonstra os conjuntos de ordem e indexação:

# 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. Mutabilidade

Lista Python: Uma lista Python é mutável, permitindo que você modifique seus elementos. Eles podem conter qualquer tipo de objeto, incluindo listas aninhadas, oferecendo assim mais flexibilidade em termos de conteúdo que podem armazenar.

O código a seguir demonstra a mutabilidade nas listas do 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 Python: assim como uma lista em Python, um conjunto Python também é mutável e pode ser modificado. No entanto, conjuntos em Python só podem conter objetos hashable (imutáveis), o que significa que você não pode ter um conjunto de conjuntos ou um conjunto contendo objetos mutáveis ​​como listas.

O código a seguir demonstra a mutabilidade dos conjuntos 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]}

Unicidade dos Elementos

Python Sets: Um recurso chave dos conjuntos é que eles armazenam apenas elementos únicos. A adição de valores duplicados a uma lista é ignorada. Isso torna um objeto de conjunto ideal para diferentes operações de conjunto, como remover duplicatas ou verificar a presença 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 do Python: as listas permitem valores duplicados e mantêm sua ordem, o que pode ser essencial em casos de uso em que as duplicatas e a ordem dos elementos desempenham um papel significativo.

  # 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. Operações Suportadas

Existem diferentes operações que podem ser executadas em conjuntos e listas, cada uma otimizada para tarefas 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. Iteração: as listas são um pouco mais rápidas do que os conjuntos quando se trata de iterar os itens. Isso ocorre porque os conjuntos requerem operações adicionais para garantir a exclusividade, enquanto as listas mantêm uma coleção ordenada simples com indexação direta.

Uso de memória

Os conjuntos geralmente consomem mais memória do que as listas porque precisam manter uma tabela de hash para garantir a exclusividade dos itens, o que acarreta um aumento no consumo de memória.

As listas armazenam apenas os elementos sequencialmente, levando a um menor consumo de memória, tornando-as uma escolha mais eficiente de memória ao lidar com grandes coleções de dados.

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")

O código fornecido mostra a comparação de desempenho entre conjuntos e listas do Python em termos de complexidade de tempo para pesquisa e iteração.

Ele gera uma grande lista e um conjunto de números inteiros aleatórios, delimitados por chaves (também chamadas de chaves).

Em seguida, ele mede o tempo necessário para procurar um item específico, usando um único argumento na lista e no conjunto, e mede o tempo necessário para percorrer todos os elementos da lista e do conjunto.

A saída ilustra as diferenças de desempenho entre listas e conjuntos Python para pesquisa e iteração, que decorrem de sua implementação subjacente.

A operação de pesquisa é mais rápida em conjuntos (0,000000 segundos) do que em listas (0,002999 segundos) devido ao uso de funções de hash para calcular valores de hash para pesquisas eficientes. No entanto, iterar em uma lista (0,007995 segundos) é um pouco mais rápido do que iterar em um conjunto (0,017989 segundos), pois os conjuntos requerem operações adicionais para garantir a exclusividade.

Operações e métodos comuns

Ambos os conjuntos e listas em Python têm várias operações e métodos, cada um otimizado para tarefas específicas e manipulação de dados. Alguns desses métodos estão listados abaixo:

Definir método

Os métodos set executam operações semelhantes às operações matemáticas e são ferramentas poderosas para lidar com valores exclusivos em uma coleção.

• add(elemento): Adiciona um elemento ao conjunto se ainda não estiver presente.

• remove(elemento): Remove o elemento especificado do conjunto; gera um erro se o elemento não for encontrado.

• discard(element): Remove o elemento especificado do conjunto se estiver presente. Nenhum erro é levantado se o elemento não for encontrado.

• union(set2): Retorna um novo conjunto contendo todos os elementos do conjunto original e do conjunto2, realizando efetivamente uma operação de conjunto.

• cruzamento(conjunto2): Retorna um novo conjunto contendo elementos comuns ao conjunto original e ao conjunto2.

• diferença(conjunto2): Retorna um novo conjunto contendo elementos no conjunto original, mas não no conjunto2.

• symmetric_difference(set2): Retorna um novo conjunto contendo elementos no conjunto original ou no conjunto2, mas não em ambos.

Método de lista

Os métodos de lista fornecem várias maneiras de manipular dados.

• append(element): Adiciona um elemento ao final da lista.

• extend(iterable): Acrescenta todos os elementos do iterável (por exemplo, outra lista) ao final da lista.

• insert(index, element): Insere um elemento no índice especificado.

• remove(elemento): Remove a primeira ocorrência do elemento especificado na lista; gera um erro se o elemento não estiver presente.

• pop(index): Remove e retorna o elemento no índice especificado. Se nenhum índice for fornecido, ele remove o último elemento.

• index(elemento): Retorna o índice da primeira ocorrência do elemento especificado na lista.

• count(element): Retorna o número de ocorrências do elemento especificado na lista.

• sort(): Classifica a lista em ordem crescente por padrão; para ordem decrescente, use o parâmetro reverse=True.

• reverse(): Inverte a ordem dos elementos na lista.

Usando esses métodos set e list do Python, você pode efetivamente manipular seus dados e resolver vários problemas em programação Python, ciência de dados e outros aplicativos.

Nossa última palavra

Ao escolher entre listas e conjuntos Python para sua estrutura de dados, considere usar listas quando precisar de uma coleção ordenada de itens, quiser preservar elementos duplicados e exigir a capacidade de acessar elementos por índice.

Opte por conjuntos quando a exclusividade dos elementos for essencial, a ordem dos elementos não for importante e o teste de pertinência mais rápido for o preferido. Enquanto as listas se destacam na iteração, os conjuntos fornecem verificações de contenção mais eficientes.

Em última análise, sua escolha depende dos requisitos do seu projeto, pois cada estrutura de dados oferece seu próprio conjunto de benefícios e limitações, tornando-os ferramentas poderosas para lidar com várias tarefas na programação Python. Aproveitar!