
## TL;DR

zip()は複数のイテラブルを受け取り、タプルで返す。`zip(*[iter(s)]*n)` を使うことでイテラブルを分割することができる。

### zip() のポイント

- 複数のイテラブルからイテレータを作る
- イテラブルの中で最短のものが尽きると停止する
- `zip(*[iter(s)]*n)` でイテラブルを分割することができる
- 余りを表示するには zip_longest()関数をインポートする

```python
a = zip('ABCD', '12')
list(a)

# [('A', '1'), ('B', '2')]
```

### 複数のリスト

複数のリストを適用すると、最も短いイテラブルの数で停止する。

```python
x = [1,2,3]
y = [4,5,6,7]
z = [8,9] # → 一番短いイテラブル

list(zip(x,y,z))
# [(1, 4, 8), (2, 5, 9)]
```

### for 文 で使う

もちろん、for 文で使うこともできる。

```python
a = [1, 2, 3, 4]
b = ['A', 'B']
c = ['い', 'ろ', 'は']

for a, b, c in zip(a, b, c):
    print(a, b, c)

# 1 A い
# 2 B ろ
```

### イテラブルを分割する

`zip(*[iter(s)]*n)` を使えば、イテラブルを n 回分割することができる。

```python
b = [1, 2, 3, 4, 5, 6, 7]
c = zip(*[iter(b)]*2)

list(c)

# [(1, 2), (3, 4), (5, 6)]
```

中身を見てみると、同じイテレータを参照している。

```python
b = [1, 2, 3, 4, 5, 6, 7]
[iter(b)]*2

# [<list_iterator at 0x7f7eab2ad790>,
#  <list_iterator at 0x7f7eab2ad790>]
```

公式サイトには以下のように書かれている。

