Python Set Vs List – todellinen ero

Python-ohjelmoinnin maailmassa kohtaat usein erilaisia ​​tietorakenteita, jotka palvelevat eri tarkoituksia. Näistä rakenteista, joukkoja ja listoja käytetään yleisesti tietokokoelmien tallentamiseen ja käsittelyyn.

Vaikka ne saattavat näyttää samanlaisilta, niiden ominaisuuksissa ja käyttötapauksissa on huomattavia eroja.

Sisällysluettelo

• Python-joukkojen ja -luetteloiden ymmärtäminen
  • Mitä Python-sarjat ovat?
  • Mitä ovat Python-listat
• 3 keskeistä eroa sarjojen ja luetteloiden välillä
  • 1. Järjestys ja indeksointi
  • 2. Muuttuvuus
  • Elementtien ainutlaatuisuus
  • 3. Tuetut toiminnot
• Kuinka valitset oikean tietorakenteen?
  • Käytä koteloita sarjoille
  • Käytä tapauksia luetteloihin
• Ajoukkojen ja luetteloiden suorituskyvyn vertailu
  • Aika monimutkaisuus
  • Muistin käyttö
• Yleiset toiminnot ja menetelmät
  • Aseta menetelmä
  • Luettelomenetelmä
• Viimeinen sanamme

Python-joukkojen ja -luetteloiden ymmärtäminen

Ok, selitetään asiat ensin.

Mitä Python-sarjat ovat?

Joukko on sisäänrakennettu tietorakenne, joka edustaa erillisten elementtien, joita kutsutaan jäseniksi, järjestämätöntä kokoelmaa.

Tämä tehokas työkalu on erityisen hyödyllinen datatieteen sovelluksissa ja matemaattisissa operaatioissa.

Python-sarjoilla on seuraavat ominaisuudet:

1. Ne ovat järjestämättömiä, mikä tarkoittaa, että joukon elementit tallennetaan niiden indeksistä riippumatta. Tämä ainutlaatuisten arvojen järjestämätön kokoelma tukee tehokkaita jäsentestauksia ja joukon ymmärtämistä.

2. Ne eivät salli päällekkäisiä arvoja. Tämä tekee niistä hyödyllisiä, kun haluat työskennellä yksilöllisten arvojen kanssa, poistaa kaksoiskappaleita luettelosta tai suorittaa joukkooperaatioita, kuten liitoksia, risteyksiä ja symmetrisiä eroja.

Pythonissa on kaksi tapaa luoda joukko:

1. Käyttämällä kiharahakasulkeita ({}), jotka tunnetaan myös nimellä kiharat hakasulkeet.

2. Käyttämällä sisäänrakennettua set()-funktiota, joka ottaa yhden argumentin, iterablen, joka sisältää elementit, jotka haluat sisällyttää joukkoon.

Alla on yleinen syntaksi Python-joukon luomiseksi kihara aaltosulkeiden ja sisäänrakennetun joukkotoiminnon avulla:

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

Mitä ovat Python-listat

Python-lista on sisäänrakennettu tietorakenne, joka muistuttaa muiden ohjelmointikielten dynaamisia taulukoita.

Niitä käytetään useiden kohteiden tallentamiseen yhteen muuttujaan, mikä tekee niistä monipuolisen vaihtoehdon erilaisten tietotyyppien, kuten merkkijonojen, numeroiden ja boolean-arvojen, käsittelyyn.

Python-listoilla on seuraavat ominaisuudet:

1. Ne ovat järjestettyjä, mikä tarkoittaa, että tietyllä elementillä on ainutlaatuinen sijainti luettelossa ja siihen pääsee käsiksi sen indeksin kautta. Tämä järjestetty kokoelma tukee satunnaiskäyttöä, jonka avulla voit suorittaa toimintoja, kuten viipalointia, ketjuttamista ja luettelon ymmärtämistä.

2. Ne ovat muunnettavissa, ja niiden elementtejä voidaan muuttaa luettelon luomisen jälkeen, mikä tarjoaa joustavuutta tietorakenteiden käsittelyssä.

3. Python-luettelot sallivat päällekkäiset arvot ja voivat tallentaa yhdistelmän tietotyyppejä, kuten merkkijonoja, numeroita ja booleaneja.

On kaksi

1. Hakasulkeilla, jotka osoittavat luettelon rajoja.

2. Käyttämällä sisäänrakennettua list()-funktiota, joka voi ottaa yhden argumentin tai iterablen, joka sisältää elementit, jotka haluat sisällyttää luetteloon.

Seuraava Python-koodi näyttää Python-luettelon luomisen hakasulkeilla ja sisäänrakennetulla list()-funktiolla:

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

