
## TL;DR

Python の最新のコードは、リポジトリである PyPI（パイパイ）で探し、Python パッケージのインストールは標準的に pip と venv というツールを使う。Python バージョン切り替えは pyenv を使う。

最初に、Python コードを見つける場所を説明する。

### PyPI（パッケージ一覧）

[PyPI](https://pypi.org/)（パイパイ） は ソフトウェアのリポジトリ。Python のパッケージ一覧が集められている。パッケージとは、Python のコードをまとめ再配布にしたライブラリのことである。パッケージを活用することで開発期間を短縮することができる。

以前は、モンティ・パイソン（Monty Python）にちなんで、チーズショップ（Python Cheese Shop）と呼ばれていた。[Wiki](https://ja.wikipedia.org/wiki/Python_Package_Index)によるとモンティ・パイソンは、イギリスの代表的なコメディグループ。「チーズ・ショップ」は、モンティ・パイソンがテレビシリーズ『空飛ぶモンティ・パイソン』で放送したスケッチだそうだ。私は見たことがない。

PyPI は、Python コミュニティによって開発・共有されている。全てオープンソースだ。ソフトウェア検索とインストールに役立つ。PyPI のトップページには、最新のトレンドとリリースが取り上げられている。

Python のトレンドコードを見つけるサイト

- [GitHub 今日のトレンド](https://github.com/trending?1=python)
- [ActiveState Code](https://code.activestate.com/recipes/langs/python/)

### venv（仮想環境作成）

venv は、Python の仮想環境作成ツール。仮想環境を管理するための標準モジュールである。環境変数とは、OS 環境をカスタマイズするためのシステム変数だ。venv は、環境変数（$PATH） を書き換える仕組みで仮想環境を実現している。

使い方は「仮想環境にしたいディレクトリ名」を記述して実行する。新規作成のコマンドは次のとおりである。コマンドを叩くことで、指定したディレクトリの中にファイルが配置される。

```
# 新規作成
python3 -m venv 仮想環境にしたいディレクトリ名

# ディレクトリに移動
cd 仮想環境にしたいディレクトリ名

# 可動
source bin/activate

# 仮想環境を終了する
deactivate
```

### pip（パッケージ管理）

Python のパッケージ管理ツール。パッケージをインストールするときは pip install コマンドを使う。pip は PyPI にパッケージを探しに行く。バージョンを指定しない場合、最新バージョンがインストールされる。アンインストールした場合、依存関係にあるパッケージは残されてしまうので、その仮想環境ごと破棄するとよい。

##### パッケージの操作方法一覧

```
# インストール
pip install パッケージ名

# 特定のバージョンをインストールする
pip install flask==0.9.0

# 最低限のバージョンをインストールする
pip install 'flask>=0.9.0'

# ライブラリの最新版アップデート
pip install -U pip

# インストールされたバージョン一覧
pip list

# バージョン表示
pip -V

# パッケージをアップグレード
pip install --upgrade パッケージ名

# アンインストール
pip uninstall プロジェクト名
```

##### 複数のパッケージをインストールする

requirements.txt ファイルを使って、複数のパッケージを指定することができる。requirements.txt を指定すると、そのファイルに書かれたパッケージがインストールされる。requirements.lock を指定し実行すると、実行環境が再現される。

freez を指定すると、これまでにインストールしたライブラリが一覧で出力される。

```
# インストール
pip install -r requirements.txt

# 書き込み
pip freeze > requirements.txt

# 環境を再現
pip install -r requirements.lock
```

[pip documentation v21.3.1](https://pip.pypa.io/en/stable/)

### Pipenv（pip に似たもの）

Pipenv は pip を使いやすくしたもの。pip と venv を結合したようなモジュールである。pip と混在させても問題ないが、pip に不自由を感じなければインストールする必要はないと思う。

公式では、次のように記されている。

> Pipenv は、手動でパッケージのインストールおよびアンインストールを行うのと同じように Pipfile に対してパッケージの追加および削除を行うのに加え、自動でプロジェクト用の仮想環境を作成し管理します。また Pipenv は、いかなるときも重要な Pipfile.lock を生成し、これを利用しビルドが常に同じ結果になるようにします。

[Pipenv](https://pipenv-ja.readthedocs.io/ja/translate-ja/)

インストール

```
brew install pipenv
```

パッケージ インストール

```
pipenv install パッケージ名
```

### pyenv（環境切り替え）

pyenv は、1 台のパソコンで複数バージョンの python 環境を簡単に切り替えることができる。

[pyenv](https://github.com/pyenv/pyenv)

特徴は次のとおり

- ユーザーに応じてグローバル Python バージョン変更
- Python バージョンを環境変数で上書きできるように変更する
- プロジェクトごとの Python バージョンのサポートを提供
- 一度に複数のバージョンの Python からコマンドを検索
- Python 自体に依存する
- virtualenv を管理する

インストール

```
brew update
brew install pyenv

# Python3 に切り替え
pyenv global 3.9.6
```

スムーズに適用されない場合があるので、バージョンを適用させるときの方法を、次の別ページで詳しく解説した。

参考：[pyenv - Python をインストールした後でバージョンが適用されない場合の対処法](https://commte.net/7259)


Python の最新のコードは、リポジトリである PyPI（パイパイ）で探し、Python パッケージのインストールは標準的に pip と venv というツー

Python: 環境開発の方法（パッケージのインストール、venv、pip、pyenv など）


## TL;DR

並行処理は、プログラムの実行時のパフォーマンスを向上させる。Python で並行処理を実現する方法として、マルチスレッドやマルチプロセスがある。どの方法がベストであるかの判断は、CPU バウンド（数値処理）か I/O バウンド（入出力操作）かによる。

### プロセスとスレッド

プログラムが実行されるとき、プロセスが作られ、システムリソース（メモリや CPU）やカーネルのデータ構造が割り当てられる。各プロセスの中には、スレッドが作られ処理が行われる。

##### プロセスとメモリのイメージ

```
メモリ
　　プロセスA
　　　　スレッド１→ CPUへ命令
　　　　スレッド２→ CPUへ命令
　　　　スレッド３→ CPUへ命令

　　プロセスB
　　　　スレッド１→ CPUへ命令
　　　　スレッド２→ CPUへ命令
　　　　スレッド３→ CPUへ命令

```

##### 処理の分類

並行性と並列性は、お互いに独立した概念である。

| Python 処理 | 意味                     | コア数       | スレッド数       |
| ----------- | ------------------------ | ------------ | ---------------- |
| 逐次処理    | 一つずつ順番に実行       | シングルコア | シングルスレッド |
| 並行処理    | 複数の処理を少しずつ実行 | シングルコア | マルチスレッド   |
| 並列処理    | 複数の処理を同時に実行   | マルチコア   | マルチプロセス   |

マルチとは複数を示す。

プロセスとは実行中のプログラムのことである。

スレッドとは、OS が CPU に割り当てている最小の実行単位である。プロセスの中に存在し、メモリを共有している。

マルチコアとは、デュアルコア CPU のように、1 チップの CPU 上に複数のコアが存在するもの。人間でいうところの脳が複数あるイメージ。

3 つの処理の違いを簡略化したイメージは次のようになる。右横に進むほど時間が経過する。

```
逐次処理
１　→　２　→　３

並行処理
１　→　２　→　３
        １　→　２　→　３

並列処理
１　→　２　→　３
１　→　２　→　３
１　→　２　→　３

```

#### 並行処理

「一つの処理を待たずに複数の処理を実行したい」

しかし、一つの CPU しかない場合、どのように複数の処理をすればよいのか？

この問題を解決するために生まれたのが並行処理である。

「我々人間が感知できないような短い間隔で、複数の処理を切り替えながら実行することによって、あたかも、人間が見ると複数の処理が並行しているように見える。」

これが並行処理の考え方である。

Python のプログラムでは、基本的には、並行処理を実装しな限り、常に逐次（ちくじ）処理となる。

マルチプロセス・マルチスレッドを利用する場合は「並行処理」、マルチコアでマルチプロセスを利用する場合は「並列処理」が該当する。

#### I/O バウンド と CPU バウンド

コンピューターが待機する理由として、次の 2 つがある。

| 状態         | 発生タイミング | 具体例                             |
| ------------ | -------------- | ---------------------------------- |
| CPU バウンド | 数値処理       | 化学計算、暗号化                   |
| I/O バウンド | 入出力操作     | Web API、DB 接続、ネットワーク通信 |

CPU バウンドな処理であればマルチプロセス、I/O バウンドであればマルチプロセス・マルチスレッドなどが有効である。

#### 同期処理と非同期処理

並行処理に関する用語に、同期処理と非同期処理がある。

簡単に説明すると同期的とは順番に続くこと、非同期とはタスクが独立していることである。

##### 同期処理

同期処理は処理の完了まで次に進めない。例えば、Python の場合、関数を呼び出したとき、呼び出し先の処理が全て完了するまで、呼び出し元は次の処理に進めない。

##### 非同期処理

一方、非同期処理は、呼び出し先の処理が実行中であっても、呼び出し元は次の処理に進める。呼び出した先の結果が返る前であっても呼び出し元は先に進んでいるので、結果はコールバック関数（関数に渡される関数）を利用して、呼び出し元に伝えられる。このとき、並行処理である。

Python においてスレッドやマルチプロセスを扱う場合は、細部に注意が必要だ。この作業を単純化するために、Python 公式ドキュメントでは、コードの並行実行のサポートを提供している。並行処理を扱うものでは、concurrent.futures モジュールがある。このモジュールの詳細については、別のページで解説する。

[並行実行のライブラリ一覧 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/concurrency.html)

#### 並列処理

複数のコアを使って同時に複数の計算を行うことを、並列処理という。物理的に同時に処理が行われている。

様々な処理が、物理的に同時進行しているパラレルワールドをイメージするとよい。

並列処理は、マルチコア（複数のコア）でマルチプロセス（複数のプロセス）を利用する場合である。マルチコアでは、同時に複数の計算ができる。各コアは独立しているから、それぞれのコアは他のコアに影響されることなく動作する。

CPU コアが 1 つだけの場合、並列処理というのはありえないということになる。デュアルコアの場合は、一つの CPU に 2 個のコアが存在するので並列処理が可能である。


並行処理は、プログラムの実行時のパフォーマンスを向上させる。Python で並行処理を実現する方法として、マルチスレッドやマルチプロセスがある。どの方法がベスト

Python: 並列処理と並列処理、プロセスとスレッドなど


## TL;DR

組み込み関数 open()は、指定したモードとエンコーディングでファイルを開きファイルオブジェクト（ファイルを読み書きするオブジェクト）を返す。既存のファイルの読み出し、新しいファイルへの書き込み、既存ファイルへの追記、既存のファイルへの上書きを行う。

### 組み込み関数 open()のポイント

- 指定したファイルを開き、ファイルオブジェクトを返す
- 通常は、with 文と合わせて使う
- モードを省略すると読み取りでテキストとして開く
- モードは、ファイルのタイプやファイルをどのように操作したいかシステムに知らせる

### with によるファイルの自動クローズ

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

第一引数に指定するパスは、拡張子まで記入したファイルを絶対パスか相対パスで指定する。相対パスはカレントディレクトリからのパスである。なお、拡張子は、txt でも md でも、テキストファイルであれば書き込み可能である。

as の後は、任意の名前をつける。encodeing のデフォルトは、プラットフォームに依存する。

モードのデフォルトは、`r` なので、読み込みを行う場合は省略可能である。

with を使わずに処理を行えるのだが、with 文を使うと close を省略してくれるので、close の書き忘れを防ぐことができる。したがって with を使うのがよい。

```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 に書かれた結果が表示される
```

with 文に対応したオブジェクトは、コンテキストマネージャーと呼ぶ。ファイルや DB 接続などで使う。with 文は「ある処理の前後の処理をまとめて再利用可能」にしてくれる。コードブロックをラップするために使われる。

関連記事：[コンテキストマネージャは with 文の前後で処理を実行する](https://commte.net/7472)

通常、open 関数は with 文と組み合わせて使う。as の後ろに指定した変数にファイルオブジェクトが格納される。

次に示すコードは、コンテキストマネージャを使ったファイル処理。組み込み関数 open()を使ってファイルの書き込みを行う処理を行っている。

```python
with open('test.txt', 'w') as f:
    f.write('add text')
# test.txt に「add text」と書き込まれる

f.closed
# True
```

通常、プログラム言語では、外部ファイルにアクセスする場合、利用後に close 処理を行う。Python においては、with 文を使うと close が省略される。これにより close の書き忘れを防ぐことができる。

with 文のブロックを抜けると、ファイルはクローズされる。次のコードは、書き込みモード内にも関わらず、意図的に書き込みモードを使って例外を発生させている。例外発生時も、ファイルはクローズされる。

```python
with open('test.txt', 'w') as f:
    f.read()
# UnsupportedOperation
# 書き込みモードを使うと例外が発生する
```

ファイルを開いた際は例外発生時であってもファイルはクローズされる。これは、ファイルの破損を防止するためである。

### モードの種類

モードを省略すると「読み取り」でテキストとして開く。テキストを読み書きしたい場合は「r」といったように指定する。

| モード | 意味                                             |
| ------ | ------------------------------------------------ |
| r      | 読み込み用に開く（デフォルト）                   |
| w      | 書き込み用に開く。ファイルを切り詰める           |
| r+     | 読み書き用に開く                                 |
| a      | 追記用に開く。ファイルが存在する場合は末尾に追記 |
| a+     | 読み込みと追記用に開く                           |
| b      | バイナリモード                                   |
| t      | テキストモード（デフォルト）                     |

「w」は書き込み用としてファイルを開く。ファイルが存在しない場合は新たにファイルが作成される。すでにファイルが存在する場合は、ファイルの中身は消去され、追記されずに上書き保存される。

「x」は、ファイルが存在しない場合は書き込まれ、ファイルが存在する場合は失敗する。

「a」は、ファイルが存在する場合、現在の末尾の後ろへ追記される。

モードの第 2 文字目は、ファイルのタイプを示す。「t」はテキスト、「b」はバイナリという意味である。

次のコードは、ファイルである「test.txt」を開き、何も書き込まずに閉じたので、空ファイルが作られる。

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

次に先程作った空ファイルに上書きしてみよう。print によって文字列「hello world」が書き込まれる。

```python
f = open('test.txt', 'w')
print('hello world', file=f)
f.close()
```

次は、print を使わずに write 関数を使って書き込む。先程書かれた「hello world」の文字は削除され、新たに「this text」という文字がファイルに上書きされた。

```python
f = open('test.txt', 'w')
f.write('this text')
f.close()
```

x モードを使えば上書きによってファイルを壊すことを防ぐことができる。

```python
f = open('test.txt', 'x')
f.write('xモードで書く')
f.close()
# FileExistsError
```

例外ハンドラと組み合わせて使うケース。

```python
try:
    f = open('test.txt', 'x')
    f.write('add text')
except FileExistsError:
    print('already exists!')
# already exists!
```

ファイルの中に書かれている文字数を数えるコード。イテレータを使った例。

```python
txt = ''
f = open('test.txt', 'r')
for i in f:
    txt += i

f.close()
len(txt)

# 8
# test.txt には、「add text」と書かれている
```

### ファイルオブジェクトのメソッド

テキストファイルを読むには、以下のメソッドがある。

| メソッド      | 戻り値                   |
| ------------- | ------------------------ |
| f.read()      | ファイル全体のデータ     |
| f.readlines() | １行ずつ分割されたリスト |
| f.readline()  | １行ごとのデータ         |

read()メソッドは、開いたファイル全体のデータを取得できる。

readlines()メソッドは、次のコードのように行ごとに分割されたリストを返す。返される要素には `\n` が含まれる。

```python
with open('test.txt') as f:
    a = f.readlines()
    print(a)
# ['１行目です\n', '２行目です\n', '最終行です']
```

readline()でなく、for 文を使うと、改行コードを含まない文字列が１行ずつ表示される。

```python
with open('test.txt') as f:
    for i in f:
        print(i)

# １行目です

# ２行目です

# 最終行です
```

ファイルに書き込むメソッド

| メソッド       | 戻り値                                 |
| -------------- | -------------------------------------- |
| f.write()      | 指定した文字列を書き込む               |
| f.writelines() | 指定した文字列リストを一つずつ書き込む |

例えば、writelines メソッドは、ファイルに対し、リストの内容を一つづつ書き込む。要素間にセパレータは入らず、詰めて連結される。

```python
f_list = ["A", "B", "CCC"]
with open('test.txt', 'w') as f:
    f.writelines(f_list)
# test.txt に　ABCCC と書き込まれた
```


組み込み関数 open()は、指定したモードとエンコーディングでファイルを開きファイルオブジェクト（ファイルを読み書きするオブジェクト）を返す。既存のファイルの

Python : ファイル入出力の基本操作編（with open など）


## TL;DR

datetime モジュールは、日時データを処理するクラスを提供する。日時や時間を扱う型が用意されている。datetime 型は、属性を指定して日付や時間を参照できる。

日付や時間の型には次のようなものがある。

| 型        | 役割                                   |
| --------- | -------------------------------------- |
| datetime  | 日時を扱う。日付と時刻を対象とする。   |
| date      | 日付を扱う。年月日を対象とする         |
| time      | 時間を扱う。時分秒と端数を対象とする。 |
| timedelta | 日付、時間の計算を扱う。               |

### datetime

#### datetime のポイント

- 変更不可能（イミュータブル）である
- 日付、時間、曜日の計算を行う
- 引数に日付や時間を指定する
- フォーマット文字列の変換が可能である
- ハッシュ可能である

datetime モジュールは、日時データ（日付と時刻を含む）を処理する。date オブジェクトは、年月日を指定し、その値を属性として取り出すことができる。

主な属性

| 属性        | 意味       |
| ----------- | ---------- |
| year        | 年         |
| month       | 月         |
| day         | 日         |
| hour        | 時         |
| minute      | 分         |
| second      | 秒         |
| microsecond | マイクロ秒 |

datetime クラス の構文は次のようになる。引数で指定した年月日時、分秒、マイクロ秒の datetime 型を生成する。次のコードは、分かりやすいように改行している。

```python
datetime(year, month, day, hour=0,
minute=0, second=0, microsecond=0)
```

数値を入力してみよう。時刻も対象となっている。この例は 2021 年 12 月 24 日午前 3 時 30 分 20 秒を示している。

```python
from datetime import datetime
xmas = datetime(2021, 12, 24, 3, 30, 20)

xmas.hour
# 3

xmas.minute
# 30

xmas.second
# 20
```

detetime オブジェクトには、isoformat() メソッドがある。中央の T は日付と時刻を分割している。

```python
from datetime import datetime
xmas = datetime(2021, 12, 24, 3, 30, 20)
xmas.isoformat()
# 2021-12-24T03:30:20
```

#### now()

datetime の now()メソッドは、現在の日付と時刻を取得できる。

```python
from datetime import datetime
now = datetime.now()
now
# datetime.datetime(2021, 10, 25, 4, 17, 42, 641682)

now.year
# 2021

now.month
# 10

now.day
# 25

now.hour
# 4

now.minute
# 20

now.second
# 13

now.microsecond
# 150095
```

#### combine()

combine()は、date オブジェクトと time オブジェクトを結合して、datetime オブジェクトを作ることができる。

```python
from datetime import date, datetime, time
noon = time(12)
this_day = date.today()
noon_today = datetime.combine(this_day, noon)
noon_today
# datetime.datetime(2021, 10, 25, 12, 0)
```

#### strptime()

日時データは、strptime()メソッドを使えば、文字列と datetime 型は相互に変換できる。

```python
datetime.strptime("日付文字列", "フォーマット文字")
```

文字列から datetime 型を生成する。

```python
from datetime import datetime

d = datetime.strptime("2021/10/23 12:01:11", "%Y/%m/%d %H:%M:%S")
print(d)
# 2021-10-23 12:01:11
```

**strptime() の書式指定子一覧表**

| 書式指定子 | 単位            | 範囲     | 例      |
| ---------- | --------------- | -------- | ------- |
| %Y         | 年 西暦 4 桁    | 1900-    | 2021    |
| %y         | 西暦 2 桁       | 19-      | 21      |
| %m         | 月 10 進表記    | 01-12    | 10      |
| %B         | 月名            | January, | Octobar |
| %b         | 月名 略称       | Jan,     | Oct     |
| %d         | 日 10 進表記    | 01-31    | 25      |
| %A         | 曜日            | Sunday,  | Monday  |
| %a         | 曜日 略称       | Sun,     | Mon     |
| %H         | 時間（24 時間） | 00-23    | 18      |
| %I         | 時間（12 時間） | 00-12    | 06      |
| %p         | 午前、午後      | AM, PM   | AM      |
| %M         | 分 10 進表記    | 00-59    | 05      |
| %S         | 秒 10 進表記    | 00-59    | 48      |

#### 現在の日時を取得する

現在の日時等を取得するには datetime.now() を使う。これは現在日時の datetime 型を生成して返すメソッドである。

```python
datetime.now()
```

現在の日付を取得してフォーマットする。

```python
import datetime
now = datetime.datetime.now()
now.strftime("%Y/%m/%d %H:%M:%S")

# 2021/10/25 06:05:08
```

リテラルを使う方法。

```python
f"{now:%Y/%m/%d - %H:%M:%S}"

# 2021/10/25 - 06:05:08
```

[time --- 時刻データへのアクセスと変換 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/time.html#time.strftime)

### date

date 型は、日付を扱うことができる。

```python
date(year, month, day)
```

引数で指定する年月日の date 型を生成する。

```python
from datetime import date
xmas = date(2021, 12, 24)
xmas
# datetime.date(2021, 12, 24)

xmas.day
# 24

xmas.month
# 12

xmas.year
# 2021
```

次のようにフォーマットすると、日付の部分が整形され、時刻は深夜 0 時 0 分になる。

```python
from datetime import date
s = date(2023, 11, 1)
fmt = "%A, %B, %d, %Y, %I:%M:%S"
s.strftime(fmt)

# Wednesday, November, 01, 2023, 12:00:00
```

現在の日付を取得する場合、date.today() メソッドを使う。

```python
from datetime import datetime, date
d = date.today()
s = d.strftime("%Y/%m/%d")
print(s)

# 2021/10/26
```

### timedelta 型

timedelata 型は、日時の計算を行う。次に示すコードは、10 日後の日付を計算したものである。

```python
from datetime import datetime, date, time, timedelta
d = date.today()
y = d + timedelta(days=10)
print(y)

# 2021-11-05
```


datetime モジュールは、日時データを処理するクラスを提供する。日時や時間を扱う型が用意されている。datetime 型は、属性を指定して日付や時間を参照

Python : 日付の基本操作編（datetime 型、date 型、strptime など）


## TL;DR

正規表現はテキストの一部にマッチさせることのできるパターンである。メタ文字と呼ばれる記号を利用し、文字列の検索パターンを表すことができる。任意の文字列の中からパターンに合致する文字列を抽出したり置換を行う。Python では正規表現機能は、標準ライブラリの re モジュールによって提供されているのでインポートして使う。

### 正規表現の意味とマッチ例

汎用的な正規表現は次のようなものがある。

| パターン | 意味                            | 使用例           | マッチ                  |
| -------- | ------------------------------- | ---------------- | ----------------------- | -------------- | -------------- |
| `.`      | 改行を除く全ての 1 文字にマッチ | .ython           | python, Python          |
| `^`      | 文字列の先頭                    | ^...             | 行の先頭から 3 文字まで |
| `$`      | 文字列の末尾                    | ...$             | 末尾までの 3 文字       |
| `*`      | 直前の正規表現が 0 以上繰り返し | p\*ython         | ython で終わる全て      |
| `+`      | 直前の正規表現が 1 以上繰り返し | p+ython          | python                  |
| `? `     | 直前の正規表現が 0 回、or 1 回  | Py?thon          | Python, CPython         |
| `        | `                               | いずれかの文字列 | Python                  | python         | Python, python |
| `()`     | グルーピング                    | (Py              | py)thon                 | Python, python |
| `[]`     | 括弧内の一文字                  | [yponthP]        | Python, CPython, python |
| `{}`     | 括弧内に繰り返し数              | p{2}             | ppython                 |

#### 特殊文字

| パターン | マッチ             |
| -------- | ------------------ |
| \d       | 1 個の数字         |
| \D       | 1 個の数字以外     |
| \w       | 1 個の英単語       |
| \W       | 1 個の英単語以外   |
| \s       | 1 個の空白文字     |
| \S       | 1 個の空白文字以外 |
| \b       | 単語の境界         |
| \B       | 単語の境界以外     |

#### 文字セット

文字セットを使うと対象を制限することができる。範囲を指定するときは`-`、否定を指定するときは `^` を使う。

| パターン                                      | 意味                       | マッチ             |
| --------------------------------------------- | -------------------------- | ------------------ |
| python(?=Love)                                | Love が続いている python   | pythonLove         |
| python(?!Love)                                | Love が続いていない python | Lovepython         |
| [a-z]                                         | 小文字の半角英文字         | abcdef ghi jklmn   |
| [A-Z]                                         | 大文字の半角英文字         | aBcdefG hiJk       |
| [0-9]                                         | 半角数字を含む             | 0120 - 123 の 4567 |
| [^0-9]                                        | 半角数字以外を含む         | 0123 の 123        |
| [a-zA-Z0-9]                                   | 半角小文字大文字数字       | abcABC012 123      |
| [ぁ-ん]                                       | ひらがな                   | あいうえお         |
| [ァ-ヴ]                                       | カタカナ                   | カキクケコ         |
| <.\*?>                                        | html タグ                  | <h3 class="hoge">  |
| ^https?://([\w-]+\.)+[\w-]+(/[\w-./?%&=]\*)?$ | url                        | https://~          |

例えば「.」は、改行を除くすべての一文字にマッチするので、`.ython` とした場合、python, Python, CPython にマッチする。

「猫は哺乳類である。」というテキストにマッチさせたい場合は、`は.*である。`というように組み合わせて使う。

正規表現の基礎をおさらいしたところで、Python の 正規表現機能について解説する。

### re モジュール

Python においての正規表現機能は re モジュールによって提供されている。

match()はソースの先頭がパターンにマッチするか調べ、seach() は任意の位置でパターンを探す。

**関数一覧**

| 関数    | 関数の説明                                       |
| ------- | ------------------------------------------------ |
| match   | 先頭がパターンにマッチするか調べる               |
| search  | 任意の位置でパターンを調べる。最初のマッチを返す |
| split   | パターンの出現で区切ってリストを返す             |
| findall | 全てのパターンのリストを返す                     |
| sub     | パターンを置換して返す                           |
| compile | 正規表現の文字列からパターンオブジェクトを作る   |
| escape  | すべての正規表現用特殊文字をエスケープする       |

#### match() による文字列の先頭のマッチ

`.*` は任意の個数の任意の文字という意味。次のコードでは、match() により `.*Man` にマッチした文字列 'Young Man' が返されている。

```python
import re
result = re.match(r'.*Man', 'Young Man')
if result:
    print(result.group())
# Young Man
```

#### sub() による置換

sub()を使って置換することができる。次のコードでは、空白を `_` に置き換えている。

```python
import re
text = 'There is always light behind the clouds.'
rep = re.sub(r'\s', '_', text)
print(rep)

# There_is_always_light_behind_the_clouds.
```

#### split() による分割

次のコードでは、数字・アルファベット以外の文字で分割し、リストに格納している。

```python
import re
text = 'Once you stop learning, you start-dying.'
rep = re.split(r'[^a-zA-Z0-9]+', text)
print(rep)

# ['Once', 'you', 'stop', 'learning', 'you', 'start', 'dying', '']
```

#### findall() を使ってすべてのマッチを検索

findall()は与えられたパターンに一致したすべての部分のリストを返す。次に示すコードは、文字の中に b という一文字の文字列が何個存在するのか調べるものである。

```python
import re
text = 'If you want to be happy, be.'
result = re.findall(r'b', text)
print(len(result))

# 2
```

次に示すコードは、文字列中の全ての単語をリストに格納している。

```python
import re
text = 'Once you stop learning, you start-dying.'
find = re.findall(r'[a-zA-Z]+', text)
print(find)

# ['Once', 'you', 'stop', 'learning', 'you', 'start', 'dying']
```

#### escape()を使ってエスケープする

escape() は、正規表現の演算子として解釈される全ての文字をエスケープする。

```python
import re
text = 'docs.python.org/ja/3/library/functions.html#bool'
esc = re.escape(text)
print(esc)

# docs\.python\.org/ja/3/library/functions\.html\#bool
```


正規表現はテキストの一部にマッチさせることのできるパターンである。メタ文字と呼ばれる記号を利用し、文字列の検索パターンを表すことができる。任意の文字列の中からパ

Python : 正規表現の使い方


## TL;DR

Python のクラスや関数などのコードを書いた .py という拡張子のファイルはモジュールと呼ばれ、モジュールをまとめたものをパッケージと呼ぶ。再利用したり、保守性を高めるために利用するとよい。パッケージの中身は、モジュールやサブパッケージが集約されている。

### モジュールのポイント

モジュール

- クラスや関数をコードをまとめたファイル
- import module として使う
- 自作のモジュールを作ることができる
- from 節を使うと、モジュールから特定の属性のみをインポートできる
- カンマ区切り（,）で、複数の属性をインポートできる
- ドット区切り（.）で、サブパッケージを指定できる
- ワイルドカード（\*）で、複数の属性を一括インポートできる

パッケージ

- .py ファイルを格納するサブディレクトリ
- 複数のモジュールをまとめる
- 目印として`__init__.py`を配置する

※ `__init__.py`は、目印の他にパッケージの初期化をする機能がある。パッケージがインポートされると、最初に実行される。

名前空間

- 「名前」が衝突しないように、使用する名前の空間を分けること

[6\. モジュール (module) — Python 3.6.13 ドキュメント](https://docs.python.org/ja/3.6/tutorial/modules.html)

### モジュールのインポート

モジュールのインポートは以下のように記述する。

```python
import モジュール名
```

モジュールの中の関数を使うには以下のように記述する。

```
モジュール名.モジュール内の関数名
```

### モジュールの使い方

それでは実際に作ってみよう。同じディレクトリに、読み込み元の foo.py ファイル、インポート先の hello.py ファイルを作ってみる。

foo.py というファイルには、リストの要素をランダムで抽出するモジュールを読み込ませる。

```python
from random import choice
lang = ['Python', 'Go', 'Rust']
def func():
    return choice(lang)
```

hello.py というファイルを作り、foo.py ファイルをインポートするコードを記述する。

```python
import foo

lang = foo.func()
print(lang)
```

その結果、読み込み元のファイルが実行され結果が返される。

dir()メソッドを使って確認すると、foo.py モジュールのトップレベルのオブジェクトを確認することができる。

```python
# hello.py

import foo

lang = foo.func()
print(dir(foo))

# [...'choice'...]
```

### as

長過ぎるモジュール名を短縮したり、どこかに同じファイルが存在するなどの理由で、別名で呼び出したい時は、モジュール名のあとに as をつけ、新たに名前をつけるとよい。

```python
import foo as f

lang = f.func()
print(lang)
```

### モジュールの名前

モジュールをインポートするとその`__name__属性`にモジュールの名前が文字列として格納される。`<モジュール名>.__name__`で取得できる。

```python
import math

print(math.__name__)

# math
```

数学の機能をまとめた math というモジュールを使う場合。

```python
import math
print(math.pi) # πの値
```

関数を、そのままの名前で書くとこうなる。

```python
from モジュール名 import モジュール内の関数名
```

```python
from math import pi
print(pi) # πの値
```

複数のモジュールをインポートする場合は、関数名をカンマ区切りする。

### モジュールをスクリプトとして実行

このイディオムは、モジュールをスクリプトとして利用したい場合に使う。

「コマンドラインからスクリプトとして直接実行したときに、以降の処理を行う」という意味を持つ。

```python
if __name__ == "__main__":
```

[参考 : スクリプトとして直接実行したときのみ処理を行う記述](https://commte.net/7345)

if 文の左辺に記述されている、特殊変数`__name__` は、Python ごとに、そのファイル名が格納される。

if 文の右辺に記述されている、特殊変数`__main__` は、Python コマンドから直接実行されたときに、この名前が格納される。

Python のスクリプトは、インポートしただけでファイルに記述した処理が実行されてしまう。しかし、自動実行が困るケースもある。できることなら、インポートされたときは自動実行をさせず、スクリプトとして直接実行したときだけ処理を行いたい。

そんなときに、この if 文で判定すると **スクリプトとして直接実行したときのみ処理を行う** ことができる。

Python のコードは、コマンドから直接実行されるか、他のプログラムをインポートして呼ばれる。その判定を行うことができる。インポート元のファイルの末尾に以下を加えることで、スクリプトとしても使えるようになる。

読込先のファイル

```python
import インポート元
print('処理')
```

インポート元のファイル

```python
def main()
    print('処理')

if __name__ == "__main__":
    main()
```


Python のクラスや関数などのコードを書いた .py という拡張子のファイルはモジュールと呼ばれ、モジュールをまとめたものをパッケージと呼ぶ。再利用したり、

Python : モジュールの使い方（import、as、パッケージ など）


## TL;DR

クラスにおけるプロパティ（@property）とは、インスタンスメソッドを、外部からアクセスしたり、変更できないようにする機能である。

### プロパティのポイント

- ゲッター、セッターは、非公開属性の値を読み書きする
- @で始まる文をデコレータと呼ぶ
- def 文で機能を定義する
- property と setter のインスタンスメソッド名は同じにする
- インスタンスメソッドを()を付けずに呼び出せる
- 属性にアンダースコア（`_`）をつけるとプライベート変数になる

英語において、property は「所有している性質、属性」、setter は「値を設定」などの意味があるが、Python においては次の性質がある。

| @property                  | @インスタンスメソッド.setter |
| -------------------------- | ---------------------------- |
| getter                     | setter                       |
| 属性アクセス（値の取得時） | 新しい値を設定する           |
| ゲッターメソッドの前       | セッターメソッドの前         |

```python
class クラス名:
    def __init__(self, 仮引数):
        self.インスタンス変数 = 仮引数

    @property
    def インスタンスメソッド(self):
        return self.インスタンス変数

    @インスタンスメソッド.setter
    def インスタンスメソッド(self, 仮引数):
        self.インスタンス変数 = 仮引数
```

#### @property

次のコードは、正方形の面積を求めるものである。edge 属性を書き換えている。

```python
class Square:
    def __init__(self, edge):
        self._edge = edge
    @property
    def calc(self):
        return self._edge ** 2

square = Square(5)

square.calc
# 25

square.edge = 10
square.calc # 100
```

#### @プロパティ.setter

次のコードの `@name.setter` が、セッターである。setter は値が代入されたときに呼び出される。メソッド名は、@property を付けたメソッド名をそのまま利用する必要がある。

```python
class A:
    def __init__(self, input_name):
        self.hidden_name = input_name

    @property # 値が呼び出されたとき
    def name(self):
        print('getter')
        return self.hidden_name

    @name.setter # 値が代入されたとき
    def name(self, input_name):
        print('setter')
        self.hidden_name = input_name


a = A('値1')
a.name # getter 値1

a.name = '値2' # setter
a.name # getter 値2
```

### マングリング（名前装飾）

そもそも Python には private 変数がないが、それに近いことはできる。

属性にアンダースコア（`_`）をつけるとプライベート変数になる。インスタンスのユーザーには非公開にしておきたいときに使う。

アンダースコアを 2 つ（`__`）つけた場合、マングリングが働く。マングリングをつかうと、インスタンス変数にアクセスできなくなる。**サブクラスでの名前衝突を防ぐために使われる**。

次に示すコードのように、実際に属性が非公開になるわけではないが、意図しないアクセスをある程度防ぐことができる。

```python
class A:
    def __init__(self, input_name):
        self.__name = input_name

    @property
    def name(self):
        print('getter')
        return self.__name

    @name.setter
    def name(self, input_name):
        print('setter')
        self.__name = input_name

a = A('hoge')
a.name
# getter
# 'hoge'

a.name = 'add text'
# setter

a.name
# getter
# 'add text'

a.__name
# __name 属性にはアクセスできない
# AttributeError: 'A' object has no attribute '__name'

# しかし、規則を知っていればアクセス可能になってしまう
a._A__name
# 'hoge'
```


クラスにおけるプロパティ（@property）とは、インスタンスメソッドを、外部からアクセスしたり、変更できないようにする機能である。プロパティのポ

Python : クラスの使い方 3


## TL;DR

継承とは、クラスを定義する際に基底クラスを指定することで、基底クラスの性質を受け継ぎ、コードの再利用を実現する方法である。

### クラスの継承のポイント

クラス名の後に`(基底クラス名)`と指定する。

```python
class Car:
    pass

class Sedan(Car):
    pass
```

- 基底クラスとは親クラスのこと
- サブクラスとは基底クラスを継承したクラス
- 継承により基底クラスの性質を継承した子クラスを定義できる
- 新しいメソッドと変数を追加できる
- 基底クラスのメソッドを上書きできる

クラスがほかのクラスを継承したかどうかは、`issubclass()` を使って判定する。

```python
class Car:
    pass

class Sedan(Car):
    pass

issubclass(Sedan, Car)

# True
```

それぞれのクラスからインスタンスを作り、name メソッドを呼び出してみると、基底クラスを継承していることが分かる。

```python
class Car:
    def name(self):
        print('私は車です。')

class Sedan(Car): # Car を継承
    pass

car  = Car()
sedan = Sedan()

car.name() # 私は車です。
sedan.name() # 私は車です。
```

### super()

メソッドのオーバーライドとは、基底クラスが持つメソッドと同名のメソッドを定義することによって、そのメソッドを上書することである。

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

オーバーライドしたメソッドでは、基底クラスのメソッドが自動で呼ばれないので、明示的に呼び出す必要がある。基底クラスのメソッドを呼び出すときは、呼び出し先の関数のブロック内に、組み込み関数 super() を記述する。

```python
class Car:
    def __init__(self, name):
        self.name = name

class Color(Car): # Car を継承
    def __init__(self, name, color): # color 引数を追加
        super().__init__(name) # 基底クラスのメソッド呼び出し
        self.color = color # 基底クラスに含まれていない要素

sedan = Color('CROWN', 'BLACK')
sedan.name # 'CROWN'
sedan.color # 'BLACK'
```

上に書いたコードが行っているのは、以下である。

1.  super()が基底クラスの定義を取り出す
2.  `super().__init__(name)` メソッドが、`Car.__init__(name)` メソッドを呼び出す
3.  引数 color が、基底クラスに渡され処理される

将来、基底クラスの定義が変更されても、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'
```

```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 の継承は、メソッド解決順序により決まる。

```python
class A:
    def __init__(self, name):
        self.name = name
    def method(self):
        print('A')
        return self.name
class B:
    def __init__(self, name):
        self.name = name
    def method(self):
        print('B')
        return self.name

class C(A, B):
    pass

c = C('ccc')
c.method()
# A
# ccc
```

ひし形継承問題

以下のように複数の継承元が同じメソッド名にすると競合が起きる。無謀な継承は避けるべきである。

```python
class A:
    def hello(self):
        print('hello A')

class B(A):
    def hello(self):
        print('hello B')
        super().hello()

class C(A):
    def hello(self):
        print('hello C')
        super().hello()

class D(B, C):
    def hello(self):
        print('hello D')
        super().hello()

d = D()
d.hello()
# hello D
# hello B
# hello C
# hello A
```

### Mixin

Mixin （ミックスイン）とは、もとのクラス階層とは直接的に関連しない処理をまとめたものである。つまり、クラス定義にヘルパーとして使うだけの親クラスを組み込むことができる。次に示すコードは、Python の標準ライブラリである pprint モジュールをインポートして、`pprint.pprint()` メソッドを使い、オブジェクトをきれいに整形して出力する例である。

```python
import pprint
class Mixin:
    def feature(self):
        pprint.pprint(vars(self))

class Taro(Mixin):
    pass

f = Taro()
f.name = 'yamada'
f.age = 17
f.broad = 'B'

f.feature()

# {'age': 17, 'broad': 'B', 'name': 'yamada'}
```

[クラスの基本操作はこちら](#)


継承とは、クラスを定義する際に基底クラスを指定することで、基底クラスの性質を受け継ぎ、コードの再利用を実現する方法である。クラスの継承のポイント

Python : クラスの使い方 2


## TL;DR

クラスをもとに生成されたオブジェクトは **インスタンス** と呼ばれる。インスタンスが持つメソッド（クラスに紐づく処理。クラスやオブジェクトの中の関数）は **インスタンスメソッド** と呼ばれる。インスタンスごとに独立した値を保持する変数を、**インスタンス変数** という。

### インスタンスのポイント

- インスタンスを作ることで、クラスの中の関数を呼び出して処理させることができる
- インスタンスは、メソッドや変数を持つ
- 第一引数には必ずインスタンス自身のオブジェクトが渡される
- 第一引数に 慣例として self を指定する

インスタンス化までの構文を紐解くと、次のようになる。

```python
class クラス名:
    def __init__(self, 仮引数1, 仮引数2): # イニシャライザで初期化
        self.インスタンス変数1 = 仮引数1 # インスタンス変数を定義
        self.インスタンス変数2 = 仮引数2
    def インスタンスメソッド(self, 仮引数1, 仮引数2):
        処理

インスタンス名 = クラス名(実引数1, 実引数2) # インスタンスの生成
インスタンス名.インスタンスメソッド
```

| 名前                 | 用語解説                                         |
| -------------------- | ------------------------------------------------ |
| インスタンス         | クラスをもとに生成されたオブジェクト             |
| インスタンスメソッド | インスタンスが持つメソッド                       |
| インスタンス変数     | インスタンスが保持する変数                       |
| **init**             | オブジェクトが作られたときに自動的に呼び出される |
| self                 | インスタンス自身を参照する                       |

インスタンスの実引数に値を入れてみると次のようになる。

```python
class クラス名:
    def __init__(self, 引数1, 引数2):
        self.インスタンス変数1 = 引数1
        self.インスタンス変数2 = 引数2 * 10

インスタンス名 = クラス名("ポチ", 10)
print(f'{インスタンス名.インスタンス変数1}の体重は{インスタンス名.インスタンス変数2}kgです。')

# ポチの体重は100kgです。
```

[クラスの基本操作はこちら](https://commte.net/7333)

### インスタンス化

インスタンス化とはクラスオブジェクトに()をつけて呼び出し、インスタンスを作ることである。このとき、クラスオブジェクトに渡された引数はイニシャライザ（`__init__`）によって初期化される。

インスタンスは関数と同じようにクラス名を呼び出して作る。

```python
インスタンス名 = クラス名()
```

具体的には次のように使う。

```python
class Menu: # クラスを定義する
    pass # 処理

x = Menu() # インスタンス化
x.name = 'hello'
x.name
# 'hello'
```

type()メソッドでインスタンスのクラスを調べてみると `__main__.Menu` と返される。isinstance()関数 で Menu クラスか調べると真、dir()関数で属性を調べると、`__class__` が返されている。

```python
class Menu:
    pass

x = Menu()
x.name = 'hello'
type(x) # __main__.Menu
isinstance(x, Menu) # True
dir(x) # ['__class__', ...]
```

### インスタンスメソッド

インスタンスが持つメソッドを、インスタンスメソッドと呼ぶ。インスタンスメソッドは、処理の中でインスタンス自身にアクセスできる。インスタンスを生成することで外からアクセスできる。

クラス定義の中でメソッドの第一引数が self になっていたら、インスタンスメソッドである。

メソッドのタイプを整理してみよう。

| メソッドのタイプ     | デコレータ    | 第一引数                 |
| -------------------- | ------------- | ------------------------ |
| インスタンスメソッド | なし          | self                     |
| クラスメソッド       | @classmethod  | cls                      |
| 静的メソッド         | @staticmethod | オブジェクトやクラス以外 |

インスタンスメソッドは、最初 function クラスのインスタンスだが、

```python
class Menu:
    def hello(self):
        print('hello')

type(Menu.hello)

# function
```

インスタンスを通じてアクセスすると method クラスになる。

```python
class Menu:
    def hello(self):
        print('hello')

menu = Menu() # インスタンス
type(menu.hello)

# method
```

### インスタンス変数

インスタンス変数とは、インスタンス（クラスをもとに生成されたオブジェクト）が保持する変数のことである。インスタンスごとに独立して扱うことができる。

```python
class クラス名:
    def __init__(self, 仮引数1, 仮引数2):
        self.インスタンス変数1 = 仮引数1
        self.インスタンス変数2 = 仮引数2
    def インスタンスメソッド(self, 仮引数1, 仮引数2):
        処理

インスタンス名 = クラス名(実引数1, 実引数2)
インスタンス名.インスタンスメソッド = 属性
```

インスタンスの属性（クラスやオブジェクトの変数のこと）に値を代入するとインスタンス変数を定義できる。オブジェクトを作る間、それらのものに属性を与えることができる。

```python
class Menu:
    def info(self):
        print(self.name)

x = Menu() # インスタンス
x.name = 'hello'
x.info()

# hello
```

クラスは、属性を追加できる。

```python
class Fruit:
    color = 'red'
apple = Fruit()
Fruit.color # 'red'
apple.color # 'red'
```

インスタンスの属性を変更しても、クラスの属性は影響されない。

```python
class Fruit:
    color = 'red'
apple = Fruit()
apple.color = 'blue' # インスタンス属性を変更
apple.color # 'blue'
Fruit.color # 'red'
```

インスタンス定義後に、クラス属性を変更しても、インスタンスには影響を与えない。

```python
class Fruit:
    color = 'red'
apple = Fruit()
apple.color = 'blue'
Fruit.color = 'yellow' # クラス属性の変更
apple.color # 'blue' クラス属性に影響されない
```

しかし、クラス属性を変更したあとに、新しいオブジェクトを作ると影響を受ける。

```python
class Fruit:
    color = 'red'
apple = Fruit()
apple.color = 'blue'
Fruit.color = 'yellow' # クラス属性の変更
lemmon = Fruit() # 新しいオブジェクト追加
lemmon.color # 'yellow'
```

### イニシャライザ

**イニシャライザとは、オブジェクトが作られたときに自動的に呼び出される関数**である。Python は、`__init()__` を呼び出す前にすでにオブジェクトを構築している。したがって、`__init()__` はコンストラクタ（インスタンスを作成したタイミングで実行されるメソッド）ではない。

```python
class Dog:
    def __init__(self, 仮引数1, 仮引数2):
        self.name = 仮引数1
        self.weight = 仮引数2

pochi = Dog("ポチ", 10)
print(f'{pochi.name}の体重は{pochi.weight}kgです。')
# ポチの体重は10kgです。
```

`__init()__` は、インスタンスの生成直後に自動で呼び出され、このクラスのインスタンス全てが同じ属性を持つようになる。第一引数にインスタンス自身が渡る。第二引数の値も利用できる。

作成時にオブジェクトの属性に値を代入する場合、イニシャライザ（初期化子）のために、特殊メソッド `__init()__` を記述する必要がある。

クラス定義で `__init()__` を定義するときは、**第一引数は self** でなければならない。（self はインスタンス自身を表す仮引数名である）

全てのクラス定義が、`__init()__` を持つ必要はない。


クラスをもとに生成されたオブジェクトはインスタンスと呼ばれる。インスタンスが持つメソッド（クラスに紐づく処理。クラスやオブジェクトの中の関数）は

Python : クラスの使い方 1


## TL;DR

例外とは、エラーが起きたときに実行されるコードのことである。try 文を用いて例外が発生しそうなところに例外処理を追加し、ユーザーに何が起こるのか知らせる。

### 例外のポイント

- Python は例外の発生を検知すると強制的にプログラムを終了する
- 例外の情報とともにトレースバックと呼ばれる例外発生の箇所に関する情報が出力される
- 例外の補足には try 文を使う
- 例外が発生したときの処理は except 節に記述する
- 例外が発生しなかったときの処理は else 文に記述する
- 例外の発生有無に関係なく実行したい処理は finally 文を記述する

#### 例外の種類

例外クラスは、BaseException という例外を継承している。

```python
BaseException
└── Exception
    ├── ZeroDivisionError
    ├── AttributeError
    ├── TypeError
    └── ValueError
```

次に示す例外は、すべて Exception のサブクラスである。

| 例外クラス        | 意味                                   |
| ----------------- | -------------------------------------- |
| IndexError        | 存在しない範囲のインデックスを指定した |
| AttributeError    | 存在しない属性を指定した               |
| KeyError          | マッピング型で存在しないキーを指定した |
| TypeError         | 不正な型を指定した                     |
| ValueError        | 不正な値を指定した                     |
| ZeroDivisionError | 0 を除算した                           |
| BaseException     | すべての例外のスーパークラス           |

#### try 文

try 文は、例外の補足を行う。

例外の発生が事前に予期できる場合は、try 文を利用すると強制終了を避けられる。try 文は、例外処理やクリーンアップ処理を行う際に利用する。

```python
try:
    例外が発生する可能性のある処理
except:
    補足したい例外が発生したときに実行される処理
else:
    例外が発生しなかったときのみ実行
finally:
    例外の発生有無にかかわらず実行
raise:
    意図的に例外を発生させる
```

### except 節

except 節は、例外が検知されたときに実行される。しかし、引数なしの except を指定すると、あらゆる例外型がキャッチされる。

次に示すコードでは、try ブロックで例外が検知され、except ブロックに記述してあるコードが実行されている。

```python
w = [10, 20, 30]
number = 4
try:
    print(w[number])
except:
    print(f'{len(w)} より小さい数でお願いします')
else:
    print('例外は発生しませんでした')
finally:
    print('お疲れ様でした')

# 3 より小さい数でお願いします
# お疲れ様でした
```

except 節の後ろには、例外型を指定することができる。次のコードは、シーケンスに無効な位置を指定されたときに返される IndexError を指定している。

```python
def n(index_number):
    lang = ['Python', 'Rust', 'Go']
    try:
        return lang[index_number]
    except IndexError:
        return '無効な位置です'

n(5)

# '無効な位置です'
```

例外型を複数追加したいときは、except 節の後に半角スペースを空け、括弧とカンマ区切りで複数の例外を記述する。`(,)` のようにカンマ区切りで列挙する。

```python
w = [10, 20, 30]
number = 5
try:
    print(w[number])
except (IndexError, TypeError):
    print('IndexError か TypeError です')

# IndexError か TypeError です
```

#### 処理を分ける

except 節は複数記述することができる。処理を分けたい場合は、except 節を 任意の数だけ追加するとよい。

```python
w = [10, 20, 30]
number = 'hoge'
try:
    print(w[number])
except IndexError:
    print('IndexError です')
except TypeError:
    print('TypeError です')

# TypeError です
```

#### 例外型の順番

先に示したように例外クラスは[継承の順番](#types)があるので、スーパークラスを先に記述すると、サブクラスの例外も補足されてしまう。したがって、**継承関係がある例外を複数記述する場合は、サブクラスの例外から記述する。**

```python
def num(a, b):
    try:
        i = a / b
        print(i)
    except TypeError:
        print('TypeError')
    except ZeroDivisionError:
        print('ZeroDivisionError')
    except Exception:
        print('Exception')
num(8, 'hoge')

# TypeError
```

#### as キーワード

例外の詳細情報を獲得したい場合、except 節の後ろに、as キーワードと変数名をつけ、except ブロック内に埋め込むと、例外オブジェクトの内容を表示することができる。

```python
except (例外型の指定) as 変数名
```

次のコードは、除数が 0 になり計算できないので、ZeroDivisionError が発生し、それを捕獲している。

```python
def num(a, b):
    try:
        i = a / b
        print(i)
    except ZeroDivisionError as er:
        print(f'{er}')
num(8, 0)

# division by zero
```

次に示すコードでは、シーケンスに無効な位置を指定されたときに返される IndexError を捕獲し、メッセージが表示される。

```python
w = [10, 20, 30]
number = 5
try:
    print(w[number])
except (IndexError, TypeError) as er:
    print(f'{er}')

# list index out of range
```

#### else 節 と finally 節

else 節は、例外が発生しなかったときに実行される。正常終了時のみの実行である。

finally 節は、例外の有無に関わらず必ず実行される。

try ブロックで例外が検知されない場合は、except ブロックは実行されず、try と else と finally が実行される。

```python
w = [10, 20, 30]
number = 2
try:
    print(w[number])
except:
    print(f'{len(w)} より小さい数でお願いします')
else:
    print('例外は発生しませんでした')
finally:
    print('お疲れ様でした')

# 30
# 例外は発生しませんでした
# お疲れ様でした
```

### raise 文

raise 文で例外を発生させることができる。raise で指定できる例外は、Exception を継承した例外クラスと例外オブジェクトである。

```python
raise 例外クラス(メッセージ)
```

```python
raise NameError('hoge')

# NameError: hoge
```

```python
try:
    raise TypeError('不正な型です')
except TypeError as er:
    print(er)

# 不正な型です
```

#### 例外を再送出する

例外が発生した際、処理を行った後に、再び例外処理を実行したい場合は、例外を再送出させる。

```python
def num(a, b):
    try:
        i = a / b
        print(i)
    except Exception as er:
        print('例外発生')
        raise er

num(8, 0)

# 例外発生
# ZeroDivisionError: division by zero
```


例外とは、エラーが起きたときに実行されるコードのことである。try文を用いて例外が発生しそうなところに例外処理を追加し、ユーザーに何が起こるのか知らせる。

2021-11-17

Python: 環境開発の方法（パッケージのインストール、venv、pip、pyenv など）

2021-11-15

Python: 並列処理と並列処理、プロセスとスレッドなど

2021-11-8

Python : ファイル入出力の基本操作編（with open など）

2021-10-26

Python : 日付の基本操作編（datetime 型、date 型、strptime など）

2021-10-20

Python : 正規表現の使い方

2021-10-18

Python : モジュールの使い方（import、as、パッケージなど）

2021-10-12

Python : クラスの使い方 3

2021-10-8

Python : クラスの使い方 2

2021-10-7

Python : クラスの使い方 1

2021-10-4

Python : 例外の基本操作編

2021-11-17

Python: 環境開発の方法（パッケージのインストール、venv、pip、pyenv など）

2021-11-15

Python: 並列処理と並列処理、プロセスとスレッドなど

2021-11-8

Python : ファイル入出力の基本操作編（with open など）

2021-10-26

Python : 日付の基本操作編（datetime 型、date 型、strptime など）

2021-10-20

Python : 正規表現の使い方

2021-10-18

Python : モジュールの使い方（import、as、パッケージ など）

2021-10-12

Python : クラスの使い方 3

2021-10-8

Python : クラスの使い方 2

2021-10-7

Python : クラスの使い方 1

2021-10-4

Python : 例外の基本操作編

Python : モジュールの使い方（import、as、パッケージなど）