
## 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文を用いて例外が発生しそうなところに例外処理を追加し、ユーザーに何が起こるのか知らせる。

Python : 例外の基本操作編


## TL;DR

関数は処理をまとめた再利用可能なコードである。関数は他のコードから切り離され、名前を付けられたコードである。

### 関数のポイント

- Python では関数もオブジェクト
- 関数を定義するには def と入力する
- 関数名の先頭は英字か`_` を使う

```python
>>> def h():
...     print('hello')
...
>>> type(h)
<class 'function'>
```

Python の関数には、3 つの特徴がある。

- 名前を持つ
- 手続きの流れを含む
- 返り値（return で定義）

### 関数の基本形

```python
def hoge():
    print('hello')

# 関数呼び出し
hoge()
# hello
```

関数名には小文字とアンダースコアを使う。引数のない呼び出しはエラーになる。

### 実引数と仮引数

関数定義時に使う引数を仮引数と呼び、関数呼び出し時に渡す引数を実引数と呼ぶ。関数の外からは実引数、関数の中では仮引数。

実引数を渡して関数を呼び出すとき、それらの値は関数内の対応する仮引数にコピーされる。

実引数が不足したり多かったりするとエラーになる。変数に関数を代入することもできる。

```python
def w():
    print('word')

h = w() # 変数に関数を代入
h
# word
```

```python
def h(name):
    print('hello ' + name)

h('john')
# hello john
```

### 位置引数

先頭から順に対応する位置の仮引数にコピーされる。

```python
def menu(a, b, c):
    """位置引数"""
    return {'A': a, 'B': b, 'C': c}
menu('X', 'Y', 'Z')
# {'A': 'X', 'B': 'Y', 'C': 'Z'}
```

### 仮引数にデフォルト値

関数の呼び出しには、デフォルト値を持たせられる。引数名=デフォルト値 といったように指定する。

```python
def h(w='word'):
    print(w)

h()
# word
```

引数を渡すと、その値が利用される。

```python
def h(w='word'):
    print(w)

h('change')
# change
```

### キーワード引数

キーワード引数は関数の呼び出しで、仮引数名を指定して渡す実引数である。キーワード引数（実引数にセット） 呼び出し時の順番は呼び出し結果に影響しない。

```python
def h(a, b):
    return a

h(b=1, a=2) # キーワード引数
# 2
```

### return 文

return 文を使うと、関数の戻り値を指定できる。return 文が実行されると、そこで処理が終了する。

```python
def i(plus):
    return plus + 1

i(2)
# 3

def h(n = 'guest'):
    if n == 'guest':
        return '名前を教えてください'

h()
# '名前を教えてください'
```

複数の引数をセットできる。以下、BMI を計算させてみる。

```python
def bmi(h,w):
    return w / (h/100) ** 2

bmi(174, 62)
# 20.478266613819528
```

#### return がない場合

return 文がない場合は None が返される。return 文が実行されない関数は保守性が低くなるので、常に return 文が実行されるように戻り値を書くべきである。

```python
def no_r():
    pass

print(no_r())

# None
```

### 可変長引数

可変長引数は、数が決まっていない引数を渡す方法である。関数の引数が任意の個数となっている。 可変長の引数を受け取る関数は、仮引数名に `*` アスタリスクをつけて定義する。 仮引数に割り当てられなかった位置引数をタプルで受け取る。

```python
# 慣例として *args と記述することが多い。
def h(*args):
    for i in args:
        print(i)

h('one', 'two', 'three')

# one
# two
# three
```

#### 可変長のキーワード引数

アスタリスクを 2 つ使うことで、キーワード引数を 1 つの辞書にまとめることができる。可変長のキーワード引数を受け取る関数は、仮引数名にアスタリスクを 2 つ付けると定義できる。

```python
# 慣例として **kwargs と記述することが多い。
def h(**kwargs):
    print(kwargs)

h(a=10, b=20, c=30)
# {'a': 10, 'b': 20, 'c': 30}
```

#### キーワード専用引数

引数に単独の `*` を付けた場合、`*` 以降の引数は、キーワード引数という形でしか渡せない。

```python
def h(a, *, b):
    print(f'{a} {b}')

h(1, b=2)

# 1 2
```

### 引数リストのアンパック

`*`演算子は、リストや辞書に格納された値を引数に渡す機能である。

```python
def print_page(one, two, three):
    print(one)
    print(two)
    print(three)

contents = ['a', 'b', 'c']
print_page(*contents)

# a b c
```

`**`演算子を使うと、辞書に格納している値をキーワード引数として渡す。

```python
def print_page(one, two, three):
    print(one)
    print('2番目 - ', two)
    print('3番目 - ', three)

dic = {'two' : 2, 'three' : 3}
print_page('1番目', **dic)

# 1番目
# 2番目 -  2
# 3番目 -  3
```

### 関数内関数

関数の中に関数を入れることも可能である。外側の関数から内側の関数を呼び出す。

