Set Python Vs Senarai – Perbezaan Sebenar

Dalam dunia pengaturcaraan Python, anda akan sering menghadapi pelbagai struktur data yang mempunyai tujuan yang berbeza. Antara struktur, set dan senarai ini biasanya digunakan untuk menyimpan dan memanipulasi koleksi data.

Walaupun ia mungkin kelihatan serupa, terdapat perbezaan ketara dalam sifat dan kes penggunaannya.

Isi kandungan

• Memahami Set dan Senarai Python
  • Apakah Set Python?
  • Apakah Senarai Python
• 3 Perbezaan Utama Antara Set dan Senarai
  • 1. Pesanan dan Pengindeksan
  • 2. Kebolehubahan
  • Keunikan Unsur
  • 3. Operasi yang Disokong
• Bagaimana Anda Memilih Struktur Data yang Betul?
  • Gunakan Kes untuk Set
  • Gunakan Kes untuk Senarai
• APerbandingan Prestasi Antara Set dan Senarai
  • Kerumitan Masa
  • Penggunaan memori
• Operasi dan Kaedah Biasa
  • Tetapkan Kaedah
  • Kaedah Senarai
• Kata Akhir Kami

Memahami Set dan Senarai Python

Ok, jadi mari kita jelaskan perkara dahulu.

Apakah Set Python?

Set Python ialah struktur data terbina dalam yang mewakili koleksi elemen yang berbeza yang tidak tertib, dipanggil ahli.

Alat berkuasa ini amat berguna dalam aplikasi sains data dan operasi matematik.

Set Python mempunyai sifat berikut:

1. Mereka tidak tertib, yang bermaksud bahawa elemen dalam set disimpan secara bebas daripada indeksnya. Koleksi nilai unik yang tidak tersusun ini menyokong ujian keahlian yang cekap dan set pemahaman.

2. Mereka tidak membenarkan nilai pendua. Ini menjadikannya berguna apabila anda perlu bekerja dengan nilai unik, mengalih keluar pendua daripada senarai atau melaksanakan operasi set seperti kesatuan, persimpangan dan perbezaan simetri.

Terdapat dua cara untuk membuat set dalam Python:

1. Dengan menggunakan kurungan kerinting ({}), juga dikenali sebagai kurungan kerinting.

2. Dengan menggunakan fungsi set() terbina dalam, yang mengambil satu hujah, lelaran yang mengandungi elemen yang anda ingin sertakan dalam set.

Sintaks generik untuk mencipta set Python menggunakan pendakap kerinting dan fungsi set terbina dalam diberikan di bawah:

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

Apakah Senarai Python

Senarai Python ialah struktur data terbina dalam yang serupa dengan tatasusunan dinamik dalam bahasa pengaturcaraan lain.

Ia digunakan untuk menyimpan berbilang item dalam satu pembolehubah, menjadikannya pilihan serba boleh untuk mengendalikan pelbagai jenis data, seperti rentetan, nombor dan boolean.

Senarai Python mempunyai sifat berikut:

1. Mereka dipesan, yang bermaksud bahawa elemen tertentu mempunyai kedudukan unik dalam senarai dan boleh diakses melalui indeksnya. Koleksi tersusun ini menyokong akses rawak, membolehkan anda melakukan operasi seperti penghirisan, penggabungan dan pemahaman senarai.

2. Ia boleh ubah, dan elemennya boleh ditukar selepas membuat senarai, menawarkan fleksibiliti apabila bekerja dengan struktur data.

3. Senarai Python membenarkan nilai pendua dan boleh menyimpan campuran jenis data, termasuk rentetan, nombor dan boolean.

Terdapat dua cara untuk membuat senarai dalam Python:

1. Dengan menggunakan kurungan segi empat sama, yang menunjukkan sempadan senarai.

2. Dengan menggunakan fungsi list() terbina dalam, yang boleh mengambil satu hujah atau lelaran yang mengandungi elemen yang anda ingin masukkan dalam senarai.

