
## 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）構造がある。リストはミュータブルであり、要素の挿入

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


## TL;DR

Python には for 文 と while 文 の 2 種類のループがある。while 文は条件を指定した処理の繰り返しである。式が真である間は処理を繰り返す。

### while のポイント

```python
while 条件式:
    繰り返す処理
```

- 式が真である間は処理を繰り返す
- continue は次のループに移る処理
- break 文はループを抜けるときに使う
- else 節は、while ループが終了時に、対象が見つからなかったときに実行
- else 節は、 break 文でループを抜ける際は実行されない
- while ループが break せずに終了したとき、else 節に渡される

次に示すのは、1 から 5 までの数値を表示するシンプルなループである。

```python
i = 1
while i <= 5:
    print(i)
    i += 1

# 1
# 2
# 3
# 4
# 5
```

上に記述したプログラムを順に解説する。

1.  i に 1 を代入する
2.  i が 5 以下ならループを続ける
3.  i を表示
4.  i を 1 ずつ **インクリメント（変数の値を 1 増やす）** する
5.  ループの先頭に戻り繰り返す
6.  i が 6 になり最初の行に戻ると i <= 5 が False になり終了する

次に示すのは、ユーザーが名前を入力するまで、入力を促すループである。

```python
i = ''
while not i:
    i = input('名前を入力してください : ')
print(f'おかえりなさい! {i} さん！')

# 名前を入力してください :
# 名前を入力してください : 花子
# おかえりなさい! 花子 さん！
```

### break

break 文はループを抜けるときに使う。次に示すのは、input()関数を使い、キーボードの入力で stop が入力されるまで、先頭の文字を大文字に変換させる無限ループである。stop が入力されると break 文が返されループを抜ける。

while True の部分が無限ループになる。このループを終了させるには、ループ内に if 文を置いて、条件が満たされたら break 文を呼び出す。

```python
while True:
    s = input('何か入力してください : ')
    if s == 'stop':
        break
    print(s.capitalize())

# 何か入力してください : abc
# Abc
# 何か入力してください : stop
```

### continue

continue は次のループに移る処理である。ループを抜けるのではなく、次のイテレーション（反復処理の 1 回分）をすぐに再開したい場合は、continue を使う。現在の繰り返しをその時点で終了し、次の繰り返しの先頭にジャンプするものである。

次に示すのは、入力欄で、奇数の数値を入れると自乗し、偶数だとスキップされ、stop と入力すると終える処理である。

```python
while True:
    i = input('数字を入力してください : ')
    if i == 'stop':
        break
    number = int(i)
    if number % 2 == 0:
        continue
    print(number * number)

# 数字を入力してください : 2
# 数字を入力してください : 3
# 9
# 数字を入力してください : 4
# 数字を入力してください : 5
# 25
# 数字を入力してください : stop
```

### else

else 節は、while ループが終了したものの、見つからなかったときに実行される。

```python
i = 0
while i < 3:
    print(f'{i}')
    i += 1
else:
    print('end')

# 0
# 1
# 2
# end
```

### else と break

else は break 文でループを抜ける際には実行されない。while ループが break せずに終了したとき、else 節に渡される。

次に示すコードは、リストの要素数だけループを行い、要素に偶数があれば break、なければ else が返る。

```python
numbers = [11, 83, 215, 899]
i = 0
while i < len(numbers):
    n = numbers[i]
    if n % 2 == 0:
        print('偶数発見')
        break
    i += 1
else:
    print('偶数が見つからない')

# 偶数が見つからない
```


Pythonにはfor文とwhile文の2種類のループがある。while文は条件を指定した処理の繰り返しである。式が真である間は処理を繰り返

Python : while 文の基本操作編（break、continue、else など）


## TL;DR

Python には for 文 と while 文 の 2 種類のループがある。ループとは処理の繰り返しである。for 文は、リストなどのオブジェクトを対象に、要素の数だけ処理を繰り返す。

Python はイテレータを頻繁に使う。イテレータとは、リストや辞書などから要素を一つずつ取り出して返すものである。

### for 文 のポイント

```python
for 変数 in 文字列・リスト・辞書 :
    実行文
```

