Python入門　numpy pandas matplotlib(〜B3に向けて〜 part2)

#モジュールを使ってみよう!

　Pythonの強みの１つは豊富なモジュールやライブラリの数です。
いちいち汎用性の関数やクラスを定義しなくても過去に試作した、或いは先人たちが作ったオープンソースのモジュールを使えばだいぶ作業量が効率化できます。

では早速代表的なライブラリを使っていきましょう！

##Numpy
NumpyはPythonで数値計算を高速かつ効率的に行うライブラリです
ライブラリを利用するときは`import`文を使います。

```py
import numpy as np
```
`as 〇〇`を`import`文の後ろにつけることで
モジュールの名前をコード内で〇〇に変えることができます。
今回では`numpy`を`np`にしています。
numpy では独自の配列(ndarrayクラスの配列)を用います。
`ndarray`クラスのオブジェクトとしては以下が挙げられます。

```py
import numpy as np

#numpy配列の宣言
a = np.arange(15).reshape(3, 5)
b = np.array([1.2,3.5,5.1])
c = ([(1.5,2,3),(4,5,6)])
print(a)
print(b)
#配列の形
print(a.shape)
#配列の次元
print(a.ndim)
#配列の要素の型
print(a.dtype.name)
#配列の要素数
print(a.size)
```

```console
#配列の表示
#配列a
[[ 0  1  2  3  4 ]
 [ 5  6  7  8  9 ] 
 [10 11 12 13 14 ]]
#配列b
[1.2 3.5 5.1 ]
#配列c
[(1.5, 2, 3), (4, 5, 6)]
#配列の形
(3, 5)
#配列の次元数
2
#配列の要素の型
int64
#配列の要素数
15
```

Numpy配列の生成は**array属性**を使うことで行えます。
多次元配列も容易に作ることが可能です。
行、列などの要素数を確認するときは**shapeプロパティ**を使います。
全要素数は**sizeプロパティ**で確認できます。
また行列の要素が何型なのか(intとかfloatとか)を確認したい場合は
**typeプロパティ**を使えばできます。

---
###ゼロ行列　空の行列
ゼロ行列や全要素が１となった行列,空の行列を
生成することもできます。

```py
import numpy as np

print(np.zeros((3,4)))
print(np.ones((2,3,4),dtype = np.int16))
print(np.empty((2,3)))
```

```console
#ゼロ行列
[[0. 0. 0. 0. ]
 [0. 0. 0. 0. ]
 [0. 0. 0. 0. ] ]

#全要素が１の行列
[[[1 1 1 1 ]
  [1 1 1 1 ]
  [1 1 1 1] ]

 [[1 1 1 1 ]
  [1 1 1 1 ]
  [1 1 1 1 ] ] ]

#空のNumpy行列
[[1.39069238e-309 1.39069238e-309 1.39069238e-309 ]
 [1.39069238e-309 1.39069238e-309 1.39069238e-309 ] ]
```
>課題
>>5*5の単位行列をゼロ行列から作ってみよう。
>>対角成分の入れ方は任せます。


---
###連番や〇個飛ばしの要素の配列
上記にもありますが**arange属性**を使うことで要素が指定の順番で入っていくようなNumpy配列の生成もできます。
`np.arange.(stop)`で`0 <= n < stop`までの`n`が連番で入ります。
`np.arange.(start,stop)` で`start <= n < stop`までの`n`が連番で入ります。
`np.arange.(start,stop,step)` で`start <= n < stop`までの`n`が`step`飛ばしで入ります。飛ばす数は小数にも対応してます。

```py
print(np.arange(10))
print(np.arange(0,10))
print(np.arange(10,30,5))
print(np.arange(0,2,0.3))

```

```console
[0 1 2 3 4 5 6 7 8 9 ]
[0 1 2 3 4 5 6 7 8 9 ]
[10 15 20 25 ]
[0.  0.3 0.6 0.9 1.2 1.5 1.8 ]
```
また`[start:stop)`の範囲を等間隔で指定した要素数に分けるような**linspace属性**もあります。

```py
print(np.linspace(0,2,9))
```

```console
[0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]
```
---

