
## 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
```


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

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


## TL;DR

辞書はキーと値のセットを扱う。要素の順序は管理されておらず、0 や 1 などのオフセットは使わない。キーはイミュータブル（変更不可オブジェクト。数値型, bool, tuple, str, range, bytes, frozenset, file object）なら何でもよい。辞書はミュータブル（変更可能オブジェクト）なので、キーとバリュー要素を追加・修正・削除ができる。

### 辞書のポイント

- 辞書はミュータブル（変更可能オブジェクト）
- キー(key) と値(value) を対応づけるデータ
- オフセットは使わない
- 辞書を扱うデータ型として dict 型がある
- 辞書のキーには、不変オブジェクト（文字列、数値、タプルなど）が利用可能
- 辞書のキーには、可変オブジェクト（リスト、辞書など）は利用不可

辞書は、`{}` にキーと値を入れて作る。キーが辞書の中に存在しない場合、例外 KeyError が発生する。例外を発生させたくない場合は、後述する get()メソッドを使う。

```python
fruits = {'apple': 1, 'banana': 2, 'grape': 3}
fruits['apple']

# 1
```

### get()

get()メソッドを使うと、キーに対応する値を例外なしで返すことができる。

キーがあれば対応するバリューが返される。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
fruits.get('apple', '見つかりません')

# 'red'
```

キーが存在しなければ、オプションのバリューで設定した文字列が返される。設定しない場合は、None が返される。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
fruits.get('lemon', '見つかりません')

# '見つかりません'
```

### dict 型

dict 型は辞書を扱う型である。辞書は `{}` を使う。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
type(fruits)

# dict
```

`{}` で囲まなくても、dict() に名前付き引数と値を渡すだけで辞書を作ることができる。

```python
fruits = dict(apple=1, banana=2, grape=3)
fruits

# {'apple': 1, 'banana': 2, 'grape': 3}
```

dict() で変換する場合、リストの中にリストがあると、シーケンス（list, tuple, range）の先頭の要素がキー、第二要素は値になる。

```python
foods = [['apple', 1], ['banana', 2], ['grape', 3]]
dict(foods)

# {'apple': 1, 'banana': 2, 'grape': 3}
```

タプルのリストも同じ結果となる。

```python
foods = [('apple', 1), ('banana', 2), ('grape', 3)]
dict(foods)

# {'apple': 1, 'banana': 2, 'grape': 3}
```

### keys()

keys()は辞書のすべてのキーを取得できる。リストにする場合は、list()関数を使う。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
list(fruits.keys())

# ['apple', 'banana', 'grape']
```

### values()

values()は辞書のすべてのバリューを取得できる。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
list(fruits.values())

# ['red', 'yellow', 'purple']
```

### items()

items() は辞書のすべてのキーとバリューを取得できる。結果は、タプルで返される。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
list(fruits.items())

# [('apple', 'red'), ('banana', 'yellow'), ('grape', 'purple')]
```

### len()

len()は、キーとバリューのペア数を数える。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
len(fruits)

# 3
```

### 辞書の結合

辞書の結合は `{**変数, **変数}` を使う。3 つ以上の辞書を渡すことができる。

```python
fruits = {'apple':1, 'banana':2}
vegetable = {'broccoli': 3, 'carrot': 4}
{**fruits, **vegetable}

# {'apple': 1, 'banana': 2, 'broccoli': 3, 'carrot': 4}
```

### update()の結合

update()関数を使うと、辞書のキーとバリューを結合できる。重複するキーがある場合、第二の辞書のバリューが渡される。

```python
fruits = {'apple':1, 'banana':2}
vegetable = {'broccoli': 3, 'carrot': 4}
fruits.update(vegetable)
fruits

# {'apple': 1, 'banana': 2, 'broccoli': 3, 'carrot': 4}

fruits = {'apple':1, 'banana':2}
vegetable = {'apple': 3, 'carrot': 4}
fruits.update(vegetable)
fruits

# {'apple': 3, 'banana': 2, 'carrot': 4}
```

