
## TL;DR

デコレータを一言で言うと関数の装飾（上書き）である。ラップする関数への呼び出しの前後で追加コードを実行することができる。これによって、入力の引数や戻り値にアクセスして値を変更したり例外を送出したりできる。この機能は、ログイン状態による制限・関数登録・引数のチェックなどを行うのに役立つ。

関数デコレータの実体は、引数に関数を一つ受け取り「別の関数を返す関数」である。

ソースコードを書き換えずに既存の関数やクラスに変更を加えたいときはデコレータを使う。デコレータを使うと、既存のクラスや関数に対してコードの変更なしに処理を追加することができるようになる。デコレータは、入力として関数を一つとり、別の関数を返す関数である。デコレータを使うことによって、コードの重複を減らすことができる。

### デコレータのポイント

デコレータの名前は「装飾する」という意味を持つ decorate からきている。

- 既存のクラスや関数に機能を追加する関数
- 関数内関数
- 引数としての関数
- 関数を変数で扱うことにより、関数の引数や戻り値として扱うことができる
- 変数のように参照させることができる
- クラスをインスタンス化する必要がない
- 関数やクラスの前に @ で始まる文字列を記述する

### デコレータ

Python では関数内で関数を定義できる。外側の関数は内側の関数を呼び出して使う。

デコレータは、ある関数に対し、指定した関数を呼び出す。以下は、関数 b に対して 関数 a を追加している。

```python
def a(x):
    def new_a():
        print('before')
        x() # 元の関数を実行する
        print('after')

    return new_a

@a
def b():
    print('middle')

b()

# before
# middle
# after
```

アスタリスクを使って、任意の数の引数（可変長引数）を指定できる。どんな引数を受け取る関数に対しても使える。

```python
def dec(f):
    def inner(*args, **kwargs):
        print('before')
        f(*args, **kwargs)
        print('after')
    return inner

@dec
def hoge(a):
    print(a)

hoge(1)
# before
# 1
#after

hoge('text')
# before
# text
# after

hoge(False)
# before
# False
# after
```

[入門 Python3](https://amzn.to/3fl6Ehu) から、ソースコードを引用させていただく。次のコードは、複数の関数をデコレータを add_ints() にデコレートしている例。デコレータの順番を返ると結果も変更される。

```python
# 関数1
def document_it(func):
    def new_function(*args, **kwargs):
        print('関数名', func.__name__)
        print('args', args)
        print('kwargs', kwargs)
        result = func(*args, **kwargs)
        print('result', result)
        return result
    return new_function

# 関数2
def square_it(func):
    def new_function(*args, **kwargs):
        result = func(*args, **kwargs)
        return result * result
    return new_function

# デコレート
@document_it
@square_it
def add_ints(a, b):
    return a + b

print(add_ints(3, 5))
# 関数名 new_function
# args (3, 5)
# kwargs {}
# result 64
# 64
```


デコレータを一言で言うと関数の装飾（上書き）である。ラップする関数への呼び出しの前後で追加コードを実行することができる。これによって、入力の引数や戻り値にアクセ

Python : デコレータは既存の関数に機能を追加する関数


## TL;DR

英語の generate は「生成する、生む」という意味がある。Python におけるジェネレーターはイテレータ（for 文で繰り返せる）の一つである。

ジェネレーターを利用すると、**関数の途中で処理を中断し値を返す**ことができる。これを **yield** と呼ぶ。その後は処理を再開することができる。

## ジェネレーターの作成方法

ジェネレーターの作成方法は以下の 2 つある。

- ジェネレーター関数
- ジェネレーター式

内部で yield を使う関数をジェネレーター関数、内包表記を使うものをジェネレーター式という。

### ジェネレーター関数のポイント

- yield 式を使う関数
- for 文で利用できるイテラブル
- リスト内の要素数が増えてもメモリ使用量を節約できる
- 呼び出されるたびに処理を記憶する
- next 関数で次の値を取り出せる
- next 関数が呼ばれるたびに、関数の中の処理が次の yield まで進む

[ジェネレータ (generator) — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/tutorial/classes.html#generators)

yield 文を含む関数はジェネレーターと呼ばれ、通常の関数とは違った動作をする。関数は return を利用し値を一つを返すが、return を yield に変えることで複数の値を一つずつ作り出すジェネレーターになる。

ジェネレーターを使えば、関数の途中まで処理を進めフリーズする。そして任意のタイミングで処理を再開することができる。以下のコードは、next が呼ばれるまで処理が中断されている例である。値がなくなると例外 StopIteration が返る。

```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() で呼び出す度に、 100 加算されて終了している。再度、next()を呼び出すと、前の処理が記憶されており、次の処理が再開されて停止している。

```python
def g(n):
     while n:
        print(n + 100)
        yield n
        n -= 1

a = g(5)
next(a)
next(a)

# 105
# 104
# 4
```

#### for

for 文でも利用可能である。

```python
def g(n):
     while n:
        yield n
        n -= 1

for i in g(3):
    print(i)

# 3
# 2
# 1
```

### ジェネレーター式

ジェネレーター式を用いて、内包表記を使いイテラブルからジェネレーターを作ることもできる。() で囲む。

これはリスト内包表記。全て計算された。

```python
a = [1, 2, 3, 4, 5]
x = [i+5 for i in a]
x

# [6, 7, 8, 9, 10]
```

\[\] を () に変えるとジェネレーター式になる。ジェネレーター式は、計算されない。待機している。

```python
a = [1, 2, 3, 4, 5]
x = (i+5 for i in a)
x

# <generator object <genexpr> at 0x7fdb069b5ed0>
```

next()を呼び出すと、一つずつ計算される。

```python
a = [1, 2, 3, 4, 5]
x = (i+5 for i in a)
x

print(next(x)) # 6
print(next(x)) # 6 7
```

リストにすると全て計算される

```python
a = [1, 2, 3, 4, 5]
x = (i+5 for i in a)
x

list(x)

# [6, 7, 8, 9, 10]
```


英語のgenerateは「生成する、生む」という意味がある。Pythonにおけるジェネレーターはイテレータ（for文で繰り返せる）の一つである。ジェ

Python : yield を使う関数をジェネレーター関数、内包表記を使うものをジェネレーター式という


## 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関数はシーケンスの長さ

2021-9-14

Python : デコレータは既存の関数に機能を追加する関数

2021-9-13

Python : yield を使う関数をジェネレーター関数、内包表記を使うものをジェネレーター式という

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()は引数に渡したオブジェクトの長さや要素の数を取得する