Python Set Vs List – ความแตกต่างที่แท้จริง

ในโลกของการเขียนโปรแกรมด้วย Python คุณมักจะพบกับโครงสร้างข้อมูลต่างๆ ที่ให้บริการตามวัตถุประสงค์ที่แตกต่างกัน ในบรรดาโครงสร้าง ชุด และรายการเหล่านี้มักใช้ในการจัดเก็บและจัดการกับชุดข้อมูล

แม้ว่าอาจดูคล้ายกัน แต่ก็มีความแตกต่างกันอย่างเห็นได้ชัดในคุณสมบัติและกรณีการใช้งาน

สารบัญ

• ทำความเข้าใจกับชุดและรายการของ Python
  • ชุด Python คืออะไร?
  • รายการ Python คืออะไร
• 3 ความแตกต่างที่สำคัญระหว่างชุดและรายการ
  • 1. การสั่งซื้อและการจัดทำดัชนี
  • 2. ความไม่แน่นอน
  • ความเป็นเอกลักษณ์ขององค์ประกอบ
  • 3. การดำเนินการที่รองรับ
• คุณจะเลือกโครงสร้างข้อมูลที่เหมาะสมได้อย่างไร?
  • ใช้กรณีสำหรับชุด
  • ใช้กรณีสำหรับรายการ
• การเปรียบเทียบประสิทธิภาพระหว่างชุดและรายการ
  • ความซับซ้อนของเวลา
  • การใช้ความจำ
• การดำเนินการและวิธีการทั่วไป
  • วิธีการตั้งค่า
  • วิธีการรายการ
• คำพูดสุดท้ายของเรา

ทำความเข้าใจกับชุดและรายการของ Python

โอเค เรามาอธิบายกันก่อนดีกว่า

ชุด Python คืออะไร?

ชุดPythonเป็นโครงสร้างข้อมูลในตัวที่แสดงถึงคอลเลกชันที่ไม่มีลำดับขององค์ประกอบที่แตกต่างกัน ซึ่งเรียกว่าสมาชิก

เครื่องมืออันทรงพลังนี้มีประโยชน์อย่างยิ่งในการใช้งานด้านวิทยาศาสตร์ข้อมูลและการดำเนินการทางคณิตศาสตร์

ชุด Python มีคุณสมบัติดังต่อไปนี้:

1. ไม่มีการเรียงลำดับ ซึ่งหมายความว่าองค์ประกอบในชุดจะถูกจัดเก็บโดยไม่ขึ้นกับดัชนี ชุดค่าที่ไม่ซ้ำกันแบบไม่เรียงลำดับนี้สนับสนุนการทดสอบการเป็นสมาชิกที่มีประสิทธิภาพและตั้งค่าความเข้าใจ

2. พวกเขาไม่อนุญาตให้ใช้ค่าที่ซ้ำกัน สิ่งนี้ทำให้มีประโยชน์เมื่อคุณต้องการทำงานกับค่าที่ไม่ซ้ำกัน ลบรายการที่ซ้ำกันออกจากรายการ หรือดำเนินการชุด เช่น ยูเนียน ทางแยก และผลต่างสมมาตร

มีสองวิธีในการสร้างชุดใน Python:

1. โดยใช้วงเล็บปีกกา ({}) หรือที่เรียกว่าวงเล็บปีกกา

2. โดยใช้ฟังก์ชัน set() ในตัว ซึ่งใช้อาร์กิวเมนต์เดียว วนซ้ำได้ซึ่งมีองค์ประกอบที่คุณต้องการรวมไว้ในชุด

ไวยากรณ์ทั่วไปสำหรับการสร้างชุด Python โดยใช้วงเล็บปีกกาและฟังก์ชันชุดในตัวมีดังต่อไปนี้:

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

รายการ Python คืออะไร

รายการ Python เป็นโครงสร้างข้อมูลในตัวที่คล้ายกับไดนามิกอาร์เรย์ในภาษาการเขียนโปรแกรมอื่นๆ

ใช้เพื่อจัดเก็บหลายรายการในตัวแปรเดียว ทำให้เป็นตัวเลือกที่หลากหลายสำหรับการจัดการประเภทข้อมูลต่างๆ เช่น สตริง ตัวเลข และบูลีน

Python Lists มีคุณสมบัติดังต่อไปนี้:

