Pythonデータ型 チートシート

cheatsheet
Pythonデータ型リスト操作文字列操作辞書操作集合演算

数値型 (Numeric Types: int, float, complex) 🔢

整数(int)、浮動小数点数(float)、複素数(complex)の操作。

基本的な算術演算

演算子 説明 例
+ 加算 
a = 10 + 5  # a は 15 (int)
b = 3.14 + 2.0 # b は 5.14 (float)
- 減算 
a = 10 - 5  # a は 5 (int)
b = 5.0 - 2.5 # b は 2.5 (float)
* 乗算 
a = 10 * 5  # a は 50 (int)
b = 2.5 * 2.0 # b は 5.0 (float)
/ 除算 (結果は常に float) 
a = 10 / 5  # a は 2.0 (float)
b = 5 / 2   # b は 2.5 (float)
// 整数除算 (小数点以下切り捨て) 
a = 10 // 5 # a は 2 (int)
b = 5 // 2  # b は 2 (int)
c = 5.0 // 2.0 # c は 2.0 (float)
% 剰余 (余り) 
a = 10 % 3  # a は 1 (int)
b = 5.5 % 2.0 # b は 1.5 (float)
** べき乗 
a = 2 ** 3  # a は 8 (int)
b = 3.0 ** 2.0 # b は 9.0 (float)

比較演算

結果はブール値 (True または False)。

演算子 説明 例
==等しい
10 == 5 * 2  # True
!=等しくない
10 != 5      # True
<より小さい
5 < 10       # True
>より大きい
10 > 5       # True
<=以下
10 <= 10     # True
>=以上
5 >= 5       # True

注意: 複素数同士の <, >, <=, >= 比較はできません。

型変換

関数 説明 例
int()整数に変換 (小数点以下切り捨て)
int(3.14)    # 3
int("100")   # 100
float()浮動小数点数に変換
float(10)    # 10.0
float("3.14") # 3.14
complex()複素数に変換
complex(2, 3) # (2+3j)
complex("5+2j") # (5+2j)

複素数操作 (complex)

複素数 z = a + bj の場合:

属性/メソッド 説明 例
z.real実部 (float)
z = 3+4j
z.real  # 3.0
z.imag虚部 (float)
z = 3+4j
z.imag  # 4.0
z.conjugate()共役複素数
z = 3+4j
z.conjugate() # (3-4j)
abs(z)絶対値 (大きさ)
z = 3+4j
abs(z) # 5.0 (sqrt(3^2 + 4^2))

ビット演算 (int) ✨

演算子 説明 例 (a=5 (0101), b=3 (0011))
&ビット単位 AND
a & b  # 1 (0001)
|ビット単位 OR
a | b  # 7 (0111)
^ビット単位 XOR
a ^ b  # 6 (0110)
~ビット単位 NOT (反転)
~a     # -6 (符号付き整数の表現による)
<<左ビットシフト
a << 1 # 10 (1010)
>>右ビットシフト
a >> 1 # 2 (0010)

数値関連の組み込み関数

関数 説明 例
abs()絶対値
abs(-10) # 10
round()四捨五入 (指定桁数)
round(3.14159, 2) # 3.14
round(3.7) # 4
pow(x, y[, z])x の y 乗 (z があれば z で割った余り)
pow(2, 3) # 8
pow(2, 3, 5) # 3 (8 % 5)
divmod(a, b)a // b (商) と a % b (余り) のタプル
divmod(10, 3) # (3, 1)

シーケンス型 (Sequence Types: list, tuple, range) 📜

順序付けられた要素の集まり。リスト(list)は変更可能(mutable)、タプル(tuple)とレンジ(range)は変更不可(immutable)。

共通操作

