---
# System prepended metadata

title: リスト(List)
tags: [Python]

---

# リスト(List)
###### tags: `Python`
変数を連続して定義したり利用する場合は、1つの変数だけでなくリストとして変数を定義します。

## リスト変数の定義
リスト変数の定義は、「,」で要素を区切って並べて[ ]で囲み定義します。リスト変数が保持している変数を要素と呼びます。

リストを定義するには、角かっこ「[]」の中にそのリストに含めるデータをカンマ「,」で区切って並べていく。リストには任意の種類のデータを好きな数だけ格納できる。リストに格納する個々のデータのことを「要素」と呼ぶ。要素には「0始まり」で番号（インデックス）が割り振られ、要素の値を使いたいときにはこれを使用する。

### 空のリスト（要素が1つもないリスト）を定義
```Python=
languages = []
languages_ver = list()
```

### リスト変数の作成
**Example:**
1と9間の整数を出力
```python=
list_variable = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in list_variable:
    print(i, end = " ")
```
**Results:**
```
1 2 3 4 5 6 7 8 9 
```

**Example:**
``` python=
languages = ['Python', 'c++', 'Java']
print(languages)
```
**Results:**
```
['Python', 'c++', 'Java']
```
**Example:**
Pythonのリストは構成する各要素の型が違っていても成り立つのです。
``` python=
languages_ver = ['Python', 3.7, 'Java', 14]
print(languages)
```
**Results:**
```
['Python', 3.7, 'Java', 14]
```
### 要素を指定した個数繰り返すリストを作成する
特定の値を持つ要素を指定した個数持つようなリストを作成する場合、次のように行うことができます。
```
リスト = [要素] * 個数
```
**Example:**
``` python=
num_list = [0] * 10
print(num_list)

num_list = [10, 20, 30] * 3
print(num_list)

string_list = ["string"] * 5
print(string_list)
```
**Results:**
```
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
[10, 20, 30, 10, 20, 30, 10, 20, 30]
['string', 'string', 'string', 'string', 'string']
```

### list()関数によるリストの作成
パラメーターに受け取ったiterable（反復可能オブジェクト）を基に、リストを作成する。

* **list(iterable)**

| パラメーター | 説明 | 
| -------- | -------- | 
| iterable	    | リストの作成に使用する反復可能オブジェクト。リストの要素は、iterableの要素と同じものになる。省略すると、空のリストが作成される     | 
**Example:**
```python=
strlist = list('Python')  # 'P'、'y'、't'、'h'、'o'、'n'を要素とするリストを作成
print(strlist)
intlist = list(range(10))  # 整数値0～9を要素とするリストを作成
print(intlist)
somelist = list(intlist)  # リストからリストを作成
print(somelist)
```
**Results:**
```
['P', 'y', 't', 'h', 'o', 'n']
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
```
## リストの要素数を求める
* **len(s)**
引数に指定したリストsの要素数を返す。
```python=
strlist = list('Python')  
print(len(strlist))
```
**Results:**
```
6
```
## 指定した要素が何個リストに格納されているか
* **count(x)**
count(x)
リストでの x の出現回数を返します。
```python=
intlist = [0, 10, 9, 2, 0, -10, -2, 0, -7, 3]
print(intlist.count(0)) 
```
**Results:**
```
3
```
## 要素を追加
* **append(x)**
リストの末尾に要素を一つ追加します。
```python=
languages = ['Python', 'c++', 'Java']
print(languages)
languages.append('PHP')
print(languages)
```
**Results:**
```
['Python', 'c++', 'Java']
['Python', 'c++', 'Java', 'PHP']
```
* **extend(iterable)**
リストの末尾に「iterable」に含まれる全要素を追加する。
```python=
languages = ['Python', 'c++', 'Java']
print(languages)
languages.extend(['PHP', 'HTML'])
print(languages) 
```
**Results:**
```
['Python', 'c++', 'Java']
['Python', 'c++', 'Java', 'PHP', 'HTML']
```
* append vs extend
これら2つのメソッドは共にリストの末尾に要素を追加するものだが、appendメソッドでは引数が反復可能オブジェクトの場合、それを1つの要素としてリストの末尾に追加する。これに対して、extendメソッドに反復可能オブジェクトを渡した場合には、その要素が展開（extend）されて、別々の要素としてリストに追加される。
```python=
languages = ['Python', 'c++', 'Java']
print(languages)
languages.extend(['PHP', 'HTML'])
print(languages) 
languages.append(['PHP', 'HTML'])
print(languages) 
```
**Results:**
```
['Python', 'c++', 'Java']
['Python', 'c++', 'Java', 'PHP', 'HTML']
['Python', 'c++', 'Java', 'PHP', 'HTML', ['PHP', 'HTML']]
```
## リストへの要素の挿入
* **insert(i, x)**
リスト中の「i」で指定したインデックス位置に、要素「x」を挿入する。
```python=
languages = ['Python', 'c++', 'Java']
print(languages)
languages.insert(1, 'PHP')
print(languages) 
```
**Results:**
```
['Python', 'c++', 'Java']
['Python', 'PHP', 'c++', 'Java']
```
## 要素を削除
* **remove(x)**
emoveメソッドは引数に削除したい要素の値を指定します。
```python=
languages = ['Python', 'c++', 'Java']
print(languages)
languages.remove('c++')
print(languages)
```
**Results:**
```
['Python', 'c++', 'Java']
['Python', 'Java']
```
* **del文**
指定したインデックス位置の要素を削除する。
```python=
languages = ['Python', 'c++', 'Java']
print(languages)
del languages[2]
print(languages) 
```
**Results:**
```
['Python', 'c++', 'Java']
['Python', 'c++']
```

