Python-set versus lijst - het echte verschil

In de programmeerwereld van Python kom je vaak verschillende datastructuren tegen die verschillende doelen dienen. Onder deze structuren worden sets en lijsten vaak gebruikt voor het opslaan en manipuleren van gegevensverzamelingen.

Hoewel ze op elkaar lijken, zijn er opmerkelijke verschillen in hun eigenschappen en gebruiksscenario's.

Inhoudsopgave

• Python-sets en -lijsten begrijpen
  • Wat zijn Python-sets?
  • Wat zijn Python-lijsten
• 3 belangrijkste verschillen tussen sets en lijsten
  • 1. Bestellen en indexeren
  • 2. Veranderlijkheid
  • Uniciteit van elementen
  • 3. Ondersteunde operaties
• Hoe kies je de juiste datastructuur?
  • Gebruik Cases voor Sets
  • Gebruik Cases voor Lijsten
• APrestatievergelijking tussen sets en lijsten
  • Tijd complexiteit
  • Geheugengebruik
• Gemeenschappelijke bewerkingen en methoden
  • Methode instellen
  • lijst methode
• Ons laatste woord

Python-sets en -lijsten begrijpen

Oké, dus laten we eerst dingen uitleggen.

Wat zijn Python-sets?

Een Python- set is een ingebouwde gegevensstructuur die een ongeordende verzameling afzonderlijke elementen vertegenwoordigt, leden genoemd.

Deze krachtige tool is vooral handig in data science-toepassingen en wiskundige bewerkingen.

Python-sets hebben de volgende eigenschappen:

1. Ze zijn ongeordend, wat betekent dat elementen in een set onafhankelijk van hun index worden opgeslagen. Deze ongeordende verzameling unieke waarden ondersteunt efficiënte lidmaatschapstests en setbegrippen.

2. Ze staan ​​geen dubbele waarden toe. Dit maakt ze handig wanneer u met unieke waarden moet werken, duplicaten uit een lijst moet verwijderen of setbewerkingen moet uitvoeren zoals vakbonden, snijpunten en symmetrische verschillen.

Er zijn twee manieren om een ​​set in Python te maken:

1. Door accolades ({}) te gebruiken, ook wel accolades genoemd.

2. Door de ingebouwde functie set() te gebruiken, waarvoor een enkel argument nodig is, een iterable die de elementen bevat die u in de set wilt opnemen.

Een generieke syntaxis voor het maken van een Python-set met behulp van accolades en de ingebouwde set-functie wordt hieronder gegeven:

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

Wat zijn Python-lijsten

Een Python-lijst is een ingebouwde gegevensstructuur die lijkt op dynamische arrays in andere programmeertalen.

Ze worden gebruikt om meerdere items in een enkele variabele op te slaan, waardoor ze een veelzijdige optie zijn voor het verwerken van verschillende gegevenstypen, zoals tekenreeksen, getallen en booleans.

Python-lijsten hebben de volgende eigenschappen:

1. Ze zijn geordend, wat betekent dat een bepaald element een unieke positie in een lijst heeft en toegankelijk is via de index. Deze geordende verzameling ondersteunt willekeurige toegang, waardoor u bewerkingen kunt uitvoeren zoals segmenteren, samenvoegen en lijstbegrip.

2. Ze zijn veranderlijk en hun elementen kunnen worden gewijzigd na het maken van een lijst, wat flexibiliteit biedt bij het werken met datastructuren.

3. Python-lijsten maken dubbele waarden mogelijk en kunnen een combinatie van gegevenstypen opslaan, waaronder tekenreeksen, getallen en booleans.

Er zijn twee manieren om een ​​lijst te maken in Python:

1. Door vierkante haken te gebruiken, die de grenzen van de lijst aangeven.

2. Door de ingebouwde functie list() te gebruiken, die een enkel argument kan gebruiken of een herhaling die de elementen bevat die u in de lijst wilt opnemen.