### del()

del()文を使うと、指定したキーと、そのキーに対応するバリューを削除する。対応するキーが存在しない場合は、例外を返す。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
del fruits['banana']

fruits

# {'apple': 'red', 'grape': 'purple'}
```

### pop()

dict.pop() も指定したキーに対応するバリューを削除する。対応するキーが存在しない場合は、例外を返すが、第二引数にデフォルトバリューを設定すると例外は発生せず、辞書は変更されない。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
fruits.pop('banana')

fruits

# {'apple': 'red', 'grape': 'purple'}

fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
fruits.pop('lemon', '見つかりませんでした')

fruits

# {'apple': 'red', 'banana': 'yellow', 'grape': 'purple'}
```

### clear()

clear() を使うと、辞書の中にあるキーとバリューを全て削除できる。空の辞書を代入しても同じように全て削除される。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
fruits.clear()
fruits

# {}

fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
fruits = {}
fruits

# {}
```

### copy() と deepcopy()

元の辞書に影響を与えず変更を加えたいときは、copy()を使う。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
foods = fruits.copy()
foods['lemon'] = 'yellow'
foods

# {'apple': 'red', 'banana': 'yellow',
#'grape': 'purple', 'lemon': 'yellow'}

fruits

# {'apple': 'red', 'banana': 'yellow', 'grape': 'purple'}

```

要素の中に二次元配列が存在する場合、元の辞書のリストを書き換えると、コピー先も書き換えられてしまうが、

```python
fruits = {'apple':['red', 'green'], 'banana':'yellow', 'grape':'purple'}
fruits_copy = fruits.copy()
fruits['apple'][1] = 'yellow'
fruits_copy

# {'apple': ['red', 'yellow'], 'banana': 'yellow', 'grape': 'purple'}
```

copy モジュールをインポートして、copy.deepcopy() を使うと、コピー先は変更されない。

```python
import copy
fruits = {'apple':['red', 'green'], 'banana':'yellow', 'grape':'purple'}
fruits_copy = copy.deepcopy(fruits)
fruits['apple'][1] = 'yellow'
fruits_copy

# {'apple': ['red', 'green'], 'banana': 'yellow', 'grape': 'purple'}
```

### for

for 文を使うと、キーが返される。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
for i in fruits:
    print(i)

# apple
# banana
# grape
```

values() 関数を使うとバリューを返す。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
for i in fruits.values():
    print(i)
# red
# yellow
# purple
```

dict.items()関数を使うとキーとバリューがタプルで返される。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
for i in fruits.items():
    print(i)
# ('apple', 'red')
# ('banana', 'yellow')
# ('grape', 'purple')
```

dict.items()の戻り値を、そのまま表示するか文字列に代入したい場合は、for の引数を 2 つ設定するとよい。

```python
fruits = {'apple':'red', 'banana':'yellow', 'grape':'purple'}
for a, b in fruits.items():
    print(f'{a} は {b} です。')

# apple は red です。
# banana は yellow です。
# grape は purple です。
```

### 真理値

空の辞書は偽となるが、要素が一つ以上存在する場合は真となる。

```python
bool({})

# False

bool({'a': 0})

# True
```

in 演算子を使うと、要素の有無を判定する。

```python
words = {'a': 1, 'b':2, 'c':3}
'a' in words

# True
```

値に対して in 演算子を使う場合は、values()を付ける。

```python
words = {'a': 1, 'b':2, 'c':3}
1 in words.values()

# True
```


辞書はキーと値のセットを扱う。要素の順序は管理されておらず、0や1などのオフセットは使わない。キーはイミュータブル（変更不可オブジェクト。数値型,boo

Python : 辞書の基本操作編（get、dict 型、keys、values、items など）


## TL;DR

Python には文字列以外に、タプルとリストの 2 種類のシーケンス（list, tuple, range）構造がある。リストはミュータブルであり、要素の挿入と削除を行うことができる。リストの内容は直接変更（要素の追加、削除、置換）できる。要素は異なっていてもよく、複雑で深いデータ構造を作ることができる。

### list 型 のポイント

- list 型は、可変な配列を扱う型である
- 0 個以上の要素をそれぞれカンマで区切り、全体を\[\]で囲む
- 要素は異なっていてもよく、複雑で深いデータ構造を作ることができる
- タプルはイミュータブルであり、書き換え不可だが、
- リストはミュータブルであり、要素の挿入と削除を行うことができる

```python
w = ['a', 'b', 'c']
type(w)

