Python入門 データ構造（リスト、タプル、集合、辞書）

# データ構造
Pythonのデータ構造には、リスト型、タプル型、集合型、辞書型があります。これらは基本的に、数値や文字列などの一つ一つのデータを一つのまとまったデータとして扱うことができます。

## リスト型
リスト型はいわゆる配列で、一度に多くの連続したデータを扱うことができます。また、メソッドを扱うことで、要素の追加や削除、検索やカウントなどの様々な操作を行うことができます。

### リスト型のメソッド
リスト型のメソッドでは、追加や削除、検索や集計、並び替え、複製などの操作を行うことができます。

#### append
appendは要素を追加することができます。

```python
data = ["a","b","c","d","e"]
data.append("f")
data
```
```:実行結果
['a', 'b', 'c', 'd', 'e', 'f']
```
appendで、リスト型の要素を追加すると、二次元配列になります。

```python
data = ["a","b","c","d","e"]
data.append(["f","g"])
data
```
```:実行結果
['a', 'b', 'c', 'd', 'e', ['f', 'g']]
```

#### extend
extendは、リストに別のリストを追加することができます。

```python
data = ["a","b","c","d","e"]
data.extend(["f","g"])
data
```
```:実行結果
['a', 'b', 'c', 'd', 'e', 'f', 'g']
```

#### insert
insertはインデックスを指定することで、要素を追加することができます。

```python
data = ["a","b","c","d","e"]
data.insert(2, "data02")
data
```
```:実行結果
['a', 'b', 'data02', 'c', 'd', 'e']
```

#### remove
removeは、指定した要素を削除することができます。

```python
data = ["a","b","c","d","e"]
data.remove("c")
data
```
```:実行結果
['a', 'b', 'd', 'e']
```

#### pop
popは、指定したインデックスの要素を削除することができます。

```python
data = ["a","b","c","d","e"]
data.pop(2)
data
```
```:実行結果
['a', 'b', 'd', 'e']
```
特にインデックスを指定しなければ、最後の要素が削除されます。

```python
data = ["a","b","c","d","e"]
data.pop()
data
```
```:実行結果
['a', 'b', 'c', 'd']
```

#### clear
clearは、リストの要素全てを削除することができます。

```python
data = ["a","b","c","d","e"]
data.clear()
data
```
```:実行結果
[]
```

#### index
indexは、指定した要素のインデックスを返します。

```python
data = ["a","b","c","d","e"]
data.index("d")
```
```:実行結果
3
```
また、要素とインデックスの範囲を指定することでインデックスを返すこともできます。

```python
data = ["a","b","c","d","e"]
data.index("d",0,4)
```
```:実行結果
3
```

#### count
countは、指定した要素の数を集計します。

```python
data = ["a","b","b","c","c","c"]
data.count("c")
```
```:実行結果
3
```

#### sort
sortは、要素を順番に並び替えます。

```python
data = [3,5,4,1,2]
data.sort()
data
```
```:実行結果
[1, 2, 3, 4, 5]
```
reverse=Trueを指定すると、大きい順に並び替えをします。

```python
data = [3,5,4,1,2]
data.sort(reverse=True)
data
```
```:実行結果
[5, 4, 3, 2, 1]
```
#### reverse
reverseは、リストの並びを反転させます。

```python
data = ["a","b","c","d","e"]
data.reverse()
data
```
```:実行結果
['e', 'd', 'c', 'b', 'a']
```

#### copy
copyは、リストを複製することができます。

```python
data01 = ["a","b","c","d","e"]
data02 = data01.copy()
data02
```
```:実行結果
['a', 'b', 'c', 'd', 'e']
```

### スタック
pythonでは、リストをappendとpopを使うことでスタックとして使うことができます。スタックとは、データの追加を末尾から行い、データの取り出しも末尾の新しいデータから行うという処理を言います。

