python初学者の備忘録　リスト型について

#### [←目次へ](https://qiita.com/dondondon/items/cd45224ca93e65c976cc)

:::note info
python,Qiita初心者なので、備忘録として記載していきます。
なにせ初心者なので、知識不足はご容赦ください。
知識を深めながら追記していきたいと思います。
:::

# リスト型とは

:::note info
オブジェクト生成後に要素を変更できるmutableオブジェクトである
:::

+ 複数の値を[]で一つの入れものにまとめて入れる
+ インデックスを指定して値を取得できる
+ 追加、削除、書き換えなどの操作が可能
+ リストの中にリストを入れる事も可能
+ 異なるデータ型を入れる事も可能

##### 文字列型のリスト
```python
>>> my_friends = ['飯田', '佐久間', '斎藤' , '照井']
>>> my_friends
['飯田', '佐久間', '斎藤' , '照井']

>>> type(my_friends)
# <class 'list'>

# -- 1番目の要素 --
>>> my_friends[0]
'飯田'

# -- 2番目の要素 --
>>> my_friends[1]
'佐久間'

# -- 4番目の要素 --
>>> my_friends[3]
'照井'
```

##### 数値型のリスト

```python
>>> numbers3 = [1, 2, 3]
>>> numbers3
[1, 2, 3]

>>> numbers4 = [4, 5, 6, 7]
>>> numbers4
[4, 5, 6, 7]

# -- リストにリストを代入 --
>>> numbers = [numbers3, numbers4]
>>> numbers 
[[1, 2, 3], [4, 5, 6, 7]]

>>> numbers[0][0]
1

>>> numbers[0]
[1, 2, 3]

>>> numbers[0][1]
2

>>> numbers[0][2]
3
```

##### 文字列型と数値型の混在するリスト

```python
>>> numbers3 = [1, 2, 3]
>>> numbers3
[1, 2, 3]

>>> strnumbers4 = ['4', '5', '6', '7']
>>> strnumbers4 
['4', '5', '6', '7']

# -- 数値型のリストに文字列型のリストを代入 --
>>> mixnumbers = [numbers3, strnumbers4]
>>> mixnumbers                           
[[1, 2, 3], ['4', '5', '6', '7']]
```

##### ` len() `関数：リストの要素数を取得できる

```python
>>> numbers5 = [0, 1, 2, 3, 4]
>>> len(numbers5)
5
```

##### ` max() `関数：リストの最大値を取得できる
| パラメーター | 省略可 | 説明 |
|:-:|:-:|:-:|
|list|×|対象のリスト|
|key|〇|[key=]リストの最大の要素を取り出す関数を指定する|
|default|〇|[default=]リストが空だった場合の戻り値を指定する。リストかつdefaultが指定されなかった場合にはエラー（ValueError例外）になる|

```python
>>> numbers5 = [0, 1, 2, 3, 4]
>>> max(numbers5)
4

# -- 数値型と文字列型のリストで評価する --
>>> numbers5 = [0, 1, '2', '3', '4']
>>> max(numbers5)
# 文字と数値の評価でエラーになる

# -- 数値型に変換して評価する --
>>> max(numbers5, key=int)
4
# -- 文字列型に変換して評価する --
>>> max(numbers5, key=str) 
4

# -- 空のリストを評価する --
>>> max([])
# エラーになる

# -- defaultを指定して、空のリストを評価する --
>>> max([], default=1000)
1000
```

##### ` min() `関数：リストの最小値を取得できる
| パラメーター | 省略可 | 説明 |
|:-:|:-:|:-:|
|list|×|対象のリスト|
|key|〇|[key=]変換する関数を指定する|
|default|〇|[default=]リストが空だった場合の戻り値を指定する。リストかつdefaultが指定されなかった場合にはエラー（ValueError例外）になる|

```python
>>> numbers5 = [0, 1, 2, 3, 4]
>>> min(numbers5)
0

# -- 数値型と文字列型のリストで評価する --
>>> numbers5 = ['0', '1', '2', 3, 4]
>>> min(numbers5)
# 文字と数値の評価でエラーになる

# -- 数値型に変換して評価する --
>>> min(numbers5, key=int)
0

# -- 文字列型に変換して評価する --
>>> min(numbers5, key=str) 
0

# -- 空のリストを評価する --
>>> min([])
# エラーになる

# -- defaultを指定して、空のリストを評価する --
>>> min([], default=1000)
1000
```

##### ` append() `メソッド：リストの末尾に要素を追加できる(イテラブルオブジェクトの場合そのまま追加)

