
## TL;DR

bool 型は int 型の派生クラスであり、bool 型の値は True と False 、2 つの組み込み定数だけである。条件を満たしているかどうか表現する等に使うことができる。

### bool 型のポイント

```python
issubclass(bool, int)
# True
```

- bool 型は int 型の派生クラス
- ブール演算を使うと、真理値を扱うことができる
- 組み込み関数 bool()によって、すべてのオブジェクトが真理値判定可能
- 組み込み関数 bool()を使えば、データ型を bool に変換できる

[class bool(\[x\]) — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/library/functions.html#bool)

### 値「True」と「False」の扱い

次は全て False として扱われる。その他のものはすべて True とみなされる。

```python
bool('') # False
bool(0) # False
bool(0.0) # False
bool([]) # False
bool(()) # False
bool({}) # False
bool(set()) # False
```

False だけでなく空データ構造かどうか調べている。

```python
a = []
if a:
    print('something')
else:
    print('empty')

# empty
```

複数の比較が必要な場合は、in 演算子 を用いて判定できる。

```python
a = 'abcde'
b = 'k'
b in a

# False
```

if と in を用いて判定。

```python
a = 'abcdefghijklmn'
b = 'k'

if b in a:
    print('something')

# something
```

### ブール演算

ブール演算を使うと、真理値を扱うことができる。ブール演算子は or, and, not の 3 つがある。

#### or

どちらか一方でも真であれば真

```python
True or True
# True

True or False
# True

False or True
# True

False or False
# False
```

#### and

両方が真なら真

```python
True and True
# True

True and False
# False

False and True
# False

False and False
# False

x = 5
3 < x and x <10 # True
(3 < x) and (x < 10) # True
3< x and x > 10 # False

```

1 個の変数に対する複数の比較を and する場合、and を省くことができる。

```python
3 < x < 10
# True

3 < x < 10 < 100
# True
```

#### not

真なら偽、偽なら真

```python
not True
# False

not False
# True
```

```python
x = ['book']
y = []
x or y # x が真なので x が返る
# ['book']
```

#### True は 1、False は 0

```python
True + 1 # 2
True + 2 # 3

False + 0 # 0
False + 1 # 1

True + True # 2
False + False # 0
True + False # 1
```

### 組み込み関数 bool()

組み込み関数 bool()を使えば、データ型を bool に変換できる。引数として任意の 1 個の値を受け付け、bool 型に変換した結果を返す。

#### False のケース

値が 0 の数値は False とみなされる。

値が 0 の数値は偽

```python
bool(0)
# False
```

空のコンテナオブジェクトは偽

```python
bool([])
# False
```

空文字は偽

```python
bool('')
# False
```

False は偽

```python
bool(False)
# False
```

#### True のケース

0 でない数値は True とみなされる。

True が入ると真

```python
bool(True)
# True
```

マイナスの整数は真

```python
bool(-1)
# True
```

偽にならないものは全て真

```python
bool(['book'])
# True
```

文字が含まれている場合は真

```python
'b' in 'book'
```

ゼロのコンテナオブジェクトが入ると真

```python
bool([0])
# True
```

コンテナオブジェクトに None が入ると真

```python
bool([None])
# True
```

### 特殊メソッド `__bool__()`

特殊メソッド `__bool__()` は、オブジェクトを真理値で評価する。オブジェクトは、デフォルトでは真と判定されるが、`__bool__()` を実装すると判定処理を変更することができる。

```python
class A:
    def __init__(self, foo):
        self.foo = foo
    def __bool__(self):
       return bool(self.foo)
a = A([])
bool(a) # False

a = A([0])
bool(a) # True
```


bool型はint型の派生クラスであり、bool型の値はTrueとFalse、2つの組み込み定数だけである。条件を満たしているかどうか表現する

Python : bool 型は真理値を扱う型


## TL;DR

コンテキストマネージャとは、with 文に対応したオブジェクトである。コンテキストマネージャーを使うと、必要なときに正確にリソースを割り当て解放することができる。

### コンテキストマネージャのポイント

- with 文に対応
- 前後の処理をまとめて再利用可能にする
- try:finally: の置き換えで利用される
- close の省略：完了するとファイルが適切に閉じられる
- `__enter__()`と`__exit__()`の特殊メソッドを実装している
- ファイル操作や DB 接続で使われる

一般的なプログラミング言語では、外部のファイルにアクセスする場合、リソースを使った後に close 処理を行う。Python の open でも close 処理が必要だが、with 文を使うと、close を省略することができる。

### コンテキストマネージャ とは何か

Python 公式ドキュメントには以下のように書いてある。

> コンテキストマネージャ(context manager) とは、 with 文の実行時にランタイムコンテキストを定義するオブジェクトです。コンテキストマネージャは、コードブロックを実行するために必要な入り口および出口の処理を扱います。コンテキストマネージャは通常、 with 文（ with 文 の章を参照）により起動されますが、これらのメソッドを直接呼び出すことで起動することもできます。

[3\. データモデル — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/reference/datamodel.html#with-statement-context-managers)

よく分からない。そもそも、コンテキスト（context）という言葉がぼんやりしたので、この意味を調べると「文章などの前後の文脈、状況、背景、状態」といったように色々な解釈が書かれている。

> - 実行中のプログラムの内部状態
> - 状況や関係
> - ンピューターが周囲の環境やユーザーの現在の状況を自動的に把握すること

["コンテキスト"とは何なのか？（栗原潔） - 個人 - Yahoo!ニュース](https://news.yahoo.co.jp/byline/kuriharakiyoshi/20141201-00041119)

PEP には、こう書かれている。

> Python 言語に「with」という新しいステートメントを追加し、try / finally ステートメントの標準的な使用を除外できるようにします。

[PEP 343 -- The "with" Statement | Python.org](https://www.python.org/dev/peps/pep-0343/)

つまり、with は、try / finally の代わりに生まれたのである。

### open 関数 と with 文

with 文はコンテキストマネージャーを使って、コードのブロックをラップするために使われる。

open 関数を使うと、指定したファイルを開き、ファイルを読み書きするためのオブジェクトを得ることができる。open 関数は with 文と合わせて使い、as の後方の変数にファイルオブジェクトが格納される。

```python
with open('ファイル', 'モード', encoding='エンコード') as f:
```

以下のコードでは、test.md というファイルに hello と書き込み、次に同じファイルを読み込みモードで開いて内容を出力している。

```python
with open('test.md', 'w') as f:
    f.write('hello')

with open('test.md', 'r') as f:
    a = f.read()

print(a)

# hello
# test.md に書かれた結果が表示される
```

### try:finally: と with の比較

with 文を使うと、try:finally: と同じ制御が行われる。

以下のコードはファイルを開き、データを書き込んだ後に閉じている。ファイルへのデータの書き込み中にエラーが発生した場合は、ファイルを閉じようとする。

```python
f = open('test.md', 'w')

try:
    f.write('try finally')
finally:
    f.close()

# test.md には try finally と書かれる
```

以下のコードは、with を使った例。コード量が減少している。メリットとしては、ネストされたブロックがどのように終了するか注意することなくファイルが確実に閉じられることである。

```python
with open('test.md', 'w') as f:
    f.write('with')

# test.md には with と書かれる
```

シェルで実行。読み込みモードのブロック内で書き込みモードを実行し、意図的に例外を発生させたが、ファイルは close されている。

```python
>>> with open('test.md', 'r') as f:
...     f.write('add')
...

Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
io.UnsupportedOperation: not writable

>>> print(f.closed)
True
```

### with の前後に呼ばれる特殊メソッド

コンテキストマネージャーは、`__enter__()`と`__exit__()`の特殊メソッドを実装している。`__enter__()`は、with ブロックに入るときに呼ばれる処理であり、`__exit__()`は with ブロックを抜けるときに呼ばれる。

```python
class A:
    def __enter__(self):
        print('before')
    def __exit__(self, exc_type, exc_value, traceback):
        print('after')

with A():
    print('with')

# before
# with
# after
```

as をつけると値を受け取ることができる

```python
class A:
    def __enter__(self):
        print('before')
        return 1
    def __exit__(self, exc_type, exc_value, traceback):
        print('after')

with A() as f:
    print(f)

# before
# 1
# after
```


コンテキストマネージャとは、with文に対応したオブジェクトである。コンテキストマネージャーを使うと、必要なときに正確にリソースを割り当て解放することができる

Python : コンテキストマネージャは with 文の前後で処理を実行する


## 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歳。
# こんにちは
```


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

2021-9-17

Python : bool 型は真理値を扱う型

2021-9-15

Python : コンテキストマネージャは with 文の前後で処理を実行する

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-17

Python : bool 型は真理値を扱う型

2021-9-15

Python : コンテキストマネージャは with 文の前後で処理を実行する

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__()は基底クラスのコンストラクタをオーバーライドする

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