```python
stack = [1,2,3,4,5]
stack.append(6)
stack
```
```:実行結果
[1, 2, 3, 4, 5, 6]
```
```python
stack.append(7)
stack
```
```:実行結果
[1, 2, 3, 4, 5, 7]
```
```python
stack.pop()
stack
```
```:実行結果
[1, 2, 3, 4, 5, 6]
```
```python
stack.pop()
stack
```
```:実行結果
[1, 2, 3, 4, 5]
```

### キュー
pythonでは、collections.dequeのappendとpopleftを使うことでキューとして機能させることもできます。キューとは、データの追加は末尾から行い、データの取り出しは先頭の一番古いデータを取り出す処理を言います。

```python
from collections import deque
queue = deque([1,2,3,4,5])
queue.append(6)
queue
```
```:実行結果
deque([1, 2, 3, 4, 5, 6])
```
```python
queue.append(7)
queue
```
```:実行結果
deque([1, 2, 3, 4, 5, 6, 7])
```
```python
queue.popleft()
queue
```
```:実行結果
deque([2, 3, 4, 5, 6, 7])
```
```python
queue.popleft()
queue
```
```:実行結果
deque([3, 4, 5, 6, 7])
```

### 内包表記

内包表記を使うと、for文でリストを生成するよりも簡潔にプログラムを書くことができます。

```python
data = [x**2 for x in range(10)]
data
```
```:実行結果
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
```

内包表記の他に以下のようなラムダ式でも簡潔に書くことができます。

```python
data = list(map(lambda x: x**2, range(10)))
data
```
```:実行結果
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
```


for節以外にもif節などの条件式(三項演算子)で要素選択することもできます。

```python
combination = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
combination
```
```:実行結果
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
```

### del文

del文は基本的には、リストのインデックスを指定することで要素を削除することができます。

```python
data = ["a","b","c","d","e"]
del data[0]
data
```
```:実行結果
['b', 'c', 'd', 'e']
```

スライスを使用してある範囲を削除することもできます。

```python
del data[1:3]
data
```
```:実行結果
['b', 'e']
```

スライスで、全てのデータを削除することもできます。

```python
del data[:]
data
```
```:実行結果
[]
```

## タプル型
タプル型は、リスト型と似ていますが、不変型なので、データの変更、削除などの操作を行うことができません。

### タプルの生成

タプルは、括弧（）で囲むことで生成できます。

```python
data = ("a","b","c","d","e")
data
```
```:実行結果
('a', 'b', 'c', 'd', 'e')
```

### タプル型のメソッド

タプルでは、変更や削除などのメソッドは使用できませんが、countやindexなどは使用できます。

#### count

countは、指定した要素を集計します。

```python
data = ("a","b","b","c","c","c")
data.count("c")
```
```:実行結果
3
```

#### index

indexは、指定した要素のインデックスを返します。

```python
data = ("a","b","c","d","e")
data.index("e")
```
```:実行結果
4
```

#### all

allは、全ての値があればTrue、そうでなければFalseの値を返します。

```python
data = ("a","b","c","d","e")
all(data)
```
```:実行結果
True
```

#### any

allは、いずれかの値があればTrue、そうでなければFalseの値を返します。

```python
data = ("a","b","c","d","e")
any(data)
```
```:実行結果
True
```

#### enumerate

enumerateを使うと、リストのインデックスを取得することができます。

```python
data = ("a","b","c","d","e")
enumerate(data)

for i, j in enumerate(data):
  print('{0}:{1}'.format(i, j))
```
```:実行結果
0:a
1:b
2:c
3:d
4:e
```

#### len

lenは、データの数を数えます。

```python
data = ("a","b","c","d","e")
len(data)
```
```:実行結果
5
```

#### max

maxは、データのうち、最大値を返します。

```python
data = (1,2,3,4,5)
max(data)
```
```:実行結果
5
```

#### min

minは、データのうち最小値を返します。

```python
data = (1,2,3,4,5)
min(data)
```
```:実行結果
1
```

#### sorted