# list
```

タプルや文字列と同じように、リストでも繰り返し可能である。

```python
['hello'] * 3

# ['hello', 'hello', 'hello']
```

### list()

組み込み関数である list()で空リストを作ることができる。

```python
a = list()
a

# []
```

list()関数は、タプル、文字列、辞書、集合などのイテラブルをリストに変換できる。

```python
list('abcde')

# ['a', 'b', 'c', 'd', 'e']

a = ('A', 'B', 'C')
list(a)

# ['A', 'B', 'C']
```

### list.append()

メソッド list.append()や `+演算子` を使えば、リストの結合ができる。リストの末尾にしか要素を追加できない。

```python
foods = ['pasta', 'curry', 'sushi']
foods.append('pizza')
foods

# ['pasta', 'curry', 'sushi', 'pizza']

foods = ['pasta', 'curry', 'sushi']
foods = ['soup'] + foods
foods

# ['soup', 'pasta', 'curry', 'sushi']
```

### join()

join() を使うと、リストの要素を一つに結合する。要素間のセパレータ文字を指定可能である。

```python
fruits = ['apple', 'banana', 'cherry']
'と'.join(fruits)

# appleとbananaとcherry
```

### for

次のコードは for 文を使って、要素内を順に処理しているケースである。

```python
fruits = ['apple', 'banana', 'cherry', 'lemon']
target = 'c'
for i in fruits:
    if i.startswith(target):
        print(f'{i}は、頭文字が{target}です')
        break
    else:
        print(f'{i}は、頭文字が{target}ではありません')


# appleは、頭文字がcではありません
# bananaは、頭文字がcではありません
# cherryは、頭文字がcです
```

for が break されずに終了したときに実行される else を使ってみよう。

```python
fruits = ['apple', 'banana', 'cherry', 'lemon']
target = 'd'
for i in fruits:
    if i.startswith(target):
        print(f'{i}は、頭文字が{target}です')
        break
    else:
        print(f'{i}は、頭文字が{target}ではありません')

else:
    print(f'結局、頭文字{target}の単語は存在しませんでした')

# appleは、頭文字がdではありません
# bananaは、頭文字がdではありません
# cherryは、頭文字がdではありません
# lemonは、頭文字がdではありません
# 結局、頭文字dの単語は存在しませんでした
```

要素を空にして、for が実行されない場合も、else に移る。

```python
fruits = []
target = 'd'
for i in fruits:
    if i.startswith(target):
        print(f'{i}は、頭文字が{target}です')
        break
    else:
        print(f'{i}は、頭文字が{target}ではありません')

else:
    print(f'要素内に、頭文字{target}の単語は存在しませんでした')

# 要素内に、頭文字dの単語は存在しませんでした
```

for をネストさせる。

```python
rows = ['1', '2']
cols = ['A', 'B']
for row in rows:
    for col in cols:
        print(row, col)

# 1 A
# 1 B
# 2 A
# 2 B
```

### リスト内包表記

リスト内包表記を使って、1 から 4 までの整数リストを作る。

```python
w = [i for i in range(1,5)]
w

# [1, 2, 3, 4]
```

次に示すコードは、1 から 10 までの整数のうち、奇数のみを抽出したものである。

```python
w = []
for i in range(1, 11):
    if i % 2 == 1:
        w.append(i) # w += [i] でもOK
w

# [1, 3, 5, 7, 9]
```

上と同じものをリスト内包表記を使って書くと簡潔になる。

```python
w = [i for i in range(1, 11) if i % 2 == 1]
w

