Python-Set vs. Liste – Der wahre Unterschied

In der Welt der Python-Programmierung werden Sie häufig auf verschiedene Datenstrukturen stoßen, die unterschiedlichen Zwecken dienen. Unter diesen Strukturen werden häufig Mengen und Listen zum Speichern und Bearbeiten von Datensammlungen verwendet.

Obwohl sie ähnlich erscheinen mögen, gibt es deutliche Unterschiede in ihren Eigenschaften und Anwendungsfällen.

Inhaltsverzeichnis

• Python-Sets und -Listen verstehen
  • Was sind Python-Sets?
  • Was sind Python-Listen?
• 3 Hauptunterschiede zwischen Sets und Listen
  • 1. Ordnung und Indexierung
  • 2. Veränderlichkeit
  • Einzigartigkeit der Elemente
  • 3. Unterstützte Operationen
• Wie wählen Sie die richtige Datenstruktur aus?
  • Anwendungsfälle für Sets
  • Anwendungsfälle für Listen
• Ein Leistungsvergleich zwischen Mengen und Listen
  • Zeitkomplexität
  • Speichernutzung
• Gemeinsame Operationen und Methoden
  • Methode festlegen
  • Listenmethode
• Unser letztes Wort

Python-Sets und -Listen verstehen

Ok, also lasst uns zuerst die Dinge erklären.

Was sind Python-Sets?

Ein Python- Set ist eine integrierte Datenstruktur, die eine ungeordnete Sammlung unterschiedlicher Elemente, sogenannte Mitglieder, darstellt.

Dieses leistungsstarke Tool ist besonders nützlich für datenwissenschaftliche Anwendungen und mathematische Operationen.

Python-Sets haben die folgenden Eigenschaften:

1. Sie sind ungeordnet, was bedeutet, dass Elemente in einer Menge unabhängig von ihrem Index gespeichert werden. Diese ungeordnete Sammlung eindeutiger Werte unterstützt effiziente Mitgliedschaftstests und Mengenverständnisse.

2. Sie erlauben keine doppelten Werte. Dies macht sie nützlich, wenn Sie mit eindeutigen Werten arbeiten, Duplikate aus einer Liste entfernen oder Mengenoperationen wie Vereinigungen, Schnittmengen und symmetrische Differenzen ausführen müssen.

Es gibt zwei Möglichkeiten, einen Satz in Python zu erstellen:

1. Durch die Verwendung von geschweiften Klammern ({}), auch geschweifte Klammern genannt.

2. Durch die Verwendung der integrierten Funktion set(), die ein einzelnes Argument akzeptiert, wird eine Iterable erstellt, die die Elemente enthält, die Sie in die Menge aufnehmen möchten.

Eine generische Syntax zum Erstellen eines Python-Sets mit geschweiften Klammern und der integrierten Set-Funktion ist unten angegeben:

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

Was sind Python-Listen?

Eine Python-Liste ist eine integrierte Datenstruktur, die dynamischen Arrays in anderen Programmiersprachen ähnelt.

Sie werden verwendet, um mehrere Elemente in einer einzigen Variablen zu speichern, was sie zu einer vielseitigen Option für die Verarbeitung verschiedener Datentypen wie Zeichenfolgen, Zahlen und boolesche Werte macht.

Python-Listen haben die folgenden Eigenschaften:

1. Sie sind geordnet, was bedeutet, dass ein bestimmtes Element eine eindeutige Position in einer Liste hat und über seinen Index darauf zugegriffen werden kann. Diese geordnete Sammlung unterstützt den wahlfreien Zugriff und ermöglicht Ihnen die Durchführung von Vorgängen wie Slicing, Verkettung und Listenverständnis.

2. Sie sind veränderbar und ihre Elemente können nach dem Erstellen einer Liste geändert werden, was Flexibilität bei der Arbeit mit Datenstrukturen bietet.

3. Python-Listen ermöglichen doppelte Werte und können eine Mischung aus Datentypen speichern, einschließlich Zeichenfolgen, Zahlen und booleschen Werten.

Es gibt zwei Möglichkeiten, eine Liste in Python zu erstellen:

1. Durch die Verwendung von eckigen Klammern, die die Grenzen der Liste kennzeichnen.

2. Mithilfe der integrierten list()-Funktion, die ein einzelnes Argument oder eine Iterable mit den Elementen annehmen kann, die Sie in die Liste aufnehmen möchten.