> `zip(*[iter(s)]*n)` を使ってデータ系列を長さ n のグループにクラスタリング（グループ分け）するイディオム（慣用表現）が使えます。これは、各出力タプルがイテレータを n 回呼び出した結果となるよう、 同じ イテレータを n 回繰り返します。これは入力を長さ n のチャンクに分割する効果があります。 [組み込み関数 — Python 3.9.4 ドキュメント](https://docs.python.org/ja/3/library/functions.html#zip)

しかし、なぜこうなるのか？

[iterator-zip（\_ \[iter（s）\] \_ n）は Python でどのように機能しますか？ - スタックオーバーフロー](https://stackoverflow.com/questions/2233204/how-does-zipitersn-work-in-python)に解説があった。例えば以下の場合、

```python
s = [1,2,3,4,5,6,7,8,9]
n = 3

list(zip(*[iter(s)]*n))

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

上を展開すると以下になる。同じイテレータを 3 回渡すと、zip()されるたびにイテレータからアイテムがプルされる。なお、余りは捨てられる。

```python
s = iter([1,2,3,4,5,6,7,8,9])
list(zip(s, s, s))

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

### zip_longest():一番長いイテラブルを出力

余りを表示するには、intertools.zip_longest()関数をインポートするとよい。一番長いイテラブルに合わせることができる。

```python
from itertools import zip_longest

b = [1, 2, 3, 4, 5, 6, 7]
c = zip_longest(*[iter(b)]*2)

list(c)

# [(1, 2), (3, 4), (5, 6), (7, None)]
```

### fillvalue:任意の値で埋める

None 以外の値で埋めたいときは、どうすればいいのか？引数に fillvalue を指定することで、任意の値で埋めることができる。

```python
from itertools import zip_longest
x = [1,2,3]
y = [4,5,6,7]
z = [8,9]

list(zip_longest(x, y, z, fillvalue=100))

# [(1, 4, 8), (2, 5, 9), (3, 6, 100), (100, 7, 100)]

```


zip()は複数のイテラブルを受け取り、タプルで返す。`zip(iter(s)n)`を使うことでイテラブルを分割することができる。zip(

Python : zip()は複数のイテラブルを受け取りタプルで返す


## TL;DR

Python におけるイテレータとはなんだろう？イテレータオブジェクト（list、tuple、set など）は内部にイテレータを持ち、for 文で要素を反復的に処理する際に自動的に使われる。要は、コンテナに入っている要素一つ一つアクセスして返している。

### イテレータのポイント

- `__iter__()`と`__next__()`が実装されている
- コンテナに入っている要素を一つ一つアクセスして返す
- イテレータは使い終わると空になる

for i in X と書いたとき、for 文は X の iter() を呼び出し、その戻り値を利用する。この戻り値はイテレータと呼ばれる。in の後に指定されたオブジェクトには必ず iter()が適用される。

### イテレータの中身

イテレータオブジェクトには、`__iter__()`と`__next__()`が実装されている。

実際に、iter()のプロパティを見てみると確認できる。

iter()のプロパティ

```python
a = iter([1, 2, 3, 4])
print(dir(a))

# [...'__iter__', '__next__',...]

```

list のプロパティ

```python
a = [1, 2, 3, 4]
print(dir(a))

# [...'__iter__'...]
# '__next__' は含まれない
```

list には`__next__()`が含まれていない。つまりイテレータを生成できるが、次の要素にアクセスすることができないのである。

### `__iter__()`と`__next__()` の違い

`__iter__()`の戻り値は、そのイテレータ自身となる。反復機能を与える処理。

`__next__()`は、ループのたびに呼び出される。次の要素にアクセスする処理。

for や辞書以外のオブジェクトであっても`__iter__()`を実装すれば、イテレーションは可能である。例えばイテレータの機能を持つクラスを実装するには、`__iter__()`を実装すればよい。

### イテラブルとイテレータの違い

イテラブルという言葉も頻出するので違いを書いておく。

`__iter__()`を実装しているオブジェクトは「イテラブル」と呼ばれ、`__next__()`を実装しているオブジェクトは「イテレータ」と呼ばれる。

list はイテラブルであり、イテレータではない。

イテラブル

- `__iter__()`を実装
- `__iter__()`の戻り値は任意のイテレータ

イテレータ

- `__iter__()`と`__next__()`を実装
- `__iter__()`の戻り値は self

イテレータは必ずイテラブルだが、イテラブルはイテレータとは限らない。名前が似ているのでややこしい。

### list と イテレータの違い

イテレータオブジェクトは次の要素を取得できるが、list には次の要素を取得する機能はない。

欲しいときに 1 個ずつ値を取得するには、値を 1 個だけ計算する関数があればよい。list を使って最初に全ての値を用意する必要はない。イテレータの代わりに list を使うのはメモリの無駄なのだ。

### イテレータは、使い終わると要素が空になる

イテレータは使い終わると空になるが、list は要素が残る。

```python
list → 全部残る

list → イテレータ（next） → 空
```

### iter() の作り方

実際にイテレータを作ってみる。

`__iter__()`は、イテレータオブジェクトを返す。print すると `<list_iterator object at 0x7fae4ab4f2d0>` と表示されている。list を使うと要素が表示された。

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

# <list_iterator object at 0x7fae4ab4f2d0>
# [1, 2, 3, 4]
```

iter()を使うと、イテラブルなオブジェクト（iter）からイテレータ（next）を取得できる。

```python
a = iter([1, 2, 3, 4])
next(a)
next(a)

# 2
```

### next() の使い方

next()を使い、イテレータオブジェクトから、順に要素を取り出すことができる。

```python
a = [1, 2, 3]
b = iter(a)
next(b)
next(b)
next(b)

# 3
```

### `__next__`

`__next__`メソッドを呼び出すと、イテレータは次の値を返す。ループのたびに呼び出される。返す値がなくなると、例外である StopIteration を生成する。

組み込み関数 next()にイテレータを渡すと、そのイテレータの`__next__()`が呼び出され、next()の戻り値として受け取れる。つまり、next() を使ってイテレータオブジェクトすると`__next__`と同じになる。

### ジェネレーター

ジェネレーター（yield 文を含む関数）は、next 関数で次の値を取り出せる。yield 文によって値が一つ生成されるたびに関数は停止し、再開を待つ。

以下のコードは、next が呼ばれるまで処理が中断されている例である。

```python
def g():
    yield 1
    yield 2
    yield 3

a = g()
print(next(a))
print(next(a))
print(next(a))

# 1
# 2
# 3
# StopIteration → 値がなくなると例外
```

next()を`__next__()` に変えても同じ結果になる。

```python
def g():
    yield 1
    yield 2
    yield 3

a = g()
print(a.__next__())
print(a.__next__())
print(a.__next__())

# 1
# 2
# 3
```


Pythonにおけるイテレータとはなんだろう？イテレータオブジェクト（list、tuple、setなど）は内部にイテレータを持ち、for文で要素を反復的に処

Python : __iter__()はイテレータを返し、__next__()は次の要素を返す


## TL;DR

特殊メソッドである`__call__`はインスタンスを関数オブジェクトとして扱う。`__call__`を実装したクラスでは、インスタンスを関数のように呼び出すことができる。

### `__call__` のポイント

- インスタンスを関数のように呼び出すことができる
- 関数を呼び出すよりスマートな書き方になる

関数の中身を dir()で見ると、`__call__` が含まれている。

```python
def func():
    pass

dir(func)

#['__annotations__',
# '__call__',
# '__class__',
# '__str__',
# '__subclasshook__']
```

これは、関数オブジェクトが `__call__` を実装した function クラスのインスタンスであることを示している。

通常、インスタンスを関数のように扱うとエラーが出る。

```python
class A:
    def __init__(self):
        print('init')

a = A() # init
a() # エラーになる
```

次に`__call__`をつけてみると、インスタンスを関数のように扱うことができるようになる。

```python
class A:
    def __init__(self):
        print('init')
    def __call__(self):
        print('call')

a = A() # init
a() # call
```

インスタンス、`__call__`、関数を比較。`__call__`を使うことで、関数を呼び出すよりスマートな書き方になる。

```python
class A:
    def __init__(self, x):
        self.x = x
        print(f'{x} init')
    def __call__(self, y):
        self.y = y
        print(f'{self.x + y} call')
    def func(self, z):
        self.z = z
        print(f'{self.x + z} func')

a = A(1) # 1 init
a.func(2) # 3 func
a(2) # 3 call
```


特殊メソッドである __call__ はインスタンスを関数オブジェクトとして扱う。__call__ を実装したクラスでは、インスタンスを関数のように呼び出すこ

Python :  __call__()は、インスタンスを関数のように扱う


## TL;DR

`__str__()`と`__repr__()`は、どちらもオブジェクトの文字列表現を返す特殊メソッドである。

### `__str__()`と`__repr__()`のポイント

- `__str__()`は、オブジェクトを文字列で表現する特殊メソッド
- `__str__()`は、print()に渡された場合に呼ばれる
- str()はユーザーが分かりやすい形で表示される
- repr()は引数にシングルクォーテーションマークを付けて返す

`__repr__()`は、組み込み関数の repr()が呼び出される。print()に渡された場合は、`__str__()`が呼ばれる。

その前に str()と repr() の違いについて説明しておく。

### str()と repr() の違い

str()は、object の 文字列、つまりユーザーが分かりやすい形で表示され、repr()はオブジェクトの印字可能な表現を含む文字列を返す。

```python
str('hoge')

# 'hoge'
```

分かりやすくいうと、repr()は、引数にシングルクォーテーションマークを付けて返す。

```python
repr('hoge')

# ''hoge''
```

### `__str__()`と`__repr__()` の違い

`__str__()`について公式を翻訳した。

> str(object)や，組み込み関数 format()，print()によって呼び出され，オブジェクトの "非公式 "またはきれいに印刷できる文字列表現を計算します．戻り値は、文字列オブジェクトでなければなりません。

> このメソッドは object.`__repr__()` とは異なり、 `__str__()` が有効な Python 式を返すことは期待されていません: より便利で簡潔な表現が使用できます。

> 組み込み型の object で定義されたデフォルトの実装では、 `object.__repr__()` を呼び出します。

`__str__()`は、オブジェクトを文字列で表現する特殊メソッドである。str(object)や、組み込み関数の print()に渡された場合に呼ばれる。

次に、`__repr__()` について公式を翻訳した。

> オブジェクトの文字列表現を計算するために repr() 組み込み関数によって呼び出されます。これは同じ値のオブジェクトを再生成するのに使用できる有効な Python の式のように見えるべきです。それができない場合は、<...some useful description...>という形式の文字列が返されます。

> 戻り値は、文字列オブジェクトでなければなりません。もし、あるクラスが`__repr__()`を定義していて、`__str__()`を定義していない場合、そのクラスのインスタンスの "非公式 "な文字列表現が必要な場合には、`__repr__()`も使用されます。

参考：[3\. Data model — Python 3.3.7 documentation](https://docs.python.org/3.3/reference/datamodel.html)

オブジェクト名のみを入力すると`object.__repr__()`が呼ばれるので、以下のような結果となる。`__repr__()`は、組み込み関数の repr()が呼び出される。

```python
a = 'hoge'
a

# 'hoge'
```

しかし、組み込み関数である print() を経由すると`__str__()`が呼ばれるので、上の結果と異なる。

```python
a = 'hoge'
print(a)

# hoge
```

オブジェクトだと`object.__repr__()`が呼ばれる。

```python
class A:
    def __init__(self, x):
        self.x = x
    def __str__(self):
        return 'str'
    def __repr__(self):
        return 'repr'

a = A(1)
a

# repr
```

print() を経由すると`__str__()`が呼ばれる。

```python
class A:
    def __init__(self, x):
        self.x = x
    def __str__(self):
        return 'str'
    def __repr__(self):
        return 'repr'

a = A(1)
print(a)

# str
```


オブジェクトの文字列表現を返す特殊メソッドである。

Python :  __str__() と __repr__() は、オブジェクトを文字列で表現する


## TL;DR

all()、any()は、イテラブル（繰り返し可能なオブジェクト）を一つだけ引数にとり、真理値（True / False）を返す組み込み関数である。

### all() と any() のポイント

- all()は、引数のイテラブルが「すべての要素が True（真）である」というふうに判定されると True を返す
- any() は「真となる要素が一つでもあれば真を返す」働きをする。それ以外は False を返す

Python における真理値とは、ある命題が「真」か「偽」かを示す値である。Python で扱う真理値は、真と偽のみ。この値を扱うデータ型として bool 型が用意されている。True や False と書くだけで利用できる。

### all()

all()は、引数のイテラブルが「すべての要素が True（真）である」というふうに判定されると True を返す。そして、一つでも False（偽） が存在する場合は、False を返す。

```python
all([True, True, True])

# True
```

```python
all([True, True, False])

# False
```

空文字を入れると、False になる。なぜなら、空文字は False だからである。

```python
all(['a', 'b', ''])

# False
```

空文字は False なので、全て空文字にしても False を返す。

```python
all(['', '', ''])

# False
```

空のタプルがあっても False を返す。

```python
all(['a', 2, {}])

# False
```

None を混入させると False になる。

```python
all(['a', 2, None])

# False
```

全ての要素に、None を入れると False を返す。

```python
all([None, None, None])

# False
```

しかし、空のイテラブルは、全てが真となるために True を返すようだ。

```python
all([])

# True
```

空文字のときに、入力漏れを出力する関数。

```python
x = ['yamada', {'year' : 21}, '']

def func(i):
    if all(i) == False:
        return '入力漏れがあります'

func(x)

# 入力漏れがあります
```

### any()

any() は「真となる要素が一つでもあれば真を返す」働きをする。それ以外は False を返す。

```python
any([True, True, False])

# True
```

```python
any([False, False, False])

# False
```

文字が一つでもあれば真となる。

```python
any(['a', 'b', ''])

# True
```

全ての要素が空の場合は False を返す。

```python
any(['', '', ''])

# False
```

None の場合は False を返す。

```python
any([None, None, None])

# False
```


all()、any()は、イテラブル（繰り返し可能なオブジェクト）を一つだけ引数にとり、真理値（True/False）を返す組み込み関数である。

Python : all()はすべての要素が真、any()は真となる要素が一つでもあれば真


## TL;DR

map()は、全ての要素に関数を適用する組み込み関数である。リストやタプルなどのイテラブルに対して同じ関数を適用する組み込み関数である。第一引数に関数、第二引数にイテラブルを指定する。

### map()のポイント

- イテラブルの中の値全てに、処理を加える
- 中身を表示させるには、list()や for()文を使う
- 第一引数に関数、第二引数にイテラブルを指定する

組み込み関数である map()は、イテラブルの中の値全てに、処理を加えて変更したい場合に使うとよい。

しかし、map()をそのまま使っただけでは、中身は出力されない。以下のように表示される。

```python
x = [1, 2, 3, 4]
map(lambda i: i * 10, x)

# <map at 0x7f27fe00a750>
```

中身を表示させるには、list()や for()文を使う。

### map() と list()

リストに変換させたいときは、list() を使うとよい。

```python
x = [1, 2, 3, 4]
list(map(lambda i: i * 10, x))

# [10, 20, 30, 40]
```

### map() と int

文字列と整数を整数に変換する。

```python
x = ['1', 2, '3', 4]
a = map(int, x)
list(a)

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

### map() と 関数

関数を使って 3 の倍数 list を作ってみる。以下は、1 から 10 までを 3 倍したものをリストに格納。

```python
x = list(range(1, 11))
def func(x):
    y = x * 3
    return y
list(map(func, x))

# [3, 6, 9, 12, 15, 18, 21, 24, 27, 30]
```

### map() と for 文

リストの中にある整数を絶対値に変換。

```python
x = [-1, 2, -3, 4]
for i in map(abs, x):
    print(i)

# 1
# 2
# 3
# 4
```

### map() と if 文

if 文を使って条件分岐させる。

```python
x = [10, 20, 30, 40, 50, 60, 70, 80, 90]

def func(i):
    if i == 70:
        return '不合格'
    elif i < 70:
        return '不合格'
    elif i > 70:
        return '合格'

for i in map(func, x):
    print(i)

# 不合格
# 不合格
# 不合格
# 不合格
# 不合格
# 不合格
# 不合格
# 合格
# 合格
```


map()は、全ての要素に関数を適用する組み込み関数である。リストやタプルなどのイテラブルに対して同じ関数を適用する組み込み関数である。第一引数に関数、第二引数

Python : map()は、全ての要素に関数を適用する。list, int, for, 関数を使った記述方法


## TL;DR

NumPy、pandas の import 時に「as」という記号がついている。この記号は一体何を意味しているのだろうか？一言でいうと as はモジュールにエイリアスを付けることができる記号である。インポート文の最後に as をつけた後に任意の名前を記述すると、インポートしたオブジェクトに別名をつけることができる。

### as のポイント

- 名前を変更するときにつかう
- 既に同じ名前のオブジェクトがある場合に上書きしてしまうことを防ぐことができる
- as の後ろに任意の名前を指定する

「as」という単語を調べると「２つの並べられた物・事が等価の関係にあることを示す」と書いてある。「同様」や「類似」という意味がある。

[as の意味・使い方・読み方](https://ejje.weblio.jp/content/as)

Python における「as」は、名前を変更するときにつかう。

### as を使ったモジュール名の変更方法

モジュール名を変更する場合は以下のように書く。

```python
from モジュール名 import 関数名 as 任意の名前
```

この書き方をすることによって、モジュール名を別の名前に変更したい場合や、既に同じ名前のオブジェクトがある場合に上書きしてしまうことを防ぐことができる。

以下の例では、モジュール名の「pi」を「math_pi」に変更している。

```python
>>> from math import pi # πの値
>>> print(pi)
3.141592653589793
>>> from math import pi as math_pi
>>> print(math_pi)
3.141592653589793
```

NumPy、pandas などは、別名をつけるのが慣例となっている。

```python
import pandas as pd
import numpy as np
```

### as の使い方

次は、上書きされてしまう例である。以下「[Python 実践入門](https://amzn.to/3B0nrPE)」からコードを引用した。

```python

# 組み込み関数の open
>>> open
<built-in function open>

# gzip の open をインポートする
>>> from gzip import open

# もう一度 open を見てみると
# open が gzip.open()に上書きされてしまった
>>> open
<function open at 0x1016d0160>
```

上書きを防ぐために、as をつけてみる

```python

# 組み込み関数の open
>>> open
<built-in function open>

# gzip の open に as をつけて「gzip_open」としてインポートする
>>> from gzip import open as gzip_open

# gzip_open を見てみる
>>> gzip_open
<function open at 0x109bc8160>

# open を見てみると、上書きされていない
>>> open
<built-in function open>
```


NumPy、pandasのimport時に「as」という記号がついている。この記号は一体何を意味しているのだろうか？一言でいうとasはモジュールにエイ

Python : as はモジュールにエイリアスを付けることができる記号


## TL;DR

以下の摩訶不思議な if 文は一体何を意味しているのだろうか？まずは、アンダースコアがついた特殊変数について説明する。

### `if __name__ == "__main__":` のポイント

- スクリプトとして直接実行したときのみ処理を行うことができる
- インポート元のファイルの末尾に加えることでスクリプトとしても使える
- 実行したいコードと実行したくないコードを分けることができる

### 特殊変数の意味

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

Python には特殊変数と呼ばれるものがあり、`__名前__`の形をしている。有名なところでは、`__init__`や`__new__`がある。

公式ドキュメントでは以下のように言及されている。

> 予約済みの識別子種 システムで定義された (system-defined) 名前です。これらの名前はインタプリタと (標準ライブラリを含む) 実装上で定義されています; 現行のシステムでの名前は 特殊メソッド名 などで話題に挙げられています。 Python の将来のバージョンではより多くの名前が定義されることになります。

[2\. 字句解析 — Python 3.5.10 ドキュメント](https://docs.python.org/ja/3.5/reference/lexical_analysis.html#reserved-classes-of-identifiers)

次に、if 文の左辺と右辺に記述されている特殊変数の意味について説明しよう。

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

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

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

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

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

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

まとめると、このコードは **「コマンドラインからスクリプトとして直接実行したときに、以降の処理を行う」** という意味である。

ひとまず、`__name__` を「モジュール名」、`__main__` を「直接実行」と解釈すると理解しやすい。

直接実行とは、コマンドから「python ファイル名.py」と入力することである。

### 記述方法

読込先のファイル

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

インポート元のファイル

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

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

この記述を使うことで、インポートしたときに自動実行されないように判定しているので、実行したいコードと実行したくないコードを分けることができる。

変数 `__name__` には、モジュール名が格納されている。Python のコードを直接実行すると、 `__main__` として認識される。

モジュールがコマンドに渡されたときに、変数 `__name__` の値が `__main__`になる。


以下の摩訶不思議なif文は一体何を意味しているのだろうか？まずは、アンダースコアがついた特殊変数について説明する。`if__name__==

Python : if __name__ == "__main__" は、スクリプトとして直接実行したときのみ処理を行う


## TL;DR

プログラミングで必ず出てくる言葉の一つに「スコープ」がある。スコープは参照できる範囲、直接アクセス可能な領域のことを言う。一言でいうと影響の範囲である。今回は Python のスコープについて解説する。

### ローカルスコープとグローバルスコープのポイント

- 関数内で変数を定義すると、その関数内のローカルスコープ内に定義される
- 関数の引数や変数はローカル変数なので外からは参照できない
- グローバルスコープは、モジュールの一番上にあるスコープを指す
- 関数内でグローバル変数を参照したあと、その関数内で同名のローカル変数を定義できない
- global 文をつけると関数内でグローバル変数の値を書き換えることができる

スコープと似ているものとして思い浮かぶのが名前空間だが、スコープと名前空間は違う。名前空間は名前の衝突を避ける為にあるが、スコープは参照できる範囲のことを言う。変数を用意すると、その変数はコードの記述位置の一番狭い範囲に定義される。

スコープは大きく分けると 2 つある。ローカルスコープとグローバルスコープである。

### ローカルスコープ

例えば関数内で変数を定義すると、その関数内のローカルスコープ内に定義される。関数の引数や変数はローカル変数なので外からは参照できない。

### グローバルスコープ

Python のグローバルスコープは、モジュールの一番上にあるスコープを指す。モジュールのトップレベルで変数を定義すると、モジュールのグローバルスコープ内に定義される。

Python において、関数内でグローバル変数を参照したあと、その関数内で同名のローカル変数を定義できないようになっている。

```python
g = 'global python'
def f():
    print(g)
    g = 'local python'
    print(g)
f()
# UnboundLocalError エラーになる
```

### globals()

変数の一覧を返す組み込み関数に、globals()と locals() がある。グローバル変数の一覧は、組み込み関数 globals() を使うと取得可能である。

```python
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}

>>> x = 'python'
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'x': 'python'}
```

一方、locals()というのがある。これはローカル領域の変数の値を全て返す。

global 文をつけると関数内でグローバル変数の値を書き換えることができる。これは、ローカルに記述した変数がローカル変数でないことを CPU に伝えている。したがって、この宣言によりローカル内でもグローバル変数の値を変更できるようになる。

```python
g = 'global python'
def f():
    global g
    print(g)
    g = 'local python'
    print(g)
f()
# global python
# local python
```

とはいえ、コードの保守性を下げる原因になるので、注意すべきである。

尚、グローバル変数がコンテナオブジェクト（リストや辞書）の場合は global 文は不要である。なぜなら、コンテナオブジェクトの代入時には参照が先に行われた後に値の更新が行われるためである。

### nonlocal

関数が入れ子になっている場合はどうすればいいのか？入れ子となった関数内で外側のスコープの値を書き換えたい場合は、nonlocal 文で宣言するとよい。

nonlocal 文 なし

```python
def func():
    w = 'w'
    def in_func():
        w = 1
        print(w)

    in_func()
    print(w)

func()
# 1
# w
```

nonlocal 文 あり

```python
def func():
    w = 'w'
    def in_func():
        nonlocal w
        w = 1
        print(w)

    in_func()
    print(w)

func()
# 1
# 1
```


プログラミングで必ず出てくる言葉の一つに「スコープ」がある。スコープは参照できる範囲、直接アクセス可能な領域のことを言う。一言でいうと影響の範囲である。今回は

Python : ローカルスコープとグローバルスコープの違い


## TL;DR

Python のクラスや関数をコードを書いたファイルはモジュールと呼ばれる。モジュールをまとめたものを、パッケージと呼ぶ。パッケージの中身は、モジュールやサブパッケージが集まっている。通常、目印として`__init__.py`を配置する。

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

- クラスや関数をコードを書いたファイル
- 自作のモジュールを作ることができる
- 目印として`__init__.py`を配置する

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

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

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

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

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

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

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

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

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

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

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

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

### 自作モジュール

自作のモジュールを作ることができる。読込元のファイルに関数を書き、読込先でインポートする。

foo.py

```python
def h(a, b):
    print(a + b)
```

foo.py を import する。

読込先のファイル

```python
import foo
foo.h(1, 2)
# 3
```

以下の書き方でも同じ結果になる。

```python
from foo import h
h(1, 2)
# 3
```


Pythonのクラスや関数をコードを書いたファイルはモジュールと呼ばれる。モジュールをまとめたものを、パッケージと呼ぶ。パッケージの中身は、モジュールやサブパ

2021-8-31

Python : zip()は複数のイテラブルを受け取りタプルで返す

2021-8-30

Python : iter()はイテレータを返し、next()は次の要素を返す

2021-8-27

Python : call()は、インスタンスを関数のように扱う

2021-8-26

Python : str() と repr() は、オブジェクトを文字列で表現する

2021-8-25

Python : all()はすべての要素が真、any()は真となる要素が一つでもあれば真

2021-8-24

Python : map()は、全ての要素に関数を適用する。list, int, for, 関数を使った記述方法

2021-8-23

Python : as はモジュールにエイリアスを付けることができる記号

2021-8-20

Python : if name == "main" は、スクリプトとして直接実行したときのみ処理を行う

2021-8-19

Python : ローカルスコープとグローバルスコープの違い

2021-8-18

Python : モジュールとはクラスや関数をコードを書いたファイルである