Python-sett vs liste – den virkelige forskjellen

I Python-programmeringens verden vil du ofte møte ulike datastrukturer som tjener ulike formål. Blant disse strukturene er sett og lister ofte brukt til å lagre og manipulere samlinger av data.

Selv om de kan virke like, er det bemerkelsesverdige forskjeller i egenskaper og brukstilfeller.

Innholdsfortegnelse

• Forstå Python-sett og -lister
  • Hva er Python-sett?
  • Hva er Python-lister
• 3 Hovedforskjeller mellom sett og lister
  • 1. Bestilling og indeksering
  • 2. Mulighet
  • Unikt av elementer
  • 3. Støttede operasjoner
• Hvordan velger du riktig datastruktur?
  • Bruksbokser for sett
  • Bruk tilfeller for lister
• APytelsessammenligning mellom sett og lister
  • Tidskompleksitet
  • Minnebruk
• Vanlige operasjoner og metoder
  • Angi metode
  • Listemetode
• Vårt siste ord

Forstå Python-sett og -lister

Ok, så la oss forklare ting først.

Hva er Python-sett?

Et sett er en innebygd datastruktur som representerer en uordnet samling av distinkte elementer, kalt medlemmer.

Dette kraftige verktøyet er spesielt nyttig i datavitenskapelige applikasjoner og matematiske operasjoner.

Python-sett har følgende egenskaper:

1. De er uordnet, noe som betyr at elementer i et sett lagres uavhengig av deres indeks. Denne uordnede samlingen av unike verdier støtter effektive medlemskapstester og faste forståelser.

2. De tillater ikke dupliserte verdier. Dette gjør dem nyttige når du trenger å jobbe med unike verdier, fjerne duplikater fra en liste eller utføre settoperasjoner som fagforeninger, skjæringspunkter og symmetriske forskjeller.

Det er to måter å lage et sett i Python:

1. Ved å bruke krøllete klammeparenteser ({}), også kjent som krøllete parenteser.

2. Ved å bruke den innebygde set()-funksjonen, som tar et enkelt argument, en iterabel som inneholder elementene du vil inkludere i settet.

En generisk syntaks for å lage et Python-sett ved å bruke krøllete klammeparenteser og den innebygde settfunksjonen er gitt nedenfor:

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

Hva er Python-lister

En Python-liste er en innebygd datastruktur som ligner på dynamiske arrays i andre programmeringsspråk.

De brukes til å lagre flere elementer i en enkelt variabel, noe som gjør dem til et allsidig alternativ for å håndtere ulike datatyper, for eksempel strenger, tall og booleaner.

Python-lister har følgende egenskaper:

1. De er ordnet, noe som betyr at et bestemt element har en unik plassering i en liste og kan nås gjennom indeksen. Denne bestilte samlingen støtter tilfeldig tilgang, slik at du kan utføre operasjoner som skjæring, sammenkobling og listeforståelse.

2. De kan endres, og elementene deres kan endres etter å ha opprettet en liste, noe som gir fleksibilitet når du arbeider med datastrukturer.

3. Python-lister tillater dupliserte verdier og kan lagre en blanding av datatyper, inkludert strenger, tall og booleaner.

Det er to

1. Ved å bruke firkantede parenteser, som angir grensene til listen.

2. Ved å bruke den innebygde list()-funksjonen, som kan ta et enkelt argument eller en iterabel som inneholder elementene du vil inkludere i listen.

Følgende Python-kode demonstrerer å lage en Python-liste ved å bruke firkantede parenteser og den innebygde list()-funksjonen:

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

3 Hovedforskjeller mellom sett og lister

De er flere forskjeller mellom et Python-sett og en liste. Noen av de viktige er listet opp nedenfor:

1. Bestilling og indeksering

Rekkefølge og indeksering i liste: En Python-liste kan støtte indeksering, noe som betyr at du kan få tilgang til elementer i en liste ved å bruke deres plassering i listen. Dette gir fleksibilitet når du manipulerer data med en kjent rekkefølge.

Følgende kode viser rekkefølgen og indekseringen av 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-sett: Et Python-sett er en uordnet samling uten indeksering, noe som betyr at du ikke kan få tilgang til elementer ved å bruke deres posisjon. Dette er nyttig når rekkefølgen på elementene ikke spiller noen rolle.

Følgende Python-kode demonstrerer rekkefølge og indekseringssett:

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