# [1, 3, 5, 7, 9]
```

### insert()

リストのオフセットを指定し、任意の場所に要素を追加する場合は、insert()を使う。オフセットを 0 にするとリストの先頭に追加される。オフセットを越える数値を入れると末尾に追加される。

```python
fruits = ['apple', 'banana', 'cherry']
fruits.insert(2, 'lemon')
fruits

# ['apple', 'banana', 'lemon', 'cherry']

fruits = ['apple', 'banana', 'cherry']
fruits.insert(10, 'lemon')
fruits

# ['apple', 'banana', 'cherry', 'lemon']
```

### list.pop()

list.pop()を使うとリストから要素を取り出し、同時に削除もできる。

```python
fruits = ['apple', 'banana', 'cherry', 'lemon']
fruits.pop() #'lemmon'
fruits

# ['apple', 'banana', 'cherry']
```

### del

del 文もリストの中にある要素を指定して削除できる。

```python
foods = ['pasta', 'curry', 'sushi']
del foods[1]
foods

# ['pasta', 'sushi']
```

### split()

split()関数を使うと、セパレータに基づいて文字列を分割してリストに変換できる。

```python
'2021/10/12'.split('/')

# ['2021', '10', '12']

url = 'https://example.com'
domain = url.split('//')
del domain[0]
domain

# ['example.com']
```

### offset

オフセットを指定すればリストから、要素を取り出せる。

```python
foods = ['pasta', 'curry', 'sushi']
foods[2]

# 'sushi'

foods = ['pasta', 'curry', 'sushi']
foods[-1]

# 'sushi'
```

リストのリストは次のように指定するとよい。

```python
w = ['a', ['b', 'c'], 'd']
w[1][1]

# 'c'
```

オフセットを使えば、要素の書き換えができる。

```python
foods = ['pasta', 'curry', 'sushi', 'pizza']
foods[1] = 'banana'
foods

# ['pasta', 'banana', 'sushi', 'pizza']
```

#### スライス

\[\]の中に `:` を入れると、スライス操作ができる。

```python
[先頭のインデックス:末尾のインデックス]
```

- `[3:]` オフセット 3 から末尾までを取得
- `[1:4]` 2 つ目から 5 つ目までを取得
- `[-1:]` 最後の 文字列を取得
- `[5::2]` オフセット 5 から末尾まで 2 文字ごとに取得
- `[:5:2]` 先頭からオフセット 5 まで 2 文字ごとに取得
- `[-1::-1]` 末尾から先頭まで逆順に取得
- `[::-1]` 末尾から先頭まで逆順に取得

次のコードにある `[0:2]` は、0 から 1 つ目までを取り出している。

```python
foods = ['pasta', 'curry', 'sushi', 'pizza']
foods[0:2]

# ['pasta', 'curry']

foods = ['pasta', 'curry', 'sushi', 'pizza']
foods[3:]

# ['pizza']

foods = ['pasta', 'curry', 'sushi', 'pizza']
foods[-1:]

# ['pizza']

foods = [1,2,3,4,5,6,7,8]
foods[1::2]

# [2, 4, 6, 8]

foods = [1,2,3,4,5,6,7,8]
foods[-1::-1]

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

#### オフセットによる要素の書き換え

右辺と左辺の要素数が同じでなくてもかまわない。

```python
n = [1, 2, 3, 4, 5, 6, 7]
n[1:5] = [10, 11, 12]
n

# [1, 10, 11, 12, 6, 7]
```

これを応用すればオフセットの中身を一括で削除することもできる。

```python
n = [1, 2, 3, 4, 5, 6, 7]
n[1:-1] = []
n

# [1, 7]
```

### zip()

zip()関数を使えば、複数のシーケンスをペアにすることができる。zip()は最も短いシーケンスの要素を処理し尽くしたときに停止する。

```python
weeks = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
day = [1, 2, 3, 4, 5, 6, 7, 8, 9]
list(zip(weeks, day))

# [('Sunday', 1),
#  ('Monday', 2),
#  ('Tuesday', 3),
#  ('Wednesday', 4),
#  ('Thursday', 5),
#  ('Friday', 6),
#  ('Saturday', 7)]
```