- リストなどのオブジェクトを対象に、要素の数だけ処理を繰り返す
- for のループの中に break 文を入れると、ループを中止する
- for には、正常終了したかチェックする else がある
- 特定の回数の繰り返し処理が必要なときは、range 関数を用いる
- enumerate()を使うと、要素と一緒にカウントも繰り返す
- for 文は、変数のスコープをブロック内に限定しない

### 文字列の挙動

文字列はイテラブル（繰り返し可能）なオブジェクトなので、for 文で文字列を使えば、1 文字ずつ str 型（文字列を扱う型）の要素が渡されることが分かる。

```python
for i  in 'hello':
    print(i)

# h
# e
# l
# l
# o
```

### break

for のループの中に break 文を入れると、ループを中止する。数値や文字列でも中止される。

```python
n = [1,2,3,4,5]
for hoge in n:
    print(hoge)
    if hoge == 3:
        break
# 1
# 2
# 3

w = 'hellowold'
for i in w:
    if i == 'o':
        break
    print(i)

# h
# e
# l
# l
```

### continue

for ループに continue を入れると、ループの次のイテレーションにジャンプする。

```python
n = [1,2,3,4,5]
for hoge in n:
    if hoge % 2 == 0: # 偶数の時
        continue # スキップする
    print(hoge)
# 1
# 3
# 5
```

### break と else

for には、正常終了したかチェックする else がある。break が呼び出されなければ、else 文が実行される。

次に示すコードは、文字列の中に特定の単語が含まれているときに break によって処理を中止し、見つからないときに else 文を実行するものである。

指定した文字を発見すると、break で中止されるが、

```python
w = 'abcde'
for i in w:
    if i == 'c':
        print(f"{i} 感知しました！")
        break
    print(i)
else:
    print("問題ありません")

# a
# b
# c 感知しました！
```

以下に示すコードでは、break が呼び出されないので else 文が実行されている。

```python
w = 'abcde'
for i in w:
    if i == 'z':
        print(f"{i} 感知しました！")
        break
    print(i)
else:
    print("問題ありません")

# a
# b
# c
# d
# e
# 問題ありません
```

このように、処理が最後まで実行されたことを確認したい場合などに使うと便利である。

### range()

特定の回数の繰り返し処理が必要なときは、range 関数を用いる。range() はイテラブル（繰り返し可能）なオブジェクトを返すので、戻り値は for in で反復処理をする。

あらかじめ大きなデータ構造を作らなくても、指定した範囲の数値のシーケンス（list, tuple, range）を返すことができる。処理を ○ 回繰り返したいという場合に役立つ。

```python
for value in range(5):
    print('Hi!')

# Hi!
# Hi!
# Hi!
# Hi!
# Hi!
```

range(n) の n に整数を渡すと、0 から n-1 までのオブジェクトを順に返す。次に示すコードの n には、0〜4 までが格納されている。

```python
for n in range(5):
    print(n)

# 0
# 1
# 2
# 3
# 4
```

range() は range(start, stop, step) で使う。start を省略すると 0 が先頭になる。stop は必須である。step のデフォルト値は 1 になる。

```python
for i in range(0, 5):
    print(i)

# 0
# 1
# 2
# 3
# 4
```

2 から 10 までの偶数を返す。

```python
for i in range(2, 11, 2):
    print(i)

# 2
# 4
# 6
# 8
# 10
```

1 から 9 までの奇数の総和を計算

```python
s = 0
for i in range(1, 10, 2):
    s = s + i

s
# 25
```

### 変数のスコープ

for 文の中で定義した変数は、ブロック外で上書きされる。

```python
for i in range(2):
    pass

i # 1

for i in range(5):
    pass
i # 4
```

### enumerate()

組み込み関数 enumerate()は、要素と一緒にカウントも繰り返す。1 から開始したい場合は、第二引数に start=1 を指定する。

```python
chars = 'word'
for count, char in enumerate(chars):
    print(f'{count}番目の文字は{char}')

# 0番目の文字はw
# 1番目の文字はo
# 2番目の文字はr
# 3番目の文字はd

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

```

### len()

文字列内の文字数を数えることができる len() との組み合わせ。

```python
words = ['one', 'two', 'three']
for w in words:
    print(w, len(w))
# one 3
# two 3
# three 5
```


Pythonにはfor文とwhile文の2種類のループがある。ループとは処理の繰り返しである。for文は、リストなどのオブジェクトを対象に、

Python : for 文の基本操作編（range、continue、break、enumerate など）