##Numpy配列の四則演算
Numpy配列の四則演算では基本同じ行と列の要素同士で計算が行われます。

```py
A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])
print(A+B)
print(A-B)
print(A*B)
```

```console

#A+B
[[3 1 ]
 [3 5 ] ]
#A-B
[[ - 1  1 ]
 [ - 3 - 3 ] ]
#A*B
[[2 0 ]
 [0 4 ] ]
```

角要素同士の掛け算でなく内積を求めたい場合は`@`や`dot関数`を用います。

```py
print(A@B)
print(A.dot(B))
```

```console
#A@B
[[5 4 ]
 [3 4 ]]
#A.dot(B)
[[5 4 ]
 [3 4 ]]
```
---
###累乗　平方根
Numpy配列の累乗は配列同士で行うと(A**B)
A[i]のB[i]乗が出力されます。
また平方根も各要素について処理が行われます。

```py
a = np.arange(1, 11, 1)
b = np.array([1,2,1,2,1,2,1,2,1,2])
print(np.power(a, b))
print(np.sqrt(a))
```

```console
[  1   4   3  16   5  36   7  64   9 100 ]
[1.   1.41421356 1.73205081 
 2.   2.23606798 2.44948974 2.64575131 2.82842712 
 3.   3.16227766 ]
```
---
###三角関数
Numpyでは三角関数や双曲線関数も対応しています。
引数は**radian**なので気をつけましょう。

```py
print(np.sin(0))
print(np.cos(0))
print(np.tan(np.pi/4))
print(np.tanh(2))
```
```bash
0.0
1.0
0.9999999999999999
0.9640275800758169
```
また逆三角関数もあります。出力は同じく**radian**です。

```py
print(np.arcsin(1.0))
print(np.arcsin(1.0)*2/np.pi)
print(np.arccos(-1.0))
print(np.arctan(-0.5))
```

```console

#arcsin(1.0)
1.5707963267948966
#arcsin(1.0)*2/np.pi
1.0
#arccos(-1.0)
3.141592653589793
#arctan(-0.5)
- 0.4636476090008061
```

###要素の数え上げ
Numpy配列の全要素のうち該当するものを数え上げる関数はいくつかあります。

```py
onehot = np.array([0, 1, 1, 0, 1, 0, 1, 1])

# 1の個数をカウントする例
print(np.count_nonzero(onehot))                    
print(len(np.where(onehot != 0)[0])) 

# 0の個数をカウントする例
print(np.count_nonzero(1 - onehot)) 
 
#0と1を同時にカウントする例
#unique関数の使用
print(np.unique(onehot, return_counts=True))

#辞書型で表示
unique, count = np.unique(onehot, return_counts=True)
print(dict(zip(unique, count)))

#bincount関数の使用
c = np.bincount(onehot)
print(c)   
```
```console
#1の個数
5    #count_nonzero
5    #len(np.where(onehot != 0)[0])
#0の個数
3    #count_nonzero(1 - onehot)
#同時にカウント
(array([0, 1]), array([3, 5]))    #unique
{0: 3, 1: 5}                      #辞書型
[3 5 ]                            #
```

特に`unique関数`や`bincount関数`は要素の全種類をカウントしてくれます。
この２つの違いは`unique関数`はNumpy配列中に存在しない値の個数を表示しないところです。

```py
A = np.array([2,3,4,3,4,4,4,6,7,1])
#unique関数の使用
u,c = np.unique(A,return_counts=True)
print(dict(zip(u,c)))
#bincount関数の使用
print(np.bincount(A))
```
```console
#unique関数の使用
{1: 1, 2: 1, 3: 2, 4: 4, 6: 1, 7: 1}
#bincount関数の使用
[0 1 1 2 4 0 1 1 ]
```

>課題
>>sin関数にπ/4ずつ入力した値の配列を作り(0~4πまで)
>>各要素をカウントしてください。

###最大の要素、最小の要素を取り出す
配列の最大の要素,最小の要素の添え字(インデックス)を取り出したいときは`argmax関数`,`argmin関数`を使います。
添え字(インデックス)とは要素の位置にあたるものです。