Python-liste: En Python-liste kan endres, slik at du kan endre elementene. De kan inneholde alle typer objekter, inkludert nestede lister, og gir dermed mer fleksibilitet når det gjelder innholdet de kan lagre.

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-sett: Akkurat som et i Python, er et Python-sett også mutbart og kan endres. Imidlertid kan sett i Python bare inneholde hashbare (uforanderlige) objekter, noe som betyr at du ikke kan ha et sett med sett eller et sett som inneholder mutbare objekter som lister.

Følgende kode demonstrerer mutabiliteten til Python-sett:

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

Unikt av elementer

Python-sett: En nøkkelfunksjon ved sett er at de bare lagrer unike elementer. Tilføyelse av dupliserte verdier til en liste ignoreres. Dette gjør et settobjekt ideelt for forskjellige settoperasjoner, for eksempel å fjerne duplikater eller sjekke tilstedeværelsen av unike 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 tillater dupliserte verdier og opprettholder rekkefølgen deres, noe som kan være avgjørende i brukstilfeller der duplikater og rekkefølgen på elementer spiller en betydelig 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. Støttede operasjoner

Det er forskjellige operasjoner man kan utføre på sett og lister, hver optimalisert for spesifikke oppgaver:

Python-lister: På grunn av deres ordnede og indeksbaserte natur, støtter lister operasjoner som skjæring, sammenkobling, repetisjon og listeforståelse. De har også innebygde metoder, for eksempel append(), pop() og sort(), som lar deg 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, skjæringspunkt, forskjell og kontroll av medlemskap ved å bruke hash-funksjoner for å finne elementer raskt. Siden de er uordnet og mangler indeksering, skiller settoperasjoner seg fra listebaserte.

# 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 velger du riktig datastruktur?

Når du arbeider med Python, er det viktig å velge den best egnede datastrukturen for din spesifikke oppgave. I denne delen vil vi diskutere de beste scenariene for bruk av sett og lister, sammen med deres unike fordeler.

La oss komme inn i det.

Bruksbokser for sett

Sett tilbyr flere fordeler som gjør dem til det ideelle valget for visse oppgaver:

Unikhet: Hvis du trenger å lagre en samling unike elementer, er sett veien å gå. Sett eliminerer automatisk duplikater, og sikrer at hvert element i settet er distinkt.

Medlemskapstester: Sett gir raskere medlemskapstester sammenlignet med lister. På grunn av deres underliggende hashtabellimplementering og bruken av hashfunksjoner, tillater sett svært effektive oppslag basert på hashverdier.

Sett operasjoner: Angir støtteoperasjoner som union, skjæringspunkt, forskjell og symmetrisk forskjell som kan være nyttige i mange algoritmer, databehandlingsoppgaver og datavitenskapsapplikasjoner.

Bruk tilfeller for lister

Lister er bedre egnet for følgende scenarier:

Ordnede data: Lister opprettholder rekkefølgen på elementene, noe som gjør dem egnet for oppgaver som krever respekt for rekkefølgen av elementer, for eksempel å behandle data i den rekkefølgen de ble opprettet eller når støtteindeksering er nødvendig.

Mulig data: Lister kan endres, slik at du kan legge til, fjerne eller endre et spesifikt element etter behov. Denne fleksibiliteten gjør lister egnet for oppgaver som innebærer endring av innholdet i samlingen eller når du arbeider med nestede datastrukturer, for eksempel lister med lister eller ordbøker.

Ikke-unike elementer: I motsetning til sett, kan lister lagre dupliserte elementer, noe som gjør dem passende for situasjoner der hyppigheten av elementer har betydning, for eksempel å telle forekomster eller opprettholde rekkefølgen på dupliserte verdier.

Sjekk ut nedenfor for å vise for å fremme læringen din.

APytelsessammenligning mellom sett og lister

I denne delen vil vi sammenligne ytelsen til Python-sett og -lister når det gjelder tidskompleksitet og minnebruk, noe som er essensielt når du arbeider med store datastrukturer eller når du optimerer kode for effektivitet.

Tidskompleksitet

Når det gjelder tidskompleksitet, har sett og lister forskjellige styrker og svakheter avhengig av operasjonene du utfører på grunn av deres underliggende implementering.

1. Søking: Sett bruker hash-oppslag og hash-funksjoner, noe som gjør søk etter et element betydelig raskere sammenlignet med lister. For eksempel tar det å søke gjennom 100 000 elementer 49,663 sekunder med en liste, men bare 0,007 sekunder med et sett, da det utnytter hash-verdien for rask tilgang.

2. Iterasjon: Lister er litt raskere enn sett når det gjelder å iterere over elementene. Dette er fordi sett krever ekstra operasjoner for å sikre unikhet, mens lister opprettholder en enkel ordnet samling med direkte indeksering.