Der folgende Python-Code demonstriert das Erstellen einer Python-Liste mit eckigen Klammern und der integrierten list()-Funktion:

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

3 Hauptunterschiede zwischen Sets und Listen

Es gibt mehrere Unterschiede zwischen einem Python-Set und einer Liste. Einige der wichtigsten sind unten aufgeführt:

1. Ordnung und Indexierung

Reihenfolge und Indizierung in einer Python- Liste: Eine Python-Liste kann die Indizierung unterstützen, was bedeutet, dass Sie über ihre Position in der Liste auf Elemente in einer Liste zugreifen können. Dies bietet Flexibilität bei der Bearbeitung von Daten mit bekannter Reihenfolge.

Der folgende Python- Code demonstriert die Reihenfolge und Indizierung von Listen:

# 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: Ein Python-Set ist eine ungeordnete Sammlung ohne Indizierung, was bedeutet, dass Sie nicht über ihre Position auf Elemente zugreifen können. Dies ist nützlich, wenn die Reihenfolge der Elemente keine Rolle spielt.

Der folgende Python-Code demonstriert Reihenfolge und Indizierungssätze:

# 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. Veränderlichkeit

Python-Liste: Eine Python-Liste ist veränderbar, sodass Sie ihre Elemente ändern können. Sie können jede Art von Objekt enthalten, einschließlich verschachtelter Listen, und bieten so mehr Flexibilität hinsichtlich der zu speichernden Inhalte.

Der folgende Code demonstriert die Veränderlichkeit in Python-Listen:

# 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: Genau wie eine Liste in Python ist auch ein Python-Set veränderbar und kann geändert werden. Allerdings können Mengen in Python nur hashbare (unveränderliche) Objekte enthalten, was bedeutet, dass Sie keine Menge von Mengen oder eine Menge haben können, die veränderliche Objekte wie Listen enthält.

Der folgende Code demonstriert die Veränderlichkeit von 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]}

Einzigartigkeit der Elemente

Python-Sets: Ein wesentliches Merkmal von Sets ist, dass sie nur eindeutige Elemente speichern. Das Hinzufügen doppelter Werte zu einer Liste wird ignoriert. Dadurch eignet sich ein festgelegtes Objekt ideal für verschiedene festgelegte Vorgänge, z. B. das Entfernen von Duplikaten oder das Überprüfen des Vorhandenseins eindeutiger Elemente.

# 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-Listen: Listen erlauben doppelte Werte und behalten ihre Reihenfolge bei, was in Anwendungsfällen, in denen Duplikate und die Reihenfolge von Elementen eine wichtige Rolle spielen, von entscheidender Bedeutung sein kann.

  # 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. Unterstützte Operationen

Es gibt verschiedene Operationen, die man an Mengen und Listen ausführen kann, die jeweils für bestimmte Aufgaben optimiert sind:

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. Iteration: Listen sind etwas schneller als Mengen, wenn es um die Iteration über die Elemente geht. Dies liegt daran, dass Mengen zusätzliche Operationen erfordern, um die Eindeutigkeit sicherzustellen, während Listen eine einfache geordnete Sammlung mit direkter Indizierung verwalten.

Speichernutzung

Sätze verbrauchen in der Regel mehr Speicher als Listen, da sie eine Hash-Tabelle verwalten müssen, um die Eindeutigkeit der Elemente sicherzustellen, was auf Kosten eines erhöhten Speicherverbrauchs geht.

Listen speichern die Elemente nur nacheinander, was zu einem geringeren Speicherverbrauch führt und sie zu einer speichereffizienteren Wahl bei der Verarbeitung großer Datensammlungen macht.

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

Der bereitgestellte Code zeigt den Leistungsvergleich zwischen Python-Sets und -Listen im Hinblick auf die Zeitkomplexität für Suche und Iteration.

Es generiert eine große Liste und einen Satz zufälliger Ganzzahlen, die in geschweifte Klammern (auch geschweifte Klammern genannt) eingeschlossen sind.

Anschließend misst es die Zeit, die für die Suche nach einem bestimmten Element benötigt wird, wobei ein einzelnes Argument sowohl in der Liste als auch im Satz verwendet wird, und misst die Zeit, die für die Iteration durch alle Elemente in der Liste und im Satz benötigt wird.

Die Ausgabe veranschaulicht die Leistungsunterschiede zwischen Python-Listen und -Sets für Suche und Iteration, die sich aus der zugrunde liegenden Implementierung ergeben.