De volgende Python-code demonstreert het maken van een Python-lijst met behulp van vierkante haken en de ingebouwde list()-functie:

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

3 belangrijkste verschillen tussen sets en lijsten

Het zijn meerdere verschillen tussen een Python-set en een lijst. Enkele van de belangrijkste worden hieronder opgesomd:

1. Bestellen en indexeren

Volgorde en indexering in Python- lijst: een Python-lijst kan indexering ondersteunen, wat betekent dat u toegang hebt tot elementen in een lijst met behulp van hun positie in de lijst. Dit biedt flexibiliteit bij het manipuleren van gegevens met een bekende volgorde.

De volgende Python- code demonstreert de volgorde en indexering van lijsten:

# 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-sets: Een Python-set is een ongeordende verzameling zonder indexering, wat betekent dat je geen toegang hebt tot elementen met behulp van hun positie. Dit is handig wanneer de volgorde van elementen er niet toe doet.

De volgende Python-code demonstreert volgorde- en indexeringssets:

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

Python-lijst: een Python-lijst is veranderlijk, waardoor u de elementen ervan kunt wijzigen. Ze kunnen elk type object bevatten, inclusief geneste lijsten, waardoor ze meer flexibiliteit bieden wat betreft de inhoud die ze kunnen opslaan.

De volgende code demonstreert veranderlijkheid in Python-lijsten:

# 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-set: net als een lijst in Python, is een Python-set ook veranderlijk en kan deze worden gewijzigd. Sets in Python kunnen echter alleen hashable (onveranderlijke) objecten bevatten, wat betekent dat je geen set sets kunt hebben of een set die veranderlijke objecten zoals lijsten bevat.

De volgende code demonstreert de veranderlijkheid van Python-sets:

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

Uniciteit van elementen

Python-sets: een belangrijk kenmerk van sets is dat ze alleen unieke elementen opslaan. Het toevoegen van dubbele waarden aan een lijst wordt genegeerd. Dit maakt een setobject ideaal voor verschillende setbewerkingen, zoals het verwijderen van duplicaten of het controleren op de aanwezigheid van unieke elementen.

# 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-lijsten: Lijsten staan ​​dubbele waarden toe en behouden hun volgorde, wat essentieel kan zijn in gevallen waarin duplicaten en de volgorde van elementen een belangrijke rol spelen.

  # 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. Ondersteunde operaties

Er zijn verschillende bewerkingen die men kan uitvoeren op sets en lijsten, elk geoptimaliseerd voor specifieke taken:

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. Iteratie: Lijsten zijn iets sneller dan sets als het gaat om het herhalen van de items. Dit komt omdat sets aanvullende bewerkingen vereisen om uniciteit te garanderen, terwijl lijsten een eenvoudig geordende verzameling behouden met directe indexering.

Geheugengebruik

Sets verbruiken doorgaans meer geheugen dan lijsten, omdat ze een hashtabel moeten onderhouden om de uniciteit van items te waarborgen, wat ten koste gaat van meer geheugengebruik.

Lijsten slaan de elementen alleen opeenvolgend op, wat leidt tot een lager geheugenverbruik, waardoor ze een meer geheugenefficiënte keuze zijn bij het verwerken van grote verzamelingen gegevens.

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

De verstrekte code toont de prestatievergelijking tussen Python-sets en -lijsten in termen van tijdcomplexiteit voor zoeken en iteratie.

Het genereert een grote lijst en een reeks willekeurige gehele getallen, omsloten door accolades (ook wel accolades genoemd).

Vervolgens wordt de tijd gemeten die nodig is om naar een specifiek item te zoeken, met behulp van een enkel argument in zowel de lijst als de set, en wordt de tijd gemeten die nodig is om alle elementen in de lijst en set te doorlopen.

De uitvoer illustreert de prestatieverschillen tussen Python-lijsten en sets voor zoeken en iteratie, die voortkomen uit hun onderliggende implementatie.