dict() に渡すと辞書ができる。

```python
weeks = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
day = [1, 2, 3, 4, 5, 6, 7, 8, 9]
dict(zip(weeks, day))

# {'Friday': 6,
#  'Monday': 2,
#  'Saturday': 7,
#  'Sunday': 1,
#  'Thursday': 5,
#  'Tuesday': 3,
#  'Wednesday': 4}
```

### remove()

削除したい要素のインデックスが不確定の場合、remove()を使って指定した要素を削除できる。

```python
foods = ['pasta', 'curry', 'sushi', 'pizza']
foods.remove('curry')
foods

# ['pasta', 'sushi', 'pizza']
```

### list.reverse()

list.reverse() はリストを直接逆順に書き換える。

```python
w = [1,2,3,4,5]
w.reverse()
w

# [5, 4, 3, 2, 1]
```

### extend()

extend() を使うと、複数のリストを一つにまとめることができる。

```python
x = ['apple', 'banana']
y = ['tomato', 'potato']
x.extend(y)
x

# ['apple', 'banana', 'tomato', 'potato']
```

append()を使うと、リストが 1 個の要素として追加される。

```python
x = ['apple', 'banana']
y = ['tomato', 'potato']
x.append(y)
x

# ['apple', 'banana', ['tomato', 'potato']]
```

### 累算代入演算子

累算代入演算子である`+=` を使うと、extend() と同じように複数のリストをひとまとめにできる。

```python
x = ['apple', 'banana']
y = ['tomato', 'potato']
x += y
x

# ['apple', 'banana', 'tomato', 'potato']
```

### clear()

clear() は、全ての要素を削除する

```python
fruits = ['apple', 'banana', 'cherry', 'lemon']
fruits.clear()
fruits

# []
```

### count()

count()は、指定した要素がリストの中にいくつ含まれているか返す。

```python
fruits = ['apple', 'banana', 'cherry', 'apple']
fruits.count('apple')

# 2
```

### index()

要素のオフセットを知りたい場合は、index()を使う。

```python
fruits = ['apple', 'banana', 'cherry']
fruits.index('banana')

# 1
```

### in

リストの中に指定した要素が存在するか確かめたい場合、ブール値を返す in を使うとよい。

```python
fruits = ['apple', 'banana', 'cherry']
'apple' in fruits

# True
```

### sort()

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]
```

```python
w = [3,5,1,7,9]
w.sort()
w
```

### copy()

リストの copy()メソッドを使えば、リストの値を新しいリストにコピーできる。

```python
a = [1, 2, 3]
b = a.copy()
print(b)

# [1, 2, 3]
```

他に list()を使ってコピーする方法もある。

```python
a = [1, 2, 3]
b = list(a)
print(b)

# [1, 2, 3]
```

オフセットを使ってもコピーできる。

```python
a = [1, 2, 3]
b = a[:]
print(b)

# [1, 2, 3]
```

上記で書いた、copy()、list()、オフセットのいずれも、書き換えではなく独立したコピーである。

### max()

max()は数値の最大値を返す。

```python
n = [1,2,3,4,5]
max(n)

# 5
```

### sum()

sum()は、数値の合計を返す。

```python
n = [1,2,3,4,5]
sum(n)

# 15
```


Pythonには文字列以外に、タプルとリストの2種類のシーケンス（list,tuple,range）構造がある。リストはミュータブルであり、要素の挿入

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-9-29

Python : 辞書の基本操作編（get、dict 型、keys、values、items など）

2021-9-28

Python : list 型の基本操作編（結合・追加・削除・分割・スライスなど）

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-9-29

Python : 辞書の基本操作編（get、dict 型、keys、values、items など）

2021-9-28

Python : list 型の基本操作編（結合・追加・削除・分割・スライス など）

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

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

Python : list 型の基本操作編（結合・追加・削除・分割・スライスなど）