Kod Python berikut menunjukkan mencipta senarai Python menggunakan kurungan segi empat sama dan fungsi list() terbina dalam:

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

3 Perbezaan Utama Antara Set dan Senarai

Mereka adalah pelbagai perbezaan antara set Python dan senarai. Beberapa yang penting disenaraikan di bawah:

1. Pesanan dan Pengindeksan

Pesanan dan Pengindeksan dalam Senarai Python : Senarai Python boleh menyokong pengindeksan, bermakna anda boleh mengakses elemen dalam senarai menggunakan kedudukan mereka dalam senarai. Ini memberikan fleksibiliti apabila memanipulasi data dengan susunan yang diketahui.

Kod Python berikut menunjukkan susunan dan pengindeksan senarai:

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

Set Python: Set Python ialah koleksi tidak tertib tanpa pengindeksan, yang bermaksud anda tidak boleh mengakses elemen menggunakan kedudukannya. Ini berguna apabila susunan unsur tidak penting.

Kod Python berikut menunjukkan susunan dan set pengindeksan:

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

Senarai Python: Senarai Python boleh berubah, membolehkan anda mengubah suai elemennya. Mereka boleh memegang sebarang jenis objek, termasuk senarai bersarang, dengan itu menawarkan lebih fleksibiliti dari segi kandungan yang boleh mereka simpan.

Kod berikut menunjukkan kebolehubahan dalam senarai Python:

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

Set Python: Sama seperti senarai dalam Python, set Python juga boleh berubah dan boleh diubah suai. Walau bagaimanapun, set dalam Python hanya boleh menyimpan objek boleh hash (tidak boleh diubah), bermakna anda tidak boleh mempunyai set set atau set yang mengandungi objek boleh ubah seperti senarai.

Kod berikut menunjukkan kebolehubahan set Python:

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

Keunikan Unsur

Set Python: Ciri utama set ialah ia hanya menyimpan elemen unik. Penambahan nilai pendua pada senarai diabaikan. Ini menjadikan objek set sesuai untuk operasi set yang berbeza, seperti mengalih keluar pendua atau menyemak kehadiran elemen unik.

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

• 

  Senarai Python: Senarai membenarkan nilai pendua dan mengekalkan susunannya, yang boleh menjadi penting dalam kes penggunaan di mana pendua dan susunan elemen memainkan peranan penting.

  # 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. Operasi yang Disokong

Terdapat operasi berbeza yang boleh dilakukan pada set dan senarai, setiap satu dioptimumkan untuk tugasan tertentu:

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. Lelaran: Senarai adalah lebih pantas sedikit daripada set apabila ia melibatkan lelaran ke atas item. Ini kerana set memerlukan operasi tambahan untuk memastikan keunikan, manakala senarai mengekalkan koleksi tertib mudah dengan pengindeksan langsung.

Penggunaan memori

Set biasanya menggunakan lebih banyak memori daripada senarai kerana mereka perlu mengekalkan jadual cincang untuk memastikan keunikan item, yang datang dengan kos peningkatan penggunaan memori.

Senarai hanya menyimpan elemen secara berurutan, membawa kepada penggunaan memori yang lebih rendah, menjadikannya pilihan yang lebih cekap memori apabila mengendalikan koleksi data yang besar.

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

Kod yang disediakan mempamerkan perbandingan prestasi antara set dan senarai Python dari segi kerumitan masa untuk carian dan lelaran.

Ia menjana senarai besar dan set integer rawak, disertakan dengan kurungan kerinting (juga dipanggil pendakap kerinting).

Ia kemudian mengukur masa yang diambil untuk mencari item tertentu, menggunakan satu hujah dalam kedua-dua senarai dan set, dan mengukur masa yang diambil untuk lelaran melalui semua elemen dalam senarai dan set.

Output menggambarkan perbezaan prestasi antara senarai Python dan set untuk carian dan lelaran, yang berpunca daripada pelaksanaan asasnya.

