Python Set vs List — реальная разница

В мире программирования на Python вы часто будете сталкиваться с различными структурами данных, которые служат разным целям. Среди этих структур наборы и списки обычно используются для хранения коллекций данных и управления ими.

Хотя они могут показаться похожими, в их свойствах и вариантах использования есть заметные различия.

Оглавление

• Понимание наборов и списков Python
  • Что такое наборы Python?
  • Что такое списки Python
• 3 ключевых различия между множествами и списками
  • 1. Порядок и индексация
  • 2. Изменчивость
  • Уникальность элементов
  • 3. Поддерживаемые операции
• Как выбрать правильную структуру данных?
  • Примеры использования наборов
  • Примеры использования списков
• Сравнение производительности наборов и списков
  • Сложность времени
  • Использование памяти
• Общие операции и методы
  • Установить метод
  • Метод списка
• Наше последнее слово

Понимание наборов и списков Python

Итак, давайте сначала все объясним.

Что такое наборы Python?

Набор Python — это встроенная структура данных, которая представляет собой неупорядоченный набор отдельных элементов, называемых членами.

Этот мощный инструмент особенно полезен в приложениях по обработке и анализу данных и математических операциях.

Наборы Python обладают следующими свойствами:

1. Они неупорядочены, что означает, что элементы в наборе хранятся независимо от их индекса. Этот неупорядоченный набор уникальных значений поддерживает эффективные тесты на членство и понимание множеств.

2. Они не допускают дублирования значений. Это делает их полезными, когда вам нужно работать с уникальными значениями, удалять дубликаты из списка или выполнять операции над множествами, такие как объединения, пересечения и симметричные различия.

Есть два способа создать набор в Python:

1. С помощью фигурных скобок ({}), также известных как фигурные скобки.

2. Используя встроенную функцию set(), которая принимает один аргумент, итерацию, содержащую элементы, которые вы хотите включить в набор.

Общий синтаксис для создания набора Python с использованием фигурных скобок и встроенной функции set приведен ниже:

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

Что такое списки Python

Список Python — это встроенная структура данных, похожая на динамические массивы в других языках программирования.

Они используются для хранения нескольких элементов в одной переменной, что делает их универсальным вариантом для обработки различных типов данных, таких как строки, числа и логические значения.

Списки Python имеют следующие свойства:

1. Они упорядочены, что означает, что конкретный элемент имеет уникальную позицию в списке и доступен через его индекс. Эта упорядоченная коллекция поддерживает произвольный доступ, позволяя выполнять такие операции, как нарезка, объединение и анализ списка.

2. Они изменяемы, и их элементы можно изменить после создания списка, что обеспечивает гибкость при работе со структурами данных.

3. Списки Python допускают дублирование значений и могут хранить различные типы данных, включая строки, числа и логические значения.

Есть два способа создать список в Python:

1. С помощью квадратных скобок, обозначающих границы списка.

2. С помощью встроенной функции list(), которая может принимать один аргумент или итерацию, содержащую элементы, которые вы хотите включить в список.

Следующий код Python демонстрирует создание списка Python с использованием квадратных скобок и встроенной функции list():

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

3 ключевых различия между множествами и списками

Это многочисленные различия между набором Python и списком. Некоторые из важных перечислены ниже:

1. Порядок и индексация

Порядок и индексация в списке Python : список Python может поддерживать индексацию, что означает, что вы можете получить доступ к элементам в списке, используя их положение в списке. Это обеспечивает гибкость при манипулировании данными с известным порядком.

Следующий код Python демонстрирует порядок и индексацию списков:

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

Наборы Python: набор Python — это неупорядоченная коллекция без индексации, что означает, что вы не можете получить доступ к элементам, используя их положение. Это полезно, когда порядок элементов не имеет значения.

Следующий код Python демонстрирует наборы порядка и индексации:

# 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. Изменчивость

Список Python. Список Python можно изменять, что позволяет изменять его элементы. Они могут содержать объекты любого типа, в том числе вложенные списки, что обеспечивает большую гибкость с точки зрения содержимого, которое они могут хранить.

Следующий код демонстрирует изменчивость списков 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]

Набор Python: как и список в Python, набор Python также является изменяемым и может быть изменен. Однако наборы в Python могут содержать только хэшируемые (неизменяемые) объекты, а это означает, что у вас не может быть набора наборов или набора, содержащего изменяемые объекты, такие как списки.

Следующий код демонстрирует изменчивость наборов 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]}

Уникальность элементов

Наборы Python: ключевой особенностью наборов является то, что они хранят только уникальные элементы. Добавление повторяющихся значений в список игнорируется. Это делает объект множества идеальным для различных операций над множествами, таких как удаление дубликатов или проверка наличия уникальных элементов.

