Lista zestawów i zestawów Pythona — prawdziwa różnica

W świecie programowania w języku Python często napotkasz różne struktury danych, które służą różnym celom. Wśród tych struktur, zbiory i listy są powszechnie używane do przechowywania zbiorów danych i manipulowania nimi.

Chociaż mogą wyglądać podobnie, istnieją znaczne różnice w ich właściwościach i przypadkach użycia.

Spis treści

• Zrozumienie zestawów i list Pythona
  • Czym są zestawy Pythona?
  • Czym są listy Pythona
• 3 kluczowe różnice między zestawami a listami
  • 1. Kolejność i indeksowanie
  • 2. Zmienność
  • Wyjątkowość elementów
  • 3. Obsługiwane operacje
• Jak wybrać odpowiednią strukturę danych?
  • Przypadki użycia dla zestawów
  • Przypadki użycia dla list
• Porównanie wydajności zestawów i list
  • Złożoność czasu
  • Zużycie pamięci
• Typowe operacje i metody
  • Ustaw metodę
  • Metoda listy
• Nasze ostatnie zdanie

Zrozumienie zestawów i list Pythona

Ok, więc najpierw wyjaśnijmy sprawę.

Czym są zestawy Pythona?

Zestaw Pythona to wbudowana struktura danych reprezentująca nieuporządkowaną kolekcję odrębnych elementów, zwanych członkami .

To potężne narzędzie jest szczególnie przydatne w aplikacjach do nauki danych i operacjach matematycznych.

Zestawy Pythona mają następujące właściwości:

1. Są nieuporządkowane, co oznacza, że ​​elementy w zbiorze są przechowywane niezależnie od ich indeksu. Ten nieuporządkowany zbiór unikatowych wartości obsługuje wydajne testy członkostwa i rozumienia zestawów.

2. Nie zezwalają na powielanie wartości. Dzięki temu są przydatne, gdy trzeba pracować z unikatowymi wartościami, usuwać duplikaty z listy lub wykonywać operacje na zbiorach, takie jak sumy, przecięcia i różnice symetryczne.

Istnieją dwa sposoby tworzenia zestawu w Pythonie:

1. Używając nawiasów klamrowych ({}), znanych również jako nawiasy klamrowe.

2. Używając wbudowanej funkcji set(), która przyjmuje jeden argument, iterowalny obiekt zawierający elementy, które chcesz uwzględnić w zestawie.

Ogólna składnia tworzenia zestawu Pythona przy użyciu nawiasów klamrowych i wbudowanej funkcji set jest podana poniżej:

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

Czym są listy Pythona

Lista Pythona to wbudowana struktura danych, podobna do tablic dynamicznych w innych językach programowania.

Służą do przechowywania wielu elementów w jednej zmiennej, co czyni je wszechstronną opcją do obsługi różnych typów danych, takich jak ciągi znaków, liczby i wartości logiczne.

Listy Pythona mają następujące właściwości:

1. Są uporządkowane, co oznacza, że ​​dany element ma unikalną pozycję na liście i można uzyskać do niego dostęp poprzez jego indeks. Ta uporządkowana kolekcja obsługuje dostęp losowy, umożliwiając wykonywanie operacji, takich jak wycinanie, konkatenacja i rozumienie listy.

2. Są zmienne, a ich elementy można zmieniać po utworzeniu listy, co zapewnia elastyczność podczas pracy ze strukturami danych.

3. Listy Pythona pozwalają na powielanie wartości i mogą przechowywać różne typy danych, w tym ciągi znaków, liczby i wartości logiczne.

Listę w Pythonie można utworzyć na dwa sposoby:

1. Używając nawiasów kwadratowych, które określają granice listy.

2. Za pomocą wbudowanej funkcji list(), która może przyjmować pojedynczy argument lub element iterowalny zawierający elementy, które chcesz uwzględnić na liście.

Poniższy kod w języku Python demonstruje tworzenie listy w języku Python przy użyciu nawiasów kwadratowych i wbudowanej funkcji list():

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