1. มีการเรียงลำดับ ซึ่งหมายความว่าองค์ประกอบเฉพาะมีตำแหน่งเฉพาะในรายการและสามารถเข้าถึงได้ผ่านดัชนี คอลเลกชันที่สั่งนี้รองรับการเข้าถึงแบบสุ่ม ช่วยให้คุณสามารถดำเนินการต่างๆ เช่น การแบ่งส่วน การต่อข้อมูล และการทำความเข้าใจรายการ

2. พวกมันไม่แน่นอนและสามารถเปลี่ยนแปลงองค์ประกอบได้หลังจากสร้างรายการ ทำให้มีความยืดหยุ่นเมื่อทำงานกับโครงสร้างข้อมูล

3. รายการ Python อนุญาตค่าที่ซ้ำกันและสามารถจัดเก็บประเภทข้อมูลผสมกัน รวมถึงสตริง ตัวเลข และบูลีน

มีสองวิธีในการสร้างรายการใน Python:

1. โดยใช้วงเล็บเหลี่ยมซึ่งแสดงถึงขอบเขตของรายการ

2. โดยใช้ฟังก์ชัน list() ในตัว ซึ่งสามารถรับอาร์กิวเมนต์เดียวหรือวนซ้ำได้ซึ่งมีองค์ประกอบที่คุณต้องการรวมไว้ในรายการ

รหัส Python ต่อไปนี้สาธิตการสร้างรายการ Python โดยใช้วงเล็บเหลี่ยมและฟังก์ชัน list() ในตัว:

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

3 ความแตกต่างที่สำคัญระหว่างชุดและรายการ

มีความแตกต่างหลายประการระหว่างชุด Python และรายการ สิ่งสำคัญบางส่วนมีการระบุไว้ด้านล่าง:

1. การสั่งซื้อและการจัดทำดัชนี

ลำดับและการสร้างดัชนีใน รายการ Python :รายการ Python สามารถรองรับการสร้างดัชนีได้ ซึ่งหมายความว่าคุณสามารถเข้าถึงองค์ประกอบในรายการโดยใช้ตำแหน่งในรายการ สิ่งนี้ให้ความยืดหยุ่นเมื่อจัดการข้อมูลด้วยคำสั่งที่ทราบ

รหัส Pythonต่อไปนี้แสดงลำดับและการจัดทำดัชนีรายการ:

# 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:ชุด Python เป็นคอลเลกชันที่ไม่เรียงลำดับโดยไม่มีการจัดทำดัชนี ซึ่งหมายความว่าคุณไม่สามารถเข้าถึงองค์ประกอบโดยใช้ตำแหน่งได้ สิ่งนี้มีประโยชน์เมื่อลำดับขององค์ประกอบไม่สำคัญ

รหัส Python ต่อไปนี้แสดงให้เห็นถึงชุดคำสั่งและการสร้างดัชนี:

# 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. ความไม่แน่นอน

รายการ Python:รายการ Python ไม่สามารถเปลี่ยนแปลงได้ ทำให้คุณสามารถปรับเปลี่ยนองค์ประกอบของรายการได้ พวกเขาสามารถเก็บวัตถุประเภทใดก็ได้ รวมถึงรายการที่ซ้อนกัน ดังนั้นจึงมีความยืดหยุ่นมากขึ้นในแง่ของเนื้อหาที่สามารถจัดเก็บได้

รหัสต่อไปนี้แสดงให้เห็นถึงความไม่แน่นอนในรายการ 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]

ชุด Python:เช่นเดียวกับรายการใน Python ชุด Python นั้นไม่แน่นอนและสามารถแก้ไขได้ อย่างไรก็ตาม เซ็ตใน Python สามารถเก็บได้เฉพาะอ็อบเจกต์แฮช (ไม่เปลี่ยนรูป) ซึ่งหมายความว่าคุณไม่สามารถมีเซ็ตของเซ็ตหรือเซ็ตที่มีอ็อบเจกต์ที่เปลี่ยนแปลงไม่ได้อย่างเช่นลิสต์

รหัสต่อไปนี้แสดงให้เห็นถึงความไม่แน่นอนของชุด 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]}

ความเป็นเอกลักษณ์ขององค์ประกอบ

ชุด Python:คุณสมบัติหลักของชุดคือเก็บเฉพาะองค์ประกอบที่ไม่ซ้ำใคร การเพิ่มค่าที่ซ้ำกันในรายการจะถูกละเว้น สิ่งนี้ทำให้วัตถุชุดเหมาะสำหรับการดำเนินการชุดต่างๆ เช่น การลบรายการที่ซ้ำกันหรือการตรวจสอบการมีอยู่ขององค์ประกอบที่ไม่ซ้ำกัน