Der Suchvorgang ist in Sätzen (0,000000 Sekunden) schneller als in Listen (0,002999 Sekunden), da Hash-Funktionen zur Berechnung von Hash-Werten für effiziente Suchvorgänge verwendet werden. Allerdings ist die Iteration über eine Liste (0,007995 Sekunden) etwas schneller als die Iteration über einen Satz (0,017989 Sekunden), da Sätze zusätzliche Vorgänge erfordern, um die Eindeutigkeit sicherzustellen.

Gemeinsame Operationen und Methoden

Sowohl Mengen als auch Listen in Python verfügen über verschiedene Operationen und Methoden, die jeweils für bestimmte Aufgaben und Datenbearbeitung optimiert sind. Einige dieser Methoden sind unten aufgeführt:

Methode festlegen

Set-Methoden führen Vorgänge aus, die mathematischen Vorgängen ähneln, und sind leistungsstarke Werkzeuge zum Umgang mit eindeutigen Werten in einer Sammlung.

• add(element): Fügt der Menge ein Element hinzu, wenn es noch nicht vorhanden ist.

• Remove(Element): Entfernt das angegebene Element aus der Menge; löst einen Fehler aus, wenn das Element nicht gefunden wird.

• Discard(Element): Entfernt das angegebene Element aus der Menge, sofern es vorhanden ist. Wenn das Element nicht gefunden wird, wird kein Fehler ausgelöst.

• union(set2): Gibt eine neue Menge zurück, die alle Elemente der ursprünglichen Menge und von set2 enthält, und führt so effektiv eine Mengenoperation aus.

• Kreuzung(Satz2): Gibt einen neuen Satz zurück, der Elemente enthält, die sowohl dem ursprünglichen Satz als auch Satz2 gemeinsam sind.

• Differenz(Satz2): Gibt einen neuen Satz zurück, der Elemente im ursprünglichen Satz, aber nicht in Satz2 enthält.

• symmetric_difference(set2): Gibt eine neue Menge zurück, die Elemente entweder in der ursprünglichen Menge oder in set2 enthält, aber nicht in beiden.

Listenmethode

Listenmethoden bieten verschiedene Möglichkeiten zum Bearbeiten von Daten.

• append(element): Fügt ein Element am Ende der Liste hinzu.

• verlängern(iterierbar): Hängt alle Elemente aus der iterierbaren (z. B. einer anderen Liste) an das Ende der Liste an.

• insert(index, element): Fügt ein Element am angegebenen Index ein.

• Remove(Element): Entfernt das erste Vorkommen des angegebenen Elements in der Liste; löst einen Fehler aus, wenn das Element nicht vorhanden ist.

• pop(index): Entfernt das Element am angegebenen Index und gibt es zurück. Wenn kein Index angegeben ist, wird das letzte Element entfernt.

• index(element): Gibt den Index des ersten Vorkommens des angegebenen Elements in der Liste zurück.

• count(element): Gibt die Anzahl der Vorkommen des angegebenen Elements in der Liste zurück.

• sort(): Sortiert die Liste standardmäßig in aufsteigender Reihenfolge; Verwenden Sie für die absteigende Reihenfolge den Parameter „reverse=True“.

• reverse(): Kehrt die Reihenfolge der Elemente in der Liste um.

Durch die Verwendung dieser Python-Set- und -List-Methoden können Sie Ihre Daten effektiv manipulieren und verschiedene Probleme in der Python-Programmierung, Datenwissenschaft und anderen Anwendungen lösen.

Unser letztes Wort

Wenn Sie zwischen Python-Listen und -Sets für Ihre Datenstruktur wählen, sollten Sie die Verwendung von Listen in Betracht ziehen, wenn Sie eine geordnete Sammlung von Elementen benötigen, doppelte Elemente beibehalten möchten und die Möglichkeit benötigen, über den Index auf Elemente zuzugreifen.

Entscheiden Sie sich für Mengen, wenn die Einzigartigkeit der Elemente entscheidend ist, die Reihenfolge der Elemente jedoch nicht wichtig ist und schnellere Mitgliedschaftstests bevorzugt werden. Während sich Listen durch Iteration auszeichnen, bieten Sets effizientere Einschlussprüfungen.

Ihre Wahl hängt letztendlich von den Anforderungen Ihres Projekts ab, da jede Datenstruktur ihre eigenen Vorteile und Einschränkungen bietet und sie zu leistungsstarken Werkzeugen für die Bewältigung verschiedener Aufgaben in der Python-Programmierung macht. Genießen!