Python Set vs List – Den verkliga skillnaden

I Python-programmeringsvärlden kommer du ofta att stöta på olika datastrukturer som tjänar olika syften. Bland dessa strukturer används uppsättningar och listor vanligtvis för att lagra och manipulera datasamlingar.

Även om de kan verka likadana, finns det betydande skillnader i deras egenskaper och användningsfall.

Innehållsförteckning

• Förstå Python-uppsättningar och listor
  • Vad är Python Sets?
  • Vad är Python-listor
• 3 nyckelskillnader mellan uppsättningar och listor
  • 1. Beställning och indexering
  • 2. Föränderlighet
  • Elementens unikhet
  • 3. Operationer som stöds
• Hur väljer du rätt datastruktur?
  • Användningsfodral för set
  • Användningsfall för listor
• APerformance Jämförelse mellan uppsättningar och listor
  • Tidskomplexitet
  • Minnesanvändning
• Vanliga operationer och metoder
  • Ställ in metod
  • Listmetod
• Vårt sista ord

Förstå Python-uppsättningar och listor

Ok, så låt oss förklara saker först.

Vad är Python Sets?

En uppsättning är en inbyggd datastruktur som representerar en oordnad samling av distinkta element, kallade medlemmar.

Detta kraftfulla verktyg är särskilt användbart i datavetenskapliga tillämpningar och matematiska operationer.

Python-uppsättningar har följande egenskaper:

1. De är oordnade, vilket innebär att element i en uppsättning lagras oberoende av deras index. Denna oordnade samling av unika värden stödjer effektiva medlemskapstester och uppfattningar.

2. De tillåter inte dubbletter av värden. Detta gör dem användbara när du behöver arbeta med unika värden, ta bort dubbletter från en lista eller utföra uppsättningsoperationer som fackföreningar, korsningar och symmetriska skillnader.

Det finns två sätt att skapa en uppsättning i Python:

1. Genom att använda lockiga parenteser ({}), även känd som lockiga parenteser.

2. Genom att använda den inbyggda set()-funktionen, som tar ett enda argument, en iterabel som innehåller de element du vill inkludera i uppsättningen.

En generisk syntax för att skapa en Python-uppsättning med hjälp av hängslen och den inbyggda uppsättningsfunktionen ges nedan:

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

Vad är Python-listor

En Python-lista är en inbyggd datastruktur som liknar dynamiska arrayer i andra programmeringsspråk.

De används för att lagra flera objekt i en enda variabel, vilket gör dem till ett mångsidigt alternativ för att hantera olika datatyper, såsom strängar, siffror och booleaner.

Pythonlistor har följande egenskaper:

1. De är ordnade, vilket innebär att ett visst element har en unik position i en lista och kan nås via dess index. Denna ordnade samling stöder slumpmässig åtkomst, vilket gör att du kan utföra operationer som skivning, sammanlänkning och listförståelse.

2. De är föränderliga och deras element kan ändras efter att du har skapat en lista, vilket ger flexibilitet när du arbetar med datastrukturer.

3. Python-listor tillåter dubbletter av värden och kan lagra en blandning av datatyper, inklusive strängar, siffror och booleaner.

Det finns två

1. Genom att använda hakparenteser, som anger gränserna för listan.

2. Genom att använda den inbyggda list()-funktionen, som kan ta ett enda argument eller en iterabel som innehåller de element du vill inkludera i listan.

Följande Python-kod demonstrerar att skapa en Python-lista med hakparenteser och den inbyggda list()-funktionen:

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

3 nyckelskillnader mellan uppsättningar och listor

De är flera skillnader mellan en Python-uppsättning och en lista. Några av de viktiga är listade nedan:

1. Beställning och indexering

Ordning och indexering i lista: En Python-lista kan stödja indexering, vilket innebär att du kan komma åt element i en lista med deras position i listan. Detta ger flexibilitet vid manipulering av data med en känd ordning.

Följande kod visar ordningen och indexeringen av listor:

# 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-uppsättningar: En Python-uppsättning är en oordnad samling utan indexering, vilket innebär att du inte kan komma åt element med deras position. Detta är användbart när ordningen på element inte spelar någon roll.

Följande Python-kod visar ordnings- och indexeringsuppsättningar:

# 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. Föränderlighet

Python-lista: En Python-lista är föränderlig, så att du kan ändra dess element. De kan hålla vilken typ av objekt som helst, inklusive kapslade listor, vilket ger mer flexibilitet när det gäller innehållet de kan lagra.

Följande kod visar förändringar i Python-listor:

# 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-uppsättning: Precis som en i Python, är en Python-uppsättning också föränderlig och kan modifieras. Uppsättningar i Python kan dock bara innehålla hashbara (oföränderliga) objekt, vilket innebär att du inte kan ha en uppsättning uppsättningar eller en uppsättning som innehåller föränderliga objekt som listor.

Följande kod visar föränderligheten hos Python-uppsättningar:

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

Elementens unikhet

Python-uppsättningar: En nyckelfunktion hos set är att de bara lagrar unika element. Tillägget av dubbletter av värden till en lista ignoreras. Detta gör ett uppsättningsobjekt idealiskt för olika uppsättningsoperationer, som att ta bort dubbletter eller kontrollera förekomsten av unika element.

# 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-listor: Listor tillåter dubbletter av värden och bibehåller deras ordning, vilket kan vara viktigt i användningsfall där dubbletter och ordningen på element spelar en betydande roll.

  # 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. Operationer som stöds

Det finns olika operationer man kan utföra på uppsättningar och listor, var och en optimerad för specifika uppgifter:

Pythonlistor: På grund av deras ordnade och indexbaserade karaktär stöder listor operationer som skivning, sammanlänkning, upprepning och listförståelse. De tillhandahåller också inbyggda metoder, såsom append(), pop() och sort(), som låter dig manipulera element i en lista.

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

som union, korsning, skillnad och kontroll av medlemskap med hjälp av hashfunktioner för att snabbt hitta element. Eftersom de är oordnade och saknar indexering skiljer sig setoperationer från listbaserade.

# 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

Hur väljer du rätt datastruktur?

När du arbetar med Python är det viktigt att välja den mest lämpliga datastrukturen för din specifika uppgift. I det här avsnittet kommer vi att diskutera de bästa scenarierna för att använda uppsättningar och listor, tillsammans med deras unika fördelar.

Låt oss gå in i det.

Användningsfodral för set

Set erbjuder flera fördelar som gör dem till det perfekta valet för vissa uppgifter:

Unikhet: Om du behöver lagra en samling unika element är set rätt väg att gå. Uppsättningar eliminerar automatiskt dubbletter, vilket säkerställer att varje element i uppsättningen är distinkt.

Medlemskapstester: Uppsättningar ger snabbare medlemskapstester jämfört med listor. På grund av deras underliggande hashtabellimplementering och användningen av hashfunktioner tillåter uppsättningar mycket effektiva uppslagningar baserade på hashvärden.

Set operationer: Ställer in stödoperationer som union, intersection, difference och symmetrisk skillnad som kan vara användbara i många algoritmer, databearbetningsuppgifter och datavetenskapliga tillämpningar.

Användningsfall för listor

Listor är bättre lämpade för följande scenarier:

Ordnade data: Listor upprätthåller ordningen på elementen, vilket gör dem lämpliga för uppgifter som kräver att sekvensen av objekt respekteras, som att bearbeta data i den ordning de skapades eller när stödindexering behövs.

Föränderlig data: Listor är föränderliga, så att du kan lägga till, ta bort eller ändra ett specifikt element efter behov. Denna flexibilitet gör listor lämpliga för uppgifter som innebär ändring av innehållet i samlingen eller när man arbetar med kapslade datastrukturer, såsom listor med listor eller ordböcker.