```python
# -- リストの末尾に要素を追加 --
>>> alpha = ['a', 'b', 'c']
>>> alpha.append(4)
>>> alpha
['a', 'b', 'c', 4]

# -- リストの末尾にリストを追加 --
>>> alpha.append([5, 6])
>>> alpha
['a', 'b', 'c', 4, [5, 6]] # リストがそのまま代入される
```

##### ` extend() `メソッド：リストの末尾に要素を追加できる(イテラブルオブジェクトの場合展開して追加)

```python
# -- リストの末尾に要素を追加 --
>>> alpha = ['a', 'b', 'c']
>>> alpha.extend(4)
# イテラブルじゃないのでエラーになる

# -- リストの末尾にリストを追加 --
>>> alpha.extend([5, 6])
>>> alpha
['a', 'b', 'c', 5, 6] # リストが展開されて代入される
```

##### ` insert() `メソッド：指定した要素に値を追加できる

| パラメーター | 省略可 | 説明 |
|:-:|:-:|:-:|
|index|×|挿入する位置|
|item|×|挿入する値|

```python
# リストの1番目に要素を追加
>>> alpha = ['a', 'b', 'c']
>>> alpha.insert(0, 'z')
>>> alpha
['z', 'a', 'b', 'c']
```

##### ` pop() `メソッド：指定した要素を取り出せる

| パラメーター | 省略可 | 説明 |
|:-:|:-:|:-:|
|index|〇|取り出す位置(省略時は最後の要素)|

```python
# 指定した要素を取り出す(引数がない場合は最後の要素)
>>> alpha = ['a', 'b', 'c']
>>> alpha.pop()
'c'
>>> alpha
['a', 'b']

# 1番目の要素を取り出す
>>> alpha.pop(0)
'a'
>>> alpha
['b']
```

##### ` remove() `メソッド：指定したデータを削除できる

```python
>>> alpha = ['a', 'b', 'c']

# 'a'を削除する
>>> alpha.remove('a')
>>> alpha
['b', 'c']

# 'c'を削除する
>>> alpha.remove('c')
>>> alpha
['b']

# 対象が複数ある場合先頭から削除する
>>> alpha = ['a', 'a', 'a', 'b']
>>> alpha
['a', 'a', 'a', 'b'] 

# 'a'を削除する
>>> alpha.remove('a')
>>> alpha
['a', 'a', 'b']

>>> alpha.remove('a')
>>> alpha
['a', 'b']

>>> alpha.remove('a')
>>> alpha
['b']
```

##### ` clear() `メソッド：リストの全要素を削除する

```python
>>> alpha = ['a', 'b', 'c']
>>> alpha.clear()
>>> alpha
[]
```

##### `del`文：指定した位置の要素を削除できる

```python
>>> alpha = ['a', 'a', 'a', 'b']
>>> alpha
['a', 'a', 'a', 'b']

# 1番目の要素を削除する
>>> del alpha[0]
>>> alpha
['a', 'a', 'b']

# スライスを使用してclearメソッドと同等の処理
>>> del alpha[:]
>>> alpha
[]

 # 引数を省略すると変数自体を削除する
>>> del alpha
>>> alpha
# 変数定義がないためエラーになる
```

:::note info
----- ソートのルール -----
・コードポイントが小さいものほど小さい値とされる
・2つの文字列の大小は先頭の文字、2文字目、3文字目……という順序で比較される
・2つの文字列があり、それらの要素が途中までは全く同じだが、一方は最後に1文字だけ追加されている場合（上の'abc'と'abcd'）などは文字列が短い方が小さい値とされる
:::

##### ` sort() `メソッド：データの並び替えができる

| パラメーター | 省略可 | 説明 |
|:-:|:-:|:-:|
|key|〇|[key=]ソート要素の基準となる関数を指定する|
|reverse|〇|[reverse=]True：降順、False/省略：昇順|

```python
>>> num_list = [20, 50, 33, 77, 15]
>>> num_list
[20, 50, 33, 77, 15]

# 昇順に並び替える
>>> num_list.sort()
>>> num_list
[15, 20, 33, 50, 77]
>>> num_list
[15, 20, 33, 50, 77] # 元のリスト自体が並び替えられる

# 降順に並び替える
>>> num_list.sort(reverse=True)
>>> num_list
[77, 50, 33, 20, 15]

# -- 数値型と文字列型のリストで評価する --
>>> num_list = [20, 50, 33, 77, 15, '20']
>>> num_list.sort()
>>> num_list
# 文字と数値の評価でエラーになる

# -- 数値型に変換して評価する --
>>> num_list.sort(key=int)
>>> num_list
[15, 20, '20', 33, 50, 77]

# -- 文字列型に変換して評価する --
>>> num_list.sort(key=str)
>>> num_list
[15, 20, '20', 33, 50, 77]
```

