Python Set Vs List - Diferența reală

În lumea programării Python, veți întâlni adesea diverse structuri de date care servesc scopuri diferite. Printre aceste structuri, seturile și listele sunt utilizate în mod obișnuit pentru stocarea și manipularea colecțiilor de date.

Deși pot părea similare, există diferențe notabile în ceea ce privește proprietățile și cazurile de utilizare.

Cuprins

• Înțelegerea seturilor și listelor Python
  • Ce sunt seturile Python?
  • Ce sunt listele Python
• 3 diferențe cheie între seturi și liste
  • 1. Comandă și indexare
  • 2. Mutabilitatea
  • Unicitatea elementelor
  • 3. Operațiuni suportate
• Cum alegi structura corectă de date?
  • Cazuri de utilizare pentru seturi
  • Cazuri de utilizare pentru liste
• AComparație de performanță între seturi și liste
  • Complexitatea timpului
  • Folosirea memoriei
• Operații și metode comune
  • Setare Metodă
  • Metoda listei
• Cuvântul nostru final

Înțelegerea seturilor și listelor Python

Ok, să explicăm lucrurile mai întâi.

Ce sunt seturile Python?

Un set Python este o structură de date încorporată care reprezintă o colecție neordonată de elemente distincte, numite membri.

Acest instrument puternic este deosebit de util în aplicațiile de știință a datelor și operațiunile matematice.

Seturile Python au următoarele proprietăți:

1. Sunt neordonate, ceea ce înseamnă că elementele dintr-o mulțime sunt stocate independent de indexul lor. Această colecție neordonată de valori unice acceptă teste eficiente de membru și înțelegeri stabilite.

2. Nu permit valori duplicate. Acest lucru le face utile atunci când trebuie să lucrați cu valori unice, să eliminați duplicatele dintr-o listă sau să efectuați operații stabilite, cum ar fi uniuni, intersecții și diferențe simetrice.

Există două moduri de a crea un set în Python:

1. Prin utilizarea acoladelor ({}), cunoscute și sub numele de paranteze.

2. Folosind funcția încorporată set(), care ia un singur argument, un iterabil care conține elementele pe care doriți să le includeți în set.

O sintaxă generică pentru crearea unui set Python folosind acolade și funcția de set încorporată este prezentată mai jos:

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

Ce sunt listele Python

O listă Python este o structură de date încorporată similară cu matricele dinamice din alte limbaje de programare.

Acestea sunt folosite pentru a stoca mai multe elemente într-o singură variabilă, ceea ce le face o opțiune versatilă pentru manipularea diferitelor tipuri de date, cum ar fi șiruri de caractere, numere și valori booleene.

Listele Python au următoarele proprietăți:

1. Sunt ordonate, ceea ce înseamnă că un anumit element are o poziție unică într-o listă și poate fi accesat prin indexul său. Această colecție ordonată acceptă acces aleatoriu, permițându-vă să efectuați operațiuni precum tăierea, concatenarea și înțelegerea listelor.

2. Sunt modificabile, iar elementele lor pot fi modificate după crearea unei liste, oferind flexibilitate atunci când lucrați cu structuri de date.

3. Listele Python permit valori duplicate și pot stoca o combinație de tipuri de date, inclusiv șiruri de caractere, numere și valori booleene.

Există două moduri de a crea o listă în Python:

1. Folosind paranteze drepte, care denotă limitele listei.

2. Folosind funcția încorporată list(), care poate lua un singur argument sau un iterabil care conține elementele pe care doriți să le includeți în listă.

Următorul cod Python demonstrează crearea unei liste Python folosind paranteze drepte și funcția încorporată list():

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

3 diferențe cheie între seturi și liste

Sunt diferențe multiple între un set Python și o listă. Unele dintre cele importante sunt enumerate mai jos:

1. Comandă și indexare

Ordinea și indexarea în lista Python : O listă Python poate suporta indexarea, ceea ce înseamnă că puteți accesa elemente dintr-o listă folosind poziția lor în listă. Acest lucru oferă flexibilitate la manipularea datelor cu o ordine cunoscută.

Următorul cod Python demonstrează ordinea și indexarea listelor:

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

Seturi Python: Un set Python este o colecție neordonată fără indexare, ceea ce înseamnă că nu puteți accesa elemente folosind poziția lor. Acest lucru este util atunci când ordinea elementelor nu contează.

Următorul cod Python demonstrează ordinea și seturile de indexare:

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

Lista Python: O listă Python este modificabilă, permițându-vă să-i modificați elementele. Ele pot deține orice tip de obiect, inclusiv liste imbricate, oferind astfel mai multă flexibilitate în ceea ce privește conținutul pe care îl pot stoca.

Următorul cod demonstrează mutabilitatea în listele 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]

Set Python: La fel ca o listă în Python, un set Python este, de asemenea, mutabil și poate fi modificat. Cu toate acestea, seturile din Python pot deține numai obiecte hashable (imuabile), ceea ce înseamnă că nu puteți avea un set de seturi sau un set care conține obiecte mutabile, cum ar fi liste.

Următorul cod demonstrează mutabilitatea seturilor 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]}

Unicitatea elementelor