* **pop(x)**
リスト中の指定された位置にある要素をリストから削除して、その要素を返します。
インデクスが指定されなければ、 a.pop() はリストの末尾の要素を削除して返します。
```python=
languages = ['Python', 'c++', 'Java', 'PHP']
print(languages)
pop_language = languages.pop(1)
print(languages) 
print('pop_language = ', pop_language) 
pop_language = languages.pop()
print(languages) 
print('pop_language = ', pop_language) 
```
**Results:**
```
['Python', 'c++', 'Java', 'PHP']
['Python', 'Java', 'PHP']
pop_language =  c++
['Python', 'Java']
pop_language =  PHP
```

* **clear()**
リスト中の全ての要素を削除します。
```python=
languages = ['Python', 'c++', 'Java', 'PHP']
print(languages)
languages.clear()
print(languages) 
```
**Results:**
```
['Python', 'c++', 'Java', 'PHP']
[]
```
## in演算子で要素を検索
リストにある特定の要素が含まれているかどうかを調べるときには、in演算子を使うことができます。
* **x in list**
戻り値はTrueかFalseです。
```python=
languages = ['Python', 'c++', 'Java']
print('Java' in languages)
print('PHP' in languages)
```
**Results:**
```
True
False
```
:::success
## 利用 + 演算子來串聯list
產生新的串聯list，原本的list不受影響。
:::
```
a = list(range((3)))
b = [4, 5, 6]
c = a + b
print("a =", a)
print("b =", b)
print("c =", c)
```
**Results:**
```
a = [0, 1, 2]
b = [4, 5, 6]
c = [0, 1, 2, 4, 5, 6]
```
:::success
## 利用 * 演算子來初始化list
利用 * 可以建構特定大小的list，並設定初始值，通常用於處理已知大小的大型list。提前調整好大小可以避免，list大小變動時會產生記憶體重新分配的額外負擔。

此方法為list的乘法運算，將list複製指定次數，並將其連接產生一個新的list。
:::
```python=
a = [None] * 3
print(a)
b = [0] * 5
print(b)
c = [1, 2, 3] * 2
print(c)
```
**Results:**
```
[None, None, None]
[0, 0, 0, 0, 0]
[1, 2, 3, 1, 2, 3]
```

