
## 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文で要素を反復的に処

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


## TL;DR

特殊メソッドである`__call__`はインスタンスを関数オブジェクトとして扱う。`__call__`を実装したクラスでは、インスタンスを関数のように呼び出すことができる。

### `__call__` のポイント

- インスタンスを関数のように呼び出すことができる
- 関数を呼び出すよりスマートな書き方になる

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

```python
def func():
    pass

dir(func)

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

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

通常、インスタンスを関数のように扱うとエラーが出る。

```python
class A:
    def __init__(self):
        print('init')

a = A() # init
a() # エラーになる
```

次に`__call__`をつけてみると、インスタンスを関数のように扱うことができるようになる。

```python
class A:
    def __init__(self):
        print('init')
    def __call__(self):
        print('call')

a = A() # init
a() # call
```

インスタンス、`__call__`、関数を比較。`__call__`を使うことで、関数を呼び出すよりスマートな書き方になる。

```python
class A:
    def __init__(self, x):
        self.x = x
        print(f'{x} init')
    def __call__(self, y):
        self.y = y
        print(f'{self.x + y} call')
    def func(self, z):
        self.z = z
        print(f'{self.x + z} func')

a = A(1) # 1 init
a.func(2) # 3 func
a(2) # 3 call
```


特殊メソッドである __call__ はインスタンスを関数オブジェクトとして扱う。__call__ を実装したクラスでは、インスタンスを関数のように呼び出すこ

Python :  __call__()は、インスタンスを関数のように扱う


## TL;DR

`__str__()`と`__repr__()`は、どちらもオブジェクトの文字列表現を返す特殊メソッドである。

### `__str__()`と`__repr__()`のポイント

- `__str__()`は、オブジェクトを文字列で表現する特殊メソッド
- `__str__()`は、print()に渡された場合に呼ばれる
- str()はユーザーが分かりやすい形で表示される
- repr()は引数にシングルクォーテーションマークを付けて返す

`__repr__()`は、組み込み関数の repr()が呼び出される。print()に渡された場合は、`__str__()`が呼ばれる。

その前に str()と repr() の違いについて説明しておく。

### str()と repr() の違い

str()は、object の 文字列、つまりユーザーが分かりやすい形で表示され、repr()はオブジェクトの印字可能な表現を含む文字列を返す。

```python
str('hoge')

# 'hoge'
```

分かりやすくいうと、repr()は、引数にシングルクォーテーションマークを付けて返す。

```python
repr('hoge')

# ''hoge''
```

### `__str__()`と`__repr__()` の違い

`__str__()`について公式を翻訳した。

> str(object)や，組み込み関数 format()，print()によって呼び出され，オブジェクトの "非公式 "またはきれいに印刷できる文字列表現を計算します．戻り値は、文字列オブジェクトでなければなりません。

> このメソッドは object.`__repr__()` とは異なり、 `__str__()` が有効な Python 式を返すことは期待されていません: より便利で簡潔な表現が使用できます。

> 組み込み型の object で定義されたデフォルトの実装では、 `object.__repr__()` を呼び出します。

`__str__()`は、オブジェクトを文字列で表現する特殊メソッドである。str(object)や、組み込み関数の print()に渡された場合に呼ばれる。

次に、`__repr__()` について公式を翻訳した。

> オブジェクトの文字列表現を計算するために repr() 組み込み関数によって呼び出されます。これは同じ値のオブジェクトを再生成するのに使用できる有効な Python の式のように見えるべきです。それができない場合は、<...some useful description...>という形式の文字列が返されます。

> 戻り値は、文字列オブジェクトでなければなりません。もし、あるクラスが`__repr__()`を定義していて、`__str__()`を定義していない場合、そのクラスのインスタンスの "非公式 "な文字列表現が必要な場合には、`__repr__()`も使用されます。

参考：[3\. Data model — Python 3.3.7 documentation](https://docs.python.org/3.3/reference/datamodel.html)

オブジェクト名のみを入力すると`object.__repr__()`が呼ばれるので、以下のような結果となる。`__repr__()`は、組み込み関数の repr()が呼び出される。

```python
a = 'hoge'
a

# 'hoge'
```

しかし、組み込み関数である print() を経由すると`__str__()`が呼ばれるので、上の結果と異なる。

```python
a = 'hoge'
print(a)

# hoge
```

オブジェクトだと`object.__repr__()`が呼ばれる。

```python
class A:
    def __init__(self, x):
        self.x = x
    def __str__(self):
        return 'str'
    def __repr__(self):
        return 'repr'

a = A(1)
a

# repr
```

print() を経由すると`__str__()`が呼ばれる。

```python
class A:
    def __init__(self, x):
        self.x = x
    def __str__(self):
        return 'str'
    def __repr__(self):
        return 'repr'

a = A(1)
print(a)

# str
```


オブジェクトの文字列表現を返す特殊メソッドである。

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-8-27

Python : call()は、インスタンスを関数のように扱う

2021-8-26

Python : str() と repr() は、オブジェクトを文字列で表現する

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-8-27

Python : __call__()は、インスタンスを関数のように扱う

2021-8-26

Python : __str__() と __repr__() は、オブジェクトを文字列で表現する

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

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

Python : call()は、インスタンスを関数のように扱う

Python : str() と repr() は、オブジェクトを文字列で表現する