関数内関数はクロージャ（ほかの関数によって動的に生成される関数）として機能し、自分の外で作られた変数の値を変更できる。

```python
def out(a, b):
    print('関数を呼び出します')
    def inner(c, d):
        return c + d
    return inner(a, b)
out(2, 3)

# 関数を呼び出します
# 5
```

### ラムダ関数

ラムダ関数は、一行で表現される無名関数である。無名関数とは、関数が必要なときにその場で定義する使い捨て関数である。無名が故に「関数名を考える必要がない」というメリットもある。

どんなときに使われるのかというと、関数を「引数」として受け取る関数を呼び出すときなど。

ラムダは 0 個以上のカンマ区切りの実引数を取り、後ろにコロンをつけ、関数定義をする。lambda では丸括弧を使わない。

無名関数は、関数の引数として関数オブジェクトを渡すときに利用される。式はそのまま返されるので、return 文は不要である。

```python
lambda 引数1, 引数2 : 戻り値
```

```python
b = lambda a : a + 1

b(2)

# 3

b = lambda a, b : a + b

b(1,2)

# 3
```

関数を引数として呼び出す。

```python
n = ['Python', 'Rust', 'Go']
f = filter(lambda i: len(i) == 4, n)
list(f)

# ['Rust']
```

### ジェネレーター関数

return を yield に変えれば、複数の値を一つずつ作り出すジェネレーターになる。ジェネレーター関数を使うことにより、yeild のところまで処理を進め一旦停止する。そして任意のタイミングで処理を再開することができる。