Operasi carian lebih pantas dalam set (0.000000 saat) berbanding dalam senarai (0.002999 saat) disebabkan penggunaan fungsi cincang untuk mengira nilai cincang untuk carian yang cekap. Walau bagaimanapun, lelaran ke atas senarai (0.007995 saat) adalah lebih pantas sedikit daripada lelaran ke atas set (0.017989 saat) memandangkan set memerlukan operasi tambahan untuk memastikan keunikan.

Operasi dan Kaedah Biasa

Kedua-dua set dan senarai dalam Python mempunyai pelbagai operasi dan kaedah, masing-masing dioptimumkan untuk tugas tertentu dan manipulasi data. Beberapa kaedah ini disenaraikan di bawah:

Tetapkan Kaedah

Kaedah tetapkan melaksanakan operasi yang serupa dengan operasi matematik dan merupakan alat yang berkuasa untuk mengendalikan nilai unik dalam koleksi.

• add(element): Menambah elemen pada set jika ia belum ada.

• remove(element): Mengeluarkan elemen yang ditentukan daripada set; menimbulkan ralat jika elemen tidak ditemui.

• buang(elemen): Mengeluarkan elemen yang ditentukan daripada set jika ia ada. Tiada ralat dibangkitkan jika elemen tidak ditemui.

• union(set2): Mengembalikan set baharu yang mengandungi semua elemen daripada set asal dan set2, dengan berkesan melaksanakan operasi set.

• intersection(set2): Mengembalikan set baharu yang mengandungi elemen biasa kepada set asal dan set2.

• perbezaan(set2): Mengembalikan set baharu yang mengandungi elemen dalam set asal tetapi bukan dalam set2.

• symmetric_difference(set2): Mengembalikan set baharu yang mengandungi elemen sama ada dalam set asal atau set2, tetapi tidak dalam kedua-duanya.

Kaedah Senarai

Kaedah senarai menyediakan pelbagai cara untuk memanipulasi data.

• append(element): Menambah elemen pada penghujung senarai.

• extend(iterable): Menambah semua elemen daripada iterable (cth, senarai lain) ke penghujung senarai.

• insert(index, element): Memasukkan elemen pada indeks yang ditentukan.

• remove(element): Mengeluarkan kejadian pertama bagi elemen yang ditentukan dalam senarai; menimbulkan ralat jika elemen tidak hadir.

• pop(index): Mengalih keluar dan mengembalikan elemen pada indeks yang ditentukan. Jika tiada indeks diberikan, ia mengalih keluar elemen terakhir.

• indeks(elemen): Mengembalikan indeks kejadian pertama elemen yang ditentukan dalam senarai.

• count(element): Mengembalikan bilangan kejadian unsur yang ditentukan dalam senarai.

• sort(): Mengisih senarai dalam tertib menaik secara lalai; untuk tertib menurun, gunakan parameter reverse=True.

• reverse(): Membalikkan susunan elemen dalam senarai.

Dengan menggunakan kaedah set dan senarai Python ini, anda boleh memanipulasi data anda dengan berkesan dan menyelesaikan pelbagai masalah dalam pengaturcaraan Python, sains data dan aplikasi lain.

Kata Akhir Kami

Apabila memilih antara senarai dan set Python untuk struktur data anda, pertimbangkan untuk menggunakan senarai apabila anda memerlukan koleksi item yang dipesan, ingin mengekalkan elemen pendua dan memerlukan keupayaan untuk mengakses elemen mengikut indeks.

Pilih set apabila keunikan elemen adalah penting, susunan elemen tidak penting dan ujian keahlian yang lebih pantas diutamakan. Walaupun senarai cemerlang dalam lelaran, set menyediakan pemeriksaan pembendungan yang lebih cekap.

Pilihan anda akhirnya bergantung pada keperluan projek anda, kerana setiap struktur data menawarkan set manfaat dan batasannya sendiri, menjadikannya alat yang berkuasa untuk menangani pelbagai tugas dalam pengaturcaraan Python. Nikmati!