3 keskeistä eroa sarjojen ja luetteloiden välillä

Ne ovat useita eroja Python-joukon ja luettelon välillä. Jotkut tärkeimmistä on lueteltu alla:

1. Järjestys ja indeksointi

Järjestys ja indeksointi luettelossa: Python-lista voi tukea indeksointia, mikä tarkoittaa, että voit käyttää luettelon elementtejä käyttämällä niiden sijaintia luettelossa. Tämä tarjoaa joustavuutta käsiteltäessä tietoja tunnetulla järjestyksellä.

Seuraava koodi näyttää luetteloiden järjestyksen ja indeksoinnin:

# 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-joukot: Python-joukko on järjestämätön kokoelma, jossa ei ole indeksointia, mikä tarkoittaa, että et voi käyttää elementtejä käyttämällä niiden sijaintia. Tämä on hyödyllistä, kun elementtien järjestyksellä ei ole väliä.

Seuraava Python-koodi näyttää järjestyksen ja indeksointijoukot:

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

Python-lista: Python-luettelo on muunnettavissa, joten voit muokata sen elementtejä. Ne voivat sisältää kaikentyyppisiä objekteja, mukaan lukien sisäkkäisiä luetteloita, mikä tarjoaa enemmän joustavuutta tallennettavan sisällön suhteen.

Seuraava koodi osoittaa muuttuvuuden Python-luetteloissa:

# 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-joukko: Kuten Pythonissa, myös Python-joukko on muuttuva ja sitä voidaan muokata. Pythonin joukot voivat kuitenkin sisältää vain hajautuskelpoisia (muuttumattomia) objekteja, mikä tarkoittaa, että sinulla ei voi olla joukkoa tai joukkoa, joka sisältää muuttuvia objekteja, kuten luetteloita.

Seuraava koodi osoittaa Python-joukkojen muuttuvuuden:

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

Elementtien ainutlaatuisuus

Python-joukot: Joukkojen keskeinen ominaisuus on, että ne tallentavat vain ainutlaatuisia elementtejä. Päällekkäisten arvojen lisääminen luetteloon ohitetaan. Tämä tekee sarjaobjektista ihanteellisen erilaisiin joukkotoimintoihin, kuten kaksoiskappaleiden poistamiseen tai ainutlaatuisten elementtien olemassaolon tarkistamiseen.

# 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-listat: Listat sallivat arvojen kaksoiskappaleet ja säilyttävät niiden järjestyksen, mikä voi olla välttämätöntä käyttötapauksissa, joissa kaksoiskappaleilla ja elementtien järjestyksellä on merkittävä rooli.

  # 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. Tuetut toiminnot

Joukoille ja listoille voidaan suorittaa erilaisia ​​toimintoja, joista jokainen on optimoitu tiettyihin tehtäviin:

Python-listat: Järjestetyn ja hakemistopohjaisen luonteensa vuoksi luettelot tukevat toimintoja, kuten viipalointia, ketjuttamista, toistoa ja luettelon ymmärtämistä. Ne tarjoavat myös sisäänrakennettuja menetelmiä, kuten append(), pop() ja sort(), joiden avulla voit käsitellä luettelon osia.

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

kuten liitto, risteys, ero ja jäsenyyden tarkistaminen hash-funktioiden avulla elementtien löytämiseksi nopeasti. Koska ne ovat järjestämättömiä ja niistä puuttuu indeksointi, joukkooperaatiot eroavat luettelopohjaisista.

# 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

Kuinka valitset oikean tietorakenteen?

Pythonin kanssa työskennellessä on tärkeää valita tehtävääsi varten sopivin tietorakenne. Tässä osiossa käsittelemme parhaita skenaarioita joukkojen ja luetteloiden käyttämiseen sekä niiden ainutlaatuisia etuja.

Mennään asiaan.

Käytä koteloita sarjoille

Sarjat tarjoavat useita etuja, jotka tekevät niistä ihanteellisen valinnan tiettyihin tehtäviin:

Ainutlaatuisuus: Jos sinun on tallennettava kokoelma ainutlaatuisia elementtejä, sarjat ovat oikea tapa. Sarjat poistavat automaattisesti kaksoiskappaleet varmistaen, että jokainen joukon elementti on erillinen.

Jäsenyystestit: Sarjat tarjoavat nopeammat jäsenyystestit luetteloihin verrattuna. Taustalla olevan hash-taulukon toteutuksen ja hash-funktioiden käytön ansiosta joukot mahdollistavat erittäin tehokkaat haut hajautusarvojen perusteella.

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: 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!