##### ` sorted() `関数：データの並び替えができる
```python
>>> num_list = [20, 50, 33, 77, 15]
>>> sorted(num_list)
[15, 20, 33, 50, 77]
>>> num_list
[20, 50, 33, 77, 15] # 元のリスト自体には影響しない
```

##### `reverse() `メソッド：リストの要素を逆順に並べ替えるができる

```python
>>> strlist = ['abcd', 'abc', 'Abcd', 'abC']
>>> strlist.reverse()
>>> strlist
['abC', 'Abcd', 'abc', 'abcd']
>>> strlist
['abC', 'Abcd', 'abc', 'abcd'] # 元のリスト自体が並び替えられる
```

#####  `reversed() `関数：リストの要素を逆順に並べ替えるができる

```python
>>> strlist = ['abcd', 'abc', 'Abcd', 'abC']
>>> reversed(strlist)
# エラーになる

# -- list関数に渡してイテレータにする --
>>> list(reversed(strlist))
['abC', 'Abcd', 'abc', 'abcd']
>>> strlist
['abcd', 'abc', 'Abcd', 'abC']
>>> strlist
['abcd', 'abc', 'Abcd', 'abC'] # 元のリスト自体には影響しない
```

:::note alert
reverse()メソッドは元のリストを書き換えるだけだが、reversed()関数は「イテレータ」を戻りとする点が異なるので注意

・reverse()メソッド：元のリストに影響する
・reversed()関数：元のリストには影響しない
:::

##### ` in `演算子：対象が含まれているかboolで返す

```python
>>> num_list = [20, 50, 33, 77, 15]

# 値が含まれているのでTrue
>>> 77 in num_list
True
```

```vb:VB.NETだと同様？
Dim num_list As Integer() = {77, 50, 33, 20, 15}
num_list.Contains(77)
```

```cs:C#だと同様？
int[] num_list= {77, 50, 33, 20, 15 };
num_list.Contains(77);
```

##### ` index() `メソッド：対象が含まれている場合、何番目に含まれているか返す

| パラメーター | 省略可 | 説明 |
|:-:|:-:|:-:|
|item|×|評価したい値|
|start|〇|検索を開始する位置を示すインデックス、省略した場合は先頭から検索を行う|
|end|〇|検索を終了する位置を示すインデックス、省略した場合は末尾まで検索を行う|

```python
>>> num_list = [20, 50, 33, 77, 15]

# 値が含まれている場合インデックスを返す
>>> num_list.index(33)
2

>>> num_list.index(0)
# 値が含まれていないためエラーになる
```

##### ` join() `メソッド：文字列の場合のみ結合して文字列にできる

```python
>>> name_list = ['My', 'name', 'is', 'Ken']
>>> name_list
['My', 'name', 'is', 'Ken']

# joinメソッドで指定した文字を文字間に入れて文字列を結合する
>>> ' '.join(name_list)
'My name is Ken'

'-'.join(name_list) 
'My-name-is-Ken'
```

##### ` split() `メソッド：文字列を分解してlistにできる

```python
# splitメソッドで文字列を分解してlistにできる
'My name is Ken'.split()
['My', 'name', 'is', 'Ken']

# 指定した文字を基準に分解してlistにできる
'My name is Ken'.split('a')
['My n', 'me is Ken'] 
```

##### ` count() `メソッド：対象が何個含まれているか返す

```python
>>> num_list = [20, 50, 33, 77, 15]

# 値が含まれている場合個数を返す
>>> num_list.count(77)
1
```

##### ` copy() `メソッド：リストのコピーを返す※戻り値は浅い(shallow)コピー

```python:sample.py
num_list1 = [20, 50, 33]
num_list2 = num_list1.copy()
num_list3 = num_list1
print(num_list1)
print(num_list2)
print(num_list3)
# -- 実行結果 --
[20, 50, 33]
[20, 50, 33]
[20, 50, 33]

# num_list1の[0]要素を変更する
num_list1[0] = 100
print(num_list1)
print(num_list2)
print(num_list3)
# -- 実行結果 --
[100, 50, 33]
[20, 50, 33]
[100, 50, 33] # num_list1の参照なので変更される

# num_list2の[0]要素を変更する
num_list2[0] = 500
print(num_list1)
print(num_list2)
print(num_list3)
# -- 実行結果 --
[100, 50, 33]
[500, 50, 33] # num_list2はコピーなので他のリストは変更されない
[100, 50, 33]
```