```py
A = np.array([2,4,3,6,7,8,8,5,4,7,8])
#要素の最大値
print(np.max(A))
#最大値のインデックス
print(np.argmax(A))
print(A.argmax())
#要素の最小値
print(np.min(A))
#最小値のインデックス
print(np.argmin(A))
print(A.argmin())
```

```console
#要素の最大値
8
#要素の最大値のインデックス
5
5
#要素の最小値
2
#要素の最小値のインデックス
0
0
```

`argmax,argmin関数`は
`np.argmax(argmin)`と`np.ndarray.argmax(argmin)`の２種類があって
`np.argmax関数`は関数の第一引数に配列を指定し、
`np.ndarray.argmax関数`はメソッドのように呼び出して使います
インデックス"0"から始めた配列Aの最大の要素のインデックス`5`が出力されています。
それぞれの引数には`axis`パラメータがあり多次元配列でも指定した軸での最大値,最小値を検索してくれます。

```py
B = np.array([[2,4,5],[9,2,8]])
#軸(axis=0)を基準とした各要素の最大値
print(B.max(axis=0))
#軸(axis=0)を基準とした各要素の最大値のインデックス
print(B.argmax(axis=0))
#軸を(axis=1)基準とした各要素の最大値
print(B.max(axis=1))
#軸(axis=1)を基準とした各要素の最大値のインデックス
print(B.argmax(axis=1))
```
```console

#軸(axis=0)を基準とした各要素の最大値
[9 4 8 ]
#軸(axis=0)を基準とした各要素の最大値のインデックス
[1 0 1 ]
#軸を(axis=1)基準とした各要素の最大値
[5 9 ]
#軸(axis=1)を基準とした各要素の最大値のインデックス
[2 0 ]
```

`axis=0`のときは配列の各列の最大値のインデックスを出力し、
`axis=1`のときは配列の各行の最大値のインデックスを出力しています。

>課題
>>ひとつ前の課題の配列最大値、最小値の
最初のインデックスを求めなさい。

##Pandas
Pandasは高速で強力、柔軟で使いやすいオープンソースのデータ分析および操作ツールです。
まずはライブラリをインポートしてみましょう。

```py
import pandas as pd
```
次にUCI Machine Learning RepositoryからIrisデータセットを読み込んでみましょう。
pandasではデータテーブルのことを**DataFrame**と呼びます。
`df`はその略ですので名前に特に意味はありませんが
よく`df`で宣言されています。


```py
import pandas as pd
#データフレームの表示
df = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data',header=None)
print(df)
```

```console
#データフレームの表示
       0    1    2    3               4
0    5.1  3.5  1.4  0.2     Iris-setosa
1    4.9  3.0  1.4  0.2     Iris-setosa
2    4.7  3.2  1.3  0.2     Iris-setosa
3    4.6  3.1  1.5  0.2     Iris-setosa
4    5.0  3.6  1.4  0.2     Iris-setosa
..   ...  ...  ...  ...             ...
145  6.7  3.0  5.2  2.3  Iris-virginica
146  6.3  2.5  5.0  1.9  Iris-virginica
147  6.5  3.0  5.2  2.0  Iris-virginica
148  6.2  3.4  5.4  2.3  Iris-virginica
149  5.9  3.0  5.1  1.8  Iris-virginica

[150 rows x 5 columns]

```
こんな感じで読み込めたと思います。
先頭や末尾のみを確認したい場合は`head,tail関数`を使います。

```py
#先頭10行の表示
print(df.head(n=10))
#末尾５行の表示
print(df.tail(n=5))
```
```console
#先頭10行の表示
     0    1    2    3            4
0  5.1  3.5  1.4  0.2  Iris-setosa
1  4.9  3.0  1.4  0.2  Iris-setosa
2  4.7  3.2  1.3  0.2  Iris-setosa
3  4.6  3.1  1.5  0.2  Iris-setosa
4  5.0  3.6  1.4  0.2  Iris-setosa
5  5.4  3.9  1.7  0.4  Iris-setosa
6  4.6  3.4  1.4  0.3  Iris-setosa
7  5.0  3.4  1.5  0.2  Iris-setosa
8  4.4  2.9  1.4  0.2  Iris-setosa
9  4.9  3.1  1.5  0.1  Iris-setosa
#末尾５行の表示
       0    1    2    3               4
145  6.7  3.0  5.2  2.3  Iris-virginica
146  6.3  2.5  5.0  1.9  Iris-virginica
147  6.5  3.0  5.2  2.0  Iris-virginica
148  6.2  3.4  5.4  2.3  Iris-virginica
149  5.9  3.0  5.1  1.8  Iris-virginica
```