## リストの並べ替え
リストの要素の大小関係を基に、それらを昇順に（小さいものから大きいものへ）並べ替える。キーワード引数「key」には、比較に用いる際のキーとなる値を算出する関数を与える（引数を1つ取り、それにリストの要素が与えられる）。同じくキーワード引数の「reverse」にTrueを指定すると、降順に並べ替えが行われる。パラメーターkeyとreverseは省略可能。
* **sort(key, reverse = False)**
```python=
intlist = [-7, 8, 3, -5, -3, 2, 10, 6, -12, -8]
intlist.sort()  # intlistを並べ替える
print(intlist)  

intlist.sort(reverse = True)
print(intlist)  

intlist.sort(key = abs)  # 絶対値を基に並べ替え
print(intlist)  
```
**Results:**
```
[-12, -8, -7, -5, -3, 2, 3, 6, 8, 10]
[10, 8, 6, 3, 2, -3, -5, -7, -8, -12]
[2, 3, -3, -5, 6, -7, 8, -8, 10, -12]
```
* **sorted(key, reverse = False)**
リスト（intlist）自体の要素が並べ替えられていることだ。もともとの順序を維持したまま、並べ替えの結果だけを得たいのであれば、組み込みのsorted関数を使用する。
```python=
intlist = [-7, 8, 3, -5, -3, 2, 10, 6, -12, -8]
result = sorted(intlist, key = abs)
print(intlist)
print(result)
```
**Results:**
```
[-7, 8, 3, -5, -3, 2, 10, 6, -12, -8]
[2, 3, -3, -5, 6, -7, 8, -8, 10, -12]
```
:::success
|  | sort()方法 | sorted()函式 |
| -------- | -------- | -------- |
| 使用方法 | list.sort() | sorted(list) |
| 排序結果 | 修改原本的list(就地排序) | 不修改原本的list，產生新的已排序的list |

* Function: 通用性較廣
list是可變變數，所以Python設計一個list專有的sort()方法來排序，並且修改原本的list成排序後的結果。
* Method: 專屬於某型別或物件的
但像string跟tuple是不可變變數，set跟字典(3.6之前)是無序的，這些型別都不能就地排序，所以設計一個sorted()函式來讓這些型別來排序(list也可以用)。
:::
## リストの反転
リストの要素を、インプレース演算で逆順にします。
* **reverse()**

```python=
languages = ['Python', 'c++', 'Java', 'PHP']
print(languages)
languages.reverse()
print(languages)
```
**Results:**
```
['Python', 'c++', 'Java', 'PHP']
['PHP', 'Java', 'c++', 'Python']
```
## リストのコピー
* **copy()**

```python=
languages = ['Python', 'c++', 'Java', 'PHP']
print(languages)
copy_languages = languages.copy()
print(copy_languages)
```
**Results:**
```
['Python', 'c++', 'Java', 'PHP']
['Python', 'c++', 'Java', 'PHP']
```

## max(iterable)
iterable の中で最大の要素、または2つ以上の引数の中で最大のものを返します。
```python=
val_list = [2, 10, -4, 8, 7, 20, -7]
print(val_list)
print("Max = {}".format(max(val_list)))
```
**Results:**
```
[2, 10, -4, 8, 7, 20, -7]
Max = 20
```
## min(iterable)
iterable の中で最小の要素、または2つ以上の引数の中で最小のものを返します。
```python=
val_list = [2, 10, -4, 8, 7, 20, -7]
print(val_list)
print("Min = {}".format(min(val_list)))
```
**Results:**
```
[2, 10, -4, 8, 7, 20, -7]
Min = -7
```

## sum(iterable)
総和を返します。
```python=
val_list = [2, 10, -4, 8, 7, 20, -7]
print(val_list)
print("Sum = {}".format(sum(val_list)))
```
**Results:**
```
[2, 10, -4, 8, 7, 20, -7]
Sum = 36
```