3 kluczowe różnice między zestawami a listami

Jest to wiele różnic między zestawem Pythona a listą. Niektóre z ważnych wymieniono poniżej:

1. Kolejność i indeksowanie

Porządek i indeksowanie na liście w języku Python : Lista w języku Python może obsługiwać indeksowanie, co oznacza, że ​​możesz uzyskać dostęp do elementów na liście, korzystając z ich pozycji na liście. Zapewnia to elastyczność podczas manipulowania danymi ze znaną kolejnością.

Poniższy kod Pythona demonstruje kolejność i indeksowanie list:

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

Zestawy Pythona: Zestaw Pythona to nieuporządkowana kolekcja bez indeksowania, co oznacza, że ​​nie można uzyskać dostępu do elementów za pomocą ich pozycji. Jest to przydatne, gdy kolejność elementów nie ma znaczenia.

Poniższy kod w języku Python demonstruje zestawy kolejności i indeksowania:

# 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. Zmienność

Lista Pythona: Lista Pythona jest zmienna, co pozwala na modyfikowanie jej elementów. Mogą przechowywać dowolny typ obiektów, w tym listy zagnieżdżone, oferując w ten sposób większą elastyczność w zakresie zawartości, którą mogą przechowywać.

Poniższy kod demonstruje zmienność na listach Pythona:

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

Zestaw Pythona: Podobnie jak lista w Pythonie, zestaw Pythona jest zmienny i można go modyfikować. Jednak zestawy w Pythonie mogą przechowywać tylko obiekty z możliwością mieszania (niezmienne), co oznacza, że ​​nie można mieć zestawu zestawów ani zestawu zawierającego zmienne obiekty, takie jak listy.

Poniższy kod demonstruje zmienność zestawów Pythona:

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

Wyjątkowość elementów

Zestawy Pythona: Kluczową cechą zestawów jest to, że przechowują tylko unikalne elementy. Dodanie zduplikowanych wartości do listy jest ignorowane. To sprawia, że ​​obiekt zestawu jest idealny do różnych operacji na zestawie, takich jak usuwanie duplikatów lub sprawdzanie obecności unikalnych elementów.

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

• 

  Listy Pythona: Listy pozwalają na zduplikowanie wartości i zachowanie ich kolejności, co może być niezbędne w przypadkach użycia, w których duplikaty i kolejność elementów odgrywają znaczącą rolę.

  # 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. Obsługiwane operacje

Na zestawach i listach można wykonywać różne operacje, z których każda jest zoptymalizowana pod kątem określonych zadań:

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. Iteracja: Listy są nieco szybsze niż zestawy, jeśli chodzi o iterację elementów. Dzieje się tak, ponieważ zestawy wymagają dodatkowych operacji w celu zapewnienia unikalności, podczas gdy listy zachowują prostą uporządkowaną kolekcję z bezpośrednim indeksowaniem.

Zużycie pamięci

Zestawy zwykle zajmują więcej pamięci niż listy, ponieważ muszą utrzymywać tablicę skrótów, aby zapewnić unikalność elementów, co odbywa się kosztem zwiększonego zużycia pamięci.

Listy przechowują elementy tylko sekwencyjnie, co prowadzi do mniejszego zużycia pamięci, co czyni je bardziej wydajnym wyborem przy obsłudze dużych zbiorów danych.

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

Dostarczony kod przedstawia porównanie wydajności zestawów i list Pythona pod względem złożoności czasowej wyszukiwania i iteracji.

Generuje dużą listę i zestaw losowych liczb całkowitych, ujętych w nawiasy klamrowe (zwane także nawiasami klamrowymi).

Następnie mierzy czas potrzebny do wyszukania określonego elementu, używając pojedynczego argumentu zarówno na liście, jak iw zbiorze, oraz mierzy czas potrzebny do iteracji przez wszystkie elementy na liście i w zbiorze.