sortedは、データを並び替えた値を返します。

```python
data = (3,1,4,5,2)
sorted(data)
```
```:実行結果
[1, 2, 3, 4, 5]
```

#### sum

sumは、データの総和を計算します。

```python
data = (1,2,3,4,5)
sum(data)
```
```:実行結果
15
```

#### tuple

tupleは、リストで書かれた形式をタプルに変換します。

```python
data = tuple([1,2,3,4,5])
type(data)
```
```:実行結果
tuple
```

## 集合型

集合型は、重複する要素を持たず、順序付けされない要素の集まります。また、集合型は、和、積、差、対称差と言った集合演算を行うことができます。

### 集合の生成
集合を生成するには、主に波括弧、set()関数、集合内包表記によって生成することができます。

#### 波括弧{}で生成
一般的に、集合を生成するときは、波括弧{}で生成します。以下のように同じ数値は、小数点が表記されていても、集合を生成した時には、一つの要素としてまとめられます。

```python
data = {1,1,2,2,2.00,3,3,3,4.00,4,4.000,4}
data
```
```:実行結果
{1, 2, 3, 4.0}
```

#### set()関数で生成（リスト）

set()関数で集合を生成することもできます。以下の例では、最初にリスト型を生成し、その後、set()関数を使用して集合型を生成しています。

```python
data = [1,2,3,4,5]
type(data)
```
```:実行結果
list
```
```python
data = set(data)
type(data)
```
```:実行結果
set
```

#### set()関数で生成（辞書）
set()関数では、辞書型も集合型にすることができます。data01で辞書型を生成し、keysやvalues、itemsなどを指定することで集合型を生成することができます。

```python
data01 = {"cat":10, "dog":15, "fish":100}
data02 = set(data01.keys())
data03 = set(data01.values())
data04 = set(data01.items())

data01
```
```:実行結果
{'cat': 10, 'dog': 15, 'fish': 100}
```

data02には、keysを指定してキーワードを集合型として生成しています。

```python
data02
```
```:実行結果
{'cat', 'dog', 'fish'}
```

data03には、valuesを指定して、値を集合型として生成しています。

```python
data03
```
```:実行結果
{10, 15, 100}
```

data04には、itemsを指定して、キーワードと値の両方を集合型にしています。

```python
data04
```
```:実行結果
{('cat', 10), ('dog', 15), ('fish', 100)}
```

#### 集合内包表記で生成

内包表記を使用することで、ある関数で生成された値を集合型にすることもできます。

```python
data = {i**2 for i in range(5)}
data
```
```:実行結果
{0, 1, 4, 9, 16}
```

### 集合の操作

集合型も追加や削除といった操作をすることができます。

#### add

addは、末尾に要素を追加することができます。

```python
data = {1,2,3,4,5}
data.add(6)
data
```
```:実行結果
{1, 2, 3, 4, 5, 6}
```

#### remove

removeは、要素をしてすることで削除することができます。

```python
data = {1,2,3,4,5}
data.remove(5)
data
```
```:実行結果
{1, 2, 3, 4}
```

#### discard

discardもremoveと同様に要素を指定して削除することができます。

```python
data = {1,2,3,4,5}
data.discard(5)
data
```
```:実行結果
{1, 2, 3, 4}
```

指定した要素がない場合は特に何も処理されず、エラーも出ません。

```python
data.discard(6)
data
```
```:実行結果
{1, 2, 3, 4}
```

#### pop

popは、先頭のデータを削除します。

```python
data01 = {1,2,3,4,5}
data02 = data01.pop()
data01
```
```:実行結果
{2, 3, 4, 5}
```

また、削除した要素を返します。

```python
data02
```
```:実行結果
1
```

#### clear

clearは、全ての要素を削除します。

```python
data = {1,2,3,4,5}
data.clear()
data
```
```:実行結果
set()
```

### 集合演算

集合型では、和、積、差、対称差などの集合演算を扱うことができます。

#### 和集合