# 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:รายการอนุญาตให้มีค่าซ้ำกันและคงลำดับไว้ ซึ่งจำเป็นในกรณีการใช้งานที่รายการซ้ำและลำดับขององค์ประกอบมีบทบาทสำคัญ

  # 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. การดำเนินการที่รองรับ

มีการดำเนินการที่แตกต่างกันที่สามารถทำได้ในชุดและรายการ ซึ่งแต่ละรายการได้รับการปรับให้เหมาะกับงานเฉพาะ:

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. การวนซ้ำ:รายการจะเร็วกว่าชุดเล็กน้อยเมื่อพูดถึงการวนซ้ำรายการต่างๆ นี่เป็นเพราะชุดต้องการการดำเนินการเพิ่มเติมเพื่อให้แน่ใจว่าไม่ซ้ำกัน ในขณะที่รายการจะรักษาคอลเลกชันที่สั่งอย่างง่ายด้วยการสร้างดัชนีโดยตรง

การใช้ความจำ

โดยทั่วไปแล้วชุดจะใช้หน่วยความจำมากกว่ารายการเนื่องจากจำเป็นต้องรักษาตารางแฮชเพื่อให้แน่ใจว่ารายการไม่ซ้ำกัน ซึ่งมาพร้อมกับต้นทุนของการใช้หน่วยความจำที่เพิ่มขึ้น

รายการจะจัดเก็บองค์ประกอบตามลำดับเท่านั้น ซึ่งนำไปสู่การใช้หน่วยความจำที่ลดลง ทำให้เป็นทางเลือกที่มีประสิทธิภาพของหน่วยความจำมากขึ้นเมื่อต้องจัดการกับชุดข้อมูลขนาดใหญ่

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

รหัสที่ให้มาแสดงการเปรียบเทียบประสิทธิภาพระหว่างชุด Python และรายการในแง่ของความซับซ้อนของเวลาสำหรับการค้นหาและการวนซ้ำ

มันสร้างรายการขนาดใหญ่และชุดของจำนวนเต็มแบบสุ่ม ล้อมรอบด้วยวงเล็บปีกกา (เรียกอีกอย่างว่าวงเล็บปีกกา)

จากนั้นจะวัดเวลาที่ใช้ในการค้นหารายการเฉพาะ โดยใช้อาร์กิวเมนต์เดียวทั้งในรายการและชุด และวัดเวลาที่ใช้ในการวนซ้ำผ่านองค์ประกอบทั้งหมดในรายการและชุด

ผลลัพธ์แสดงความแตกต่างของประสิทธิภาพระหว่างรายการ Python และชุดสำหรับการค้นหาและการวนซ้ำ ซึ่งเกิดจากการนำไปใช้งานพื้นฐาน

การดำเนินการค้นหาเป็นชุด (0.000000 วินาที) เร็วกว่าแบบเป็นรายการ (0.002999 วินาที) เนื่องจากใช้ฟังก์ชันแฮชเพื่อคำนวณค่าแฮชสำหรับการค้นหาที่มีประสิทธิภาพ อย่างไรก็ตาม การวนซ้ำรายการ (0.007995 วินาที) จะเร็วกว่าการวนซ้ำชุดหนึ่ง (0.017989 วินาที) เล็กน้อย เนื่องจากชุดต้องมีการดำเนินการเพิ่มเติมเพื่อให้แน่ใจว่าไม่ซ้ำกัน

การดำเนินการและวิธีการทั่วไป

ทั้งชุดและรายการใน Python มีการดำเนินการและวิธีการต่างๆ ซึ่งแต่ละชุดจะปรับให้เหมาะกับงานเฉพาะและการจัดการข้อมูล วิธีการเหล่านี้บางส่วนแสดงไว้ด้านล่าง:

วิธีการตั้งค่า

เมธอดชุดดำเนินการที่คล้ายกับการดำเนินการทางคณิตศาสตร์และเป็นเครื่องมือที่มีประสิทธิภาพสำหรับการจัดการค่าที่ไม่ซ้ำกันในคอลเลกชัน

• เพิ่ม (องค์ประกอบ): เพิ่มองค์ประกอบในชุดหากยังไม่มีอยู่