## TL;DR

このページでは Python で使われる数値の基本操作方法を網羅的に述べる。

### 数値のポイント

- 四則演算などがサポートされている
- 数値型は不変な型なので、演算結果は常に新しいオブジェクトとして返される
- 組み込みの数値型は 3 つある

組み込みの数値型は数値を書くだけで値を作成できる。これを**数値リテラル**という。数値リテラルには、整数を扱う int 型、浮動小数点を扱う float 型、複素数を扱う complex 型の 3 つがある。これについては後述する。

### 整数の演算

次の表に示すのは整数の基本的な演算方法である。

| 演算子 | 意味                   | 例       | 結果 |
| ------ | ---------------------- | -------- | ---- |
| `+ `   | 加算                   | 1 + 2    | 3    |
| `- `   | 減算                   | 100 - 10 | 90   |
| `* `   | 乗算                   | 3 \* 5   | 15   |
| `/ `   | 浮動小数点の除算       | 7 / 2    | 3.5  |
| `//`   | 整数の除算（切り捨て） | 7 // 2   | 3    |
| `% `   | 剰余                   | 7 % 3    | 1    |
| `**`   | べき乗                 | 3 \*\* 4 | 81   |

整数を整数で割るときも、/ を使うと、浮動小数点で返される。プレフィックスで基数を指定しない限り、10 進と見なされる。

```python
9 / 5
# 1.8
```

整数と小数の差は小数となり、整数どうしの商は小数になる。

```python
print(1 + 2) # 3（整数どうしの和は整数）
print(1 - 2.0) # -1.0（整数と小数の差は小数）
print(1.0 * 2j) # 2j（小数と複素数の積は複素数）
print(1 / 1) # 1.0（整数どうしの商は小数）
```

```python
7**2
# 49

7/2
# 3.5

7/1
# 7.0

7//1
# 7
# // は、整除

7%2
# 1

# ピタゴラスの定理
x = 3
y = 4
z = 5
n = 2
x**n + y**n == z**n
# True

# フェルマーの定理
from math import sqrt
x = 10
y = 6
n = 4
z = x**n+y**n
sqrt(z) # 106.28264204469139
type(sqrt(z)) == int # False
```

整数と浮動小数点を計算すると、整数値が浮動小数点数値に**キャスト**される。

```python
50 + 3.
# 53.0
```

ブール値の False は 0（0.0）、True は 1（1.0） として扱われる。

```python
True + 2
# 3

False + 2.0
# 2.0
```

### 累算代入演算子

\= の前に算術演算子を入れると、演算と代入を結合できる。左辺の値と右辺の値を計算した結果が左辺に代入される。代入文と 2 項演算が複合した演算子。

```python
a = 10
b = 3
a += b
a

# 13
```

```python
a = 10
b = 3
a %= b
a

# 1
```

```python
a = 10
b = 3
a **= b
a

# 1000
```

### カンマ

カンマをつけるとタプルになる。

```python
1,000,000
# (1, 0, 0)
```

### アンダースコア

数字のセパレータをアンダースコアにすると数値が表示される。アンダースコアは無視される。

```python
1_000_000
# 1000000

1_2_3
# 123
```

### ゼロで割る

除算でも、ゼロで割ると例外が発生する。

```python
3 / 0
# ZeroDivisionError

3 // 0
# ZeroDivisionError
```

### 組み込み関数

Python では、組み込みの数値型は 3 つある。

- int:整数を扱う
- float:浮動小数点
- complex:複素数

#### int()

数値型の値は、組み込み関数の int(),float(),complex() を使っても値を生成できる。

Python の整数以外のデータ型を整数に変換するには int() 関数を使う。int 型どうしの演算結果は、割り算では float 型、それ以外は int 型になる。

```python
5 / 1
# 5.0

a = int(1)
a # 1

int('1')
# 1
```

浮動小数点を整数に変換すると、小数点以下が切り捨てられる。

```python
int(2.9)
# 2
```

小数点を含む文字列は処理できない。

```python
int('1.0')
# ValueError: invalid literal for int() with base 10: '1.0'
```

#### float()

整数を浮動小数点に変換する。float 型どうしの演算は float 型になる。数値として扱えない NaN も float 型として扱われる。