操作 説明 例 (seq = [1, 2, 3] または (1, 2, 3))
seq[i]インデックス i の要素にアクセス
seq[0]  # 1
seq[-1] # 3 (末尾から)
seq[i:j]スライス (インデックス i から j-1 まで)
seq[0:2] # [1, 2] または (1, 2)
seq[i:j:k]ステップ付きスライス
seq = [0, 1, 2, 3, 4, 5]
seq[::2] # [0, 2, 4] (偶数番目)
seq[::-1] # [5, 4, 3, 2, 1, 0] (逆順)
seq1 + seq2連結
[1, 2] + [3, 4] # [1, 2, 3, 4]
(1, 2) + (3, 4) # (1, 2, 3, 4)
seq * n繰り返し
[1, 2] * 3 # [1, 2, 1, 2, 1, 2]
(1, 2) * 2 # (1, 2, 1, 2)
x in seq要素 x が含まれるか
2 in seq # True
x not in seq要素 x が含まれないか
4 not in seq # True
len(seq)要素数
len(seq) # 3
min(seq)最小値
min(seq) # 1
max(seq)最大値
max(seq) # 3

リスト (list) – 可変 🔧

要素の変更、追加、削除が可能です。

要素の追加

メソッド説明例 (lst = [1, 2])
lst.append(x)末尾に要素 x を追加
lst.append(3) # lst は [1, 2, 3]
lst.insert(i, x)インデックス i に要素 x を挿入
lst.insert(1, 99) # lst は [1, 99, 2]
lst.extend(iterable)イテラブルの全要素を末尾に追加
lst.extend([4, 5]) # lst は [1, 2, 4, 5]

要素の削除

メソッド/文説明例 (lst = [1, 99, 2, 99])
lst.remove(x)最初に現れる要素 x を削除 (なければValueError)
lst.remove(99) # lst は [1, 2, 99]
lst.pop([i])インデックス i の要素を削除し返す (i省略時は末尾)
item = lst.pop(1) # item は 99, lst は [1, 2, 99]
last = lst.pop()  # last は 99, lst は [1, 2]
lst.clear()全要素を削除
lst.clear() # lst は []
del lst[i]インデックス i の要素を削除
del lst[1] # lst は [1, 2, 99]
del lst[i:j]スライスで指定した範囲の要素を削除
del lst[1:3] # lst は [1, 99]

要素の検索・カウント

メソッド説明例 (lst = [1, 2, 3, 2])
lst.index(x[, start[, end]])要素 x が最初に現れるインデックスを返す (なければValueError)
lst.index(2) # 1
lst.count(x)要素 x の出現回数を返す
lst.count(2) # 2

ソート・反転

メソッド/関数説明例 (lst = [3, 1, 4, 2])
lst.sort(key=None, reverse=False)リスト自体をソート (インプレース)
lst.sort() # lst は [1, 2, 3, 4]
lst.sort(reverse=True) # lst は [4, 3, 2, 1]
sorted(iterable, key=None, reverse=False)ソートされた新しいリストを返す (元のリストは変更されない)
new_lst = sorted(lst) # new_lst は [1, 2, 3, 4], lst は [3, 1, 4, 2] のまま
lst.reverse()リストの要素の順序を反転させる (インプレース)
lst.reverse() # lst は [2, 4, 1, 3]

コピー

メソッド/方法説明例 (lst = [1, [2, 3]])
lst.copy()リストの浅いコピー(shallow copy)を作成
lst2 = lst.copy()
lst2[0] = 99 # lst は [1, [2, 3]], lst2 は [99, [2, 3]]
lst2[1][0] = 88 # lst は [1, [88, 3]], lst2 は [99, [88, 3]] (ネストしたリストは共有)
lst[:]スライスによる浅いコピー
lst3 = lst[:] # lst.copy() と同様の効果

深いコピー(deep copy)が必要な場合は copy モジュールの deepcopy() を使用します。

リスト内包表記 (List Comprehensions) 🚀

簡潔な構文でリストを生成する方法。