Minnebruk

Sett bruker vanligvis mer minne enn lister fordi de trenger å vedlikeholde en hash-tabell for å sikre unike elementer, noe som kommer på bekostning av økt minneforbruk.

Lister lagrer bare elementene sekvensielt, noe som fører til lavere minneforbruk, noe som gjør dem til et mer minneeffektivt valg når du håndterer store datasamlinger.

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

Den medfølgende koden viser ytelsessammenligningen mellom Python-sett og -lister når det gjelder tidskompleksitet for søk og iterasjon.

Den genererer en stor liste og sett med tilfeldige heltall, omgitt av krøllete parenteser (også kalt krøllete klammeparenteser).

Den måler deretter tiden det tar å søke etter et spesifikt element, ved å bruke et enkelt argument i både listen og settet, og måler tiden det tar å iterere gjennom alle elementene i listen og settet.

Utdataene illustrerer ytelsesforskjellene mellom Python-lister og sett for søk og iterasjon, som stammer fra deres underliggende implementering.

Søkeoperasjonen er raskere i sett (0,000000 sekunder) enn i lister (0,002999 sekunder) på grunn av bruken av hash-funksjoner for å beregne hash-verdier for effektive oppslag. Men å iterere over en liste (0,007995 sekunder) er litt raskere enn å iterere over et sett (0,017989 sekunder) siden sett krever ekstra operasjoner for å sikre unikhet.

Vanlige operasjoner og metoder

Både sett og lister i Python har ulike operasjoner og metoder, hver optimalisert for spesifikke oppgaver og datamanipulering. Noen av disse metodene er listet opp nedenfor:

Angi metode

Settmetoder utfører operasjoner som ligner på matematiske operasjoner og er kraftige verktøy for å håndtere unike verdier i en samling.

• add(element): Legger til et element til settet hvis det ikke allerede er til stede.

• remove(element): Fjerner det angitte elementet fra settet; oppstår en feil hvis elementet ikke blir funnet.

• discard(element): Fjerner det angitte elementet fra settet hvis det er tilstede. Ingen feil oppstår hvis elementet ikke blir funnet.

• union(sett2): Returnerer et nytt sett som inneholder alle elementer fra det originale settet og sett2, og utfører effektivt en settoperasjon.

• skjæringspunkt(sett2): Returnerer et nytt sett som inneholder elementer som er felles for både det opprinnelige settet og sett2.

• forskjell(sett2): Returnerer et nytt sett som inneholder elementer i det opprinnelige settet, men ikke i sett2.

• symmetrisk_forskjell(sett2): Returnerer et nytt sett som inneholder elementer i enten det opprinnelige settet eller sett2, men ikke i begge.

Listemetode

Listemetoder gir ulike måter å manipulere data på.

• append(element): Legger til et element på slutten av listen.

• extend(iterable): Legger til alle elementer fra den iterable (f.eks. en annen liste) til slutten av listen.

• insert(index, element): Setter inn et element ved den angitte indeksen.

• remove(element): Fjerner den første forekomsten av det angitte elementet i listen; gir en feil hvis elementet ikke er tilstede.

• pop(indeks): Fjerner og returnerer elementet ved den angitte indeksen. Hvis ingen indeks er gitt, fjerner det det siste elementet.

• indeks(element): Returnerer indeksen for den første forekomsten av det angitte elementet i listen.

• count(element): Returnerer antall forekomster av det angitte elementet i listen.

• sort(): Sorterer listen i stigende rekkefølge som standard; for synkende rekkefølge, bruk reverse=True-parameteren.

• reverse(): Reverserer rekkefølgen på elementene i listen.

Ved å bruke disse Python-sett- og listemetodene kan du effektivt manipulere dataene dine og løse ulike problemer i Python-programmering, datavitenskap og andre applikasjoner.

Vårt siste ord

Når du velger mellom Python-lister og -sett for datastrukturen din, bør du vurdere å bruke lister når du trenger en ordnet samling av elementer, ønsker å bevare dupliserte elementer og krever muligheten til å få tilgang til elementer etter indeks.

Velg sett når elementenes unike er avgjørende, rekkefølgen på elementene ikke er viktig, og raskere medlemskapstesting foretrekkes. Mens lister utmerker seg i iterasjon, gir sett mer effektive inneslutningskontroller.

Valget ditt avhenger til syvende og sist av prosjektets krav, siden hver datastruktur tilbyr sine egne fordeler og begrensninger, noe som gjør dem til kraftige verktøy for å takle ulike oppgaver i Python-programmering. Nyt!