---
データセットの形状などを確認していきましょう。

```py
#行数、列数の確認
print(df.shape)
#indexの確認
print(df.index)
#カラムの確認
print(df.columns)
#dataframeの各列のデータ型の確認
print(df.dtypes)
```
```bash
#行数、列数の確認
(150, 5)
#indexの確認
RangeIndex(start=0, stop=150, step=1)
#カラムの確認
Int64Index([0, 1, 2, 3, 4], dtype='int64')
#dataframeの各列のデータ型の確認
0    float64
1    float64
2    float64
3    float64
4     object
dtype: object
```
データフレームの統計量は`describe()関数`で求めることができます。

```py
print(df.describe())
```
```console

                0           1           2           3
count  150.000000  150.000000  150.000000  150.000000
mean     5.843333    3.054000    3.758667    1.198667
std      0.828066    0.433594    1.764420    0.763161
min      4.300000    2.000000    1.000000    0.100000
25%      5.100000    2.800000    1.600000    0.300000
50%      5.800000    3.000000    4.350000    1.300000
75%      6.400000    3.300000    5.100000    1.800000
max      7.900000    4.400000    6.900000    2.500000
```

---


データフレームの一部のみ取り出すともできます。

```py
#100~109個目のデータを取得
print(df[100:110],"\n\n")
#100個目のデータのみ取得
print(df.loc[100],"\n\n")
#0~100行の第４列のみを取得
print(df.iloc[0:100,4])
```

```console
       0    1    2    3               4
100  6.3  3.3  6.0  2.5  Iris-virginica
101  5.8  2.7  5.1  1.9  Iris-virginica
102  7.1  3.0  5.9  2.1  Iris-virginica
103  6.3  2.9  5.6  1.8  Iris-virginica
104  6.5  3.0  5.8  2.2  Iris-virginica
105  7.6  3.0  6.6  2.1  Iris-virginica
106  4.9  2.5  4.5  1.7  Iris-virginica
107  7.3  2.9  6.3  1.8  Iris-virginica
108  6.7  2.5  5.8  1.8  Iris-virginica
109  7.2  3.6  6.1  2.5  Iris-virginica 


0               6.3
1               3.3
2                 6
3               2.5
4    Iris-virginica
Name: 100, dtype: object 


0         Iris-setosa
1         Iris-setosa
2         Iris-setosa
3         Iris-setosa
4         Iris-setosa
           ...       
95    Iris-versicolor
96    Iris-versicolor
97    Iris-versicolor
98    Iris-versicolor
99    Iris-versicolor
Name: 4, Length: 100, dtype: object
```
---

###順序特徴量のマッピング
例えば服のサイズなど特徴量に順序付けが行われている場合特徴量を整数などへマッピングすることで
学習アルゴリズムなどが順序特徴量を正しく解釈できるようになります。
また、逆変換も行えるようにします。


```py
df = pd.DataFrame([
                   ['green','M',10.1,'class1'],
                   ['red','L',13.5,'class2'],
                   ['blue','XL',15.3,'class1']
])
#列名を設定
df.columns = ['color','size','price','classlabel']
print(df,"\n")
size_mapping = {'XL':3,'L':2,'M':1}
df['size']= df['size'].map(size_mapping)
print(df,"\n")
#逆変換の関数を定義
inv_size_mapping = {v:k for k,v in size_mapping.items()}
df['size']=df['size'].map(inv_size_mapping)
print(df)
```

```console
   color size  price classlabel
0  green    M   10.1     class1
1    red    L   13.5     class2
2   blue   XL   15.3     class1 
#変換後
   color  size  price classlabel
0  green     1   10.1     class1
1    red     2   13.5     class2
2   blue     3   15.3     class1 
#逆変換後
   color size  price classlabel
0  green    M   10.1     class1
1    red    L   13.5     class2
2   blue   XL   15.3     class1
```
---