和集合は、データAにもデータBにも含まれるという意味になります。

```python
data01 = {1,2,3}
data02 = {3,4,5}
union = data01 | data02
union
```
```:実行結果
{1, 2, 3, 4, 5}
```

#### 積集合

積集合は、データAとデータBに共通するデータを表示します。

```python
data01 = {1,2,3}
data02 = {3,4,5}
intersection = data01 & data02
intersection
```
```:実行結果
{3}
```

#### 差集合

差集合は、グループAとグループBがあった時、グループAのみに含まれているデータを表示します。

```python
data01 = {1,2,3}
data02 = {3,4,5}
difference = data01 - data02
difference
```
```:実行結果
{1, 2}
```

#### 対称差集合

対称差集合は、グループAもしくはグループBのみに含まれているデータを表示します。

```python
data01 = {1,2,3}
data02 = {3,4,5}
symmetric = data01 ^ data02
symmetric
```
```:実行結果
{1, 2, 4, 5}
```

## 辞書型
### 辞書の生成

辞書型はkeyとvalueが組み合わせとなっているデータ型で、keyを使って、valueを呼び出したりすることができます。

辞書型は、波括弧、dict()関数、辞書内包表記などによって生成することができます。

#### 波括弧{}で辞書を生成

辞書を作る時は、波括弧{}で囲み、keyとvalueの組み合わせで生成します。

```python
dict01 = {"猫":100,"犬":200,"兎":150}
dict01
```
```:実行結果
{'兎': 150, '犬': 200, '猫': 100}
```

#### dict()で辞書を生成

dict()関数を使用すると以下のように辞書を生成することができます。

```python
dict01 = dict(猫=100,犬=200,兎=150)
dict01
```
```:実行結果
{'兎': 150, '犬': 200, '猫': 100}
```

#### 辞書内包表記で生成

リスト型であらかじめ、keyとvalueを用意しておくことで、辞書内包表記でも辞書型を生成できます。

```python
keys = ['犬', '猫', '兎']
values = [100, 200, 150]

dict01 = {k: v for k, v in zip(keys, values)}
dict01
```
```:実行結果
{'兎': 150, '犬': 100, '猫': 200}
```

### 辞書の操作

辞書の操作では、データの取り出しや、書換え、追加などの操作を行えます。

#### 特定の値を出力

keyを指定することで、valueを取り出すことができます。

```python

dict01 = {"猫":100,"犬":200,"兎":150}
dict01["犬"]
```
```:実行結果
200
```

#### 特定の値を書換え

keyを指定して、valueを入れることで値を書き換えることができます。

```python
dict01 = {"猫":100,"犬":200,"兎":150}
dict01["犬"] = 2000
dict01
```
```:実行結果
{'兎': 150, '犬': 2000, '猫': 100}
```

#### 新たなキーと値を追加

新しいkeyを指定して、valueを入れることで、辞書にキーと値を追加することができます。

```python
dict01 = {"猫":100,"犬":200,"兎":150}
dict01["金魚"] = 500
dict01
```
```:実行結果
{'兎': 150, '犬': 200, '猫': 100, '金魚': 500}
```

### 辞書のメソッド

辞書のメソッドには、keys、values、itemsなどのデータを取り出すものと、updateのようなデータの更新を行うことができものがあります。

#### keys

keysを使用すると、キーのみを取り出すことができます。

```python
dict01 = {"猫":100,"犬":200,"兎":150}
dict01.keys()
```
```:実行結果
dict_keys(['猫', '犬', '兎'])
```

#### values

valuesを使用すると、値のみを取り出すことができます。


```python
dict01 = {"猫":100,"犬":200,"兎":150}
dict01.values()
```
```:実行結果
dict_values([100, 200, 150])
```

#### items

itemsを使用すると、キーと値を取り出すことができます。

```python
dict01 = {"猫":100,"犬":200,"兎":150}
dict01.items()
```
```:実行結果
dict_items([('猫', 100), ('犬', 200), ('兎', 150)])
```