##### ` copy() `関数：copyメソッドと同様の処理
```python:sample3.py
import copy # copyモジュールをインポートする
num_list1 = [[1, 2], [3, 4], [5, 6]]
num_list2 = copy.copy(num_list1)
print(num_list1)
print(num_list2)
# -- 実行結果 --
[[1, 2], [3, 4], [5, 6]]
[[1, 2], [3, 4], [5, 6]]
```

##### `浅いコピー(shallow copy)の特徴`
```python:sample2.py
# 入れ子のリストの場合
num_list1 = [[1, 2], [3, 4], [5, 6]]
num_list2 = num_list1.copy()
print(num_list1)
print(num_list2)
# -- 実行結果 --
[[1, 2], [3, 4], [5, 6]]
[[1, 2], [3, 4], [5, 6]]

# num_list1の[0][0]要素を変更する
num_list1[0][0] = 100
print(num_list1)
print(num_list2)
# -- 実行結果 --
[[100, 2], [3, 4], [5, 6]]
[[100, 2], [3, 4], [5, 6]] # num_list2も変更される

# num_list2の[0][0]要素を変更する
num_list2[0][0] = 1000
print(num_list1)
print(num_list2)
# -- 実行結果 --
[[1000, 2], [3, 4], [5, 6]] # num_list1も変更される
[[1000, 2], [3, 4], [5, 6]]

# num_list1の[0]要素を変更する
num_list1[0] = [10000,20000]
print(num_list1)
print(num_list2)
# -- 実行結果 --
[[10000, 20000], [3, 4], [5, 6]]
[[1000, 2], [3, 4], [5, 6]] # num_list2は変更されない
```

:::note warn
以上の事から浅いコピーは新しいオブジェクトは作成するが、中身のオブジェクトは参照している事が分かる
:::

##### ` deepcopy() `関数：参照をたどりながら最後の要素までコピーする
```python:sample4.py
from copy import deepcopy # copyモジュールからdeepcopyをインポートする
num_list1 = [[1, 2], [3, 4], [5, 6]]
num_list2 = deepcopy(num_list1)
print(num_list1)
print(num_list2)
# -- 実行結果 --
[[1, 2], [3, 4], [5, 6]]
[[1, 2], [3, 4], [5, 6]]

# 浅いコピー同様にnum_list2の[0][0]要素を変更する
num_list2[0][0] = 1000
print(num_list1)
print(num_list2)
# -- 実行結果 --
[[1, 2], [3, 4], [5, 6]] # num_list1には影響しない
[[1000, 2], [3, 4], [5, 6]]
```

## リストに使える関数とメソッド
`len()`関数：リストの要素数を取得できる
`max()`関数：最大の要素を取得できる
`min()`関数：最小の要素を取得できる
`append()`メソッド：リストの末尾に要素を追加できる(イテラブルオブジェクトの場合そのまま追加)
`extend()`メソッド：リストの末尾に要素を追加できる(イテラブルオブジェクトの場合展開して追加)
`insert()`メソッド：指定した要素に要素を追加できる
`pop()`メソッド：指定した要素を取り出せる※指定しない場合最後の要素
`remove()`メソッド：指定したデータを削除できる
`clear()`メソッド：リストの全要素を削除する
`del`文：指定したインデックス位置の要素を削除できる
`sort()`メソッド：データの並び替えができる
`reverse()`メソッド：リストの要素を逆順に並べ替えるができる
`sorted()`関数：データの並び替えができる
`reversed()`関数：リストの要素を逆順に並べ替えるができる
`in`演算子：対象が含まれている場合Trueを返す
`index()`メソッド：対象が含まれている場合、何番目に含まれているか返す
`not in`演算子：対象が含まれていない場合Trueを返す
`join()`メソッド：文字列の場合のみ指定した文字と結合して文字列にできる
`split()`メソッド：文字列を指定した文字で分解してlistにできる
※指定しない場合スペース
`count()`メソッド：対象が何個含まれているか返す
`copy()`メソッド(shallow copy)：リストのコピーを返す※戻り値は浅いコピーとなる
`copy()`関数(shallow copy)：copyメソッドと同様の処理
`deepcopy()`関数(deep copy)：参照をたどりながら最後の要素までコピーする