```python
1.0 + 4.0
# 5.0

type(1.0)
# float

type(float('nan'))
# float

float(2.0)
# 2.0
```

#### complex()

complex()型は、複素数を扱う型である。数値リテラルに、j もしくは J を付けると定義できる。complex()どうしの演算は complex 型になる。

```python
complex(1)
# (1+0j)

type(complex(1 + 2j))
# complex

complex(1 + 2j) + 3j
# (1+5j)

type(complex(1 + 2j) + 3j)
# complex
```

#### bool()

bool()関数は整数に対応するブール値を返す。ゼロは偽、ゼロ以外は真となる。なお、無限大は真となる。

```python
bool(0)
# False

bool(1)
# Ture

bool(-1)
# True

bool(float('-inf')) # 無限大は真
# True
```

#### divmod()

divmod() を使えば、商と剰余を同時に出力することができる。

```python
divmod(14, 5)
# (2, 4)
```

#### round()

round()は、第一引数の値を第二引数の桁数で丸める。最も近い整数に丸めて返す。丸めとは、数値の端数を処理して、指定した丸め幅の整数倍の数値に置き換えることである。Python では、四捨五入ではなく偶数丸めになる。

```python
round(21.5)
# 22

n = 7 * 0.9
round(n)
# 6

round(0.5) # 0
round(1.5) # 2
round(2.5) # 2
round(3.5) # 4
round(4.5) # 4
```

#### floor()

floor(x) は x 以下の最大の整数を返す。floor 関数は math モジュールが入っているので、import して使う。

```python
import math
math.floor(21.5)
# 21
```

#### ceil()

math モジュールには、floor とは反対の動きをする ceil 関数がある。ceil 関数は、指定の数値以上の最小の整数を返す。

```python
import math
math.ceil(21.5)
# 22
```

#### sqrt()

sqrt は平方根を返す。from import を指定した後は、モジュール名を書かなくてもモジュールに入っている関数を使えるようになる。

```python
import math
math.sqrt(9)
# 3.0

from math import sqrt
sqrt(9)
# 3.0
```


このページではPythonで使われる数値の基本操作方法を網羅的に述べる。数値のポイント四則演算などがサポートされている数値

Python : 数値型の基本操作編（演算、累算代入演算子、組み込み関数など）


## TL;DR

このページでは Python で使われる文字列の基本操作方法を網羅的に述べる。

### 文字列のポイント

- 文字列はイミュータブル（書き換え不可）である
- 文字リテラルは、横に並べるだけでも連結可能
- print() 関数の引数の間には空白が入り、末尾には改行が反映される

※ カタカナ用語の解説は後述する。

### str 型

```python
a = 'A'
type(a)
# str
```

str 型は文字列を扱う型である。シングルクオートか、ダブルクオートで文字列を囲むと str 型の値を定義できる。このことを**文字リテラル**という。（※ 2）

※ 2:リテラルとは、プログラムに直接記述された値のことを指す。

str()関数を使えば、データ型を文字列に変換できる。

```python
str(1234)
# '1234'

str(1.0e4)
# '10000.0'

str(True)
# 'True'
```

### イミュータブルのコピー

Python の文字列はイミュータブル（書き換え不可）なシーケンス（※1）である。

※1:イミュータブルなシーケンスには、tuple, str, range, bytes などがある。

オブジェクト（データ、機能。変数に代入できるもの）に入っているデータの値、文字列をその場で書き換えることはできない。

しかし、**文字列の一部を別の文字列にコピーし、同じ結果を得ることは可能**である。

**既存の変数を新しい変数に代入すると同じオブジェクトを指す**ようになる。次のコードをみよう。

```python
x = 'A'
y = x
y # 'A'

x = 'B'
y # 'A' のままである
```

x に 'A' を代入し、y に x を代入すると同じ値を示す。その後 x の値を変更すると x は 新しく作られた 'B' というオブジェクト を指すようになる。つまり 'A' を格納しているオブジェクトを書き換えているわけではない。y の値は x の値に左右されない。

### for 文での挙動

文字列はイテラブル（繰り返し可能）なオブジェクトなので、for 文で文字列を使えば、1 文字ずつ str 型の要素が渡されることが分かる。

```python
for i  in 'hello':
    print(i)

# h
# e
# l
# l
# o
```

### 文字列の改行

文字列の改行は `\n` を使う。