###クラスラベルのエンコーディング
機械学習ライブラリではクラスラベルを整数値として要求されていることが多いのでエンコードします。順序特徴量と同様に逆変換も用意します。

```py
class_mapping = {label:idx for idx, label in enumerate(np.unique(df['classlabel']))}
df['classlabel']=df['classlabel'].map(class_mapping)
print(df,"\n")
inv_class_mapping = {v : k for k, v in class_mapping.items()}
df['classlabel'] = df['classlabel'].map(inv_class_mapping)
print(df)
```

```console
   color size  price  classlabel
0  green    M   10.1           0
1    red    L   13.5           1
2   blue   XL   15.3           0 

   color size  price  classlabel
0  green    M   10.1           0
1    red    L   13.5           1
2   blue   XL   15.3           0
```
---
###One-hotエンコーディング
####カテゴリ変数をダミー変数に変換する
機械学習のクラス分け分類の分類項目が最初からクラス１,クラス２...と数値になっていることはあまりありません。
例えば男性と女性の分類の時に0と1のようなダミー変数に変換したほうが処理が楽になることがあります。
また、多クラスの特徴量をone-hot表現に変換したいときも来るでしょう。
そんな時には`get_dummies()関数`が便利です。
今回は順序のない名義特徴量と呼ばれる特徴量の一種である色に対して**one-hotエンコーディング**をしていきます。

```py
pd.get_dummies(df[['price','color','size']])
```
```console
    price size	color_blue	color_green	color_red
0	10.1	1      0	        1           0
1	13.5	2      0	        0           1
2	15.3	3      1	        0           0
```
---
###欠損値の補充
データは全てがみっちり埋まっているとは限りません。
そのようなときに欠損値(NaN)を埋める必要があります。

```py
from io import StringIO
#サンプルデータの作成
csv_data = '''A,B,C,D 
              1.0,2.0,3.0,4.0
              5.0,6.0,,8.0
              10.0,11.0,12.0,'''
df = pd.read_csv(StringIO(csv_data))
print(df)
print(df.describe())
```

ここで`StringIO`は変数`csv_data`に代入された文字列を
DataFrameオブジェクトに読み込めるようにするために使っています。

```console
    A     B     C   D 
0   1.0   2.0   3.0  4.0
1   5.0   6.0   NaN  8.0
2  10.0  11.0  12.0  NaN
               A          B          C        D 
count   3.000000   3.000000   2.000000  2.000000
mean    5.333333   6.333333   7.500000  6.000000
std     4.509250   4.509250   6.363961  2.828427
min     1.000000   2.000000   3.000000  4.000000
25%     3.000000   4.000000   5.250000  5.000000
50%     5.000000   6.000000   7.500000  6.000000
75%     7.500000   8.500000   9.750000  7.000000
max    10.000000  11.000000  12.000000  8.000000
```

このDataFrameには２つの欠損値が見つかりました。
DataFrameが巨大なとき目視で確認するにも限度があるため、欠損データを`isnull()`関数で探してみます。

```py
print(df.isnull(),"\n")
print(df.isnull().sum())
```

```console
       A      B      C     D 
0  False  False  False  False
1  False  False   True  False
2  False  False  False   True 

A     0
B     0
C     1
D     1
dtype: int64
```
これでC列とD列に欠損値があることがわかりました。
今回はこれらを同カラムの他の値の中央値(median)で補完していきます。
補完するときは`fillna()関数`を使います。

```py
df["C"]=df["C"].fillna(df["C"].median())
df["D"]=df["D"].fillna(df["D"].median())
print(df.isnull().sum())
```

```console
A    0
B    0
C    0
D    0
dtype: int64
```
これで欠損値が埋まりました。

---
一方、欠損値のある行や列を削除することも`dropna()メソッド`で可能です。

```py
csv_data = '''A,B,C,D
              1.0,2.0,3.0,4.0
              5.0,6.0,,8.0
              10.0,11.0,12.0,'''
df = pd.read_csv(StringIO(csv_data))
print(df.dropna(),"\n")
print(df.dropna(axis=1))
```

