
## TL;DR

sort()は元のリストをソートするメソッドに対し、sorted() は、常に新しいオブジェクトで返す関数である。

### sorted() のポイント

- iterable の要素を並べ替えた新たなリストを返す
- 結果は常に新しいオブジェクトで返される
- 引数に不変な型も受け取ることができる
- 戻り値は常にリストである
- 文字と整数が混在するとエラーになるので引数に無名関数を使う

```python
sorted(iterable, *, key=None, reverse=False)
```

[sorted() - 組み込み関数 — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/library/functions.html#sorted)

### sorted 関数 と sort メソッド の違い

リストをソートする場合、以下の 2 通りの方法がある。

- 組み込み関数 sorted 関数
- リスト自身が持つ sort メソッド

sort()は元のリストをソートするメソッドに対し、sorted() は、常に新しいオブジェクトで返す関数。

```python
# sorted()
sorted(list型変数)

# sort()
list型変数.sort()

```

違いを比較してみる。sort()は元のリストも破壊的に変更されてしまうが、sorted()は元のリストは変更されない。

#### sort()

sort()によって元のリストは変更されてしまう。

```python
# sort()
x = [8, 2, 7, 6, 1]

print(x) # 元のリストも破壊的に変更された
# [1, 2, 6, 7, 8]

```

sort()自体は None を返す。

```python
x = [4, 2, 1, 5, 3]

y = x.sort()
print(y) # None
print(x) # [1, 2, 3, 4, 5]
```

#### sorted()

sorted()は元のリストは変更されない。

```python
# sorted()
s = [8, 2, 7, 6, 1]

print(sorted(s))
# [1, 2, 6, 7, 8]

print(s) # 元のリストは変更されない
# [8, 2, 7, 6, 1]
```

### 絶対値で並べ替える

sorted()を使う場合、リストにマイナスが入ると、マイナス順に **ソート** されてしまう。絶対値でソートしたいときは、第二引数に key 引数を設定する。

```python
sorted(イテラブル, key=abs)
```

マイナス値が入っている整数を並べ替えてみよう。

```python
# リストにマイナスが入ると、マイナス順にソートされる

x = [1, -2, 3, -4]
x.sort()
print(x)

# [-4, -2, 1, 3]

# 絶対値でソートしたいときは、key引数を使う

y = [1, -2, 3, -4]
print(sorted(y, key=abs))

# [1, -2, 3, -4]
```

### 文字と整数をソート

文字と整数が混在するときは、エラーになるので、引数 key に無名関数を指定する。以下は lambda を key に入れている例。ソートされるときに、lambda に渡されるため、比較に利用する値を返す。

```python
x = ['1', 2, '3', 4]
sorted(x, key=lambda v: int(v))

# sorted(リスト, 名前=lambda 引数: 式)
# ['1', 2, '3', 4]
```

### 逆順にソートする

逆順にソートしたいときは、reverse=True を使う。

```python
x = [1, 3, 9, 2]
sorted(x, reverse=True)

# [9, 3, 2, 1]
```

### 大文字と小文字を区別せずにソートする

関数を指定することもできる。key に関数 str.lower を指定すると要素が小文字に変換された後に、ソート結果が出力される。

```python
x = ['d', 'B', 'a', 'c']
print(sorted(x)) # ['B', 'a', 'c', 'd']

y = ['d', 'B', 'a', 'c']
print(sorted(y, key=str.lower)) # ['a', 'B', 'c', 'd']
```


sort()は元のリストをソートするメソッドに対し、sorted()は、常に新しいオブジェクトで返す関数である。sorted()のポイント

Python : sorted() は、イテラブル要素を並び替える関数である


## TL;DR

hasattr() は、文字列がオブジェクトの属性名（メソッドやプロパティ）の一つであった場合 True を返す。オブジェクトが指定の属性を持つかどうか事前に判定することができる。

### hasattr() のポイント

- object が name の属性を持っている場合に True を返す
- 引数はオブジェクトと文字列
- 必要な属性のみ確認したい場合に使う

```python
hasattr(object, name)
```

ドキュメントに「この関数は、getattr(object, name) を呼び出して AttributeError を送出するかどうかを見ることで実装されています。」と書かれている。

つまり、getattr() で指定の属性を取得できれば True 、AttributeError が発生すると False を返す。

[hasattr() - 組み込み関数 — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/library/functions.html#hasattr)

### 属性を調べる組み込み関数

Python は動的に構成を変更することが可能なので、オブジェクトがどういった変数やメソッドを保持しているのか分からないときがある。

そのようなときに、メソッドを呼び出してうまく実行されるか願うのではなく、要求されているメソッドが存在するかチェックする必要がある。

#### dir()

dir() 関数を使うとオブジェクトの全ての属性を返すことができる。

```python
class A:
    def __init__(self, x, y):
        self.x = x
        self.y = y

a = A(1, 2)
print(dir(a))

# ['__class__', '__delattr__', '__dict__',... 'x', 'y']

```

#### hasattr()

あるオブジェクトが、指定した属性を保持しているかだけ調べたい場合は、hasattr()を使うとよい。

```python
class A:
    def __init__(self, x, y):
        self.x = x
        self.y = y

a = A(1, 2)
print(hasattr(a, 'x'))

# True
```

メソッドを調べる。

```python
class A:
    pass
    def b(self):
        pass
a = A
a.b(1)
dir(a) # ['b']
hasattr(a, 'b') # True
```

### オブジェクトの属性を操作したい場合

オブジェクトの属性を操作する組み込み関数に、getattr()、setattr()、delattr()があるが、これらを使うと、オブジェクトの属性を動的に操作することができる。


hasattr()は、文字列がオブジェクトの属性名（メソッドやプロパティ）の一つであった場合Trueを返す。オブジェクトが指定の属性を持つかどうか事前に判

Python : hasattr() はオブジェクトの属性の有無を調べる


## TL;DR

Python は動的型付き言語なので、プログラム実行中にオブジェクトの属性を追加したり、削除することができる。getattr()は、オブジェクトの属性の値を返す組み込み関数である。メソッド名を入力せずに、文字列の内容を元にメソッドを呼び出すことが可能である。

### getattr() のポイント

```python
getattr(object, name[, default])
```

第一引数の object にはオブジェクト名、第二引数 name には属性を指定する。属性が存在しない場合はデフォルト値 default を返す。

- オブジェクトの属性の値を返す
- インスタンス変数だけでなく、メソッドも取得できる
- 第二引数は'文字列'でなくてはならない
- 第二引数に組み込み関数を指定し適用できる
- getattr(a, 'b') は a.b と等価である
- ループで使うことができる

公式には以下のように記載されている。

> object の指名された属性の値を返します。 name は文字列でなくてはなりません。文字列がオブジェクトの属性の一つの名前であった場合、戻り値はその属性の値になります。 例えば、 getattr(x, 'foobar') は x.foobar と等価です。指名された属性が存在しない場合、 default が与えられていればそれが返され、そうでない場合には AttributeError が送出されます。

[getattr() - 組み込み関数 — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/library/functions.html#getattr)

### setattr() で属性を設定し、getattr()で属性を取り出す

以下は、setattr() を用いてクラス A の属性に値をセットして、getattr() で値を返している。

```python
class A:
    pass

a = A()
setattr(a, 'txt','x')
setattr(a, 'No', 2)

getattr(a, 'txt') # 'x'
getattr(a, 'No') # 2
```

### 第三引数にデフォルト値を指定する

属性が存在しない場合は AttributeError になるので、第三引数にデフォルト値を指定してみよう。

```python
class A:
    name = 'Taro'

a = A()

a.name # 'Taro'
getattr(a, 'name') # 'Taro'

# getattr(a, 'mail') # 属性が存在しない場合はAttributeErrorになる
getattr(a, 'mail', 'Gmail') # 第三引数にデフォルト値を指定する 'Gmail'
```

### メソッドの取得

すべてのテキストを大文字にする upper()メソッドを取得してみる。getattr() の第二引数に upper()を指定すると、txt.upper() と同じになる。

```python
txt = 'abcde'
a = getattr(txt, 'upper')
a() # 'ABCDE'

# txt.upper() と同じ結果を返している
```

### メソッドに引数を指定

メソッドに引数を指定する場合、getattr(クラス名, 'メソッド名')('引数')のように書くとよい。

```python
class A:
    name = 'Taro'
    def hoge(self, b):
        print(b)

a = A()
getattr(a, 'name') # 'Taro'
getattr(a, 'hoge')('hello') # hello
```

### 例外

例外を適用してみる。

```python
class a():
    def japan(self):
        print ('こんにちは')
    def english(self):
        print ('hello')
    def unknown(self):
        print ('何語ですか？')

def hello(lang):
    try:
        getattr(a(),lang)()
    except:
        getattr(a(),'unknown')()

hello('japan') # こんにちは
hello('english') # hello
hello('german') # 何語ですか？
```

### ループで使う

メソッドの反復処理を行うこともできる。以下は、メソッドをリストに入れて for 文で順に処理を実行している例。

```python
class A:
    def add(self, x, y):
        return x + y
    def sub(self, x, y):
        return x - y

a = A()

for i in ['add', 'sub']:
    f = getattr(a, i)(1, 2)
    print(f)

# 3
# -1
```


Pythonは動的型付き言語なので、プログラム実行中にオブジェクトの属性を追加したり、削除することができる。getattr()は、オブジェクトの属性の値を返す

Python : getattr()はオブジェクトの属性の値を返す


## TL;DR

filter()は、イテラブルの要素を絞り込む。第一引数に関数、第二引数にイテラブルを指定する。イテラブル要素を順に関数に渡し判定する。関数は無名関数でもよい。

### filter() のポイント

- 関数が True を返す要素のリストを返す
- イテラブルの中から指定条件に合致した要素を抽出する
- リストに変換可能

```python
filter(function, iterable)
```

iterable はシーケンスか、反復をサポートするコンテナか、イテレータとなる。

[filter() - 組み込み関数 — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/library/functions.html#filter)

filter()だけではオブジェクトが返されるだけで数値は表示されないので、値を表示するときは、for か list を使う。

```python
filter(関数, イテラブル)

# リストで出力
list(filter())

# 数値を出力
for hoge in filter(関数, x):
    print(hoge)
```

### 関数を使って奇数を出力

関数を使うと以下のようになる。

```python
def a(n):
    return (n%2) == 1

b = [1, 2, 3, 4, 5, 6]
list(filter(a, b))

# [1, 3, 5]
```

### lambda（ラムダ式）を使ってリストで出力する

3 より大きい数値をリストで出力してみよう。

```python
x = (1, 2, 3, 4, 5)
list(filter(lambda i: i > 2, x))
[3, 4, 5]
```

### lambda（ラムダ式）を使って偶数を出力する

for 文を使って、偶数を出力してみよう。

```python
# 偶数を抽出する

x = [1, 2, 3, 4, 5, 6]

for hoge in filter(lambda i: i % 2 == 0, x):
    print(hoge)

# 2
# 4
# 6
```

### None

function が None なら iterable の偽である要素がすべて除去される。第一引数に None を渡すと真理値評価の結果で絞り込まれる。

```python
a = [None, [], {}, 0, '', False, 1, 'A']
list(filter(None, a))

# [1, 'A']
```


filter()は、イテラブルの要素を絞り込む。第一引数に関数、第二引数にイテラブルを指定する。イテラブル要素を順に関数に渡し判定する。関数は無名関数でもよい。

Python : filter()はイテラブルの要素を絞り込む


## TL;DR

callable()は、呼び出し可能オブジェクトを判定する組み込み関数である。呼び出し可能オブジェクトとは、関数やメソッドのように () を付けて呼び出せるオブジェクトのことである。

### callable() のポイント

- object 引数が呼び出し可能オブジェクトであれば True を返す
- クラスは呼び出し可能である
- 関数は呼び出し可能である
- インスタンスオブジェクトは呼び出しできないが
- `__call__()` を持つインスタンスは () を付けて呼び出せる
- 関数が引数となる場合に使う

```python
callable(object)
```

### False のケース

呼び出し可能オブジェクトでない場合、False が返る。

```python
x = 1
print(callable(x))

# False
```

クラスは 呼び出し可能オブジェクトなので True になるが、

```python
class A:
  def func(self):
    pass

callable(A)

# True
```

インスタンスオブジェクトは False になる。

```python
class A:
  def func(self):
    pass

a = A()
callable(a)

# False
```

しかし、特殊メソッド`__call__()` を実装したインスタンスでは True を返す。`__call__`を実装したクラスでは、インスタンスを関数のように呼び出すことができるようになる。しかしなぜ、関数のように呼び出し可能になるのだろうか？

```python
class A:
  def __call__(self):
    pass

a = A()
callable(a)

# True
```

関数の中身を dir()で見ると、`__call__` が含まれている。

```python
def func():
    pass

dir(func)

#['__annotations__',
# '__call__',
# '__class__',
# '__str__',
# '__subclasshook__']
```

これは、関数オブジェクトが `__call__` を実装した function クラスのインスタンスであることを示している。

### True のケース

#### 関数

```python
def a(x):
    return x

callable(a)

# True
```

#### ラムダ関数

ラムダ関数も呼び出し可能な関数なので True となる。

```python
callable(lambda x: x + 1)

# True
```

#### クラス

カスタムクラスは`__call__` を実装すれば、関数のように呼び出し可能となるので True が返る。

```python
class A:
  def __call__(self):
    pass

print(callable(A))

# True
```

クラスのメソッドも True になる。

```python
class A:
    def calc(self, x):
        self.x = x
    def talk(self):
        print(self)

b = 'hoge'

a = A()

callable(A) # True
callable(a.calc) # True
callable(b) # False
```


callable()は、呼び出し可能オブジェクトを判定する組み込み関数である。呼び出し可能オブジェクトとは、関数やメソッドのように()を付けて呼び出せるオブ

Python : callable()は、呼び出し可能オブジェクトかどうか判定する


## TL;DR

基底クラスのコンストラクタをオーバーライドするなら、スーパークラスのコンストラクタも呼び出す必要がある。なぜなら、オブジェクトがきちんと初期化されないからだ。

### `super().__init__()` のポイント

- 基底クラス（継承元）のコンストラクタをオーバーライドする
- コンストラクタの上書きは`super().__init__()`
- メソッドの上書きは`super().メソッド名()`

### メソッドを上書きする場合

基底クラスのメソッドやコンストラクタを上書きするには、名前を明示することなく親クラスを参照できる super() を使う。

[super(\[type\[, object-or-type\]\]) - 組み込み関数 — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/library/functions.html#super)

例えば、基底クラスが持つメソッドと同名のメソッドを定義すると、そのメソッドを上書きできる。基底クラスのメソッドやコンストラクタを利用する場合、明示的に呼び出す必要がある。

```python
# 基底クラス(継承元)
class Parent:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def w(self):
        return self.b

# 継承先
class Child(Parent):
    def w(self): # メソッドのオーバーライド
        return super().w()

child = Child(0, 'hello')
child.w()

# 'hello'
```

### 基底クラスのコンストラクタを上書きする場合

サブクラスにおいて、コンストラクタを定義したい場合はどうすればいいのだろうか？

サブクラスで`__init__`を定義すると、親の`__init__`が上書きされてしまう。親の`__init__`を、サブクラスで上書きすると未定義のままになり、以下のような例外が発生する。

```python
AttributeError    Traceback (most recent call last)
```

エラーが起こらないように、親クラスのコンストラクタをオーバーライドする場合も、`__init__`の処理の最初に、スーパークラスの`__init__`の呼び出しをするとよい。

```python
class クラス名(継承元クラス):
    def __init__(self, 引数):
        super().__init__(引数)
        処理
```

以下のコードは、基底クラスのコンストラクタをオーバーライドする例である。

```python
# 基底クラス(継承元)
class A:
    def __init__(self, name):
       self.name = name

# 継承先
class B(A):
    def __init__(self, name, mail):
        super().__init__(name) # 基底クラスのコンストラクタをオーバーライド
        self.mail = mail

b = B("yamada", "gmail")
b.name

# 'yamada'
```

`super().__init__()`をつけることで、親クラスの`__init__`と同じ処理を実行してくれるのである。

```python
# 基底クラス(継承元)
class Parent:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def my_name(self):
        print("名前は" + self.name + "。年齢は" + str(self.age) + "歳。")

# 継承先
class Child(Parent):
    def __init__(self, name, age):
        super().__init__(name, age)  # 基底クラスのコンストラクタをオーバーライド

    def my_hello(self):
        print("こんにちは")

# インスタンス化
yamada = Child("山田", 20)
yamada.my_name()
yamada.my_hello()

# 名前は山田。年齢は20歳。
# こんにちは
```


基底クラスのコンストラクタをオーバーライドするなら、スーパークラスのコンストラクタも呼び出す必要がある。なぜなら、オブジェクトがきちんと初期化されないからだ。

Python : super().__init__()は基底クラスのコンストラクタをオーバーライドする


## TL;DR

isinstance()はオブジェクトの型を調べる組み込み関数である。引数のチェック、関数、メソッドの戻り値を調べるときに利用する。組み込み関数の type 関数や isinstance 関数で型を調べることができる。

### isinstance()のポイント

```python
isinstace(オブジェクト, クラス)
```

- 第一引数に渡したオブジェクトが第二引数に渡したクラスに属していれば True を返す
- 結果は bool 型で得ることができる

整数か調べる。

```python
isinstance(100, int)

# True
```

第二引数にタプルを使う。第二引数が型オブジェクトのタプルの場合、 第一引数がいずれかのインスタンスであれば True を返す。

```python
isinstance(1, (int, str))

# True
```

文字型が調べる。

```python
isinstance('a', str)
# True
```

辞書の型を調べる。

```python
a = {}
isinstance(a, dict)
# True

a = {}
isinstance(a, object)
# True

a = {}
isinstance(a, int)
# False
```

クラスを調べる。

```python
class A:
    pass

a = A()
isinstance(a, A)

# True
```

### type() との違い

isinstance()は、サブクラスから生成したオブジェクトはスーパークラスと同じ型であると判定する。

しかし、type()は、サブクラスとスーパークラスは異なると判定する。

```python
class A():
    pass

class B(A):
    pass

a = A()
b = B()

isinstance(a, A) # True
isinstance(b, A) # True

type(a) == A # True
type(b) == A # False
```


isinstance()はオブジェクトの型を調べる組み込み関数である。引数のチェック、関数、メソッドの戻り値を調べるときに利用する。組み込み関数のtype関

Python : isinstance()はオブジェクトの型を調べる


## TL;DR

len()は、引数に渡したオブジェクトの長さや要素の数を取得する組み込み関数である。

### len 関数のポイント

- len 関数はシーケンスの長さ（要素の数）を返す
- 0 以上の整数を返す
- 0 以上の整数でない場合は全てエラーになる

引数はシーケンス (文字列、バイト列、タプル、リスト、range 等) 、もしくはコレクション (辞書、集合、凍結集合等) となる。

len 関数は内部で`__len__()`メソッドを実行しているので、len 関数と、`__len__()`メソッドの結果は同じになる

#### 文字数の取得

文字列を渡すと、文字数を取得できる。

```python
len('abcd')

# 4

'abcd'.__len__()

# 4
```

#### リストの要素数を取得

リストの要素数を数える。

```python
x = [1, 2, 3, 4]
len(x)

# 4
```

#### タプルの要素数を取得

```python
x = (1, 2, 3, 4)
len(x)

# 4
```

#### 辞書の要素数を取得

```python
x = {'a': 0, 'b': 1, 'c': 2, 'd':3}

len(x)

# 4
```

#### 数値はエラーになる

しかし、数値はエラーになる

```python
len(4)

# Traceback (most recent call last)
# <ipython-input-10-00d7b5c8c880> in <module>()
# ----> 1 len(4)
#
# TypeError: object of type 'int' has no len()
```

len()は`__len__()`があれば動く。0 以上の整数を返す。

```python
class A:
    def __len__(self):
        return 1

a = A()
len(a)

# 1
```

len()は、`__len__()`の値が int になっているか判定しているので、int 以外の値を返すとエラーになる。したがって 0 以上の整数でない場合は全てエラーになる。

```python
class A:
    def __len__(self):
        return 5.0

a = A()
len(a)

# Traceback (most recent call last)
# <ipython-input-6-c0b67c89f783> in <module>()
#       4
#       5 a = A()
# ----> 6 len(a)
#
# TypeError: 'float' object cannot be interpreted as an integer
```


len()は、引数に渡したオブジェクトの長さや要素の数を取得する組み込み関数である。len関数のポイントlen関数はシーケンスの長さ

Python : len()は引数に渡したオブジェクトの長さや要素の数を取得する


## TL;DR

zip()は複数のイテラブルを受け取り、タプルで返す。`zip(*[iter(s)]*n)` を使うことでイテラブルを分割することができる。

### zip() のポイント

- 複数のイテラブルからイテレータを作る
- イテラブルの中で最短のものが尽きると停止する
- `zip(*[iter(s)]*n)` でイテラブルを分割することができる
- 余りを表示するには zip_longest()関数をインポートする

```python
a = zip('ABCD', '12')
list(a)

# [('A', '1'), ('B', '2')]
```

### 複数のリスト

複数のリストを適用すると、最も短いイテラブルの数で停止する。

```python
x = [1,2,3]
y = [4,5,6,7]
z = [8,9] # → 一番短いイテラブル

list(zip(x,y,z))
# [(1, 4, 8), (2, 5, 9)]
```

### for 文 で使う

もちろん、for 文で使うこともできる。

```python
a = [1, 2, 3, 4]
b = ['A', 'B']
c = ['い', 'ろ', 'は']

for a, b, c in zip(a, b, c):
    print(a, b, c)

# 1 A い
# 2 B ろ
```

### イテラブルを分割する

`zip(*[iter(s)]*n)` を使えば、イテラブルを n 回分割することができる。

```python
b = [1, 2, 3, 4, 5, 6, 7]
c = zip(*[iter(b)]*2)

list(c)

# [(1, 2), (3, 4), (5, 6)]
```

中身を見てみると、同じイテレータを参照している。

```python
b = [1, 2, 3, 4, 5, 6, 7]
[iter(b)]*2

# [<list_iterator at 0x7f7eab2ad790>,
#  <list_iterator at 0x7f7eab2ad790>]
```

公式サイトには以下のように書かれている。

> `zip(*[iter(s)]*n)` を使ってデータ系列を長さ n のグループにクラスタリング（グループ分け）するイディオム（慣用表現）が使えます。これは、各出力タプルがイテレータを n 回呼び出した結果となるよう、 同じ イテレータを n 回繰り返します。これは入力を長さ n のチャンクに分割する効果があります。 [組み込み関数 — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/library/functions.html#zip)

しかし、なぜこうなるのか？

[iterator-zip（\_ \[iter（s）\] \_ n）は Python でどのように機能しますか？ - スタックオーバーフロー](https://stackoverflow.com/questions/2233204/how-does-zipitersn-work-in-python)に解説があった。例えば以下の場合、

```python
s = [1,2,3,4,5,6,7,8,9]
n = 3

list(zip(*[iter(s)]*n))

# [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
```

上を展開すると以下になる。同じイテレータを 3 回渡すと、zip()されるたびにイテレータからアイテムがプルされる。なお、余りは捨てられる。

```python
s = iter([1,2,3,4,5,6,7,8,9])
list(zip(s, s, s))

# [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
```

### zip_longest():一番長いイテラブルを出力

余りを表示するには、intertools.zip_longest()関数をインポートするとよい。一番長いイテラブルに合わせることができる。

```python
from itertools import zip_longest

b = [1, 2, 3, 4, 5, 6, 7]
c = zip_longest(*[iter(b)]*2)

list(c)

# [(1, 2), (3, 4), (5, 6), (7, None)]
```

### fillvalue:任意の値で埋める

None 以外の値で埋めたいときは、どうすればいいのか？引数に fillvalue を指定することで、任意の値で埋めることができる。

```python
from itertools import zip_longest
x = [1,2,3]
y = [4,5,6,7]
z = [8,9]

list(zip_longest(x, y, z, fillvalue=100))

# [(1, 4, 8), (2, 5, 9), (3, 6, 100), (100, 7, 100)]

```


zip()は複数のイテラブルを受け取り、タプルで返す。`zip(iter(s)n)`を使うことでイテラブルを分割することができる。zip(

Python : zip()は複数のイテラブルを受け取りタプルで返す


## TL;DR

Python におけるイテレータとはなんだろう？イテレータオブジェクト（list、tuple、set など）は内部にイテレータを持ち、for 文で要素を反復的に処理する際に自動的に使われる。要は、コンテナに入っている要素一つ一つアクセスして返している。

### イテレータのポイント

- `__iter__()`と`__next__()`が実装されている
- コンテナに入っている要素を一つ一つアクセスして返す
- イテレータは使い終わると空になる

for i in X と書いたとき、for 文は X の iter() を呼び出し、その戻り値を利用する。この戻り値はイテレータと呼ばれる。in の後に指定されたオブジェクトには必ず iter()が適用される。

### イテレータの中身

イテレータオブジェクトには、`__iter__()`と`__next__()`が実装されている。

実際に、iter()のプロパティを見てみると確認できる。

iter()のプロパティ

```python
a = iter([1, 2, 3, 4])
print(dir(a))

# [...'__iter__', '__next__',...]

```

list のプロパティ

```python
a = [1, 2, 3, 4]
print(dir(a))

# [...'__iter__'...]
# '__next__' は含まれない
```

list には`__next__()`が含まれていない。つまりイテレータを生成できるが、次の要素にアクセスすることができないのである。

### `__iter__()`と`__next__()` の違い

`__iter__()`の戻り値は、そのイテレータ自身となる。反復機能を与える処理。

`__next__()`は、ループのたびに呼び出される。次の要素にアクセスする処理。

for や辞書以外のオブジェクトであっても`__iter__()`を実装すれば、イテレーションは可能である。例えばイテレータの機能を持つクラスを実装するには、`__iter__()`を実装すればよい。

### イテラブルとイテレータの違い

イテラブルという言葉も頻出するので違いを書いておく。

`__iter__()`を実装しているオブジェクトは「イテラブル」と呼ばれ、`__next__()`を実装しているオブジェクトは「イテレータ」と呼ばれる。

list はイテラブルであり、イテレータではない。

イテラブル

- `__iter__()`を実装
- `__iter__()`の戻り値は任意のイテレータ

イテレータ

- `__iter__()`と`__next__()`を実装
- `__iter__()`の戻り値は self

イテレータは必ずイテラブルだが、イテラブルはイテレータとは限らない。名前が似ているのでややこしい。

### list と イテレータの違い

イテレータオブジェクトは次の要素を取得できるが、list には次の要素を取得する機能はない。

欲しいときに 1 個ずつ値を取得するには、値を 1 個だけ計算する関数があればよい。list を使って最初に全ての値を用意する必要はない。イテレータの代わりに list を使うのはメモリの無駄なのだ。

### イテレータは、使い終わると要素が空になる

イテレータは使い終わると空になるが、list は要素が残る。

```python
list → 全部残る

list → イテレータ（next） → 空
```

### iter() の作り方

実際にイテレータを作ってみる。

`__iter__()`は、イテレータオブジェクトを返す。print すると `<list_iterator object at 0x7fae4ab4f2d0>` と表示されている。list を使うと要素が表示された。

```python
a = [1, 2, 3, 4]
b = iter(a)
print(b)
list(b)

# <list_iterator object at 0x7fae4ab4f2d0>
# [1, 2, 3, 4]
```

iter()を使うと、イテラブルなオブジェクト（iter）からイテレータ（next）を取得できる。

```python
a = iter([1, 2, 3, 4])
next(a)
next(a)

# 2
```

### next() の使い方

next()を使い、イテレータオブジェクトから、順に要素を取り出すことができる。

```python
a = [1, 2, 3]
b = iter(a)
next(b)
next(b)
next(b)

# 3
```

### `__next__`

`__next__`メソッドを呼び出すと、イテレータは次の値を返す。ループのたびに呼び出される。返す値がなくなると、例外である StopIteration を生成する。

組み込み関数 next()にイテレータを渡すと、そのイテレータの`__next__()`が呼び出され、next()の戻り値として受け取れる。つまり、next() を使ってイテレータオブジェクトすると`__next__`と同じになる。

### ジェネレーター

ジェネレーター（yield 文を含む関数）は、next 関数で次の値を取り出せる。yield 文によって値が一つ生成されるたびに関数は停止し、再開を待つ。

以下のコードは、next が呼ばれるまで処理が中断されている例である。

```python
def g():
    yield 1
    yield 2
    yield 3

a = g()
print(next(a))
print(next(a))
print(next(a))

# 1
# 2
# 3
# StopIteration → 値がなくなると例外
```

next()を`__next__()` に変えても同じ結果になる。

```python
def g():
    yield 1
    yield 2
    yield 3

a = g()
print(a.__next__())
print(a.__next__())
print(a.__next__())

# 1
# 2
# 3
```


Pythonにおけるイテレータとはなんだろう？イテレータオブジェクト（list、tuple、setなど）は内部にイテレータを持ち、for文で要素を反復的に処

2021-9-10

Python : sorted() は、イテラブル要素を並び替える関数である

2021-9-9

Python : hasattr() はオブジェクトの属性の有無を調べる

2021-9-8

Python : getattr()はオブジェクトの属性の値を返す

2021-9-7

Python : filter()はイテラブルの要素を絞り込む

2021-9-6

Python : callable()は、呼び出し可能オブジェクトかどうか判定する

2021-9-3

Python : super().init()は基底クラスのコンストラクタをオーバーライドする

2021-9-2

Python : isinstance()はオブジェクトの型を調べる

2021-9-1

Python : len()は引数に渡したオブジェクトの長さや要素の数を取得する

2021-8-31

Python : zip()は複数のイテラブルを受け取りタプルで返す

2021-8-30

Python : iter()はイテレータを返し、next()は次の要素を返す

2021-9-10

Python : sorted() は、イテラブル要素を並び替える関数である

2021-9-9

Python : hasattr() はオブジェクトの属性の有無を調べる

2021-9-8

Python : getattr()はオブジェクトの属性の値を返す

2021-9-7

Python : filter()はイテラブルの要素を絞り込む

2021-9-6

Python : callable()は、呼び出し可能オブジェクトかどうか判定する

2021-9-3

Python : super().__init__()は基底クラスのコンストラクタをオーバーライドする

2021-9-2

Python : isinstance()はオブジェクトの型を調べる

2021-9-1

Python : len()は引数に渡したオブジェクトの長さや要素の数を取得する

2021-8-31

Python : zip()は複数のイテラブルを受け取りタプルで返す

2021-8-30

Python : __iter__()はイテレータを返し、__next__()は次の要素を返す

Python : super().init()は基底クラスのコンストラクタをオーバーライドする

Python : iter()はイテレータを返し、next()は次の要素を返す