[参考 : yield を使う関数をジェネレーター関数、内包表記を使うものをジェネレーター式という](https://commte.net/7466)

次のコードは、next 関数が呼ばれるたびに、関数の中の処理が次の yield まで進んでいることを示している。値がなくなると例外 StopIteration が返る。

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

a = g(100)
next(a) # 100
next(a) # 98
next(a) # 96
```

### デコレータ

ソースコードを書き換えずに、既存の関数に変更を加えたいことがある。デコレータは、既存関数に対してコードの変更なしに処理を追加する関数である。

[参考 : デコレータは既存の関数に機能を追加する関数](https://commte.net/7469)

```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 w(a:int) -> int:
    return a

w(3)
# 3
```

```python
def greeting(name: str) -> str:
    return 'Hello ' + name
```

### 再帰

関数が自分自身を呼び出すことを再帰という。再帰はリストのネストなど、平坦ではないデータを処理するときに役立つ。

```python
def flat(x):
    for i in x:
        if isinstance(i, list):
            for i_in in flat(i):
                yield i_in
        else:
            yield i

x = [1, 2, [3, 4, 5], [6, [7, 8, 9]]]
list(flat(x))

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

### Docstring

関数には Docstring を記述することができる。Docstring は、コメントと同じように何を書いてもよいが、エディタでヒントを出したときに理解の手助けとなるように、引数・戻り値・関数の概要を記述するとよい。

```python
def print_page(one, two, three):
    """関数の概要

    引数:
        引数の説明
    戻り値:
        戻り値の説明

    """
    print(one)
    print(two)
    print(three)
```

Google の Python Docstrings の例が記述してある[Example Google Style Python Docstrings — napoleon 0.7 documentation](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/example_google.html)が、参考になる。

Docstring は複数行にまたがることがあり、段落が作られる。段落の題名：の後にインデントされたテキストのブロックが続く。

```python
def function_with_types_in_docstring(param1, param2):
    """Example function with types documented in the docstring.

    `PEP 484`_ type annotations are supported. If attribute, parameter, and
    return types are annotated according to `PEP 484`_, they do not need to be
    included in the docstring:

    Args:
        param1 (int): The first parameter.
        param2 (str): The second parameter.

    Returns:
        bool: The return value. True for success, False otherwise.

    .. _PEP 484:
        https://www.python.org/dev/peps/pep-0484/

    """

```


関数は処理をまとめた再利用可能なコードである。関数は他のコードから切り離され、名前を付けられたコードである。関数のポイントPython

Python : 関数の基本操作編


## TL;DR

集合は一意な要素の集合を扱うイテラブル（繰り返し可能）オブジェクトである。個々のキーはユニークである必要がある。重複を排除しユニークな要素だけ抽出したいときに便利に使えるだろう。

### 集合のポイント

- 要素の重複を排除する
- 要素の順番を保持しないのでインデックスアクセスは不可
- set 型と frozenset 型がある
- set 型は可変、frozenset 型は不変
- 空の場合は偽、要素が一つでもあれば真

集合は、組み込み関数である set()関数を使うか、`{}` で作る。実は`{}` で作られるのは空辞書である。

```python
empty_set = set()
empty_set

# set()

even_n = {2, 4, 6, 8}
even_n

# {2, 4, 6, 8}
```

順番を保持しないので、添字によるアクセスはできない。

```python
lang = {'Python', 'Go', 'Rust', 'JavaScript'}
lang[1]

# TypeError: 'set' object is not subscriptable
```

### set 型

set 型は可変なオブジェクトであり、一意な要素の集合を扱う。重複する要素は一つになる。

重複する要素は排除され、一つにまとめられる。リスト、文字列、タプル、辞書から重複する値を取り除くことができる。

```python
set([1, 2, 3, 3, 4, 5, 5])
set((1, 2, 3, 3, 4, 5, 5))
set({1, 2, 3, 3, 4, 5, 5})

# ↑は全て {1, 2, 3, 4, 5} が返る

set('hello')

# {'e', 'h', 'l', 'o'}
```

#### set.add()

set.add()は、set 型に要素を追加するメソッドである。

```python
lang = {'Python', 'Go', 'Rust', 'JavaScript'}
lang.add('Java')
lang

# {'Go', 'Java', 'JavaScript', 'Python', 'Rust'}
```

#### set.remove()

set.remove()は、要素を指定して削除するメソッドである。

```python
lang = {'Python', 'Go', 'Rust', 'JavaScript'}
lang.remove('JavaScript')
lang

# {'Go', 'Python', 'Rust'}
```

#### len()

要素の数を数えるときは、len() を使う。

```python
lang = set(('Python', 'Go', 'Rust', 'Java'))
len(lang)

# 4
```

#### for in

集合は for 文で反復可能である。ユニークな要素に何か付与したい場合などに使う。次のコードは、重複なしの要素に数字を付けて返すものである。

```python
lang = set(('Python', 'Go', 'Rust', 'Java', 'Python'))
for count, i in enumerate(lang, start=1):
    print(f'言語{count}：{i}')

# 言語1：Rust
# 言語2：Go
# 言語3：Java
# 言語4：Python
```

### frozenset 型

frozenset 型は、set 型を不変にした型である。不変なので要素の変更（add、remove など）はできない。

```python
lang = frozenset(('Python', 'Go', 'Rust', 'Java'))
lang.remove('Go')

# AttributeError: 'frozenset' object has no attribute 'remove'
```

### 集合演算

#### 和集合

和集合の演算を行う場合は`|`か set.union()を使う。両方に含まれる要素が返される。重複する要素はない。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
frontend = {'JavaScript', 'html', 'css'}

backend | frontend

# {'Go', 'JavaScript', 'Python', 'Rust', 'css', 'html'}
```

set.union() も `|` と同じ結果になる。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
frontend = {'JavaScript', 'html', 'css'}

backend.union(frontend)

# {'Go', 'JavaScript', 'Python', 'Rust', 'css', 'html'}
```

#### 差集合

差集合の演算を行う場合は`-`か set.difference()を使う。対象となる集合の中から指定の集合に属する要素を取り去る。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
ng = {'JavaScript', 'html', 'css'}
backend - ng

# {'Go', 'Python', 'Rust'}
```

set.difference() も `-` と同じ結果になる。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
ng = {'JavaScript', 'html', 'css'}
backend.difference(ng)

# {'Go', 'Python', 'Rust'}
```

#### 積集合

積集合の演算を行う場合は`&`か set.intersection()を使う。共通の要素を取り出す。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
frontend = {'JavaScript', 'html', 'css'}

backend & frontend

# {'JavaScript'}
```

set.intersection() も `&` と同じ結果になる。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
frontend = {'JavaScript', 'html', 'css'}

backend.intersection(frontend)

# {'JavaScript'}
```

#### 対称差

積集合の演算を行う場合は`^`か set.symmetric_difference()を使う。どちらか一方だけに属する要素だけが返る。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
frontend = {'JavaScript', 'html', 'css'}

backend ^ frontend

# {'Go', 'Python', 'Rust', 'css', 'html'}
```

set.symmetric_difference() も `^` と同じ結果になる。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
frontend = {'JavaScript', 'html', 'css'}

backend.symmetric_difference(frontend)

# {'Go', 'Python', 'Rust', 'css', 'html'}
```

#### 部分集合

部分集合か判定する場合は`<=`か issubset()を使う。片方の集合が、もう片方の部分集合になっているか判定する。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
frontend = {'JavaScript'}

frontend <= backend

# True
```

set.issubset() も `<=` と同じ結果になる。

```python
backend = {'Python', 'Go', 'Rust', 'JavaScript'}
frontend = {'JavaScript'}

frontend.issubset(backend)

# True
```


集合は一意な要素の集合を扱うイテラブル（繰り返し可能）オブジェクトである。個々のキーはユニークである必要がある。重複を排除しユニークな要素だけ抽出したいときに便

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-10-1

Python : 関数の基本操作編

2021-9-30

Python : 集合の基本操作編（set 型、frozenset 型など）

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-10-1

Python : 関数の基本操作編

2021-9-30

Python : 集合の基本操作編（set 型、frozenset 型 など）

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

Python : 集合の基本操作編（set 型、frozenset 型など）