Pythonの基本的な組み込み型とその一般論まとめ

Pythonの基本的な組み込み型である、数値型、シーケンス型、テキストシーケンス型、集合型、マッピング型、およびその一般論についてまとめてみました。半分くらいが一般論になってしまいました。

値と参照の違いでハマりやすいところ、イテラブルなオブジェクト、浅いコピー、ハッシュ可能なオブジェクト、といったようなややこみいった話や、ちょっとした便利な技についても適宜まとめましたので、基本的な型なんかもう知ってるんだけど、という方にも役立てるところがあるかと思います。

- Pythonのバージョンについては、3.3以降ならこの内容で大丈夫だろうと思います
- Pythonの環境構築の方法については、著者別記事の「[[覚え書き] Pythonの環境構築について](https://qiita.com/nakasan/items/73c6d6546f9994c0083c)」を是非ご覧下さい

**目次**

- [一般論](https://qiita.com/nakasan/items/bc9ba8eb57f5b7a22698#%E4%B8%80%E8%88%AC%E8%AB%96)
- [数値型](https://qiita.com/nakasan/items/bc9ba8eb57f5b7a22698#%E6%95%B0%E5%80%A4%E5%9E%8B) (`int`, `float`, `complex`, `bool`)
- [シーケンス型・テキストシーケンス型](https://qiita.com/nakasan/items/bc9ba8eb57f5b7a22698#%E3%82%B7%E3%83%BC%E3%82%B1%E3%83%B3%E3%82%B9%E5%9E%8B%E3%83%86%E3%82%AD%E3%82%B9%E3%83%88%E3%82%B7%E3%83%BC%E3%82%B1%E3%83%B3%E3%82%B9%E5%9E%8B) (`list`, `tuple`, `str`)
- [集合型](https://qiita.com/nakasan/items/bc9ba8eb57f5b7a22698#%E9%9B%86%E5%90%88%E5%9E%8B) (`set`, `frozenset`)
- [マッピング型](https://qiita.com/nakasan/items/bc9ba8eb57f5b7a22698#%E3%83%9E%E3%83%83%E3%83%94%E3%83%B3%E3%82%B0%E5%9E%8B) (`dict`)

**参考文献**

- [Python公式ドキュメント/標準ライブラリ/4.組み込み型](https://docs.python.jp/3/library/stdtypes.html)

---

# **一般論**
#### **型の分類**
型には、ミュータブル（変更可能）なものとイミュータブル（変更不可能）なものがある。

- 混乱しやすいところについてメモ：　Pythonでは、変数は全てオブジェクトへの参照を格納していて、オブジェクト自体を格納しているわけじゃない。なので、オブジェクトがイミュータブルであろうと、変数の値、つまり「どのオブジェクトを参照するか」は変更できる
    + 例。代入文`x = 1.5`においては、`float`オブジェクト`1.5`が作られて、変数`x`がそのオブジェクトを参照するようになる。そのあとで`x = 2.5`とするときは、`float`オブジェクト`2.5`が作られて、`x`の参照はそっちに移る。`float`オブジェクト`1.5`自体はイミュータブルで変更できないけれど、変数`x`がどのオブジェクトを参照するかは変更できる

シーケンス型、集合型、マッピング型のように、複数のオブジェクトをひとまとめにできる型をコレクション型とかコンテナ型と言う。テキストシーケンス型は含まない。（たぶん、文字列はなにか複数のオブジェクトをひとまとめにして作ってるわけじゃないのだろう。実際、他の言語における`char`のような、1文字を表す型はPythonにはない。）

ただし、コンテナ型はオブジェクトの列ではなく変数の列、つまりオブジェクトへの参照の列だ。

- なので、イミュータブルなコンテナでは、「コンテナの各要素がどのオブジェクトを参照しているか」を変更できないというだけで、参照されているオブジェクト自体を変化させることは自由：

```py3
a = ([1],[2])
a[0].append(3)
a

Out[1]:
([1, 3], [2])
```
イミュータブルなはずのタプル`a`が一見変化して見える。けれど実際は、要素、つまり「どのオブジェクトを参照しているか」は変化していない。ミュータブルなオブジェクト`[1]`は`[1, 3]`に変化したけれど、オブジェクトとしては同一だからだ。

- 変数（オブジェクトへの参照）を変更することと、オブジェクト自体を変化させることは違う。これを意識していると、変なところでハマらずに済む


#### **型について**
Pythonでは全てがオブジェクトであり、`int`や`str`といった型自体も`type`型のオブジェクトだ（`type`の型も`type`だ。ウケる）。これらは型変換する関数としても使える。例えば：

- 数字による文字列`s`を`int`型に変換する:`int(s)`
- `int`型の`i`を`float`型に変換する： `float(i)`
- オブジェクト`x`を`str`型に変換する: `str(x)`
   + `print(x)`では、`x`は暗黙のうちに`str`型へ変換されている
- `type(x)`で`x`の型を取得できる（"`type`型への型変換"とも思える）

Pythonでは全てがオブジェクトであり、クラスすらオブジェクトである。とくに、型はクラスである。`1`が`int`型だというのはつまり、`1`が`int`クラスのインスタンスだということだ。`type`は`type`クラスのインスタンスだ。そんなことできるのか。すさまじい。

```py3
isinstance(type, type)

Out[1]:
True
```

#### **比較演算**
- `x == y`, `x != y`は値が同じか違うかどうか、`x is y`, `x is not y`はオブジェクトとして同じか違うかどうかの真偽値を返す。違うオブジェクトでも値は同じになりえる
    + Pythonでは、演算子の多くは何らかのメソッドの実行の略記である（これによって演算子のオーバーロードが簡単にできる）。`x == y`では、実際はメソッド`x.__eq__(y)`を実行している。「値が同じかどうか」というのはつまり、そのオブジェクトが属すクラスでメソッド`__eq__()`がどう実装されているかによる
    + 全てのオブジェクトは識別値(identity)と呼ばれる整数値を持っていて、`id(x)`で取得できる。`x is y`は`id(x) == id(y)`と等価だ。つまり、（オブジェクトx, yが同時に存在するときだけど）、オブジェクトとして同じであるかどうかは識別値が同じかどうかを見ても分かる
    + 例えば`None`かどうかの判定では、`x == None`より`x is None`を使うほうが良い。`==`の結果はメソッド`__eq__()`の実装によるからだ。あと速いらしい

```py3
x = (1, 2, 3)
y = (1, 2, 3)
x == y, x is y

Out[1]:
(True, False)
```
xとyは違うオブジェクトだけど、値は同じである。


```py3
x = y = (1, 2, 3)
x == y, x is y

Out[1]:
(True, True)
```
変数x, yは同じオブジェクトを参照している。値はもちろん同じだ。

- 比較演算は、`a < b <= c > d != e`, `a is b is None`のようにいくらでも連鎖できる
- `<`とか`>=`みたいな不等号は、複素数`complex`とマッピング`dict`を除いて、どの型でも基本的に使える
    + シーケンス型は辞書式で比較する
    + 集合型では包含関係として比較する。全順序じゃなくて半順序（$x \le y$でも$x \ge y$でもないような、比較不能な場合がある）なので、ソートはできない


#### **コンテナ型・テキストシーケンス型について**
`len(s)`: `s`の要素数。

- `len(s)`は、メソッド`s.__len__()`を呼び出して、結果が`int`かチェックしてから返す、ということをしている

`x in s`, `x not in s`: `s`が`x`を要素として含むかどうか、含まないかどうかの真偽値。

`max(s)`, `min(s)`: `s`の最大、最小の要素。

- 同名の可変引数関数もあって、`max(1,　2,　3)`といった使い方もできる


`s.copy()`: コンテナ`s`の浅いコピーを生成して返す。

- 単なる代入文`x = s`では、変数`x`が`s`と同じオブジェクトを参照するようになるだけだ。一方、浅いコピーは、元のオブジェクトとは別に新しく作られたオブジェクトになっている。つまり、`x = s.copy()`としたあとに`s`の要素を追加・削除しても、`x`は影響を受けない
- ただし、コンテナは変数（オブジェクトへの参照）の列だから、各要素が参照しているオブジェクトは同じだ。参照されているオブジェクト自体を変化させたら、一見`s`と`x`が連動しているように見える
- 各要素が参照しているオブジェクトまでも新しく作るには、深いコピー`copy.deepcopy(s)`を使う
- `s.copy()`はなぜか`tuple`ではできない。そうか、イミュータブルだからコピー作る必要もとくにないってことかなあと思ったら、同じくイミュータブルな`frozenset`ではできる。謎。

`s.clear()`: ミュータブルなコンテナ`s`の全要素を消去する。

- 具体的には、`list`, `set`, `dict`型で使える


#### **イテラブル**
イテラブルを説明するにはまず、イテレータについて説明する必要がある。

イテレータ（イテレータ型のオブジェクト）とは、データの繰り返しの概念を抽象化したもので、`__next__()`メソッドが実装されているようなオブジェクトのこと。このメソッドは、呼び出されるたびになにかオブジェクト（への参照）を吐き出す。吐き出されるオブジェクトは、一般には呼び出されるたびに違う。吐き尽くしたら`StopIteration`例外を上げて、以降は何度呼び出しても`StopIteration`例外を上げる。

- イテレータを進めるには普通は`next(it)`と書く。これはメソッド`it.__next__()`を呼び出す

実は`for`文`for x in s`がやっているのは、`s`に対して`iter()`関数を適用してイテレータ`iter(s)`を作り、このイテレータが吐き出すオブジェクトを`x`として使うことを`StopIteration`例外が上がるまでくり返す、ということ。`iter(s)`でイテレータを作れるオブジェクト、つまり`in`のあとに置けるようなオブジェクト`s`はイテラブルであるという。

- コンテナ、文字列は全てイテラブル。`iter(s)`は、`s`の要素を1個ずつ返すようなイテレータを作る
- イテレータ`it`は`iter`で自分自身を返す（`iter(it) is it`）ので、自明にイテラブル
- `iter(s)`は、新たにイテレータを作るメソッド`s.__iter__()`がもしあれば呼び出し、もし無ければ、要素にアクセスするメソッド`s.__getitem(key)__`（`x = s[key]`とするときに呼び出されるメソッド）を使って新しくイテレータを作る、ということをしている
- イテレータは使い捨てであることに注意。データを取っておきたい場合はコンテナに保存しておく必要がある。例：

```py3
x = map(int, '192.168.0.0'.split('.'))
print(list(x))
print(list(x))

[192, 168, 0, 0]
[]
```
`map`関数はジェネレータというイテレータ型のオブジェクトを返すので、一度`list()`にかけると使い切ってしまう。この場合は、例えば`x = tuple(map(int, '192.168.0.0'.split('.')))`のようにタプルに変換しておけば何度でも呼び出せる。

他の例：

```py3
square_of_odds = (x ** 2 for x in range(10) if x % 2) #奇数の2乗の列
print(25 in square_of_odds)
print(list(square_of_odds))

True
[49, 81]
```
丸括弧`()`による内包表記もジェネレータというイテレータ型のオブジェクトを返す。`in`演算子で要素が入っているか調べると、イテレータをそこまで消費してしまう。要素を保存しておきたいなら、この場合も例えば`tuple(x ** 2 for x in range(10) if x % 2)`のようにタプルに変換しておけばよい。

#### **内包表記**
コンテナを構成するには、外延表記`[a, b, c, ...]`による方法の他に、内包表記`[y for x in iterable]`による方法があり、これがとても便利。

- 後置`if`で条件を追加できて、これも便利: `[y for x in iterable if b]`
- `for`はネストできる: `[z for x in s for y in t]`

# **数値型**
`int`（整数）、`float`（浮動小数点数）、`complex`（複素数）があり、全てイミュータブル。標準ライブラリには、他にも`fraction`（分数）や`decimal`（十進小数）がある。

`bool`（真偽値）は`int`の派生クラスで、`1`に対応する`True`という定数と、`0`に対応する`False`という定数がある。

- `True > False` とか `True * 2 == 2 + False`とかよく分からないことが起きるので、この`bool`の実装は良くないんじゃないかと思う。`bool`を`int`として使わないようにしよう
 
#### **割り算**
- `x / y`: 普通の意味での割り算で、`int`型同士の割り算が`float`型になりうる
- `x // y`: 整数としての割り算の商（Python2では、`int`に対して`/`も`//`もこれになる。普通の意味での割り算にするには、`int`は`float`に型変換する必要があった）
- `x % y`: 整数としての割り算の余り
- `divmod(x, y)`: 商と余りのペア`(x // y, x % y)`

#### **値を丸める**
- `round(x, n=0)`: n桁目で偶数丸め（Python2ではただの四捨五入だった）
- `math.ceil(x)`: 切り上げ、つまり天井関数$\lceil x \rceil$
- `math.floor(x)`: 切り捨て、つまり床関数$\lfloor x \rfloor$

#### **その他**
- `pow(x, y)`, `x ** y`: べき乗
- `abs(x)`: 絶対値

#### **真理値判定**
どんなオブジェクトも`bool`型に変換できる。とくに、`if`や`while`といった`bool`を求める構文や、`and`, `or`, `not`といった`bool`に対する演算に何かオブジェクトを入れると、そのオブジェクトは暗黙のうちに`bool`へ型変換される。

基本的には`True`に変換されるけど、以下の場合には`False`に変換される：

- 定数`None`
- 0に対応する数字: `0`, `0.0`, `0j`, `Decimal(0)`, `Fraction(0)`
- 空のコンテナや文字列: `[]`, `()`, `''`, `{}`, `set()`, `range(0)`

オブジェクトが0かどうか、空かどうかチェックしたいときは結構あるので、そういうときに便利。

- `bool(x)`はメソッド`x.__bool__()`がもしあれば呼び出して、無ければ代わりにメソッド`x.__len__()`を呼び出して0でないかどうか調べる、ということをしている

# **シーケンス型・テキストシーケンス型**
シーケンス型にはミュータブルな`list`（リスト）とイミュータブルな`tuple`（タプル）があって、テキストシーケンス型にはイミュータブルな`str`（文字列）がある。

### **共通の機能**
#### **要素へのアクセス**
- `s[i]`: i番目の要素
- `s[i:j]`: i番目からj-1番目までのスライス
- `s[i:j:k]`: i番目からj-1番目までのk飛びでのスライス

これらは浅いコピーと同じく、`s`とは異なるオブジェクトを新しく作って返している。つまり、`a = s[i:j]`としたあとに`s`の要素を追加・削除しても、`a`は影響を受けない。


番号について：

- 0番目から数え始める。終端は`len(s)-1`番目
- 終わりから逆に数えて何番目かを表すには、引数i, jを負の数にする。終端は-0番目ではなく-1番目であることに注意。-0は単に0だ
    + シーケンスが輪になってると思えば、終端が-1番目なのは始端の0番目の1個前だからと思える
- iやjは、省略するか`None`を入れることで勝手にシーケンスの端になる。どちらの端になるかはkの符号による
    + 例えば、`s[::-1]`で順番をひっくり返したシーケンスを作れる

ネストされたシーケンスでは、`s[2][:][:7]`などと角括弧`[]`を連鎖できる。


#### **和と積**
- `s + t`: シーケンスの結合
- `s * n`, `n * s`: 同じシーケンスをn個結合

コンテナは変数（オブジェクトへの参照）の列なので、和や積においてはなにかオブジェクトが増えているわけではなく、ただ参照が増えている。あるオブジェクトを変更すると、そのオブジェクトを参照している全ての要素が影響を受けて見えることに注意。例えば、こういう挙動が起きる：

```py3
a = [[]] * 3
b = a + [[]] * 2
a[0].append(1)
print(a, b, sep='\n')

[[1], [1], [1]]
[[1], [1], [1], [], []]
```

`a[0].append(1)`では、変数`a[0]`が参照しているオブジェクト`[]`を`[1]`へ変化させているので、そのオブジェクトを参照している他の変数達も`[1]`を返すようになる。

一方、`a[0].append(1)`を`a[0] = [1]`に書き換えてみると、同じじゃないかと思うかもしれないけれど、違う挙動になる：

```py3
a = [[]] * 3
b = a + [[]] * 2
a[0] = [1]
print(a, b, sep='\n')

[[1], [], []]
[[], [], [], [], []]
```
代入`a[0] = [1]`では、変数`a[0]`の参照先をオブジェクト`[]`から別の新しいオブジェクト`[1]`へ移している。元のオブジェクトは変化させず、ある変数がどのオブジェクトを参照するかを変更しているだけなので、元のオブジェクト`[]`を参照している他の変数達は依然として元のオブジェクトを参照し続けることになる。

#### **その他**
- `s.count(x)`: `s`に何回`x`が現れるか
- `s.index(x[, i[, j]])`: （i番目からj-1番目の範囲で）`x`が`s`の何番目で初めて見つかるか。`x`が見つからないとき、`ValueError`を上げる


### **`list`（リスト）**
#### **構成方法**
- 空のリスト: `[]`
- 外延表記: `[a]`, `[a, b, c]`
- 内包表記: `[y for x in iterable]`
- 型変換: `list(iterable)`

浅いコピーは`s.copy()`でも`s[:]`でも作れる。

リストはミュータブルなので、以下のようにシーケンスを変化させるような演算ができる。

#### **書き換え**
- `s[i] = x`: i番目の要素を`x`に入れ替える
- `s[i:j] = t`: i番目からj-1番目を、イテラブルなオブジェクト`t`に置き換える
- `s.append(x)`: `x`を`s`の最後に付け加える
- `s.insert(i, x)`: i番目に`x`を挿入
- `s.reverse()`: 順番をひっくり返す
- `s.sort(key=None, reverse=False)`: （キー関数`key`の返り値で）ソート
  + 新しいオブジェクトを作って返すなら`sorted(s)`を使う。これなら任意のイテラブル`s`で使える

#### **除去**
全消し`s.clear()`という共通の操作以外には：

- `del s[i]`: i番目の要素を除去
- `del s[i:j]`: i番目からj-1番目を除去
  + `s[i:j] = []`とも書ける
- `s.pop(i)`: i番目の要素を返すと同時に除去
- `s.remove(x)`: 最初に現れた`x`を除去



### **`tuple`（タプル）**

#### **構成方法**
- 空のタプル: `()`
- 外延表記: `a, b, c`または`(a, b, c)`
    + 要素が1個の場合は、`a,`または`(a,)`と書く。タプルを作るのは丸括弧`()`ではなくカンマ`,`だからなのだそうだけど、空のタプルを`()`と書くルールと整合してない気がする
    + `f((x, y))`のようにタプルが関数の引数になっているときは、引数が複数個の場合`f(x, y)`と区別するために丸括弧`()`が必要。もし同じ記号を使っていたとしたら、可変引数関数はどちらと解釈して良いか困っていただろう
- 型変換: `tuple(iterable)`
    + 内包表記 `(y for x in iterable)`は`tuple`ではなくジェネレータを返す。タプルにしたい場合は、型変換して`tuple(y for x in iterable)`とする

#### **その他**
- イテラブルなオブジェクトを変数のタプルへ代入できる。`x, y = divmod(3, 2)`や`x, y, z = 1, 2, 3`, `x, y, z = 'dog'`のような同時代入文が書けて便利
- `return x, y`のように多値を返す関数が作れる
- イテラブル`t`の要素がタプルなら、`for x, y in t`のような多値に渡る`for`文が書ける
    + 例えば、ループ`for x in y`で今何ループ目か`i`の情報も欲しいときは、`for i, x in enumerate(y)`とする


### **`str`（文字列）**
`str`では、`in`演算子を部分シーケンスの判定にも使える。

```py3
'京都' in '東京都'

Out[1]:
True
```
#### **構成方法**
- シングルクォートで囲む： `'piyo'`
- ダブルクォートで囲む： `"piyo"`
- シングルクォートかダブルクォートの三重引用符で囲む：`'''piyo'''`, `"""piyo"""`
  + 三重引用符文字列は複数行に分けて書くことができる。複数行のコメントアウトや、クラスや関数にコメント(docstringという)を書くのに使われる


#### **操作**
大文字に変更`s.upper()`とかアルファベットか判定`s.ispalpha()`とか、部分文字列を探す`s.find(sub)`とか置換する`s.replace(old, new)`とか、文字列に対して行いたい操作としてすぐ思いつくメソッドはだいたい用意されている。とくに、以下はとても便利

- `s.join(iterable)`: `iterable`から出てくる文字列達を、間に`s`を挟みながら結合した文字列を返す。`s`として便利なのは空白` `とかカンマ`, `とか改行`\n`とか。普通に結合したいときは`+`でつなげばよい

```py3
'と'.join(('俺','お前','大五郎'))

Out[1]:
'俺とお前と大五郎'
```


- `s.split(sep=None)`: 文字列`s`を区切り文字`sep`で分割する。`sep`が指定されてないときは、任意の長さの空白で分割する：

```py3
'俺とお前と大五郎'.split('と'), ' a b  c'.split()

Out[1]:
(['俺', 'お前', '大五郎'], ['a', 'b', 'c'])
```
- `s.format(*args, **kwargs)`: 書式化操作。長くなりそうなので、また別の場所に改めてまとめる予定。


## **集合型**
ハッシュ可能なオブジェクトの重複なし順序なしコレクションで、ミュータブルな`set`とイミュータブルな`frozenset`がある。

#### **重複がない・ハッシュ可能とは**
- 「重複がない」というのは、`x == y`となる`x`と`y`が同時に含まれることはないということ。`x`と`y`が違うオブジェクト（`x is not y`）であっても、値が同じ（`x == y`）なら重複と見なされる。`x == y`かどうかを一個ずつまともに判定するのは大変なので、要素のオブジェクトはハッシュ可能なものに限っている
- ハッシュ可能なオブジェクトとは、生きている間ずっと変わらないハッシュ値を持っていて（`__hash__()` メソッドを持っていて）、他のオブジェクトと`==`で比較できる(`__eq__()` メソッドを持っている)オブジェクトのこと
- ハッシュ値というのは、オブジェクトが持っているかもしれない整数で、`hash(x)`で取得できる（`__hash__()` メソッドが呼び出される）。ハッシュ値の定義としては、同値`x == y`なオブジェクトのハッシュ値は同じ`hash(x) == hash(y)`でなければならない。なので、ハッシュ可能なオブジェクトなら、コンテナ`s`の各要素`y`に対して`x == y`かどうかを全て調べ上げる操作が効率的にできる。まずハッシュ値が一致する要素があるか調べて、一致したものだけ`x == y`かどうか調べればよいからだ
- 組み込み型では、イミュータブルなもの（数値型、`tuple`, `str`, `frozenset`）はハッシュ可能だけど、ミュータブルなもの（`list`, `set`, `dict`）はハッシュ不可能になっている。ユーザー定義のクラスのインスタンスは、デフォルトではハッシュ可能

#### **`set`の構成方法**
- 空集合: `set()`
  + `{}`だと空の辞書になる
- 外延表記: `{a, b, c}`
- 内包表記: `{y for x in iterable}`
- 型変換: `set(iterable)`

`frozenset`は型変換で作る。

#### **基本的操作**
- `x | y`: 和集合
- `x & y`: 積集合
- `x - y`: 差集合
- `x ^ y`: 対称差（排他的論理和に対応）

`set`はミュータブルなので、以下のような変更操作もできる。

- `x.add(a)`: 要素`a`の追加
- `x.remove(a)`: 要素`a`を除去。含まれていなければ`KeyError`を上げる
- `x.discard(a)`: 要素`a`がもし含まれていれば除去
- `x.pop()`:　要素をどれか1個返すと同時に除去。空集合なら`KeyError`を上げる

## **マッピング型**
ハッシュ可能なオブジェクト（キーという）から任意のオブジェクト（値という）へのマップで、ミュータブルな`dict`がある。キーと値の組（項目という）の、キー重複なしの順序なしコレクションとも言える。

- 同値なキーが複数含まれることはない。集合と同じく、同値かどうかを一個ずつまともに判定するのは大変なので、キーはハッシュ可能なオブジェクトに限っている。キーでなく値なら、重複はいくらあってもよいし、ハッシュ可能である必要はない。

`dict`型に対しては、`in`や`not in`演算子は、キーが含まれているかいないかを判定する。

`list()`や`set()`などで別のコンテナに型変換すると、キーのコンテナが作られる。

#### **構成方法**
- 空の辞書: `{}`
- 外延表記: `{k1:v1, k2:v2, k3:v3}`
- 内包表記: `{key:value for x in iterable}`
- 型変換: `dict([(k1,v1), (k2,v2), (k3,v3)])`
  + `zip`関数を使えば`dict(zip([k1,k2,k3], [v1,v2,v3]))`とも書ける
  + キーワード引数を使った、`dict(k1=v1, k2=v2, k3=v3)`というやり方もある

#### **基本的操作**
- `d[key]`: キー`key`に対する値を返す。`key`がキーになければ`KeyError`を上げる
- `d.get(key, default=None)`: キー`key`に対する値を返す。`key`がキーになければ`default`を返す
- `d[key] = value`: キー`key`に対して値`value`を対応させる項目を追加する。キー`key`が既にあったら値が上書きされる

#### **除去**
- `del d[key]`: キー`key`の項目を除去する。`key`がキーになければ`KeyError`を上げる
- `d.pop(key[, default])`: キー`key`があればその値を返してその項目を除去する。`key`がキーになければ`default`を返すけれど、`default`が設定されてなかったら`KeyError`を上げる
- `d.popitem()`: 項目`(key, value)`をどれか1個返すと同時に除去

#### **ビューオブジェクトの取得**
ビューオブジェクトとは、自身に要素を保持せずに元のオブジェクトへの参照を保っているだけの、イテラブルなオブジェクト。

- `d.items()`: `d`の全項目からなるビューオブジェクトを返す
- `d.keys()`: `d`の全キーからなるビューオブジェクトを返す
- `d.values()`: `d`の全値からなるビューオブジェクトを返す

---

以上です。お読み頂いてありがとうございます。
どこか間違っているところ、怪しいところ、用語の使い方が変なところなどあるかもしれません。指摘、コメント、質問、感想など、何でもお待ちしております。
もし良いなと感じたら、いいねを押して頂けるととても嬉しいです。他の記事も書いてみようというモチベーションになります。