# 0から9の二乗のリストを作成
squares = [x**2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 偶数のみを抽出
evens = [x for x in range(10) if x % 2 == 0]
# [0, 2, 4, 6, 8]

# ネストしたループ
pairs = [(x, y) for x in [1, 2] for y in [3, 4]]
# [(1, 3), (1, 4), (2, 3), (2, 4)]

タプル (tuple) – 不変 🧱

一度作成すると要素の変更、追加、削除はできません。シーケンスとしての共通操作 (インデックス、スライスなど) は可能です。

要素の検索・カウント

メソッド説明例 (tpl = (1, 2, 3, 2))
tpl.index(x[, start[, end]])要素 x が最初に現れるインデックスを返す (なければValueError)
tpl.index(2) # 1
tpl.count(x)要素 x の出現回数を返す
tpl.count(2) # 2

アンパック (Unpacking)

タプルの要素を変数に個別に代入できます。

point = (10, 20)
x, y = point
print(x) # 10
print(y) # 20

要素数が1つのタプルを作成する場合は、要素の後ろにカンマが必要です: single_tuple = (1,)

レンジ (range) ➡️

連続した整数のシーケンスを表現します。主に for ループで使用されます。

形式説明例
range(stop)0 から stop-1 までの整数
list(range(5)) # [0, 1, 2, 3, 4]
range(start, stop)start から stop-1 までの整数
list(range(2, 5)) # [2, 3, 4]
range(start, stop, step)start から stop-1 まで step 刻みの整数
list(range(0, 10, 2)) # [0, 2, 4, 6, 8]

range オブジェクト自体はリストではなく、必要に応じて値を生成するイテレータのようなものです。メモリ効率が良いです。

文字列型 (String Type: str) 🔤

テキストデータを扱うための型。不変(immutable)であり、一度作成すると変更できません。シーケンスとしての共通操作 (インデックス、スライス、len, in, +, *) が可能です。

大文字/小文字変換

メソッド説明例 (s = “hello World”)
s.upper()すべて大文字に変換
s.upper() # 'HELLO WORLD'
s.lower()すべて小文字に変換
s.lower() # 'hello world'
s.capitalize()最初の文字のみ大文字、他は小文字
s.capitalize() # 'Hello world'
s.title()各単語の先頭を大文字、他は小文字
s.title() # 'Hello World'
s.swapcase()大文字と小文字を入れ替え
s.swapcase() # 'HELLO wORLD'

検索/置換

メソッド説明例 (s = “python programming”)
s.find(sub[, start[, end]])部分文字列 sub を検索し、最初のインデックスを返す (見つからなければ -1)
s.find("pro") # 7
s.find("java") # -1
s.rfind(sub[, start[, end]])右側から検索し、最初のインデックスを返す (見つからなければ -1)
s = "ababa"
s.rfind("a") # 4
s.index(sub[, start[, end]])find と同様だが、見つからない場合に ValueError
s.index("py") # 0
# s.index("java") -> ValueError
s.rindex(sub[, start[, end]])rfind と同様だが、見つからない場合に ValueError
s = "ababa"
s.rindex("a") # 4
s.count(sub[, start[, end]])部分文字列 sub の出現回数を返す
s.count("p") # 2
s.replace(old, new[, count])old を new に置換 (count を指定すると最大置換回数)
s.replace("p", "P") # 'Python Programming'
s.replace("p", "P", 1) # 'Python programming'
s.startswith(prefix[, start[, end]])指定した prefix で始まるか
s.startswith("py") # True
s.endswith(suffix[, start[, end]])指定した suffix で終わるか
s.endswith("ing") # True

分割/結合

メソッド説明例
s.split([sep[, maxsplit]])sep を区切り文字として分割し、リストを返す (sep 省略時は空白文字)
s = "one two three"
s.split() # ['one', 'two', 'three']
csv = "a,b,c"
csv.split(',') # ['a', 'b', 'c']
s.rsplit([sep[, maxsplit]])右側から分割
s = "a,b,c,d"
s.rsplit(',', 1) # ['a,b,c', 'd']
s.splitlines([keepends])改行文字で分割し、リストを返す (keepends=True で改行文字を含む)
text = "line1\nline2\r\nline3"
text.splitlines() # ['line1', 'line2', 'line3']
sep.join(iterable)イテラブルの要素を文字列 sep で結合
words = ['hello', 'world']
" ".join(words) # 'hello world'
"-".join(['a', 'b', 'c']) # 'a-b-c'
s.partition(sep)最初の sep で分割し、(前, sep, 後) のタプルを返す (なければ (s, ”, ”))
s = "name=value"
s.partition("=") # ('name', '=', 'value')
s.partition(":") # ('name=value', '', '')
s.rpartition(sep)最後の sep で分割
s = "path/to/file.txt"
s.rpartition("/") # ('path/to', '/', 'file.txt')

空白除去

メソッド説明例 (s = ” spam ham “)
s.strip([chars])先頭と末尾の空白 (または指定文字 chars) を除去
s.strip() # 'spam ham'
"---abc---".strip('-') # 'abc'
s.lstrip([chars])先頭の空白 (または指定文字 chars) を除去
s.lstrip() # 'spam ham  '
s.rstrip([chars])末尾の空白 (または指定文字 chars) を除去
s.rstrip() # '  spam ham'

判定メソッド (True/Falseを返す)

メソッド説明例
s.isdigit()すべて数字か
"123".isdigit() # True
"1.23".isdigit() # False
s.isdecimal()すべて十進数字か (Unicode含む)
"123".isdecimal() # True
s.isnumeric()すべて数値文字か (Unicode数字、分数、ローマ数字など含む)
"123".isnumeric() # True
"½".isnumeric() # True
s.isalpha()すべてアルファベットか
"abc".isalpha() # True
"abc1".isalpha() # False
s.isalnum()すべて英数字か
"abc1".isalnum() # True
"abc!".isalnum() # False
s.islower()すべて小文字か (アルファベットが1文字以上必要)
"hello".islower() # True
"Hello".islower() # False
"123".islower() # False
s.isupper()すべて大文字か (アルファベットが1文字以上必要)
"HELLO".isupper() # True
"Hello".isupper() # False
"123".isupper() # False
s.isspace()すべて空白文字か (スペース、タブ、改行など)
" \t\n".isspace() # True
" a ".isspace() # False
s.istitle()タイトルケースか (単語の先頭が大文字、他が小文字)
"Hello World".istitle() # True
"Hello world".istitle() # False
s.isidentifier()有効なPython識別子か (予約語はFalse)
"my_variable".isidentifier() # True
"1variable".isidentifier() # False
"if".isidentifier() # False

フォーマット 🎨

文字列内に値を埋め込む方法。

f-string (フォーマット済み文字列リテラル, Python 3.6+)

最も推奨される方法。

name = "Alice"
age = 30
height = 1.65
print(f"Name: {name}, Age: {age}, Height: {height:.2f}m")
# Output: Name: Alice, Age: 30, Height: 1.65m

# 式も埋め込める
print(f"Age next year: {age + 1}")
# Output: Age next year: 31

# 波括弧自体を表示するには二重にする
print(f"Braces: {{}}")
# Output: Braces: {}

str.format() メソッド

name = "Bob"
age = 25
# 位置引数
print("Name: {}, Age: {}".format(name, age))
# Output: Name: Bob, Age: 25

# インデックス指定
print("Age: {1}, Name: {0}".format(name, age))
# Output: Age: 25, Name: Bob

# キーワード引数
print("Name: {n}, Age: {a}".format(n=name, a=age))
# Output: Name: Bob, Age: 25

# 書式指定
pi = 3.14159
print("Pi: {:.3f}".format(pi))
# Output: Pi: 3.142

エンコード/デコード

文字列とバイト列 (bytes) の相互変換。

メソッド説明例
s.encode(encoding='utf-8', errors='strict')文字列をバイト列にエンコード
s = "こんにちは"
b = s.encode('utf-8') # b は b'\xe3\x81\x93\xe3\x82\x93\xe3\x81\xab\xe3\x81\xa1\xe3\x81\xaf'
b.decode(encoding='utf-8', errors='strict')バイト列を文字列にデコード (bytes オブジェクトのメソッド)
s_decoded = b.decode('utf-8') # s_decoded は 'こんにちは'

errors 引数には 'ignore' (無視), 'replace' (置換文字) などを指定可能。

パディング (文字埋め)

メソッド説明例
s.ljust(width[, fillchar])指定幅 width で左寄せ (右側を fillchar で埋める, デフォルトは空白)
"abc".ljust(5)     # 'abc  '
"abc".ljust(5, '-') # 'abc--'
s.rjust(width[, fillchar])指定幅 width で右寄せ (左側を fillchar で埋める)
"abc".rjust(5)     # '  abc'
"abc".rjust(5, '0') # '00abc'
s.center(width[, fillchar])指定幅 width で中央寄せ (左右を fillchar で埋める)
"abc".center(7)     # '  abc  '
"abc".center(7, '*') # '**abc**'
s.zfill(width)指定幅 width で右寄せし、左側を ‘0’ で埋める (符号を考慮)
"42".zfill(5)  # '00042'
"-42".zfill(5) # '-0042'

マッピング型 (Mapping Type: dict) 🗺️

キー(key)と値(value)のペアを格納するコレクション。キーは一意で不変(immutable)な型である必要があります (文字列、数値、タプルなど)。Python 3.7以降では挿入順序が保持されます。

要素のアクセス・追加・更新

操作/メソッド説明例 (d = {‘a’: 1, ‘b’: 2})
d[key]キー key に対応する値を取得 (なければKeyError)
d['a'] # 1
# d['c'] -> KeyError
d[key] = valueキー key に値 value を代入 (既存なら更新、なければ追加)
d['b'] = 99 # d は {'a': 1, 'b': 99}
d['c'] = 3  # d は {'a': 1, 'b': 99, 'c': 3}
d.get(key[, default])キー key の値を取得 (なければ default を返す、default 省略時は None)
d.get('a')    # 1
d.get('c')    # None
d.get('c', 0) # 0
d.setdefault(key[, default])key が存在すれば値を返し、存在しなければ d[key] = default を設定して default を返す
val = d.setdefault('b', 0) # val は 99, d は {'a': 1, 'b': 99, 'c': 3}
val = d.setdefault('d', 4) # val は 4, d は {'a': 1, 'b': 99, 'c': 3, 'd': 4}

要素の削除

メソッド/文説明例 (d = {‘a’: 1, ‘b’: 2, ‘c’: 3})
d.pop(key[, default])キー key の要素を削除し、その値を返す (なければKeyError、default指定時はそれを返す)
val = d.pop('b') # val は 2, d は {'a': 1, 'c': 3}
val = d.pop('x', 0) # val は 0, d は {'a': 1, 'c': 3}
# d.pop('x') -> KeyError
d.popitem()最後に追加されたキーと値のペアを削除し、(key, value) タプルで返す (Python 3.7+)。それ以前は任意。空ならKeyError。
item = d.popitem() # item は ('c', 3), d は {'a': 1} (順番による)
d.clear()全要素を削除
d.clear() # d は {}
del d[key]キー key の要素を削除 (なければKeyError)
del d['a'] # d は {'c': 3}

キー/値/アイテムビューの取得

これらのメソッドは辞書の内容に連動する「ビューオブジェクト」を返します。辞書が変更されるとビューも変化します。

メソッド説明例 (d = {‘a’: 1, ‘b’: 2})
d.keys()キーのビューオブジェクト
keys = d.keys() # dict_keys(['a', 'b'])
list(keys) # ['a', 'b']
d.values()値のビューオブジェクト
values = d.values() # dict_values([1, 2])
list(values) # [1, 2]
d.items()(キー, 値) タプルのビューオブジェクト
items = d.items() # dict_items([('a', 1), ('b', 2)])
list(items) # [('a', 1), ('b', 2)]

ループでよく使われます:

for key in d: # デフォルトはキーをイテレート
    print(key)

for value in d.values():
    print(value)

for key, value in d.items():
    print(f"{key}: {value}")

存在確認

演算子説明例 (d = {‘a’: 1, ‘b’: 2})
key in dキー key が辞書に存在するか
'a' in d # True
'c' in d # False
key not in dキー key が辞書に存在しないか
'c' not in d # True

in 演算子はキーの存在を確認します。値の存在を確認するには value in d.values() を使います。

辞書の結合/更新

メソッド/演算子説明例 (d1={‘a’:1,’b’:2}, d2={‘b’:3,’c’:4})
d1.update(d2)d1 を d2 のキー/値で更新 (インプレース)
d1.update(d2)
# d1 は {'a': 1, 'b': 3, 'c': 4}
{**d1, **d2}新しい辞書を作成して結合 (Python 3.5+)
merged = {**d1, **d2}
# merged は {'a': 1, 'b': 3, 'c': 4}
d1 | d2新しい辞書を作成して結合 (和集合演算子, Python 3.9+)
merged = d1 | d2
# merged は {'a': 1, 'b': 3, 'c': 4}
d1 |= d2d1 を d2 で更新 (インプレース版和集合演算子, Python 3.9+)
d1 |= d2
# d1 は {'a': 1, 'b': 3, 'c': 4}

辞書内包表記 (Dictionary Comprehensions) 🚀

リスト内包表記と同様に、簡潔な構文で辞書を生成できます。

# 数値とその二乗の辞書
squares = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# 条件付き
odd_squares = {x: x**2 for x in range(10) if x % 2 != 0}
# {1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

# 既存の辞書から新しい辞書を作成
old_dict = {'a': 1, 'b': 2, 'c': 3}
new_dict = {k.upper(): v * 10 for k, v in old_dict.items() if v > 1}
# {'B': 20, 'C': 30}

コピー

メソッド説明例 (d = {‘a’: 1, ‘b’: [10, 20]})
d.copy()辞書の浅いコピー(shallow copy)を作成
d2 = d.copy()
d2['a'] = 99 # d は {'a': 1, 'b': [10, 20]}, d2 は {'a': 99, 'b': [10, 20]}
d2['b'][0] = 88 # d は {'a': 1, 'b': [88, 20]}, d2 は {'a': 99, 'b': [88, 20]} (ネストしたリストは共有)

深いコピー(deep copy)が必要な場合は copy モジュールの deepcopy() を使用します。

集合型 (Set Types: set, frozenset) 🧩

順序がなく、重複する要素を持たないコレクション。集合演算 (和集合、積集合など) に適しています。set は変更可能 (mutable)、frozenset は変更不可 (immutable) です。

共通操作

操作/メソッド説明例 (s1 = {1, 2, 3}, s2 = {3, 4, 5})
x in s要素 x が集合に含まれるか
2 in s1 # True
x not in s要素 x が集合に含まれないか
4 not in s1 # True
len(s)要素数
len(s1) # 3
s.copy()集合の浅いコピーを作成 (set のみ)
s3 = s1.copy() # s3 は {1, 2, 3}
s1.union(s2, ...)
s1 | s2 | ...		和集合 (すべての要素)
s1.union(s2) # {1, 2, 3, 4, 5}
s1 | s2     # {1, 2, 3, 4, 5}
s1.intersection(s2, ...)
s1 & s2 & ...		積集合 (共通の要素)
s1.intersection(s2) # {3}
s1 & s2            # {3}
s1.difference(s2, ...)
s1 - s2 - ...		差集合 (s1 にあり s2 にない要素)
s1.difference(s2) # {1, 2}
s1 - s2           # {1, 2}
s2 - s1           # {4, 5}
s1.symmetric_difference(s2)
s1 ^ s2		対称差集合 (どちらか一方にのみ含まれる要素)
s1.symmetric_difference(s2) # {1, 2, 4, 5}
s1 ^ s2                    # {1, 2, 4, 5}
s1.issubset(s2)
s1 <= s2		s1 が s2 の部分集合か
{1, 2}.issubset(s1) # True
s1 <= {1, 2, 3, 4} # True
s1 < s2s1 が s2 の真部分集合か (完全に含まれ、かつ等しくない)
{1, 2} < s1 # True
s1 < {1, 2, 3} # False
s1.issuperset(s2)
s1 >= s2		s1 が s2 の上位集合か
s1.issuperset({1, 2}) # True
s1 >= {1, 2}          # True
s1 > s2s1 が s2 の真上位集合か
s1 > {1, 2} # True
s1 > {1, 2, 3} # False
s1.isdisjoint(s2)s1 と s2 が互いに素か (共通要素がないか)
s1.isdisjoint({4, 5}) # True
s1.isdisjoint(s2)    # False (3が共通)

集合演算メソッド (union(), intersection()など) は引数に他のイテラブル (リスト、タプルなど) を取れますが、演算子 (|, &など) は両方が集合型である必要があります。

セット (set) – 可変 🔧

要素の追加、削除が可能です。

要素の追加

メソッド説明例 (s = {1, 2})
s.add(elem)要素 elem を追加 (既に存在すれば何もしない)
s.add(3) # s は {1, 2, 3}
s.add(2) # s は {1, 2, 3} のまま
s.update(iterable, ...)イテラブルの全要素を追加 (和集合のインプレース版)
s.update([3, 4], {4, 5}) # s は {1, 2, 3, 4, 5}

要素の削除

メソッド説明例 (s = {1, 2, 3})
s.remove(elem)要素 elem を削除 (存在しなければKeyError)
s.remove(2) # s は {1, 3}
# s.remove(4) -> KeyError
s.discard(elem)要素 elem を削除 (存在しなくてもエラーにならない)
s.discard(3) # s は {1}
s.discard(4) # s は {1} のまま (エラーなし)
s.pop()任意の要素を削除して返す (空ならKeyError)
elem = s.pop() # elem は 1 (または他の要素)、s は残りの要素
s.clear()全要素を削除
s.clear() # s は set() (空のセット)

集合演算 (インプレース)

演算結果で元のセットを更新します。

メソッド/演算子説明例 (s1 = {1, 2, 3}, s2 = {3, 4, 5})
s1.update(s2)
s1 |= s2		s1 を s1 と s2 の和集合で更新
s1.update(s2) # s1 は {1, 2, 3, 4, 5}
s1.intersection_update(s2)
s1 &= s2		s1 を s1 と s2 の積集合で更新
s1.intersection_update(s2) # s1 は {3}
s1.difference_update(s2)
s1 -= s2		s1 を s1 と s2 の差集合で更新
s1.difference_update(s2) # s1 は {1, 2}
s1.symmetric_difference_update(s2)
s1 ^= s2		s1 を s1 と s2 の対称差集合で更新
s1.symmetric_difference_update(s2) # s1 は {1, 2, 4, 5}

セット内包表記 (Set Comprehensions) 🚀

リスト内包表記と同様に、簡潔な構文でセットを生成できます。

# 0から4の平方数のセット
squares = {x**2 for x in range(5)}
# {0, 1, 4, 9, 16}

# 文字列中のユニークな文字のセット (小文字)
text = "Programming"
unique_chars = {char.lower() for char in text if char.isalpha()}
# {'o', 'a', 'p', 'i', 'n', 'g', 'r', 'm'} (順序は不定)

空のセットを作成するには {} ではなく set() を使います。{} は空の辞書を作成します。

フローズンセット (frozenset) – 不変 🧊

set と同様の集合演算が可能ですが、要素の追加や削除はできません。不変であるため、辞書のキーや他の集合の要素として使用できます。

# 作成
fs1 = frozenset([1, 2, 3])
fs2 = frozenset([3, 4, 5])

# 集合演算は可能
union_fs = fs1 | fs2 # frozenset({1, 2, 3, 4, 5})
intersection_fs = fs1 & fs2 # frozenset({3})

# 要素の変更は不可
# fs1.add(4) -> AttributeError
# fs1.remove(1) -> AttributeError

# 辞書のキーとして使用可能
d = {fs1: "set one"}
print(d[frozenset([1, 2, 3])]) # "set one"

# セットの要素として使用可能
s = {fs1, fs2}
print(s) # {frozenset({1, 2, 3}), frozenset({3, 4, 5})}

ブール型 (Boolean Type: bool) 👍👎

真 (True) または偽 (False) のいずれかの値をとる型。

値

True と False の2つの定数があります (大文字で始まる点に注意)。

ブール演算

演算子説明例
and論理積 (両方が真なら True)
True and True   # True
True and False  # False
False and False # False
or論理和 (少なくとも一方が真なら True)
True or True    # True
True or False   # True
False or False  # False
not論理否定 (真偽を反転)
not True  # False
not False # True

and と or は短絡評価 (short-circuit evaluation) を行います。例えば False and x では x は評価されません。

他の型との関係

  • 数値として扱われる場合、True は 1、False は 0 と等価です。
  • bool() 関数を使って他の型の値をブール値に変換できます。
print(True == 1)  # True
print(False == 0) # True
print(True + True) # 2

print(bool(0))       # False
print(bool(1))       # True
print(bool(""))      # False (空文字列)
print(bool("abc"))   # True
print(bool([]))      # False (空リスト)
print(bool([1, 2]))  # True
print(bool(None))    # False

真偽値判定

Pythonでは、以下の値が偽 (False) とみなされます。

  • False
  • None
  • 数値型のゼロ (0, 0.0, 0j)
  • 空のシーケンスやコレクション ('', (), [], {}, set(), range(0))

これら以外の値はすべて真 (True) とみなされます。if 文などで直接評価できます。

my_list = []
if my_list:
    print("List is not empty")
else:
    print("List is empty") # こちらが実行される

value = 0
if value:
    print("Value is non-zero")
else:
    print("Value is zero") # こちらが実行される

None型 (None Type: NoneType) ∅

値が存在しないこと、または未定義の状態を表す特別な型。この型に属する値は None のみです。

値

None という唯一の定数があります (大文字で始まる点に注意)。

用途

  • 関数のデフォルトの戻り値 (return 文がない場合や return の後に値がない場合)。
  • 変数が初期化されていない、または有効な値を持たないことを示すためのプレースホルダー。
  • オプション引数のデフォルト値として、「値が指定されなかった」ことを示す。
def my_func(x=None):
    if x is None:
        print("No value provided")
    else:
        print(f"Value is {x}")

my_func()     # Output: No value provided
my_func(10)   # Output: Value is 10

result = print("Hello") # print関数はNoneを返す
print(result) # Output: None

同一性確認

None かどうかを確認するには、== ではなく is または is not を使うのが慣例です。これは None がシングルトン (プログラム全体で唯一のオブジェクト) であるためです。

value = None

# 推奨される方法
if value is None:
    print("Value is None")

if value is not None:
    print("Value is not None")

# 動作はするが、非推奨
if value == None:
    print("Value equals None (not recommended)")

コメント

タイトルとURLをコピーしました