Seturi Python: O caracteristică cheie a seturilor este că stochează doar elemente unice. Adăugarea de valori duplicate la o listă este ignorată. Acest lucru face ca un obiect set să fie ideal pentru diferite operațiuni de set, cum ar fi eliminarea duplicatelor sau verificarea prezenței elementelor unice.

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

• 

  Liste Python: Listele permit valori duplicate și mențin ordinea acestora, ceea ce poate fi esențial în cazurile de utilizare în care duplicatele și ordinea elementelor joacă un rol semnificativ.

  # 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țiuni suportate

Există diferite operații pe care le puteți efectua pe seturi și liste, fiecare optimizată pentru sarcini specifice:

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ție: Listele sunt puțin mai rapide decât seturile atunci când vine vorba de repetarea elementelor. Acest lucru se datorează faptului că seturile necesită operații suplimentare pentru a asigura unicitatea, în timp ce listele mențin o colecție ordonată simplă cu indexare directă.

Folosirea memoriei

Seturile consumă, de obicei, mai multă memorie decât listele, deoarece trebuie să mențină un tabel hash pentru a asigura unicitatea articolelor, ceea ce vine cu prețul unui consum crescut de memorie.

Listele stochează doar elementele secvenţial, ceea ce duce la un consum mai mic de memorie, făcându-le o alegere mai eficientă din punct de vedere al memoriei atunci când se manipulează colecţii mari de date.

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

Codul furnizat prezintă comparația performanței dintre seturile și listele Python în ceea ce privește complexitatea timpului pentru căutare și iterare.

Acesta generează o listă mare și un set de numere întregi aleatorii, închise de paranteze (numite și acolade).

Apoi măsoară timpul necesar pentru a căuta un anumit element, folosind un singur argument atât în ​​listă, cât și în set și măsoară timpul necesar pentru a itera toate elementele din listă și din set.

Rezultatul ilustrează diferențele de performanță dintre listele și seturile Python pentru căutare și iterare, care provin din implementarea lor subiacentă.

Operația de căutare este mai rapidă în seturi (0,000000 secunde) decât în ​​liste (0,002999 secunde) datorită utilizării funcțiilor hash pentru a calcula valorile hash pentru căutări eficiente. Totuși, repetarea pe o listă (0,007995 secunde) este puțin mai rapidă decât repetarea peste un set (0,017989 secunde), deoarece seturile necesită operații suplimentare pentru a asigura unicitatea.

Operații și metode comune

Atât seturile, cât și listele în Python au diverse operațiuni și metode, fiecare optimizată pentru sarcini specifice și manipularea datelor. Unele dintre aceste metode sunt enumerate mai jos:

Setare Metodă

Metodele set efectuează operații care sunt similare cu operațiile matematice și sunt instrumente puternice pentru manipularea valorilor unice dintr-o colecție.

• add(element): Adaugă un element la set dacă nu este deja prezent.

• remove(element): Îndepărtează elementul specificat din set; generează o eroare dacă elementul nu este găsit.

• discard(element): Îndepărtează elementul specificat din set dacă este prezent. Nu apare nicio eroare dacă elementul nu este găsit.

• union(set2): Returnează un nou set care conține toate elementele din setul original și set2, efectuând efectiv o operație de set.

• intersection(set2): Returnează un nou set care conține elemente comune atât setului original, cât și setului2.

• diferență(set2): returnează un nou set care conține elemente în setul original, dar nu și în set2.

• symmetric_difference(set2): returnează un nou set care conține elemente fie în setul original, fie în set2, dar nu în ambele.

Metoda listei

Metodele listă oferă diferite moduri de manipulare a datelor.

• append(element): adaugă un element la sfârșitul listei.

• extinde(iterabil): Adaugă toate elementele din iterabil (de exemplu, o altă listă) la sfârșitul listei.

• insert(index, element): Inserează un element la indexul specificat.

• remove(element): elimină prima apariție a elementului specificat din listă; generează o eroare dacă elementul nu este prezent.

• pop(index): elimină și returnează elementul la indexul specificat. Dacă nu este dat niciun index, acesta elimină ultimul element.

• index(element): Returnează indexul primei apariții a elementului specificat din listă.

• count(element): Returnează numărul de apariții ale elementului specificat în listă.

• sort(): Sortează lista în ordine crescătoare în mod implicit; pentru ordinea descrescătoare, utilizați parametrul reverse=True.

• reverse(): inversează ordinea elementelor din listă.

Folosind aceste metode de set și listă Python, vă puteți manipula în mod eficient datele și puteți rezolva diverse probleme în programarea Python, știința datelor și alte aplicații.

Cuvântul nostru final

Când alegeți între liste și seturi Python pentru structura dvs. de date, luați în considerare utilizarea listelor atunci când aveți nevoie de o colecție ordonată de articole, doriți să păstrați elemente duplicate și aveți nevoie de abilitatea de a accesa elemente prin index.

Optează pentru seturi atunci când unicitatea elementelor este esențială, ordinea elementelor nu este importantă și este preferată testarea mai rapidă a membrilor. În timp ce listele excelează în iterație, seturile oferă verificări de izolare mai eficiente.

Alegerea dvs. depinde în cele din urmă de cerințele proiectului dvs., deoarece fiecare structură de date oferă propriul set de beneficii și limitări, făcându-le instrumente puternice pentru abordarea diferitelor sarcini în programarea Python. Bucurați-vă!