Wynik ilustruje różnice w wydajności między listami i zestawami Pythona do wyszukiwania i iteracji, które wynikają z ich podstawowej implementacji.

Operacja wyszukiwania jest szybsza w zestawach (0,000000 sekund) niż w listach (0,002999 sekund) ze względu na użycie funkcji skrótu do obliczania wartości skrótu w celu wydajnego wyszukiwania. Jednak iteracja po liście (0,007995 sekundy) jest nieco szybsza niż iteracja po zestawie (0,017989 sekundy), ponieważ zestawy wymagają dodatkowych operacji w celu zapewnienia unikalności.

Typowe operacje i metody

Zarówno zestawy, jak i listy w Pythonie mają różne operacje i metody, z których każda jest zoptymalizowana pod kątem określonych zadań i manipulacji danymi. Niektóre z tych metod wymieniono poniżej:

Ustaw metodę

Metody zestawów wykonują operacje podobne do operacji matematycznych i są potężnymi narzędziami do obsługi unikalnych wartości w kolekcji.

• add(element): Dodaje element do zestawu, jeśli jeszcze go nie ma.

• remove(element): Usuwa określony element ze zbioru; zgłasza błąd, jeśli element nie zostanie znaleziony.

• odrzuć (element): Usuwa określony element ze zbioru, jeśli jest obecny. Nie zostanie zgłoszony żaden błąd, jeśli element nie zostanie znaleziony.

• union(set2): Zwraca nowy zestaw zawierający wszystkie elementy z oryginalnego zestawu i zestawu2, efektywnie wykonując operację na zestawie.

• skrzyżowanie(zbiór2): Zwraca nowy zestaw zawierający elementy wspólne zarówno dla oryginalnego zestawu, jak i zestawu2.

• różnica(zbiór2): Zwraca nowy zestaw zawierający elementy z oryginalnego zestawu, ale nie z zestawu2.

• symmetric_difference(set2): Zwraca nowy zestaw zawierający elementy albo z oryginalnego zestawu, albo z zestawu 2, ale nie z obu.

Metoda listy

Metody listy zapewniają różne sposoby manipulowania danymi.

• append(element): Dodaje element na koniec listy.

• extend(iterable): Dołącza wszystkie elementy z iterowalności (np. inną listę) na koniec listy.

• insert(index, element): Wstawia element pod określonym indeksem.

• remove(element): Usuwa pierwsze wystąpienie określonego elementu na liście; zgłasza błąd, jeśli element nie jest obecny.

• pop(index): Usuwa i zwraca element o podanym indeksie. Jeśli nie podano indeksu, usuwa ostatni element.

• index(element): Zwraca indeks pierwszego wystąpienia określonego elementu na liście.

• count(element): Zwraca liczbę wystąpień określonego elementu na liście.

• sort(): domyślnie sortuje listę w porządku rosnącym; dla porządku malejącego użyj parametru reverse=True.

• reverse(): Odwraca kolejność elementów na liście.

Używając tych metod zestawów i list w języku Python, możesz skutecznie manipulować danymi i rozwiązywać różne problemy w programowaniu w języku Python, nauce o danych i innych aplikacjach.

Nasze ostatnie zdanie

Wybierając między listami i zestawami Pythona dla swojej struktury danych, rozważ użycie list, gdy potrzebujesz uporządkowanej kolekcji elementów, chcesz zachować zduplikowane elementy i potrzebujesz możliwości dostępu do elementów według indeksu.

Zdecyduj się na zestawy, gdy istotna jest unikalność elementów, kolejność elementów nie jest ważna i preferowane jest szybsze testowanie przynależności. Podczas gdy listy doskonale sprawdzają się w iteracjach, zestawy zapewniają wydajniejsze sprawdzanie zawartości.

Twój wybór ostatecznie zależy od wymagań twojego projektu, ponieważ każda struktura danych oferuje własny zestaw korzyści i ograniczeń, co czyni je potężnymi narzędziami do rozwiązywania różnych zadań w programowaniu w Pythonie. Cieszyć się!