```console
     A    B    C    D
0  1.0  2.0  3.0  4.0 

      A     B
0   1.0   2.0
1   5.0   6.0
2  10.0  11.0
```

`dropna()メソッド`では引数に何も入れない場合は行(axis=0),軸を引数に入れることで軸方向に欠損値の含まれる列を消去します。

---

>課題　ここから

https://www.kaggle.com/
kaggleからデータセットを取ってきます。


![2020-03-19 (1)_LI.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/758d4339-8190-3ee5-db76-2b3ebdb686ef.jpeg)
My　accountに入ります。

<img width="1280" alt="スクリーンショット 2020-03-20 0.46.12.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/740aa85b-d587-385d-f9d4-24291342d950.png">

|Create New API token| 
---

をクリック

Kaggle.jsonファイルが保存されてと思うので。Google Colabの方に移ります。

以下を入力します。

```py
from google.colab import files
files.upload()
!mkdir -p ~/.kaggle
!mv kaggle.json ~/.kaggle/
!chmod 600 /root/.kaggle/kaggle.json
!pip install kaggle
!kaggle competitions download -c titanic
```

そうすると`files.upload()`が起動して
<img width="428" alt="スクリーンショット 2020-03-20 0.56.13.png" src="https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/258290bd-1a28-1142-7ab9-d8f2039951f9.png">
このようなファイル選択欄が出てくるので、そこに先ほど保存したKaggle.jsonファイルを選択します。
そうするとその下のコマンドでkaggleフォルダにtitanicのデータが保存されるのでそのトレインデータを使います。

```py
df = pd.read_csv('/content/train.csv',header=None)
print(df.tail(n=10))
```

```console

     0  1  2   ...       9     10 11
882  882  0  3  ...   7.8958   NaN  S
883  883  0  3  ...  10.5167   NaN  S
884  884  0  2  ...     10.5   NaN  S
885  885  0  3  ...     7.05   NaN  S
886  886  0  3  ...   29.125   NaN  Q
887  887  0  2  ...       13   NaN  S
888  888  1  1  ...       30   B42  S
889  889  0  3  ...    23.45   NaN  S
890  890  1  1  ...       30  C148  C
891  891  0  3  ...     7.75   NaN  Q

[10 rows x 12 columns ]
```

1. 欠損値が含まれる列を探しましょう。
2. 欠損値のある列で数値を示すものは中央値で補完しましょう。
3. カラムがEmbarkedの列の欠損値にはSを入れましょう(最頻値が"S"でした)。
4. 残りの欠損数の多い列は消去しましょう。
5. 要素が文字列の列のうちはSexカラムとEmbarkedカラムの要素を数値へダミー変換しましょう。
ただし　Sexは「male」「female」の2つのカテゴリー文字列、Embarkedはは「S」「C」「Q」の3つの文字列となります。

　



##Matplotlib
**Matplotlib**は静的、アニメーション、およびインタラクティブな視覚化を作成するための包括的なライブラリです。
何事も可視化は割と大切な作業です。
文字列だけでは見えづらいデータも可視化すれば相関が見えてくるものも多いです。
では早速インポートしていきましょう。

```py
import matplotlib.pyplot as plt
```

簡単な数直線を書いていきましょう。

```py
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/68c5faf7-82c4-15d9-3463-9c9184c4adbf.png)

`plot関数`でデータをプロットしていきます。
今回はx軸に相当するものを明示的に記載していませんが、単一の配列を指定する場合は自動でy値のシーケンスとみなしx値を生成します。
`ylabel関数`でy軸のラベル名を指定できます。
x対yのプロットはこのように行います。

```py

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel('x-axis')
plt.ylabel('y-axis')
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/738b5bc1-b923-9b5e-0e06-babe419c6812.png)

もちろん散布図もできます。