• ลบ (องค์ประกอบ): ลบองค์ประกอบที่ระบุออกจากชุด ทำให้เกิดข้อผิดพลาดหากไม่พบองค์ประกอบ

• ทิ้ง (องค์ประกอบ): ลบองค์ประกอบที่ระบุออกจากชุดหากมีอยู่ ไม่มีข้อผิดพลาดเกิดขึ้นหากไม่พบองค์ประกอบ

• union(set2): ส่งกลับชุดใหม่ที่มีองค์ประกอบทั้งหมดจากชุดเดิมและชุดที่ 2 ดำเนินการชุดอย่างมีประสิทธิภาพ

• ทางแยก (set2): ส่งกลับชุดใหม่ที่มีองค์ประกอบร่วมกันทั้งชุดเดิมและ set2

• ความแตกต่าง (set2): ส่งกลับชุดใหม่ที่มีองค์ประกอบในชุดเดิม แต่ไม่ได้อยู่ใน set2

• symmetric_difference(set2): ส่งกลับชุดใหม่ที่มีองค์ประกอบในชุดเดิมหรือชุดที่ 2 แต่ไม่ใช่ทั้งสองอย่าง

วิธีการรายการ

เมธอดรายการมีหลายวิธีในการจัดการกับข้อมูล

• ผนวก (องค์ประกอบ): เพิ่มองค์ประกอบที่ส่วนท้ายของรายการ

• ขยาย (ทำซ้ำได้): ผนวกองค์ประกอบทั้งหมดจากรายการที่ทำซ้ำได้ (เช่น รายการอื่น) ต่อท้ายรายการ

• แทรก (ดัชนี, องค์ประกอบ): แทรกองค์ประกอบที่ดัชนีที่ระบุ

• ลบ (องค์ประกอบ): ลบรายการที่เกิดขึ้นครั้งแรกขององค์ประกอบที่ระบุในรายการ ทำให้เกิดข้อผิดพลาดหากไม่มีองค์ประกอบ

• ป๊อป (ดัชนี): ลบและส่งคืนองค์ประกอบที่ดัชนีที่ระบุ หากไม่มีการกำหนดดัชนี จะลบองค์ประกอบสุดท้ายออก

• ดัชนี (องค์ประกอบ): ส่งกลับดัชนีของการเกิดขึ้นครั้งแรกขององค์ประกอบที่ระบุในรายการ

• นับ (องค์ประกอบ): ส่งกลับจำนวนของการเกิดขึ้นขององค์ประกอบที่ระบุในรายการ

• sort(): เรียงลำดับรายการจากน้อยไปมากตามค่าเริ่มต้น สำหรับลำดับจากมากไปน้อย ให้ใช้พารามิเตอร์ reverse=True

• ย้อนกลับ (): กลับลำดับขององค์ประกอบในรายการ

เมื่อใช้เมธอดชุดและรายการของ Python เหล่านี้ คุณจะจัดการข้อมูลได้อย่างมีประสิทธิภาพและแก้ปัญหาต่างๆ ในการเขียนโปรแกรม Python วิทยาศาสตร์ข้อมูล และแอปพลิเคชันอื่นๆ ได้

คำพูดสุดท้ายของเรา

เมื่อเลือกระหว่างรายการ Python และชุดสำหรับโครงสร้างข้อมูลของคุณ ให้พิจารณาใช้รายการเมื่อคุณต้องการชุดรายการตามลำดับ ต้องการรักษาองค์ประกอบที่ซ้ำกัน และต้องการความสามารถในการเข้าถึงองค์ประกอบด้วยดัชนี

เลือกใช้ชุดเมื่อความเป็นเอกลักษณ์ขององค์ประกอบเป็นสิ่งสำคัญ ลำดับขององค์ประกอบไม่สำคัญ และต้องการการทดสอบการเป็นสมาชิกที่เร็วกว่า ในขณะที่รายการเก่งในการวนซ้ำ ชุดให้การตรวจสอบการบรรจุที่มีประสิทธิภาพมากขึ้น

ท้ายที่สุดแล้ว ทางเลือกของคุณขึ้นอยู่กับความต้องการของโปรเจกต์ของคุณ เนื่องจากโครงสร้างข้อมูลแต่ละแบบมีประโยชน์และข้อจำกัดที่แตกต่างกัน ทำให้เป็นเครื่องมือที่มีประสิทธิภาพสำหรับจัดการงานต่างๆ ในการเขียนโปรแกรม Python สนุก!