De zoekbewerking is sneller in sets (0,000000 seconden) dan in lijsten (0,002999 seconden) vanwege het gebruik van hash-functies om hash-waarden te berekenen voor efficiënte zoekopdrachten. Het herhalen van een lijst (0,007995 seconden) is echter iets sneller dan het herhalen van een set (0,017989 seconden), aangezien sets aanvullende bewerkingen vereisen om uniciteit te garanderen.

Gemeenschappelijke bewerkingen en methoden

Zowel sets als lijsten in Python hebben verschillende bewerkingen en methoden, elk geoptimaliseerd voor specifieke taken en gegevensmanipulatie. Enkele van deze methoden worden hieronder vermeld:

Methode instellen

Set-methoden voeren bewerkingen uit die vergelijkbaar zijn met wiskundige bewerkingen en zijn krachtige hulpmiddelen voor het omgaan met unieke waarden in een verzameling.

• add(element): Voegt een element toe aan de set als het nog niet aanwezig is.

• remove(element): Verwijdert het gespecificeerde element uit de set; genereert een fout als het element niet wordt gevonden.

• throw(element): Verwijdert het gespecificeerde element uit de set als het aanwezig is. Er wordt geen fout gegenereerd als het element niet wordt gevonden.

• union(set2): Retourneert een nieuwe set die alle elementen bevat van de oorspronkelijke set en set2, waarmee effectief een setbewerking wordt uitgevoerd.

• intersectie(set2): Retourneert een nieuwe set met elementen die gemeenschappelijk zijn voor zowel de originele set als set2.

• verschil(set2): Retourneert een nieuwe set met elementen in de originele set maar niet in set2.

• symmetrisch_verschil(set2): Retourneert een nieuwe set met elementen in de originele set of set2, maar niet in beide.

lijst methode

Lijstmethoden bieden verschillende manieren om gegevens te manipuleren.

• append(element): Voegt een element toe aan het einde van de lijst.

• extend(iterable): Voegt alle elementen van de iterable (bijvoorbeeld een andere lijst) toe aan het einde van de lijst.

• insert(index, element): Voegt een element in op de gespecificeerde index.

• remove(element): Verwijdert het eerste voorkomen van het gespecificeerde element in de lijst; geeft een foutmelding als het element niet aanwezig is.

• pop(index): Verwijdert en retourneert het element op de gespecificeerde index. Als er geen index wordt gegeven, wordt het laatste element verwijderd.

• index(element): Retourneert de index van het eerste voorkomen van het gespecificeerde element in de lijst.

• count(element): Retourneert het aantal keren dat het opgegeven element in de lijst voorkomt.

• sort(): Sorteert de lijst standaard in oplopende volgorde; gebruik voor aflopende volgorde de parameter reverse=True.

• reverse(): Keert de volgorde van de elementen in de lijst om.

Door deze set- en lijstmethoden van Python te gebruiken, kunt u uw gegevens effectief manipuleren en verschillende problemen oplossen in Python-programmering, datawetenschap en andere toepassingen.

Ons laatste woord

Wanneer u kiest tussen Python-lijsten en -sets voor uw gegevensstructuur, overweeg dan om lijsten te gebruiken wanneer u een geordende verzameling items nodig heeft, dubbele elementen wilt behouden en de mogelijkheid nodig hebt om elementen per index te openen.

Kies voor sets wanneer het unieke karakter van de elementen essentieel is, de volgorde van de elementen niet belangrijk is en snellere lidmaatschapstests de voorkeur hebben. Terwijl lijsten uitblinken in iteratie, bieden sets efficiëntere inperkingscontroles.

Uw keuze hangt uiteindelijk af van de vereisten van uw project, aangezien elke datastructuur zijn eigen set voordelen en beperkingen biedt, waardoor het krachtige hulpmiddelen zijn voor het aanpakken van verschillende taken in Python-programmering. Genieten!