Python sæt vs liste – den rigtige forskel

I Python-programmeringens verden vil du ofte støde på forskellige datastrukturer, der tjener forskellige formål. Blandt disse strukturer er sæt og lister almindeligvis brugt til lagring og manipulation af datasamlinger.

Selvom de kan virke ens, er der bemærkelsesværdige forskelle i deres egenskaber og anvendelsestilfælde.

Indholdsfortegnelse

• Forståelse af Python-sæt og -lister
  • Hvad er Python-sæt?
  • Hvad er Python-lister
• 3 nøgleforskelle mellem sæt og lister
  • 1. Bestilling og indeksering
  • 2. Foranderlighed
  • Elementernes unikke karakter
  • 3. Understøttede operationer
• Hvordan vælger du den rigtige datastruktur?
  • Brug Cases til sæt
  • Brugssager til lister
• APydeevnesammenligning mellem sæt og lister
  • Tidskompleksitet
  • Hukommelsesbrug
• Fælles operationer og metoder
  • Indstil metode
  • Listemetode
• Vores sidste ord

Forståelse af Python-sæt og -lister

Ok, så lad os forklare tingene først.

Hvad er Python-sæt?

Et sæt er en indbygget datastruktur, der repræsenterer en uordnet samling af særskilte elementer, kaldet medlemmer.

Dette kraftfulde værktøj er særligt nyttigt i datavidenskabelige applikationer og matematiske operationer.

Python-sæt har følgende egenskaber:

1. De er uordnede, hvilket betyder, at elementer i et sæt gemmes uafhængigt af deres indeks. Denne uordnede samling af unikke værdier understøtter effektive medlemstests og sæt forståelser.

2. De tillader ikke duplikerede værdier. Dette gør dem nyttige, når du skal arbejde med unikke værdier, fjerne dubletter fra en liste eller udføre sæt-operationer som f.eks. fagforeninger, skæringspunkter og symmetriske forskelle.

Der er to måder at oprette et sæt i Python på:

1. Ved at bruge krøllede parenteser ({}), også kendt som krøllede parenteser.

2. Ved at bruge den indbyggede set() funktion, som tager et enkelt argument, en iterable, der indeholder de elementer, du vil inkludere i sættet.

En generisk syntaks til at skabe et Python-sæt ved hjælp af krøllede seler og den indbyggede sætfunktion er angivet nedenfor:

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

Hvad er Python-lister

En Python-liste er en indbygget datastruktur, der ligner dynamiske arrays i andre programmeringssprog.

De bruges til at gemme flere elementer i en enkelt variabel, hvilket gør dem til en alsidig mulighed for håndtering af forskellige datatyper, såsom strenge, tal og booleaner.

Python-lister har følgende egenskaber:

1. De er ordnet, hvilket betyder, at et bestemt element har en unik position i en liste og kan tilgås via dets indeks. Denne ordnede samling understøtter tilfældig adgang, hvilket giver dig mulighed for at udføre operationer såsom udskæring, sammenkædning og listeforståelse.

2. De kan ændres, og deres elementer kan ændres efter oprettelse af en liste, hvilket giver fleksibilitet, når du arbejder med datastrukturer.

3. Python-lister giver mulighed for duplikerede værdier og kan gemme en blanding af datatyper, herunder strenge, tal og booleaner.

Der er to

1. Ved at bruge firkantede parenteser, som angiver listens grænser.

2. Ved at bruge den indbyggede list() funktion, som kan tage et enkelt argument eller en iterabel, der indeholder de elementer, du vil inkludere i listen.

Følgende Python-kode demonstrerer oprettelse af en Python-liste ved hjælp af firkantede parenteser og den indbyggede list()-funktion:

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

3 nøgleforskelle mellem sæt og lister

De er flere forskelle mellem et Python-sæt og en liste. Nogle af de vigtige er listet nedenfor:

1. Bestilling og indeksering

Rækkefølge og indeksering i liste: En Python-liste kan understøtte indeksering, hvilket betyder, at du kan få adgang til elementer i en liste ved at bruge deres placering på listen. Dette giver fleksibilitet ved manipulation af data med en kendt rækkefølge.

Følgende kode viser rækkefølgen og indekseringen af ​​lister:

# 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-sæt: Et Python-sæt er en uordnet samling uden indeksering, hvilket betyder, at du ikke kan få adgang til elementer ved hjælp af deres position. Dette er nyttigt, når rækkefølgen af ​​elementer ikke betyder noget.

Følgende Python-kode demonstrerer rækkefølge og indekseringssæt:

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