```py
import numpy as np
t = np.arange(0., 5., 0.2)
# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)
# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bX', t, t**3, 'g^',t,t**4,'y*')
plt.show()
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/70bcc6fd-cd2c-a4f5-2b18-07c9918e31cb.png)


ここで`r--`,`bs`,`g^`,`y-`などはプロットの設定で最初の英字１文字が色の略記号です。
簡略表記は{b(lue),g(ray),r(ed),c(ian),m(asenta),y(ellow),k(ey-plate黒),w(hite)}の８種類があります。
そのほかの色を試してみたい方は
https://qiita.com/KntKnk0328/items/5ef40d9e77308dd0d0a4
こちらを参照してください。
また、プロットの線種は以下のようなものがあります。

|記号|線種|
---|---
|:|点線|
|-|実線|
|-.|一点鎖線|
|--|破線|

マーカーも様々です。

|記号|マーカー|記号|マーカー|
---|---|---|---
|.|点|*|星|
|,|ピクセル|1|Y|
|o|丸|2|Y(↓)|
|v|下三角形|3|Y(←)|
|^|上三角形|4|(→)|
|<|左三角形|＋|+|
|>|右三角形|x|x|
|s|四角形|X|x(filled)|
|p|五角形|D|ひし形|
|h|六角形|d|細いひし形|
|8|八角形|　|マーカーなし|

---
###3D描画、等高線の描画
3次元空間のプロットを等高線表示したり３Dグラフで表示したりすることも可能です。

```py

from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

#格子点の作成
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
#各点における関数の値の計算
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

fig_1 = plt.figure()
ax = Axes3D(fig_1)
ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.viridis)
fig_2, ax_2 = plt.subplots(figsize=(8, 6))
#等高線の表示
contour = ax_2.contourf(X, Y, Z)
#カラーバーの表示
fig_2.colorbar(contour)
plt.show()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/aafc6b81-6301-79f5-2f38-43ee3b7bad19.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/52b49384-9b2c-dccf-15f3-f2db5b5e5ff8.png)


まずnumpy.meshgrid関数で格子点を作成します。
そのあと格子点上の関数の値を計算します。
今回描画しているのはZです。
3Dグラフの描画は引数に`plot_surface(X,Y,Z)`と渡すことで行われます。
その他の引数の意味は

|パラメータ名|意味|
|---|---|
|rstride|行のとび幅|
|cstride|列のとび幅|
|rcount|行の要素で使う最大数|
|ccount|列の要素で使う最大数|
|color|表面の色|
|cmap|表面のカラーマップ|
|facecolor|個々のパッチの色|
|norm|マップの値から色へ変換する際の標準化インスタンス|
|vmax|マップの最大値|
|vmin|マップの最小値|
|shade|影の有無|

等高線は`countourf関数`を使っ描画します。
また、等高線にたいする値の対応表(カラーバー)は`colorbar関数`に等高線を渡すことで表示されます。　


>課題
>>好きな３次元データを描画してみよう！

---



###囲まれた領域に色をつける
2つ以上の関数があった時にできる領域の塗りつぶしなどは`fill_between関数`が対応しています。

```py
x = np.arange(0,5,0.01)
y1 = np.sin(x) 
y2 = np.cos(x)
plt.plot(x,y1,color='k',label="sin")
plt.plot(x,y2,color='r',label="cos")
plt.legend()
plt.fill_between(x,y1,y2,color='b',alpha = 0.1)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/eed44466-7b47-7ceb-90ee-a6ba66b27e88.png)





---

###画像または２次元配列を表示する
既存の画像や各ピクセルの値が入った２次元配列などを表示するときは、`imshow関数`を使います。
第一引数に配列オブジェクトやPILイメージを渡すことで画像が表示されます。

好きな画像をjpeg形式で保存してきて左のファイルから


![Inked2020-03-18_LI.jpg](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/30b94426-14e1-d5e5-581c-a16c16d6a1ef.jpeg)

アップロードをします。

![2020-03-18 (4).png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/7872358f-21d1-e041-bcda-d2538bbf8922.png)



```py
import matplotlib.image as mpimg
img = mpimg.imread("〇〇.jpg")
plt.imshow(img)
```

`〇〇.jpg`のところにファイル名を入れれば画像が表示されるはずです。

配列の表示の場合は以下のように行います。
２次元の乱数配列をプロットしてみます。

```py
x = np.random.random((100, 100))
plt.imshow(x, cmap="plasma")
plt.colorbar()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/462398/358ad2c2-21d0-3b76-c202-f7d31380b1ea.png)