#### update

updateを使用すると、すでにあるキーは値が更新され、新しいキーはキーと値が追加されます。

```python
dict01 = {"猫":100,"犬":200,"兎":150}
dict02 = {"兎":250,"豚":120,"鶏":240}
dict01.update(dict02)
dict01
```
```:実行結果
{'兎': 250, '犬': 200, '猫': 100, '豚': 120, '鶏': 240}
```

## ループ

ループ処理の中でも、辞書型やnumerate、zip、reversed、sortedなどを使用すると便利に処理を行えます。

### items

辞書型のループ処理を行う場合に、itemsを使用すると、キーと値を両方取り出しながら処理を行えます。

```python
dict01 = {"猫":100,"犬":200,"兎":150}
for i, j in dict01.items():
    print(i, j)
```
```:実行結果
猫 100
犬 200
兎 150
```

### enumerate

enumerateは、リスト型のインデックスを取得しながらループ処理を行うことができます。

```python
for i, j in enumerate(["猫","犬","兎"]):
    print(i, j)
```
```:実行結果
0 猫
1 犬
2 兎
```

### zip

zipは二つ以上のリスト型を組み合わせてループ処理を行う時に使用します。

```python
animals = ["猫","犬","兎"]
images = ["気まま","賢い","寂しがり屋"]
for i, j in zip(animals, images):
    print('{0}は、どんな印象ですか? {0}は{1}な印象です。'.format(i, j))
```
```:実行結果
猫は、どんな印象ですか? 猫は気ままな印象です。
犬は、どんな印象ですか? 犬は賢いな印象です。
兎は、どんな印象ですか? 兎は寂しがり屋な印象です。
```

### reversed

reversedを使用すると、出力結果を反転して出力することができます。

```python
for i in reversed(range(0, 10)):
    print(i)
```
```:実行結果
9
8
7
6
5
4
3
2
1
0
```

### sorted

sortedを使用すると、処理するリスト型のデータを順番に並び替えて、新しいリストを作ります。

```python
box = ['赤', '白', '黒', '黒', '白', '赤']
for i in sorted(set(box)):
    print(i)
```
```:実行結果
白
赤
黒
```

## 条件

条件処理は、if文以外にも、inやis、比較の連結、andやorなどがあります。

### in および not in

inはあるリストなどに指定した要素があるかどうかを判定します。ある場合は、True、そうでなければFalseを返します。

```python
box = ['赤', '白', '黒', '黒', '白', '赤']
x = '赤' in box
print(x)
```
```:実行結果
True
```

not inは、ない場合にTrue、そうでない場合に、Falseを返します。

```python
box = ['赤', '白', '黒', '黒', '白', '赤']
x = '赤' not in box
print(x)
```
```:実行結果
False
```

### is および is not

isは、ある変数の中身が一致しているかどうかを判定します。一致している場合は、True、そうでなければFalseを返します。

```python
box = 2
x = 2 is box
print(x)
```
```:実行結果
True
```

is notの場合は、一致していなければTrue、そうでなければFalseを返します。

```python
box = 2
x = 2 is not box
print(x)
```
```:実行結果
False
```

### 比較の連結

比較演算子は、連結して条件を増やすことができます。

```python
int01 = 10
int02 = 20
int03 = 20
x = int01 < int02 == int03
print(x)
```
```:実行結果
True
```

### and と or

andとorは、それぞれ、orの場合、左が「真」の場合、左の値を返し、左が「偽」の場合、右の値を返します。andの場合、左が「真」の場合、右の値を返し、左が「偽」の場合、左の値を返します。

```python
string1 = ''
string2 = 'こんにちは'
string3 = 'さようなら'
non_null = string1 or string2 or string3
print(non_null)
```
```:実行結果
こんにちは
```
```python
x = 100
y = x == 100 and x > 50 and x < 200
print(y)
```
```:実行結果
True
```