Python-liste: En Python-liste kan ændres, så du kan ændre dens elementer. De kan indeholde enhver type objekt, inklusive indlejrede lister, og derved tilbyde mere fleksibilitet med hensyn til det indhold, de kan gemme.

Følgende kode demonstrerer mutabilitet i Python-lister:

# 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-sæt: Ligesom et i Python er et Python-sæt også mutable og kan ændres. Men sæt i Python kan kun indeholde hashbare (uforanderlige) objekter, hvilket betyder, at du ikke kan have et sæt sæt eller et sæt, der indeholder foranderlige objekter som lister.

Følgende kode demonstrerer mutabiliteten af ​​Python-sæt:

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

Elementernes unikke karakter

Python-sæt: En nøglefunktion ved sæt er, at de kun gemmer unikke elementer. Tilføjelsen af ​​duplikerede værdier til en liste ignoreres. Dette gør et sætobjekt ideelt til forskellige sætoperationer, såsom fjernelse af dubletter eller kontrol af tilstedeværelsen af ​​unikke elementer.

# 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-lister: Lister tillader duplikerede værdier og bevarer deres rækkefølge, hvilket kan være essentielt i brugstilfælde, hvor dubletter og rækkefølgen af ​​elementer spiller en væsentlig rolle.

  # 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. Understøttede operationer

Der er forskellige operationer, man kan udføre på sæt og lister, hver optimeret til specifikke opgaver:

Python-lister: På grund af deres ordnede og indeksbaserede karakter understøtter lister operationer som udskæring, sammenkædning, gentagelse og listeforståelse. De giver også indbyggede metoder, såsom append(), pop() og sort(), der giver dig mulighed for at manipulere elementer i en liste.

# 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, intersection, difference og kontrol af medlemskab ved hjælp af hash-funktioner til hurtigt at finde elementer. Da de er uordnede og mangler indeksering, adskiller sætoperationer sig fra listebaserede.

# 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

Hvordan vælger du den rigtige datastruktur?

Når du arbejder med Python, er det vigtigt at vælge den bedst egnede datastruktur til din specifikke opgave. I dette afsnit vil vi diskutere de bedste scenarier for brug af sæt og lister sammen med deres unikke fordele.

Lad os komme ind i det.

Brug Cases til sæt

Sæt tilbyder flere fordele, der gør dem til det ideelle valg til visse opgaver:

Unikhed: Hvis du skal opbevare en samling unikke elementer, er sæt vejen at gå. Sæt eliminerer automatisk dubletter, hvilket sikrer, at hvert element i sættet er adskilt.

Medlemskabstest: Sæt giver hurtigere medlemskabstest sammenlignet med lister. På grund af deres underliggende hash-tabelimplementering og brugen af ​​hashfunktioner tillader sæt højeffektive opslag baseret på hashværdier.

Sæt operationer: Indstiller understøttende operationer såsom forening, skæringspunkt, forskel og symmetrisk forskel, der kan være nyttige i mange algoritmer, databehandlingsopgaver og datavidenskabelige applikationer.

Brugssager til lister

Lister er bedre egnede til følgende scenarier:

Ordnede data: Lister opretholder rækkefølgen af ​​elementer, hvilket gør dem egnede til opgaver, der kræver respekt for rækkefølgen af ​​elementer, såsom behandling af data i den rækkefølge, de blev oprettet, eller når supportindeksering er nødvendig.

Foranderlige data: Lister kan ændres, så du kan tilføje, fjerne eller ændre et specifikt element efter behov. Denne fleksibilitet gør lister velegnede til opgaver, der involverer ændring af indholdet af samlingen, eller når der arbejdes med indlejrede datastrukturer, såsom lister over lister eller ordbøger.

Ikke-unikke elementer: I modsætning til sæt kan lister gemme duplikerede elementer, hvilket gør dem passende til situationer, hvor hyppigheden af ​​elementer har betydning, såsom at tælle forekomster eller opretholde rækkefølgen af ​​duplikerede værdier.

Tjek nedenstående for at vise for at fremme din læring.

APydeevnesammenligning mellem sæt og lister

I dette afsnit vil vi sammenligne ydeevnen af ​​Python-sæt og -lister med hensyn til tidskompleksitet og hukommelsesforbrug, hvilket er essentielt, når man arbejder med store datastrukturer, eller når man optimerer kode for effektivitet.

Tidskompleksitet

Når det kommer til tidskompleksitet, har sæt og lister forskellige styrker og svagheder afhængigt af de operationer, du udfører på grund af deres underliggende 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!