Icke-unika element: Till skillnad från uppsättningar kan listor lagra dubblettelement, vilket gör dem lämpliga för situationer där frekvensen av objekt har betydelse, till exempel att räkna förekomster eller bibehålla ordningen på dubblettvärden.

Kolla in nedan för att visa för att främja ditt lärande.

APerformance Jämförelse mellan uppsättningar och listor

I det här avsnittet kommer vi att jämföra prestanda för Python-uppsättningar och listor när det gäller tidskomplexitet och minnesanvändning, vilket är viktigt när man arbetar med stora datastrukturer eller när man optimerar kod för effektivitet.

Tidskomplexitet

När det kommer till tidskomplexitet har uppsättningar och listor olika styrkor och svagheter beroende på vilka operationer du utför på grund av deras underliggande implementering.

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. Iteration: Lists are slightly faster than sets when it comes to iterating over the items. This is because sets require additional operations to ensure uniqueness, while lists maintain a simple ordered collection with direct indexing.

Memory Usage

Sets typically consume more memory than lists because they need to maintain a hash table to ensure the uniqueness of items, which comes at the cost of increased memory consumption.

Lists only store the elements sequentially, leading to lower memory consumption, making them a more memory-efficient choice when handling large collections of data.

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

The provided code showcases the performance comparison between Python sets and lists in terms of time complexity for searching and iteration.

It generates a large list and set of random integers, enclosed by curly brackets (also called curly braces).

It then measures the time taken to search for a specific item, using a single argument in both the list and set, and measures the time taken to iterate through all elements in the list and set.

The output illustrates the performance differences between Python lists and sets for search and iteration, which stem from their underlying implementation.

The search operation is faster in sets (0.000000 seconds) than in lists (0.002999 seconds) due to the use of hash functions to compute hash values for efficient lookups. However, iterating over a list (0.007995 seconds) is slightly faster than iterating over a set (0.017989 seconds) since sets require additional operations to ensure uniqueness.

Common Operations and Methods

Both sets and lists in Python have various operations and methods, each optimized for specific tasks and data manipulation. Some of these methods are listed below:

Set Method

Set methods perform operations that are similar to mathematical operations and are powerful tools for handling unique values in a collection.

• add(element): Adds an element to the set if it is not already present.

• remove(element): Removes the specified element from the set; raises an error if the element is not found.

• discard(element): Removes the specified element from the set if it is present. No error is raised if the element is not found.

• union(set2): Returns a new set containing all elements from the original set and set2, effectively performing a set operation.

• intersection(set2): Returns a new set containing elements common to both the original set and set2.

• difference(set2): Returns a new set containing elements in the original set but not in set2.

• symmetric_difference(set2): Returns a new set containing elements in either the original set or set2, but not in both.

List Method

List methods provide various ways to manipulate data.

• append(element): Adds an element to the end of the list.

• extend(iterable): Appends all elements from the iterable (e.g., another list) to the end of the list.

• insert(index, element): Inserts an element at the specified index.

• remove(element): Removes the first occurrence of the specified element in the list; raises an error if the element is not present.

• pop(index): Removes and returns the element at the specified index. If no index is given, it removes the last element.

• index(element): Returns the index of the first occurrence of the specified element in the list.

• count(element): Returns the number of occurrences of the specified element in the list.

• sort(): Sorts the list in ascending order by default; for descending order, use the reverse=True parameter.

• reverse(): Reverses the order of the elements in the list.

By using these Python set and list methods, you can effectively manipulate your data and solve various problems in Python programming, data science, and other applications.

Our Final Say

When choosing between Python lists and sets for your data structure, consider using lists when you need an ordered collection of items, want to preserve duplicate elements, and require the ability to access elements by index.

Opt for sets when the uniqueness of elements is essential, the order of elements is not important, and faster membership testing is preferred. While lists excel in iteration, sets provide more efficient containment checks.

Your choice ultimately depends on your project’s requirements, as each data structure offers its own set of benefits and limitations, making them powerful tools for tackling various tasks in Python programming. Enjoy!