Python セットとリスト

Python プログラミングの世界では、さまざまな目的に役立つさまざまなデータ構造に遭遇することがよくあります。これらの構造のうち、セットとリストは、データのコレクションを保存および操作するために一般的に使用されます。

これらは似ているように見えますが、その特性と使用例には顕著な違いがあります。

Python セットとリスト – 本当の違い

Python のセットとリストを理解する
- Python セットとは何ですか?
- Python リストとは
セットとリストの 3 つの主な違い
適切なデータ構造を選択するにはどうすればよいですか?
- セットの使用例
- リストの使用例
Aセットとリスト間のパフォーマンスの比較
- 時間計算量
- メモリ使用量
一般的な操作とメソッド
- セットメソッド
- リストメソッド
私たちの最終決定権

Python のセットとリストを理解する

さて、それではまず説明しましょう。

Python セットとは何ですか?

Pythonセットは、メンバーと呼ばれる個別の要素の順序付けされていないコレクションを表す組み込みデータ構造です。

この強力なツールは、データサイエンスアプリケーションや数学的演算で特に役立ちます。

Python セットには次のプロパティがあります。

これらは順序付けされていません。つまり、セット内の要素はインデックスとは独立して格納されます。この一意の値の順序付けされていないコレクションは、効率的なメンバーシップテストと集合の内包表記をサポートします。
重複する値は許可されません。このため、一意の値を操作したり、リストから重複を削除したり、和集合、交差、対称差分などの集合演算を実行する必要がある場合に便利です。

Python でセットを作成するには 2 つの方法があります。

中括弧 ({}) (中括弧とも呼ばれます) を使用します。
組み込みの set() 関数を使用します。この関数は、セットに含める要素を含む反復可能引数を 1 つ受け取ります。

中かっこと組み込みの set 関数を使用して Python セットを作成するための一般的な構文を以下に示します。

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

Python リストとは

Python リストは、他のプログラミング言語の動的配列に似た組み込みデータ構造です。

これらは複数の項目を 1 つの変数に格納するために使用され、文字列、数値、ブール値などのさまざまなデータ型を処理するための多用途のオプションになります。

Python リストには次のプロパティがあります。

それらは順序付けされています。これは、特定の要素がリスト内で一意の位置を持ち、そのインデックスを通じてアクセスできることを意味します。この順序付けされたコレクションはランダムアクセスをサポートしており、スライス、連結、リスト理解などの操作を実行できます。
これらは変更可能であり、リストの作成後にその要素を変更できるため、データ構造を操作する際に柔軟性が得られます。
Python リストでは値の重複が許可され、文字列、数値、ブール値などのデータ型を組み合わせて保存できます。

Python でリストを作成するには2 つの方法があります。

リストの境界を示す角括弧を使用します。
組み込みの list() 関数を使用します。この関数は、単一の引数、またはリストに含める要素を含む反復可能値を受け取ることができます。

次の Python コードは、角括弧と組み込みの list() 関数を使用して Python リストを作成する方法を示しています。

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 セットは、インデックスのない順序付けされていないコレクションです。つまり、位置を使用して要素にアクセスすることはできません。これは、要素の順序が重要でない場合に便利です。

次の 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)

Python セットとリスト – 本当の違い

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 のセットはハッシュ可能 (不変) オブジェクトのみを保持できます。つまり、セットのセットや、リストのような変更可能なオブジェクトを含むセットを保持することはできません。

次のコードは、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 セットとリスト – 本当の違い

要素の独自性

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

Python セットとリスト – 本当の違い

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 セットとリスト – 本当の違い

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

Python セットとリスト – 本当の違い

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.

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.
反復:項目の反復に関しては、リストはセットよりもわずかに高速です。これは、セットは一意性を確保するために追加の操作が必要であるのに対し、リストは直接インデックスを使用して単純な順序付きコレクションを維持するためです。

メモリ使用量

セットは通常、リストよりも多くのメモリを消費します。これは、項目の一意性を保証するためにハッシュテーブルを維持する必要があり、メモリ消費量が増加するという代償が伴うためです。

リストは要素を順番に格納するだけなので、メモリ消費量が少なくなり、大規模なデータコレクションを処理する際のメモリ効率の高い選択肢となります。

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 のセットとリスト間のパフォーマンスの比較を示しています。

中括弧 (中括弧とも呼ばれます) で囲まれた大きなリストとランダムな整数のセットが生成されます。

次に、リストとセットの両方で 1 つの引数を使用して特定の項目を検索するのにかかる時間を測定し、リストとセットのすべての要素を反復処理するのにかかる時間を測定します。

Python セットとリスト – 本当の違い

出力は、基礎となる実装に起因する、検索および反復における Python のリストとセットのパフォーマンスの違いを示しています。

検索操作は、効率的な検索のためのハッシュ値を計算するハッシュ関数の使用により、リスト (0.002999 秒) よりもセット (0.000000 秒) の方が高速です。ただし、セットの一意性を確保するために追加の操作が必要になるため、リストの反復 (0.007995 秒) はセットの反復 (0.017989 秒) よりもわずかに高速です。

一般的な操作とメソッド

Python のセットとリストにはさまざまな操作とメソッドがあり、それぞれが特定のタスクとデータ操作用に最適化されています。これらの方法のいくつかを以下に示します。

セットメソッド

Set メソッドは数学的演算に似た演算を実行し、コレクション内の一意の値を処理するための強力なツールです。

add(element): 要素がまだ存在しない場合は、セットに要素を追加します。
Remove(element): 指定された要素をセットから削除します。要素が見つからない場合はエラーが発生します。
Discard(element): 指定された要素が存在する場合、セットからそれを削除します。要素が見つからない場合でもエラーは発生しません。
Union(set2): 元のセットと set2 のすべての要素を含む新しいセットを返し、事実上セット演算を実行します。
Intersection(set2): 元のセットと set2 の両方に共通の要素を含む新しいセットを返します。
Difference(set2): 元のセットにはあるが set2 には含まれていない要素を含む新しいセットを返します。
symetric_difference(set2): 元のセットまたは set2 のどちらか一方の要素を含む新しいセットを返しますが、両方には要素が含まれません。