# 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]

• 

  Списки Python: списки допускают дублирование значений и сохраняют их порядок, что может быть важно в случаях использования, когда дубликаты и порядок элементов играют важную роль.

  # 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. Поддерживаемые операции

Существуют различные операции, которые можно выполнять над множествами и списками, каждая из которых оптимизирована для определенных задач:

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. Итерация: списки немного быстрее, чем наборы, когда дело доходит до итерации по элементам. Это связано с тем, что наборы требуют дополнительных операций для обеспечения уникальности, а списки поддерживают простую упорядоченную коллекцию с прямым индексированием.

Использование памяти

Наборы обычно потребляют больше памяти, чем списки, поскольку им необходимо поддерживать хеш-таблицу для обеспечения уникальности элементов, что достигается за счет увеличения потребления памяти.

Списки хранят элементы только последовательно, что приводит к меньшему потреблению памяти, что делает их более эффективным выбором при обработке больших коллекций данных.

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

Предоставленный код демонстрирует сравнение производительности наборов и списков Python с точки зрения временной сложности поиска и итерации.

Он генерирует большой список и набор случайных целых чисел, заключенных в фигурные скобки (также называемые фигурными скобками).

Затем он измеряет время, затраченное на поиск определенного элемента, используя один аргумент как в списке, так и в наборе, и измеряет время, затраченное на перебор всех элементов в списке и наборе.

Выходные данные иллюстрируют различия в производительности между списками и наборами Python для поиска и итерации, которые связаны с их базовой реализацией.

Операция поиска выполняется быстрее в наборах (0,000000 секунд), чем в списках (0,002999 секунд) из-за использования хеш-функций для вычисления хеш-значений для эффективного поиска. Однако итерация по списку (0,007995 секунд) немного быстрее, чем по набору (0,017989 секунд), поскольку наборы требуют дополнительных операций для обеспечения уникальности.

Общие операции и методы

И наборы, и списки в Python имеют различные операции и методы, каждый из которых оптимизирован для конкретных задач и манипулирования данными. Некоторые из этих методов перечислены ниже:

Установить метод

Методы set выполняют операции, аналогичные математическим операциям, и являются мощными инструментами для обработки уникальных значений в коллекции.

• add(element): Добавляет элемент в набор, если он еще не присутствует.

• remove(element): удаляет указанный элемент из набора; выдает ошибку, если элемент не найден.

• discard(element): удаляет указанный элемент из набора, если он присутствует. Если элемент не найден, ошибка не возникает.

• union(set2): возвращает новый набор, содержащий все элементы из исходного набора и set2, эффективно выполняя операцию набора.

• пересечение (набор2): возвращает новый набор, содержащий элементы, общие как для исходного набора, так и для набора2.

• разница(набор2): возвращает новый набор, содержащий элементы исходного набора, но не набор2.

• symmetric_difference(set2): возвращает новый набор, содержащий элементы либо исходного набора, либо набора2, но не обоих.

Метод списка

Методы списка предоставляют различные способы манипулирования данными.

• append(element): Добавляет элемент в конец списка.

• extend(iterable): Добавляет все элементы из итерируемого объекта (например, другого списка) в конец списка.

• вставка (индекс, элемент): вставляет элемент по указанному индексу.

• remove(element): удаляет первое вхождение указанного элемента в списке; выдает ошибку, если элемент отсутствует.

• pop(index): удаляет и возвращает элемент по указанному индексу. Если индекс не указан, удаляется последний элемент.

• index(element): возвращает индекс первого вхождения указанного элемента в списке.

• count(element): возвращает количество вхождений указанного элемента в списке.

• sort(): по умолчанию сортирует список в порядке возрастания; для убывания используйте параметр reverse=True.

• reverse(): меняет порядок элементов в списке на обратный.

Используя эти методы набора и списка Python, вы можете эффективно манипулировать своими данными и решать различные проблемы в программировании Python, науке о данных и других приложениях.

Наше последнее слово

Выбирая между списками и наборами Python для своей структуры данных, рассмотрите возможность использования списков, когда вам нужна упорядоченная коллекция элементов, вы хотите сохранить повторяющиеся элементы и требуется возможность доступа к элементам по индексу.

Выбирайте наборы, когда важна уникальность элементов, порядок элементов не важен и предпочтительно более быстрое тестирование членства. В то время как списки преуспевают в итерации, наборы обеспечивают более эффективные проверки содержания.

Ваш выбор в конечном счете зависит от требований вашего проекта, поскольку каждая структура данных предлагает свой собственный набор преимуществ и ограничений, что делает их мощными инструментами для решения различных задач в программировании на Python. Наслаждаться!