```python
print('abcd\nefg')
# abcd
# efg
```

シングルクォートで囲んだ文字列の中に、`\t` を挿入するとタブ文字入れることができる。

```python
print('abcd\tefg')

# abcd	efg
```

### エスケープ文字

シングルクォートで囲んだ文字列の中にシングルクオートがある場合、エラーになる。エスケープするには、バックスラッシュ`\`を使う。

```python
print('Let's go!')
# SyntaxError: invalid syntax

print('Let\'s go!')
# Let's go!
```

### トリプルクオート

文字列を **クォーテーションを使って 3 つ連続で書き囲むと改行を反映させることができる**。先頭や末尾にスペースがある場合、それも反映される。

```python
a = """
abc
def
   ghi
"""
print(a)

# abc
# def
#    ghi
```

### 文字の連結

文字の連結は `+演算子` を使うと、リテラル文字、文字列変数を連結できる。

文字リテラルの場合、**横に並べるだけでも連結可能**だが、**文字列変数は横に並べて連結することはできない**。

```python
'hello' + ' world'
# 'hello world'

'hello' ' world'
# 'hello world'

a = 'hello'
b = 'world'
a b
# SyntaxError: invalid syntax

# マイナスはサポートされてない
'hello world' - 'hello'
# TypeError: unsupported operand type(s) for -: 'str' and 'str'
```

### 空白の処理

文字列の連結では、自動的にスペースは追加されない。**print() 関数の引数の間には空白が入り、末尾には改行が反映される**。

```python
a = 'A'
b = 'B'
c = 'C'
d = 'D'

a + b + c + d
# 'ABCD'

print(a, b, c, d)
# A B C D

```

### 演算

文字は演算可能である。`*演算子` を使うと文字列を繰り返すことができる。`*` は `+` より優先度が高い。

```python
name = 'hoge '
name * 3
# 'hoge hoge hoge '

'Hey ' * 3 + 'ビビってる! ' * 2
# 'Hey Hey Hey ビビってる! ビビってる!'
```

### 比較演算子

比較演算子を使って比較するとブール値（False および True）が返る。

```python
'abc' == 'abc'
# True
```

```python
'abc' != 'def'
# True
```

### オフセット

文字列の中にある文字を一つだけ取り出したいときは、文字列変数名の後ろに `[]` で囲んだ文字であるオフセット（※ 3）を使う。

このインデックス参照は、シーケンス型であるリストやタプルでも機能する。

※ 3:オフセットとは、指定した位置からの距離を示すデータの位置

```python
word = 'abcdefghijklmn'
word[0] # 'a'
word[1] # 'b'
word[-1] # 'n'
```

**文字列はイミュータブル（書き換え不可）** なので、書き換えようとするとエラーがでる。

```python
word = 'hello'
word[1] = 'H'
# TypeError: 'str' object does not support item assignment
```

書き換えたい場合は、以下に示す replace() を使うとよい。

### replace()

replace() で文字列を置換できる。

```python
n = 'hello'
n.replace('h', 'k')
# 'kello'
```

第三引数に数字を設定すると、置換する回数を指定できる。

```python
w = 'abcde abcde abcde abcde abcde'
w.replace('a', 'A', 2)
# Abcde Abcde abcde abcde abcde
```

### スライス

スライスを使えば文字列から部分文字列を抽出することができる。

- `[:]` はシーケンス全体をスライス
- `[3:]` オフセット 3 から末尾までをスライス
- `[1:4]` 2 つ目から 5 つ目までをスライス
- `[-1:]` 最後の 文字列をスライス
- `[::2]` 2 字ごとにスライス
- `[5::2]` オフセット 5 から末尾まで 2 文字ごとにスライス
- `[:5:2]` 先頭からオフセット 5 まで 2 文字ごとにスライス
- `[-1::-1]` 末尾から先頭まで逆順に表示
- `[::-1]` 末尾から先頭まで逆順に表示

```python
w = '0123456789'
w[:] # 文字列全体が指定される
# '0123456789'

w = '0123456789'
w[3:] # オフセット3から末尾までを切り取る
# '3456789'

w = '0123456789'
w[1:4] # 2つ目から5つ目までをスライスする
# '123'

w = '0123456789'
w[0:4] # 1つ目から4つ目までをスライスする
# '0123'

w = '0123456789'
w[3:9:2] # 3 ~ 9 まで2文字おきに
# '357'

w = '0123456789'
w[-1:] # 最後の 文字列をスライス
# '9'

w = '0123456789'
w[::2] # 2 字ごとにスライス
# 02468

w = '0123456789'
w[5::2] # オフセット 5 から末尾まで 2 文字ごとにスライス
# '579'

w = '0123456789'
w[:5:2] # 先頭からオフセット 5 まで 2 文字ごとにスライス
# 024

w = '0123456789'
w[-1::-1] # 逆順
# '9876543210'

w = '0123456789'
w[::-1] # 逆順
# '9876543210'
```

### format()

format() は文字列の中にある `{}` が、format()の引数に渡した値に置換される。

```python
'Python is {} {}'.format('Programming', 'Language')
# Python is Programming Language
```

引数の中に数値を入れると、位置を変更できる。

```python
'Python {2} {1} {0}.'.format('Language', 'Programming', 'is')
# Python is Programming Language
```

キーワード引数を指定することもできる。

```python
'Python {c} {b} {a}.'.format(a='Language', b='Programming', c='is')
# Python is Programming Language
```

辞書も可能。format()の引数に `**` をつけると辞書の値を取得できる。

```python
w = {'a' : 'apple', 'b' : 'banana', 'c' : 'cherry'}
fruits = '{a} {c}'
fruits.format(**w)
# 'apple cherry'
```

`{0}` は format() への第一引数を表す。

```python
w = {'a' : 'Apple', 'b' : 'Banana', 'c' : 'Cherry'}
'{0[a]} is not the same as {0[b]}.'.format(w)
# Apple is not the same as Banana.
```

### f-string（f 文字列）

f-string は式を埋め込める文字リテラルである。先頭に f を付けて定義する。`{}`の中では、演算子などの式を利用することができる。

```python
w = 'world'
f'hello {w}'
# 'hello world'

w = 'world '
f'hello {w * 3}'
# 'hello world world world'

file_name = 'flower.jpg'
alt_name = '花の写真です'
f'<img src="{file_name}" alt="{alt_name}">'
# <img src="flower.jpg" alt="花の写真です">
```

リストの要素を返すこともできる。

```python
img = ['flower.jpg', '花の写真です']
f'<img src="{img[0]}" alt="{img[1]}">'
# <img src="flower.jpg" alt="花の写真です">

w = ['apple', 'banana', 'cherry']
f'{w[1].title()}'
# 'Banana'
```

式を複数入れられる。

```python
w = ['apple', 'banana', 'cherry']
f'{w[0].capitalize()} is not the same as...{w[1].rjust(20)}.'
# 'Apple is not the same as...              banana.'
```

### len()

組み込み関数である len() を使うと文字列内の文字数を数えることができる。

```python
w = 'word'
len(w)
# 4
```

### split()

組み込み関数である split() は、セパレータに基づき分割しリストに格納する。

```python
w = 'a-b-c'
w.split('-') #分割して配列に格納
# ['a', 'b', 'c']

w = 'Lorem ipsum, dolor sit amet, consectetur adipisicing, elit'
w.split(',')
# ['Lorem ipsum', ' dolor sit amet', ' consectetur adipisicing', ' elit']
```

### join()

join()関数は、シーケンス（list, tuple, range）のリストを一つの文字列に結合する。split()関数の逆と考えるとよい。

```python
w = ['A', 'B', 'C', 'D']
print(' to the '.join(w))
# A to the B to the C to the D
```

### strip()

strip()関数は文字列の先頭と末尾の文字を削除する。単語の間にあるものは削除しない。引数が指定されてないと、スペースや改行を取り除く。

```python
w = '     abcd    '
w.strip()
# abcd

w = '<p>hello</p>'
w.strip('<p></p>')
# 'hello'

w = 'http://example.com'
w.strip('http://')
# example.com
```

指定した先頭と末尾の記号を除去する。文字列の中にあるものはそのままだ。

```python
w = '....abcd...efg...hijk....'
w.strip('.')
# 'abcd...efg...hijk'
```

rstrip()は右だけ、lstrip()は左だけ除去する。

```python
w = '    abcd    '
w.lstrip()
# 'abcd    '
```

### find()

部分文字列のオフセット（※ 3）を探すメソッドは、find() と index() である。find()は、指定した文字が見つからなければ -1 を返すが、index() は例外を返す。

find()は、部分文字列が見つかった場所の一番左のインデックスを返し、見つからなければ -1 を返す。find メソッドはブール値を返さない。find が 0 を返せば文字列の最初に検索対象があるということである。

```python
w = 'abcde abcde abcde abcde abcde'
w.find('d')
# 3

w = 'abcde fghi jk lmn opqrstu'
w.find('lmn')
# 14

w = 'abcde fghi jk lmn opqrstu'
w.find('de')
# 3

w.find('z')
# -1
```

### index()

index()は、対象の文字列が存在しないときに、例外を吐く。

```python
'abcdefghijklmn'.index('e') # 検索する
# 4

w = 'abcde abcde abcde abcde abcde'
w.index('z')
# ValueError: substring not found
```

### in 演算子

in 演算子を使うと、文字列の中に、指定した文字列が含まれているかどうかをブール値（False および True）で判定することができる。not in は、含まないという意味である。

```python
'lo' in 'hello'
# True
```

```python
'hello' not in 'z' # not in は、含まないという意味
# True
```

### count()

count() は、文字のシーケンスがいくつ含まれているか数える。

```python
'hello'.count('l') # 指定した文字を数える
# 2
```

### capitalize()

capitalize() は先頭の文字を大文字に変換して返す。

```python
'abcde'.capitalize()
# 'Abcde'
```

### title()

title() は、単語の先頭文字を全て大文字に変換して返す。

```python
'python is a general-purpose programming language.'.title()
# 'Python Is A General-Purpose Programming Language.'
```

### upper()、lower()、swapcase()

upper()は、全ての文字を大文字に変換する。lower()を使うと、全ての文字が小文字になる。swapcase() は大文字と小文字を逆に変換する。

```python
'python is programming language.'.upper()
# 'PYTHON IS PROGRAMMING LANGUAGE.'

'Python Is Programming Language.'.lower()
# 'python is programming language.'

'Python Is Programming Language.'.swapcase()
# 'pYTHON iS pROGRAMMING lANGUAGE.'
```


このページではPythonで使われる文字列の基本操作方法を網羅的に述べる。文字列のポイント文字列はイミュータブル（書き換え不可）であ

Python : 文字列の基本操作編（str 型、改行、エスケープ、連結、演算、オフセット、スライス、置換、変換など）


## TL;DR

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

### bool 型のポイント

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

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

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

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

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

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

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

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

# empty
```

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

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

# False
```

if と in を用いて判定。

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

if b in a:
    print('something')

# something
```

### ブール演算

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

#### or

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

```python
True or True
# True

True or False
# True

False or True
# True

False or False
# False
```

#### and

両方が真なら真

```python
True and True
# True

True and False
# False

False and True
# False

False and False
# False

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

```

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

```python
3 < x < 10
# True

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

#### not

真なら偽、偽なら真

```python
not True
# False

not False
# True
```

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

#### True は 1、False は 0

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

False + 0 # 0
False + 1 # 1

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

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

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

#### False のケース

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

値が 0 の数値は偽

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

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

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

空文字は偽

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

False は偽

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

#### True のケース

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

True が入ると真

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

マイナスの整数は真

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


## TL;DR

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### open 関数 と with 文

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

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

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

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

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

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

print(a)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

with A():
    print('with')

# before
# with
# after
```

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

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

with A() as f:
    print(f)

# before
# 1
# after
```


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

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

Python : while 文の基本操作編（break、continue、else など）

2021-9-24

Python : for 文の基本操作編（range、continue、break、enumerate など）

2021-9-22

Python : 数値型の基本操作編（演算、累算代入演算子、組み込み関数など）

2021-9-21

Python : 文字列の基本操作編（str 型、改行、エスケープ、連結、演算、オフセット、スライス、置換、変換など）

2021-9-17

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

2021-9-15

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

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

Python : while 文の基本操作編（break、continue、else など）

2021-9-24

Python : for 文の基本操作編（range、continue、break、enumerate など）

2021-9-22

Python : 数値型の基本操作編（演算、累算代入演算子、組み込み関数など）

2021-9-21

Python : 文字列の基本操作編（str 型、改行、エスケープ、連結、演算、オフセット、スライス、置換、変換など）

2021-9-17

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

2021-9-15

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

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

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