pythonのリストとか辞書とかその辺を理解する。

#list

## list()

リストを生成する/リストに変換する。
`文字列 → リスト`や`タプル → リスト`が可能。

```python:生成
hoge = []
hoge = list()  # 上と同じこと
```

```python:変換
list('cat')
# ['c','a','t']
```

## Offset

```python:スライス
hoge = ['a','b','c','d']
hoge[::2]
# ['a','c']
hoge[::-2]
# ['d','b'] #逆からになる
hoge[::-1]
# ['d','c','b','a'] #逆順になる
```

## append() extend()

```python:追加と結合
hoge = ['a','b','c','d']
fuga = ['e']

hoge.append('e')
hoge.extend(fuga)
hoge += fuga
# ['a','b','c','d','e'] #すべて同じ結果
```

## insert()

```python
piyo = ['a','b','d','e']
piyo.insert(2, 'c')
# ['a','b','c','d','e']
```
## remove() pop()

```python
hoge = ['a','b','c','d','e']
hoge.remove('d') # 要素自体を指定して削除
hoge.pop(3) # オフセットを指定して削除 (正確には取り出し)
# hoge = ['a','b','c','e'] # 同じ結果
```

## 存在チェック

```python
hoge = ['a','b','c','d','e']
if 'a' in hoge:
    print("exist")
else
    print("not exist")
# exist
```

## split() join()

```
fuga = 'a,b,c,d'
fuga.split(',')
# ['a','b','c','d']

hoge = ['a','b','c','d']
','.join(hoge)    #hoge.join(',')ではないことに注意！
# 'a,b,c,d'
```

## copy()

pythonは基本的に参照渡しである。

```
hoge = ['a','b','c','d']
fuga = hoge
# この後hogeを変更すると、fugaも変更が反映されている。 = fugaはhogeを参照している。

fuga = hoge.copy()
fuga = list(hoge)
fuga = hoge[:]
# これらどれかであれば参照ではなくコピーを生成しているのでhofgeを変更してもfugaは元のlistを保っている。
```

## オフセットと値を取得 enumerate()

```python
hoge = ['a','b','c','d']
for i, val in enumerate(hoge):
    print(i, val)
```

# タプル

リストとの違いはイミュータブル、つまり変更が効かないこと。

```python:作成
hoge = 4, 10, 5
hoge = (4, 10, 5)
hoge = tuple(4, 10, 5)  #全て同じ。
```

## アンパック

一時変数を用いずにタプルの中身を各変数に代入できること。

```python:アンパック
hoge = tuple(4, 10, 5)
a, b, c = hoge
```

# 辞書

## dict()

```python:生成
hoge = {}
hoge = dict()
```

```python:変換
fuga = [('a', 'b'), ('c', 'd')] # リストのリストなども変換可能
hoge = dict(fuga)
# {
#     'a': 'b',
#     'c': 'd'
# }

piyo = list(hoge.items()) # タプルのリストで変換される。(なお、list()を噛ませないとdict_itemsの形で返る。)
# [('a', 'b'), ('c', 'd')]

# なお、以下のようにかけるのはタプルのアンパックの性質を用いているため。
for key, item in hoge.items():
    pass
```

```python:追加と結合
hoge = {
    'a': 'b',
    'c': 'd'
}
hoge['e'] = 'f' # 勝手に指定すれば良い

fuga = {
    'g': 'h'
}
hoge.update(fuga) # 結合する
```

## 存在チェック

リストと同じ。

```python
hoge = {
    'a': 'b',
    'c': 'd'
}
if 'a' in hoge:
    print("exist")
else
    print("not exist")
# exist
```

## keys() values()

```
hoge = {
    'a': 'b',
    'c': 'd'
}
hoge.keys()
# dict_keys(['a', 'c']) →イテラブルなキーのviewを返す。list()を噛ませてリストに変換する必要あり。
list(hoge.keys())
# ['a', 'c']
```

values()も上記と同じ。

## copy()

リストと同じ。参照渡しをしない時。

# 集合

順番を気にしない時。形は`{0, 2, 7, 1, 4}`のように表される。

```python:作成
hoge = set()           # 空の集合
hoge = {0, 2, 7, 1, 4} # 中身も定義した集合
hoge = {}              # これは辞書

hoge = set( ["hoge", "fuga", "piyo"] ) # リストのほか、タプルや文字列、辞書も対応(辞書ではkeyのみ抽出)
# {"piyo", "hoge", "fuga"}
```

# バイト列

bytes → バイトのタプルみたいなもの、イミュータブル。
bytearray → バイトのリストみたいなもの、ミュータブル。

# 他の関数

## zip()

タプルを返却する。for文でアンパックすることで次のように使える。

```
hoge = ["a", "b", "c"]
fuga = ["A", "B", "C", "D"]

for small, large in zip(hoge, fuga):
    print("small:", small, "large:", large)

# small: a large: A
# small: b large: B
# small: c large: C  # 短い方に合わせて終了、"D"はでてこない。
```

## range()

シーケンスの作成。`range(start, end, step)`という構文。
`end`の直前の数字まで。

```
range(0, 3)
# 0, 1, 2
```

# 内包表記

## リスト内包表記

リストの`[]`ないでforループを記述する。

```:構文1
 [ 式 for 変数 in イテラブルオブジェクト ]
```

```python:例
hoge = [num for num in range(0, 3)]
# [0, 1, 2]

fuga = [num * 2 for num in range(0, 3)]
# [0, 2, 4]

piyo = [(a, b) for a in range(0, 2) for b in range(0, 3)]
#[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)]
```

___

```:構文2
 [ 式 for 変数 in イテラブルオブジェクト if 条件]
```

```python:例
hoge = [num for num in range(0, 3) if num % 2 == 0]
# [0, 2]

```

## 辞書内包表記

```:構文
 { 式 : 式 for 変数 in イテラブルオブジェクト }
```

```:例
word = "letter" #リストや集合をおいてもok
hoge = { let : word.count(let) fot let in word }
# { "l": 1, "e": 2, "t": 2, "r": 1}
```

## 集合内包表記
同じ。省略

## ×タプル内包表記  ○ジェネレータ式
→ タプルには内包表記がない！
上記と同じ書式で書くとジェネレータオブジェクトを返す。