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

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で使われる文字列の基本操作方法を網羅的に述べる。文字列のポイント文字列はイミュータブル（書き換え不可）であ

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-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-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-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 型、改行、エスケープ、連結、演算、オフセット、スライス、置換、変換など）

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

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