numpyチュートリアル（ビギナーズ向け）

<font color=blue size=4>本書は、[numpyチュートリアル（ビギナーズ向け）](https://numpy.org/doc/stable/user/absolute_beginners.html) を翻訳及び加筆<font size=1>（※）</font>でしたものです。</font>

※わかりにくいと思われる箇所の補足や、ipythonでコードが実行できるようにテストデータを作成するコードの追加等を実施しています

本コードを動かしながら学べるようにコードをGithubに公開しました（2022年1月）。
ご活用ください。

<center>https://qiita.com/DeepTama/items/e943baaa0270a4ed22f3</center>

&nbsp;
同様にPythonのチュートリアルを動かしながら学習できるようにGithubに公開しました。

<https://qiita.com/DeepTama/items/4bf9e3139471918eb0fe>


![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/0b0bd29d-77ad-65c6-2e7b-f50942f7c7c6.png)
© Copyright 2008-2021, The NumPy community.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

:::note warn
筆者が所属するNPO法人の勉強用にメモしたものですので、誤りや不足、加筆修正すべきことろがありましたらご指摘ください。継続してブラッシュアップしていきます。
:::

pandasのチュートリアルの翻訳も実施しています。合わせてご参照ください。

https://qiita.com/DeepTama/items/983dcee3d522f4e9f07a

@2021 NPO法人AI開発推進協会

# <font color="blue">NumPyへようこそ!</font>
  
NumPy (Numerical Python) は、科学や工学のほぼすべての分野で使用されているオープンソースの Python ライブラリです。これは Python で数値データを扱うための普遍的な標準であり、科学的な Python と PyData のエコシステムの中核をなしています。NumPyのユーザーは、初心者のコーダーから、最先端の科学や産業の研究開発を行っている経験豊富な研究者まで、誰もが参加しています。NumPy APIは 
 Pandas、SciPy、Matplotlib、scikit-learn、scikit-image、その他ほとんどのデータサイエンスや科学的Pythonパッケージで幅広く使用されています。
  
NumPyライブラリには多次元配列と行列データ構造が含まれています（これについては後のセクションで詳しく説明します）。均質な n 次元配列オブジェクトである ndarray と、その上で効率的に操作するためのメソッドを提供します。NumPy は配列に対する様々な数学的操作を行うために使用できます。 <span style="color: red; ">配列や行列を使った効率的な計算を保証する強力なデータ構造をPythonに追加し、これらの配列や行列を操作する高レベルの数学関数の膨大なライブラリを提供します</span>。
  
NumPyについての詳細は[こちら](https://numpy.org/devdocs/user/whatisnumpy.html#whatisnumpy)!

# <font color="blue">NumPyのインストール</font>
NumPyをインストールするには、科学的向けPythonディストリビューションを使うことを強くお勧めします。お使いのオペレーティングシステムにNumPyをインストールするための完全な手順をお探しの場合は、[ここですべての詳細を見つける](https://www.scipy.org/install.html)ことができます。

すでにPythonをお持ちの方は、下記のコマンドを使ってNumPyをインストールしておきましょう。

```python
conda install numpy
```
or 

```python
pip install numpy
```

もしあなたがまだ Python を持っていないのであれば、Anaconda の使用を検討してみてはいかがでしょうか。これが一番簡単に始められる方法です。このディストリビューションの良いところは、NumPy や pandas, Scikit-Learn などのようなデータ解析に使用する主要なパッケージを別途インストールする必要がないことです。
  
インストールの詳細は[SciPy](https://www.scipy.org/)の[Installationセクション](https://www.scipy.org/install.html)
にあります。

# <font color="blue">NumPyのインポート方法</font>  
パッケージやライブラリをコードの中で使いたいときはいつでも、まずそれにアクセスできるようにする必要があります。

NumPy と NumPy で利用できるすべての関数を使い始めるには、NumPy をインポートする必要があります。これは、インポート文で簡単にできます。  

```python
import numpy as np
```
  
><font color="gray"> [補足]　ipythonで学習する際の操作に対する補足
>
+ ipythonで学習する際（途中からの再開を含む）は、以下のimport文を毎回実施してください。   
+ テキスト部分は「↓」ボタンでスクロール、各コマンドラインは「shift]+「retutn」キーで順番に実行してください。   
+ テキスト画面を編集で開いた場合は「shift]+「retutn」で閉じてください。  
+ 誤ってテキストを編集した場合は、「Ctrl」+「z」で取り消すことができます。  
+ 追加で動作確認したい場合は任意の場所でセル（メニューバーのInsert（挿入））を追加して試してください。
</font>

numpy を <font color="blue">np </font> と短縮することで時間を節約し、そしてまたコードを標準化しておくことで、あなたのコードを使って作業している誰もが簡単に理解して実行できるようにしています。

# <font color="blue">コード例の読みかた</font>

多くのコードを含むチュートリアルを読むことにまだ慣れていない場合、このようなコードブロックをどのように解釈すればいいのかわからないかもしれません。

```python
a = np.arange(6)
a2 = a[np.newaxis, :]
a2.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/4eb45c7e-4840-2959-bd58-be54d9f2495a.png)

このスタイルに慣れていない人でも、とてもわかりやすいと思います。  
もし `>>>` が見えていたら、あなたは入力、つまりあなたが入力するコードを見ていることになります。前に `>>>` がないものはすべて出力、つまりコードを実行した結果です。これはpythonをコマンドラインで実行しているときに表示されるスタイルですが、IPythonを使っている場合は違うスタイルが表示されるかもしれません。
<font color="gray">［補足］IPythonを使う場合、入力欄には `In [ ]` または `In[n]` 、出力欄は `Out[n]` が左端に表示されます（nは実行順を示す数字です）。</font>

# <font color="blue">PythonのリストとNumPyの配列の違いなんですか？</font>

NumPyは、配列を作成したり、その中の数値データを操作したりするための高速かつ効率的な方法を提供してくれます。<font color="red">Pythonのリストは1つのリスト内に異なるデータ型を含むことができますが、NumPyの配列内のすべての要素は同種でなければなりません</font>。もし配列が同種でなければ、配列上で実行されることを意図した数学的な操作は非常に非効率的です。

### なぜNumPyを使うのか？

<font color="red">NumPyの配列はPythonのリストよりも高速でコンパクトです。配列はメモリ消費量が少なくて便利です</font>。NumPyはデータを格納するのに使用するメモリがかなり少なく、データ型を指定する仕組みを提供しています。これにより、コードをさらに最適化することができます。

# <font color="blue">配列とは何ですか？</font>
<font color="red">配列はNumPyライブラリの中心的なデータ構造です</font>。配列は値のグリッドであり、生データに関する情報、要素の探し方、要素の解釈方法などが含まれています。要素のグリッドを持ち、様々な方法でインデックスを作成することができます。要素はすべて同じ型で、配列のdtypeと表されます。

<font color="red">配列は，非負の整数のタプル，ブーリアン，別の配列，または整数によってインデックスを作成することができます。配列のランク（rank）は，次元数です。配列の形状（shape）は，各次元に沿った配列のサイズを与える整数のタプルです</font>。

NumPyの配列を初期化する方法の1つとしてPythonのリストを使います。2次元以上のデータは入れ子になったリストを使います。

例えば，以下のようになります。

```python
a = np.array([1, 2, 3, 4, 5, 6])
```

or

```python
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
```

配列の要素には角括弧を使ってアクセスします。要素にアクセスするときは、<font color="red">NumPyのインデックスは0から始まる</font>ことを覚えておいてください。 つまり、配列の最初の要素にアクセスしたい場合は、要素 "0 "にアクセスすることになります。

```python
print(a[0])
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/4997d0d3-93a1-faf8-e78f-86b9140da0fa.png)

# <font color="blue">配列の詳細情報</font>
  
1次元配列、2次元配列、ndarray、ベクトル、行列について説明します。

たまに「NDARRAY」と呼ばれる配列を耳にすることがありますが、これは「N次元配列」の略語です。N次元配列とは、単純に任意の次元数の配列のことです。**1-D**、**１次元配列**, **2-D**, **２次元配列**などと呼ばれることもあります。NumPyのndarrayクラスは、行列とベクトルの両方を表現するのに使われます。<font color="red">ベクトルは1次元の配列（行ベクトルと列ベクトルの違いはありません）であり，行列は2次元の配列を指します。3次元またはそれ以上の次元の配列では，テンソル</font>という用語もよく使われます。
<font color=gray>［補足］ベクトル（1次元の配列）は１次元テンソル、行列（２次元の配列）は２次元テンソルとも表現されます。

# <font color="blue">配列の属性とは何ですか？</font>

配列とは、通常、同じ種類＆サイズの項目の固定サイズの容器です。配列の次元と項目の数は、その形状によって定義されます。配列の形状は、各次元のサイズを指定する非負の整数のタプルです。

NumPyでは、<font color="red">次元は軸（axis）と呼ばれます</font>。つまり、次のような2次元配列があれば、以下のようになります。

```python
[[0., 0., 0.],
 [1., 1., 1.]]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/36619805-0fac-5cf0-1e3a-40d43ce910f4.png)

この配列には2つの軸があります。1つ目の軸の長さは2、2つ目の軸の長さは3です。

他のPythonコンテナオブジェクトと同様に、配列の内容はインデックスを作成したりスライスしたりすることでアクセスしたり変更したりすることができます。典型的なコンテナオブジェクトとは異なり、異なる配列は同じデータを共有することができるので、ある配列で行われた変更は別の配列でも見ることができます。

配列の属性は、配列自体に内在する情報を反映しています。新しい配列を作成せずに配列のプロパティを取得したり設定したりする必要がある場合は、その属性を使用して配列にアクセスすることができます。

配列の属性についての詳細は[こちら](https://numpy.org/devdocs/reference/arrays.ndarray.html#arrays-ndarray)を、配列オブジェクトについては[こちら](https://numpy.org/devdocs/reference/arrays.html#arrays)をご覧ください。

# <font color="blue">基本的な配列の作り方</font>
ここでは，np.array()，np.zeros()，np.ones()，np.empty()，np.arange()，np.linspace()，dtypeを扱います．  
***  
<font color="red">NumPy配列を作成するには、関数np.array()を使用します</font>。

単純な配列を作成するために必要なのは、リストを渡すだけです。必要に応じて、リストに含まれるデータの型を指定することもできます。データ型についての詳細は[こちら](https://numpy.org/devdocs/reference/arrays.dtypes.html#arrays-dtypes)をご覧ください。

```python
import numpy as np
a = np.array([1, 2, 3])
```

このようにして配列を可視化することができます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/1e22742e-2e98-f800-2aa0-2c23dfcab9df.png)

これらの可視化は，概念を単純化し，NumPyの概念と力学の基本的な理解を得るためのものであることに注意してください．配列や配列操作はここで紹介したものよりもはるかに複雑です。

要素の並びから配列を作成する以外にも、0で埋め尽くされた配列を簡単に作成することができます。

```python
np.zeros(2)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/39dbeb30-8610-f674-b6ef-6f1734e253dd.png)

または、<font color="red">1を埋めた配列を作成する</font>こともできます。

```python
np.ones(2)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/10f2666e-f219-f26c-6aab-8d463fd1be0f.png)

空の配列でも良いのです! 関数 empty は、最初の内容がランダムでメモリの状態に依存する配列を作成します。<font color="red">ゼロよりも空の配列を使う理由は、速度を上げる</font>ためです。
ただ、後ですべての要素を必ず埋めてください。

```python
# Create an empty array with 2 elements
np.empty(2)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/0b0ddd30-3574-fd85-4c47-a5c939cbfa7b.png)
<font color=gray>［補足］この出力はメモリの状態に依存するため一定ではありません</font>

要素の範囲で配列を作成することができます。

```python
np.arange(4)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/fe3764fa-30e1-0d39-d951-632e54c172bf.png)
さらには、等間隔の範囲を含む配列も作成できます。これを行うには、最初の番号、最後の番号、間隔を指定します。  
<font color="red">［補足］最後の番号(n)は含まず、n-1までになります</font>

```python
np.arange(2, 9, 2)     #［補足］2から8(9-1)まで間隔２で作成
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/ec2f28f4-00a6-6614-f3b6-8f617bddb24f.png)

np.linspace() を使用して、指定した間隔で直線的に間隔を置いた値を持つ配列を作成することもできます。  
<font color="red">［補足］linspace()では、最後の番号(n)を含みます</font>

```python
np.linspace(0, 10, num=5)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/e73392a9-bd8f-bc7a-cd89-13674abf9631.png)

### データタイプの指定

<font color="red">既定のデータ型は浮動小数点 (np.float64) です</font>が、dtype キーワードを使用して、どのデータ型を使用するかを明示的に指定できます。

```python
x = np.ones(2, dtype=np.int64)
x
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/158e8c86-1f0d-703a-25a2-f5c82a8753ae.png)

配列の作成についての詳細はこちらを[参照](https://numpy.org/devdocs/user/quickstart.html#quickstart-array-creation)してください。

# <font color="blue">要素の追加、削除、ソート</font>  
  
このセクションでは、np.sort()、np.concatenate()について説明します。  

要素のソートはnp.sort()で簡単にできます。関数を呼び出すときに軸、種類、順序を指定できます。

下記の配列で始めると、

```python
arr = np.array([2, 1, 5, 3, 7, 4, 6, 8])
```

こうして昇順に素早く並び替えることができます。

```python
np.sort(arr)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/31ac6975-b464-f05c-f8f5-57ac189d6b36.png)

配列のソートされたコピーを返す sort に加えて、次のようなものが使えます。

- [argsort](https://numpy.org/devdocs/reference/generated/numpy.argsort.html#numpy.argsort) 、指定した軸に沿った間接的なソートです。
  
- [lexsort](https://numpy.org/devdocs/reference/generated/numpy.lexsort.html#numpy.lexsort)、複数のキーに対して間接的に安定したソートを行う 。
  
- [searchsorted](https://numpy.org/devdocs/reference/generated/numpy.searchsorted.html#numpy.searchsorted) 、ソートされた配列の要素を見つけます。
  
- [partition](https://numpy.org/devdocs/reference/generated/numpy.partition.html#numpy.partition)、これは部分的なソートです。
  
配列のソートについての詳細は、 [sort](https://numpy.org/devdocs/reference/generated/numpy.sort.html#numpy.sort) を参照してください。
  
下記のこれらの配列から始めると、

```python
a = np.array([1, 2, 3, 4])
b = np.array([5, 6, 7, 8])
```

<font color="red">np.concatenate()で連結することができます</font>。

```python
np.concatenate((a, b))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/5652ee54-a214-8a44-1c55-ea305369c319.png)

あるいは、これらの配列から始めると、

```python
x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6]])
```

下記で連結ができます。

```python
np.concatenate((x, y), axis=0)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/780f2590-2be2-f394-98ab-b584da47902e.png)

配列から要素を削除するには、インデックスを使って保持したい要素を選択するのが簡単です。

連結についての詳細は [concatenate](https://numpy.org/devdocs/reference/generated/numpy.concatenate.html#numpy.concatenate) を参照してください。

# <font color="blue">配列の形状やサイズを知るにはどうすればいいのでしょうか？</font>    
このセクションでは、ndarray.ndim、ndarray.size、ndarray.shapeを扱います。

<font color="red">ndarray.ndim は配列の軸数、つまり次元を教えてくれます</font>。

<font color="red">ndarray.size は配列の要素の総数を示します。これは配列の形状の要素の積です</font>。

<font color="red">ndarray.shape は、配列の各次元に沿って格納されている要素の数を示す整数のタプルを表示します</font>。例えば、2行3列の2次元配列を作成した場合、配列の形状は(2, 3)となります。

例えば、以下のような配列を作成したとします。

```python
array_example = np.array([[[0, 1, 2, 3],
                          [4, 5, 6, 7]],
                          
                          [[0, 1, 2, 3],
                           [4, 5, 6, 7]],
                          
                          [[0 ,1 ,2, 3],
                           [4, 5, 6, 7]]])
```

配列の次元数を調べるには、次のように実行します。

```python
array_example.ndim
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/95a1980b-4c71-5c08-ef39-f44a15dbfb11.png)

配列の総要素数を求めるには，次のように実行します。

```python
array_example.size
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/4d0955b5-d9fa-1aa2-afb7-b41033ddad6e.png)

そして，配列の形状を求めるには，次のように実行します。

```python
array_example.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/9ba7a112-d5dc-c776-7806-27a4a1350949.png)

# <font color="blue">配列のリシェイプはできますか？</font>  
  
この節では arr.reshape() を扱います。

**できます!**

<font color="red">arr.reshape() を使用すると、データを変更することなく配列に新しい形を与えることができます</font>。ただ、reshape メソッドを使用する際には、生成したい配列の要素数が元の配列と同じである必要があることを覚えておいてください。12 個の要素を持つ配列から始めた場合、新しい配列も合計 12 個の要素を持つようにしなければなりません。

以下の配列で始めた場合、

```python
a = np.arange(6)
print(a)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/ca0fc49d-fc6b-044b-b023-1112d7b714dc.png)

reshape() を使用して、配列の形状を変更することができます。たとえば、この配列を 3 行 2 列の配列にリシェイプすることができます。

```python
b = a.reshape(3, 2)
print(b)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/22d7e886-1081-346c-4e07-f8f54ac5b664.png)

np.reshapeでは、いくつかのオプションのパラメータを指定することができます。

```python
np.reshape(a, newshape=(1, 6), order='C')
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/d0426383-51b3-06bf-bb7e-8ac1919b9aed.png)

a はリシェイプされる配列です。  
  
newshape：新しい形状を指定します。整数か整数のタプルを指定することができます。整数を指定した場合、結果はその長さの配列になります。形状は元の形状と互換性のあるものでなければなりません。
  
order：C は C ライクなインデックス順で要素を読み書きすることを意味し、F は Fortran ライクなインデックス順で要素を読み書きすることを意味し、A は a がメモリ内で Fortran が連続している場合は Fortran ライクなインデックス順で要素を読み書きすることを意味し、そうでない場合は C ライクなインデックス順で要素を読み書きすることを意味します。(これはオプションのパラメータであり、指定する必要はありません)。

CとFortranの順序についてもっと知りたい場合は、[ここで](https://numpy.org/devdocs/reference/internals.html#numpy-internals)NumPy配列の内部組織についての詳細を読むことができます。基本的に、CとFortranの順序は、配列がメモリに格納されている順序にインデックスがどのように対応するかに関係しています。Fortranでは、メモリに格納されている2次元配列の要素を移動するとき、最初のインデックスが最も急速に変化するインデックスです。最初のインデックスが変化しながら次の行に移動すると、行列は1列ずつ格納されます。これがFortranがカラムメジャー言語として考えられている理由です。一方、C言語では、最後のインデックスが最も早く変化します。行列は行単位で格納されるので、行メジャー言語になります。CとFortranのどちらをどうするかは、インデックスの規則を守ることと、データの並び替えをしないことのどちらが重要かにかかっています。  
  
形状操作については[こちら](https://numpy.org/devdocs/user/quickstart.html#quickstart-shape-manipulation)をご覧ください。

# <font color="blue">1次元配列を2次元配列に変換する方法（配列に新しい軸を追加する方法）</font>
ここでは、np.newaxis、np.expand_dimsを扱います。

<font color="red">np.newaxis と np.expand_dims を使用して、既存の配列の寸法を増やすことができます</font>。

np.newaxisを使用すると、1回使用すると配列の次元が1次元増加します。これは、1次元配列が2次元配列になり、2次元配列が3次元配列になることを意味します。

例えば、以下の配列から始めた場合、

```python
a = np.array([1, 2, 3, 4, 5, 6])
a.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/7f6a6af8-74a2-a8a9-4ea0-8f798b8b240a.png)

np.newaxisを使用して新しい軸を追加することができます。

```python
a2 = a[np.newaxis, :]
a2.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/9e4c1f45-b92e-96c2-cc46-63adc485df8c.png)

np.newaxis を使用して，明示的に 1 次元配列を行ベクトルまたは列ベクトルに変換することができます．例えば，1 次元に沿って軸を挿入することで，1 次元配列を行ベクトルに変換することができます。

```python
row_vector = a[np.newaxis, :]
row_vector.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/433a1c91-c909-b4f5-e738-4fe7f6c258cb.png)

または、列ベクトルの場合は、2次元に沿って軸を挿入することができます。

```python
col_vector = a[:, np.newaxis]
col_vector.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/dd5d11cb-a5f3-ae7f-5102-6ee62e808858.png)

また、np.expand_dimsで指定した位置に新しい軸を挿入して配列を拡張することもできます。  
  
例えば、以下ような配列から始めると、

```python
a = np.array([1, 2, 3, 4, 5, 6])
a.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/d0717518-8f97-9eba-afbd-de485d6279ee.png)

np.expand_dimsを使ってインデックス位置1に軸を追加することができます。

```python
b = np.expand_dims(a, axis=1)
b.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/294dd846-e3bb-13c1-6c46-9abe2b2643d9.png)

インデックス位置0に軸を追加することができます。

```
c = np.expand_dims(a, axis=0)
c.shape
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/b31e6ee1-8433-0a48-b293-40b4c3713f87.png)

newaxisについての詳細は[こちら](https://numpy.org/devdocs/reference/arrays.indexing.html#arrays-indexing)を、expand_dimsについては[expand_dims](https://numpy.org/devdocs/reference/generated/numpy.expand_dims.html#numpy.expand_dims)を参照してください。

# <font color="blue">インデックスとスライス</font>  
  
Pythonのリストをスライスするのと同じように、<font color="red">NumPyの配列をインデックス化してスライスすることができます</font>。

```python
data = np.array([1, 2, 3])
data[1]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/2ef7870e-3219-f4a5-40fa-081c14ad37d9.png)

```python
data[0:2]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/70cbb679-5f48-7f57-5b7f-e8aaa9c223c9.png)

```python
data[1:]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/db44eb90-23c2-dd0f-4db0-451589537150.png)

```python
data[-2:]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/d452cdef-e873-787d-29d8-97dbcb36b9ae.png)

このように可視化することができます。 

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/67837a67-adff-8e3c-cebd-9f4d2054b7a9.png)

配列の一部や特定の配列要素を取り出して、さらなる分析や追加の操作に使用したい場合もあるでしょう。そのためには、配列のサブセット、スライス、インデックスを作成する必要があります。
　　
配列から特定の条件を満たす値を選択したい場合は、NumPyを使えば簡単です。

例えば、次のような配列から始めると、

```python
a = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
```
配列内の5未満の値をすべて簡単に表示することができます。

```
print(a[a < 5])
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/31316938-2d28-64f9-de22-eae4c9399cf4.png)

また、例えば5以上の数値を選択して、その条件を使って配列のインデックスを作成することもできます。

```python
five_up = (a >= 5)
print(a[five_up])

#[補足] five_upはbooleanのインデックスになります
#   [[False False False False]
#   [ True  True  True  True]
#   [ True  True  True  True]]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/b8ec0574-ed33-e544-8f2d-dbb12de42890.png)


2で割り切れる要素を選択することができます。

```python
divisible_by_2 = a[a%2==0]
print(divisible_by_2)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/d13241a9-482d-6215-d7c9-fe6699139fcc.png)

または、& 演算子と｜演算子を使って2つの条件を満たす要素を選択することができます。

```python
c = a[(a > 2) & (a < 11)]
print(c)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/a63a9c6b-18a3-2565-e03e-903e86c6d760.png)

また、論理演算子 & や | を使用して、配列内の値が特定の条件を満たすかどうかを指定するブール値を返すこともできます。これは、名前やその他のカテゴリカルな値を含む配列で便利です。

```python
five_up = (a > 5) | (a == 5)
print(five_up)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/dfc8bcab-d554-7d87-c6a4-c86103d3d227.png)

np.nonzero() を使用して、配列の要素やインデックスを選択することもできます。  
  
下記の配列から始めて、

```python
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
```

np.nonzero()を使用して、例えば5未満の要素のインデックスを表示することができます。

```python
b = np.nonzero(a < 5)
print(b)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/82c715cd-0769-94ca-d779-1882c9c68c25.png)

この例では、配列のタプルが返されました。
各次元に対して 1 つの配列が返されました。最初の配列は、これの値が見つかった行のインデックスを表し、2 番目の配列は、値が見つかった列のインデックスを表します。
  
<font color="red">要素が存在する座標のリストを生成したい場合は，zip関数を使用して配列のリストを繰り返し処理し，それを表示することができます</font>。例えば、以下のようになります。

```python
list_of_coordinates = list(zip(b[0], b[1]))

for coord in list_of_coordinates:
    print(coord)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/bae60f6a-0f10-8a23-4c4f-f0a2660a6238.png)

np.nonzero()を使用して、配列の要素が5未満のものを表示することもできます。

```python
print(a[b])
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/d6345d72-090c-73c9-7663-a7e0c30717b1.png)

探している要素が配列内に存在しない場合、返されるインデックスの配列は空となります。例えば、以下のようになります。

```python
not_there = np.nonzero(a == 42)
print(not_there)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/dda949c1-6489-2f9c-98b6-3fd05871836b.png)

インデックス作成とスライスについては、[ここ](https://numpy.org/devdocs/user/quickstart.html#quickstart-indexing-slicing-and-iterating)と[ここ](https://numpy.org/devdocs/user/basics.indexing.html#basics-indexing)を参照してください。  
  
nonzero 関数の使用についての詳細は[nonzero](https://numpy.org/devdocs/reference/generated/numpy.nonzero.html#numpy.nonzero)を参照してください。

# <font color=blue>既存のデータから配列を作成する方法</font>

このセクションでは、スライスとインデックス作成、np.vstack()、np.hstack()、np.hsplit()、.view()、copy()を扱います。

<font color="red">既存の配列の一部から新しい配列を作成することが簡単にできます</font>。  
  
このような配列があるとしましょう。  

```python
a = np.array([1,  2,  3,  4,  5,  6,  7,  8,  9, 10])
```

配列をスライスしたい場所を指定することで、いつでも配列の一部から新しい配列を作成することができます。

```python
arr1 = a[3:8]
arr1
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/db398722-1da8-a4d7-0f25-b378c48701d7.png)

ここでは、インデックス位置3からインデックス位置8までの配列の部分を取得しています。  
  
また、<font color="red">既存の2つの配列を縦にも横にも重ねることができます</font>。2 つの配列 a1 と a2 があるとしましょう。

```python
a1 = np.array([[1, 1],
               [2, 2]])
a2 = np.array([[3, 3],
               [4, 4]])
```

vstackで縦に積み上げることができます。

```python
np.vstack((a1, a2))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/b1b58cac-dc0e-e945-d168-ddb7afdad136.png)

または hstack で水平にスタックします。

```python
np.hstack((a1, a2))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/bd54c31a-368f-c8f9-8cc0-88065fa5c64f.png)

hsplit を使用して、配列をいくつかの小さな配列に分割することができます。返される配列の数や分割後の列を指定することができます。

次のような配列があるとしましょう。

```python
x = np.arange(1, 25).reshape(2, 12)
x
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/a4967ac3-f001-4e15-3ee6-1b9edfe218f2.png)

この配列を3つの均等な形の配列に分割したい場合は、以下のように実行します。

```python
np.hsplit(x, 3)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/69a1b4df-c91e-59d5-0746-acdec199540b.png)

3列目及び４列目で配列を分割する場合は、以下を実行します。

```python
np.hsplit(x, (3, 4))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/333939ae-bf37-07e9-4a53-dc2136b30c81.png)

<font color="gray">[補足]行方向に配列を分割するにはvsplit関数を使用します</font>

配列のスタッキングと分割については[こちら](https://numpy.org/devdocs/user/quickstart.html#quickstart-stacking-arrays)をご覧ください。

<font color="red">viewメソッドを使って、元の配列と同じデータを見る新しい配列オブジェクトを作成することができます（浅いコピー）</font>。
<font color="gray">[補足]浅いコピーではメモリ上は同一エリアを使います</font>

ビューはNumPyの重要な概念です。 NumPyの関数は、インデックスやスライスなどの操作と同様に、可能な限りビューを返します。これは<font color="red">メモリの節約になり、そして高速です（データのコピーを作成する必要がありません）。しかし、注意しなければならないことがあります</font> - <font color="red">ビュー内のデータを変更すると、元の配列も変更されてしまいます</font>。
  
以下の配列を作成したとしましょう。

```python
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
```

ここで、aをスライスして配列b1を作成し、b1の最初の要素を修正します。これにより、aの対応する要素も変更されます!

```python
b1 = a[0, :]
b1
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/588d4e54-1985-40e2-6133-8c1194e18c6f.png)

```python
b1[0] = 99
b1
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/e9ebaae1-0864-5521-b657-5befe30ee9c2.png)

```python
a
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/659305d7-ef0b-5d3a-26e0-9992885029e5.png)

<font color="red">copy メソッドを使用すると、配列とそのデータの完全なコピーを作成します (深いコピー)</font>。    
  
<font color="gray">[補足]深いコピーでは、（浅いコピーはメモリ上は同一であるのにくらべ）メモリ上も別エリアを確保してコピーします（＝別エリア）</font>    
  
これを配列に使用するには、以下のように実行します。  

```python
b2 = a.copy()
```
コピーやビューについての詳細は[こちら](https://numpy.org/devdocs/user/quickstart.html#quickstart-copies-and-views)をご覧ください。

# <font color="blue">基本的な配列操作</font>  
足し算、引き算、掛け算、割り算などについて説明します。

配列を作成したら、それを使って作業を始めることができます。例えば、"data" と "ones" という 2 つの配列を作成したとしましょう。  

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/5e73424d-b2d9-8af8-9860-0375a4c3860c.png)

プラス記号と一緒に配列を追加することができます。

```python
data = np.array([1, 2])
ones = np.ones(2, dtype=int)
data + ones
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/4fc73768-3860-006e-12cf-05560f402cb0.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/844cf7d3-50a3-0273-e090-85f45658d24e.png)

もちろん、足し算だけではありません!

```python
data - ones
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/42917a0e-4312-bc68-b4de-585c82f47815.png)

```python
data * data
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/04957c3d-cf8d-37d3-4581-6afe40d0df99.png)

```python
data / data
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/e2c9fc9e-d2fd-e730-dd30-d5b45cf35acc.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/30e92246-42e3-462f-f5e7-bb70b68fee2a.png)

NumPyの基本的な操作は簡単です。配列の要素の和を求めるには，sum()を使います。これは，1次元配列，2次元配列，高次元の配列で動作します。

```python
a = np.array([1, 2, 3, 4])
a.sum()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/8b6e23e0-a289-b54d-5ad3-e9b587b4a136.png)

<font color="red">2次元配列の行や列を追加するには、軸を指定します</font>。

以下の配列から始めると、

```python
b = np.array([[1, 1], [2, 2]])
```
以下で行の合計ができます。  
<font color="gray">［補足］指定した軸(axis)に沿っていくので、指定された軸の要素が１になるイメージです</font>

```python
b.sum(axis=0)   #[補足] 行単位なので１行になるように各列の要素を集計   
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/f9c7e2a0-7bfe-03a3-b940-749a1d844433.png)

以下で例の合計ができます。

```python
b.sum(axis=1)    #[補足] 列単位なので１列になるように各行の要素を集計 
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/8ab6b665-6b64-a3c0-eb57-f57acef17bb9.png)

基本的な操作の詳細ついては[こちら](https://numpy.org/devdocs/user/quickstart.html#quickstart-basic-operations)をご覧ください。

# <font color="blue">ブロードキャスティング</font>

配列と単一の数値（ベクトルとスカラの間の演算とも呼ばれます）や、2つの異なるサイズの配列の間で演算を行いたい場合があるでしょう。例えば、ある配列(ここでは「data」と呼ぶことにします)にはマイル単位の距離の情報が含まれているかもしれませんが、その情報をキロメートルに変換したいとします。この操作は次のようにして行うことができます。

```python
data = np.array([1.0, 2.0])
data * 1.6
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/8395163f-0fe9-9394-9aad-f0a4f14d205e.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/bcec41c2-ea4b-9dc6-6e3e-1a9b0ab36e8a.png)

NumPyは、乗算はそれぞれのセルで行われる必要を理解しています。この概念はブロードキャストと呼ばれています。<font color="red">ブロードキャスティングは、NumPyが異なる形状の配列に対して演算を実行できるようにするメカニズムです</font>。配列の次元は互換性がなければなりません。例えば、両方の配列の次元が等しい場合や、片方が1の場合などです。 次元に互換性がない場合は、ValueErrorが発生します。  
  
ブロードキャストについての詳細は[こちら](https://numpy.org/devdocs/user/basics.broadcasting.html#basics-broadcasting)をご覧ください。

# <font color="blue">より便利な配列操作</font>  
  
このセクションでは、最大、最小、合計、平均、積、標準偏差などを扱います。

NumPyは集計関数も実行します。min, max, sumに加えて、平均を得るためのmean、要素を掛け合わせた結果を得るためのprod、標準偏差を得るためのstdなどを簡単に実行することができます。

```python
data.max()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/aa4f6752-eed0-1c0b-c2cd-859397ed5b23.png)

```python
data.min()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/10276f7d-abea-0fcb-8684-bdb8fa87b581.png)

```python
data.sum()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/1805fd4c-5bbd-98c7-0344-e7066691147e.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/63b141c9-d221-7dce-d37a-2c7f5908c438.png)

まずは以下の配列、"a "から始めましょう。

```python
a = np.array([[0.45053314, 0.17296777, 0.34376245, 0.5510652],
              [0.54627315, 0.05093587, 0.40067661, 0.55645993],
              [0.12697628, 0.82485143, 0.26590556, 0.56917101]])
```

行や列に沿って集計したいというのは非常によくあることです。デフォルトでは、すべてのNumPy集約関数は配列全体の総和を返します。配列の要素の合計または最小値を求めるには、以下のように実行します。

```python
a.sum()      #合計
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/c5a5863e-9c7e-b42f-dfaa-c76261df682c.png)

あるいは

```python
a.min()      #最小値
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/c3463d4a-a520-c70a-e8ed-af6bb0e47364.png)

集約関数を計算させたい軸を指定できます。例えば、axis=0 を指定することで、各列内の最小値を見つけることができます。

```python
a.min(axis=0)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/044d64b4-f603-d8a7-debd-522ead86729a.png)

上記の4つの値は、配列の列数に対応しています。4列の配列の場合、結果として 4 つの値が得られます。

配列のメソッドについての詳細は[こちら](https://numpy.org/devdocs/reference/arrays.ndarray.html#array-ndarray-methods)をご覧ください。

# <font color="blue">行列の作成</font>
Pythonのリストを渡して、NumPy向けの2次元配列（または「行列」）を作ることができます。

```python
data = np.array([[1, 2], [3, 4], [5, 6]])
data
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/3dd74209-f067-e9d7-002a-d7e61722a07a.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/40911902-7b9d-d7c9-86f1-0d2a062f3d20.png)

行列を操作する際には、インデックスやスライス操作が便利です。

```python
data[0, 1]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/bebd2904-304b-9ebd-7501-17a4076ded1a.png)

```python
data[1:3]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/aa8ece8a-f29f-4ee9-db31-abbf02fb3e2d.png)

```python
data[0:2, 0]
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/2d965cad-2bb0-0c24-fe9a-9e3e30c74036.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/dccc70df-71ef-fd08-95ae-5f0f7e3e9c92.png)

ベクトルを集約するのと同じように行列を集約することができます。

```python
data.max()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/8decc519-ceb3-37da-f834-3f1123231506.png)

```python
data.min()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/e3cfb5e0-4093-36c4-f06e-a6cc8517f76e.png)

```python
data.sum()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/eaeee3ab-b2cc-da7c-7a1e-7f939d0a8e40.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/5ca83615-10f7-5638-20b6-35cf4a26679c.png)

行列内のすべての値を集約することができ、軸パラメータを使用して列または行にまたがって集約することができます。

```python
data.max(axis=0)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/587bd79c-a199-8179-140c-7b175aa50388.png)

```python
data.max(axis=1)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/872b9867-7943-bfdb-4524-91b56322a6a0.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/5d25351c-3adb-97ab-0df4-ad3a23dc1b1f.png)

行列を作成したら、同じ大きさの行列が2つあれば、算術演算子を使って足し算や掛け算をすることができます。

```python
data = np.array([[1, 2], [3, 4]])
ones = np.array([[1, 1], [1, 1]])
data + ones
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/30f346fd-19f5-614c-7725-2248233c42c4.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/8f3c2726-53a0-79ce-fd13-7ae90ce857f7.png)

<font color="red">異なるサイズの行列に対してこれらの算術演算を行うことができますが、1つの行列が1列または1行しかない場合に限ります</font>。この場合、NumPyは<font color="red">ブロードキャスト規則</font>を使って演算を行います。

```python
data = np.array([[1, 2], [3, 4], [5, 6]])
ones_row = np.array([[1, 1]])
data + ones_row
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/a1ff05f8-39a4-de4a-e822-a9e3d321fa9f.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/624b9766-07a9-77ce-1e09-5934f734dede.png)

NumPyがN次元配列を表示するとき，最後の軸は最も速く，最初の軸は最も遅くループされることに注意してください。  
例えば、

```python
np.ones((4, 3, 2))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/a82b3318-ee88-f92a-be89-4bbec16e0db2.png)

NumPyで配列の値を初期化したい場合がよくあります。NumPy には ones() や zeros() のような関数や、乱数を生成する random.Generator クラスがあります。必要なのは、生成してほしい要素数を渡すだけです。

```python
np.ones(3)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/f5dd3616-3225-59c6-639e-ee127457fa3e.png)

```python
np.zeros(3)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/9e894528-6ac7-d54a-ab43-f242f9b0a5bf.png)

```python
rng = np.random.default_rng(0)
rng.random(3)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/01c4a8a3-a95c-1e42-c021-66e3a7af6a8e.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/1262010f-c982-25c1-2d9a-2e464ae02a3c.png)

また，行列の次元を記述するタプルを与えれば， ones()，zeros()，random() を用いて 2 次元配列を作成することもできます。

```python
np.ones((3, 2))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/80381a11-d454-04c9-4e79-5d57d3f0a70c.png)

```python
np.zeros((3, 2))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/1d5484a8-659c-8a5a-a06c-e714595f0a98.png)

```python
rng.random((3, 2))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/b958126d-45ec-ae19-3c45-c82fb11116ec.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/16709c38-19bd-7a84-e5c9-36151b2ce1b5.png)

0、1、その他の値や初期化されていない値で埋められた配列を作成することについての詳細は、[array creation routines](https://numpy.org/devdocs/reference/routines.array-creation.html#routines-array-creation)参照してください。

# <font color="blue">乱数の生成</font>

<font color="red">乱数生成の使用は、多くの数値計算や機械学習アルゴリズムの構成や評価の重要な部分です。人工ニューラルネットワークで重みをランダムに初期化する場合でも、データをランダムなセットに分割する場合でも、データセットをランダムにシャッフルする場合でも、乱数（実際には再現性のある擬似乱数）を生成できることは不可欠です</font>。

Generator.integersを使えば、低位（NumPyに含まれることを忘れないようにしてください）から高位（排他的）までの乱数を生成することができます。endpoint=Trueを設定することで、高位の数値を含むようにすることができます。

以下で、0から4までの乱数の2×4配列を生成することができます。

```python
rng.integers(5, size=(2, 4))
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/30bff91d-3449-2be0-d19e-c03c98a333c5.png)

乱数の生成については[こちら](https://numpy.org/devdocs/reference/random/index.html#numpyrandom)をご覧ください。

# <font color="blue">ユニークアイテムとカウント数の取得方法</font>  
  
このセクションでは、np.unique()を扱います。

配列のユニークな要素はnp.uniqueを使えば簡単に見つけることができます。

例えば、次のような配列で始まるとします。

```python
a = np.array([11, 11, 12, 13, 14, 15, 16, 17, 12, 13, 11, 14, 18, 19, 20])
```

配列内の一意な値を表示するには np.unique を使用します。

```python
unique_values = np.unique(a)
print(unique_values)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/13135539-8796-9920-5348-cd1f37fdef49.png)

NumPy配列（配列内のユニークな値の最初のインデックス位置の配列）でユニークな値のインデックスを取得するには、np.unique()に、配列と同様にreturn_index引数を渡すだけです。

```python
unique_values, indices_list = np.unique(a, return_index=True)
print(indices_list)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/f69d13e3-fce7-33ca-902c-250fbbff6023.png)

配列と一緒にnp.unique()のreturn_counts引数を渡すことで、NumPy配列内のユニークな値の頻度カウントを取得することができます。

```python
unique_values, occurrence_count = np.unique(a, return_counts=True)
print(occurrence_count)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/200a2748-85f8-dd1b-c0ba-3d7c6a1a4355.png)

これは2次元配列でも動作します! 以下の配列から始めると、

```python
a_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [1, 2, 3, 4]])
```

以下で、ユニークな値を見つけることができます。

```python
unique_values = np.unique(a_2d)
print(unique_values)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/d8d8cfa9-6e06-45e4-36db-535a0c6596c7.png)

axis 引数が渡されていない場合、2D 配列は平坦化（１次元化）されます。

ユニークな行や列を取得したい場合は、必ず axis 引数を渡してください。ユニークな行を取得するには axis=0 を、列を取得するには axis=1 を指定します。

```python
unique_rows = np.unique(a_2d, axis=0)
print(unique_rows)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/74a36dcf-e843-2632-ad27-4f13bc58d504.png)

ユニークな行、インデックスの位置、出現数を取得するには、以下が使えます。

```python
unique_rows, indices, occurrence_count = np.unique(
    a_2d, axis=0, return_counts=True, return_index=True)
print(unique_rows)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/ea66473c-537b-044b-f466-3d05b3f51bdf.png)

```python
print(indices)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/3b54f313-4f07-1020-6505-e50599ea9695.png)

```python
print(occurrence_count)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/8a464844-e49d-77e9-a278-c3411e8360ab.png)

配列の中から一意な要素を見つける方法の詳細については、 [unique](https://numpy.org/devdocs/reference/generated/numpy.unique.html#numpy.unique) を参照してください。

# <font color="blue">行列の転置とリシェイプ</font>
このセクションでは， arr.reshape()， arr.transpose()， arr.Tを扱います。

<font color="red">行列を転置する必要があることはよくあることです。NumPy配列には、行列の転置を可能にするTというプロパティがあります</font>。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/2a2bb4c8-5b80-8221-7ff6-68e39d98948a.png)

また、行列の次元を切り替える必要があるかもしれません。これは、例えば、データセットとは異なる特定の入力形状を想定したモデルがある場合などに起こります。このような場合に reshape メソッドが役立ちます。単に，行列に必要な新しい次元を渡す必要があるだけです。

```python
data.reshape(2, 3)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/58f7be70-b1d5-0f1e-3c14-b5c0060e80ad.png)

```python
data.reshape(3, 2)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/03f812dc-47fc-e991-b05a-4ba19d4f86ac.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/34a22a0b-85ce-7cf8-c12b-c93a6f7385c5.png)

また、.transpose() を使用して、指定した値に応じて配列の軸を反転させたり変更したりすることもできます。

以下の配列で開始した場合、

```python
arr = np.arange(6).reshape((2, 3))
arr
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/ec8900a2-8b78-e8d9-6336-c6204048ba10.png)

arr.transpose() を使用して配列を転置することができます。

```python
arr.transpose()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/5bd9fe15-92d7-f873-0f3c-54bbcc3afe1d.png)

arr.T.を使用することもできます。

```python
arr.T
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/53a593dd-53a2-c730-668b-dc1456c1ea34.png)

配列の転置とリシェイプの詳細については、 [transpose](https://numpy.org/devdocs/reference/generated/numpy.transpose.html#numpy.transpose) と [reshape](https://numpy.org/devdocs/reference/generated/numpy.reshape.html#numpy.reshape)を参照してください。

# <font color="blue">配列を反転させる方法</font>

このセクションでは、np.flip()を扱います。
  
<font color="red">NumPyのnp.flip()関数では、配列の内容を軸に沿って反転させたり、反転させたりすることができます</font>。np.flip()を使用する際には、反転させたい配列と軸を指定します。軸を指定しなかった場合、NumPyは入力配列のすべての軸に沿って内容を反転します。  
  
**1次元配列の反転**  
  
以下のような1次元配列から始めると、

```python
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
```

以下で反転させることができます。

```python
reversed_arr = np.flip(arr)
```

逆さにした配列を表示したい場合は、以下を実行します。

```python
print('Reversed Array: ', reversed_arr)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/a0dc1089-ccc3-7356-b5cf-30c45b742b10.png)

**2次元配列の反転**

2次元配列も同じように動作します。

以下の配列から始めると、

```python
arr_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
```

以下で、すべての行とすべての列の内容を反転させることができます。

```python
reversed_arr = np.flip(arr_2d)
print(reversed_arr)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/c24dda6a-79dc-beaa-0886-69bd9fba17af.png)

以下で、行だけを簡単に反転させることができます。

```python
reversed_arr_rows = np.flip(arr_2d, axis=0)
print(reversed_arr_rows)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/6709769b-e1cc-4490-4984-3615b183a7e6.png)

または、以下で列だけを反転させることもできます。

```python
reversed_arr_columns = np.flip(arr_2d, axis=1)
print(reversed_arr_columns)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/ec8342f5-6e76-4cf6-2581-391c76387d66.png)

また、1つの列または行だけの内容を反転させることもできます。例えば、インデックス位置1（2行目）の行の内容を反転させることができます。

```python
arr_2d[1] = np.flip(arr_2d[1])
print(arr_2d)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/0915b443-10a9-8082-fa1a-765265eff16c.png)

インデックス位置1（2列目）の列を反転させることもできます。

```python
arr_2d[:,1] = np.flip(arr_2d[:,1])
print(arr_2d)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/51cb4da2-8430-471b-a8fa-ceda84226349.png)

配列の反転についての詳細は[flip](https://numpy.org/devdocs/reference/generated/numpy.flip.html#numpy.flip)を参照してください。

# <font color="blue">多次元配列のリシェイプと平坦化</font>  
  
このセクションでは、.flatten()、ravel()を扱います。

  
<font color="red">配列を平坦化するには、.flatten() と .ravel() の 2 つの一般的な方法があります</font>。この二つの主な違いは、ravel() で作成される新しい配列は実際には親配列への参照 (つまり "ビュー" です) であるということです。つまり、新しい配列への変更は親配列にも影響するということです。ravel はコピーを作成しないので、メモリ効率が良いです。

以下の配列から始めた場合、

```python
x = np.array([[1 , 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
```

配列を1次元配列に平坦化するには、flattenを使用することができます。

```python
x.flatten()
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/f274090e-e469-1270-9c76-793c4ab50168.png)

flatten を使用した場合、新しい配列を変更しても親配列は変更されません。  
  
例えば、

```python
a1 = x.flatten()
a1[0] = 99
print(x)  # Original array
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/ae29f284-03c2-b6ec-cba2-2226a33cc0ef.png)

```python
print(a1)  # New array
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/b267be24-5967-03d9-1b36-1469222b4a2b.png)

しかし、ravel を使用した場合、新しい配列に加えた変更は親配列に影響を与えます。  
  
例えば、

```python
a2 = x.ravel()
a2[0] = 98
print(x)  # Original array
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/cfa52753-fadd-7375-061e-99dd47ae704a.png)

```python
print(a2)  # New array
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/116a1256-a3b3-44d3-5e0c-69b4c283df57.png)

flattenについてはの詳細は[ndarray.flatten](https://numpy.org/devdocs/reference/generated/numpy.ndarray.flatten.html#numpy.ndarray.flatten)、ravelの詳細は[ravel](https://numpy.org/devdocs/reference/generated/numpy.ravel.html#numpy.ravel) を参照してください。

# <font color="blue">詳細を知るためにdocstringにアクセスする方法</font>
  
このセクションでは、help(), ?, ??について扱います。
  
データサイエンスのエコシステムといえば、PythonとNumPyはユーザーのことを考えて構築されています。その最良の例の一つが、組み込みのドキュメントへのアクセスです。すべてのオブジェクトは文字列への参照を含んでおり、これはdocstringとして知られています。ほとんどの場合、このdocstringにはオブジェクトとその使い方の簡単で簡潔な要約が含まれています。Pythonには、この情報にアクセスするのに役立つ help() 関数が組み込まれています。つまり、より多くの情報が必要になったときにはほぼいつでも、 help() を使って必要な情報を素早く見つけることができます。

例えば、

```python
help(max)
```
>Help on built-in function max in module builtins:
>
>max(...)
>    max(iterable, *[, default=obj, key=func]) -> value
>    max(arg1, arg2, *args, *[, key=func]) -> value
>    
>    With a single iterable argument, return its biggest item. The
>    default keyword-only argument specifies an object to return if
>    the provided iterable is empty.
>    With two or more arguments, return the largest argument.

追加情報へのアクセスは非常に便利なので、IPythonでは'?'という文字を使ってこのドキュメントにアクセスし、他の関連情報にもアクセスできるようにしています。
IPythonは複数の言語でインタラクティブな計算を行うためのコマンドシェルです。IPythonについての詳しい情報は[こちら](https://ipython.org/)をご覧ください。

例えば、

```python
max?
```
>max(iterable, *[, default=obj, key=func]) -> value
>max(arg1, arg2, *args, *[, key=func]) -> value
>
>With a single iterable argument, return its biggest item. The
>default keyword-only argument specifies an object to return if
>the provided iterable is empty.
>With two or more arguments, return the largest argument.
>Type:      builtin_function_or_method

この表記法は、オブジェクトメソッドやオブジェクトそのものにも使えます。

以下のような配列を作成したとしましょう。

```python
a = np.array([1, 2, 3, 4, 5, 6])
```

すると、多くの有用な情報を得ることができます(最初にa自身の詳細、次にaがインスタンスであるndarrayのdocstringが続きます)。

```python
a?
```
>Type:            ndarray
>String form:     [1 2 3 4 5 6]
>Length:          6
>File:            ~/anaconda3/lib/python3.7/site-packages/numpy/__init__.py
>Docstring:       <no docstring>
>Class docstring:
>ndarray(shape, dtype=float, buffer=None, offset=0,
>        strides=None, order=None)
>
>An array object represents a multidimensional, homogeneous array
>of fixed-size items.  An associated data-type object describes the
>format of each element in the array (its byte-order, how many bytes it
>occupies in memory, whether it is an integer, a floating point number,
>or something else, etc.)
>
>Arrays should be constructed using `array`, `zeros` or `empty` (refer
>to the See Also section below).  The parameters given here refer to
>a low-level method (`ndarray(...)`) for instantiating an array.
>
>For more information, refer to the `numpy` module and examine the
>methods and attributes of an array.
>
>Parameters
> `------`
>(for the __new__ method; see Notes below)
>
>shape : tuple of ints
>        Shape of created array.
>...


これは、関数やその他のオブジェクトを作成した場合にも動作します。ただ、文字列リテラルを使用して関数に docstring を含めることを忘れないでください (`"""`  `"""` またはドキュメントの周りに `'''` 
 `'''` を使用してください)。  
  
例えば、次のような関数を作成したとします。

```python
def double(a):
    '''Return a * 2'''
    return a * 2
```

この関数に関する情報を得ることができます。

```python
double?
```
>Signature: double(a)
>Docstring: Return a * 2
>File:      ~/Desktop/~
>Type:      function

興味のあるオブジェクトのソースコードを読むことで、別のレベルの情報にリーチすることができます。二重のクエスチョンマーク(??)を使うと、ソースコードにアクセスできます。

例えば、

```python
double??
```
>Signature: double(a)
>Source:
>def double(a):
>&nbsp;&nbsp;&nbsp;&nbsp;'''Return a * 2'''
>&nbsp;&nbsp;&nbsp;&nbsp;return a * 2
>File:      ~/Desktop/~
>Type:      function

知りたいオブジェクトがPython以外の言語でコンパイルされている場合、'??'を使用すると'?'と同じ情報が返されます。これは、例えば組み込みのオブジェクトや型の多くで見られるでしょう。

```python
len?
```
>Signature: len(obj, /)
>Docstring: Return the number of items in a container.
>Type:      builtin_function_or_method

そして、

```python
len??
```
>Signature: len(obj, /)
>Docstring: Return the number of items in a container.
>Type:      builtin_function_or_method

lenは、Python以外のプログラミング言語でコンパイルされているため、同じ出力を持っています。


# <font color="blue">数式を使った作業</font>  
  
<font color="red">配列上で動作する数式の実装の容易さは、NumPyが科学的なPythonコミュニティでこれほどまでに広く使われている理由の一つです</font>。

例えば、これは平均二乗誤差の公式（回帰を扱う教師付き機械学習モデルで使われる中心的な公式）です。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/591b3917-a1ce-9050-c27d-74c6b07d14fd.png)

この式の実装は、NumPyではシンプルで簡単です。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/b8c7ddcf-4049-c304-6788-fee31246bbe7.png)

これが非常にうまく機能するのは、予測値とラベルが1つまたは1000個の値を含むことができるからです。これらは同じサイズである必要があります。

このように可視化することができます。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/d52bdd78-61e1-70de-5ccf-96fe6b0767c5.png)

この例では、予測ベクトルとラベルベクトルの両方に3つの値が含まれており、nには3つの値があることを意味します。減算を行った後、ベクトル内の値は2乗されます。NumPyが値を合計し、その結果が予測値の誤差値とモデルの品質のスコアとなります。

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/71bcbf19-4c9c-e1f4-d857-3681c13573a1.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/270e0a5c-8fd6-3446-9165-0619843d35ad.png)

# <font color="blue">NumPyオブジェクトの保存と読み込み方法</font>  
  
ここでは、np.save、np.savez、np.savetxt、np.load、np.loadtxtを扱います。
  
ある時点での、配列をディスクに保存して、コードを再実行することなくロードしたいと思うことがあるでしょう。幸いなことに，NumPyではオブジェクトを保存したりロードしたりする方法がいくつかあります．ndarrayオブジェクトは、通常のテキストファイルを扱うloadtxtとsavetxt関数、NumPyバイナリファイルを扱うloadとsave関数、NumPyファイルを扱うsavez関数を使ってディスクファイルに保存したり、ディスクファイルからロードしたりすることができます（拡張子は.npyです）。  
  
.npyと.npzファイルは、ファイルが異なるアーキテクチャの別のマシン上にある場合でも、配列を正しく取得できるように、データ、形状、dtype、およびNDアレイを再構築するために必要なその他の情報を格納します。

1つのndarrayオブジェクトを保存したい場合は、np.saveを使用して.npyファイルとして保存します。複数のndarrayオブジェクトを1つのファイルに保存したい場合は、np.savezを使用して.npzファイルとして保存します。また、複数の配列を1つのファイルに保存するには、savez_compressedを使用して圧縮されたnpz形式で保存することもできます。

np.save()を使えば、簡単に保存して読み込んで配列にすることができます。保存したい配列とファイル名を指定するだけです。例えば、このような配列を作成した場合、

```python
a = np.array([1, 2, 3, 4, 5, 6])
```

以下で、これを「filename.npy」として保存することができます。  
  
<span style="color: gray; ">［補足］下記をiPythonで実行した場合、カレントフォルダに「filename.npy」が作られますので後で削除してください</span>

```python
np.save('filename', a)
```

np.load() を使用して配列を再構築することができます。

```python
b = np.load('filename.npy')
```

配列をチェックしたい場合は、以下を実行します。

```python
print(b)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/3a190ac7-211e-6c89-df67-e1873f3d7aa8.png)

NumPy配列は，np.savetxtで.csvや.txtファイルのようなプレーンテキストファイルとして保存することができます。  
  
例えば、以下のような配列を作成した場合、

```python
csv_arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
```

以下のように「new_file.csv」という名前の.csvファイルとして簡単に保存することができます。
  
<span style="color: gray; ">［補足］下記をiPythonで実行した場合、カレントフォルダに「new_file.npy」が作られますので後で削除してください</span>

```python
np.savetxt('new_file.csv', csv_arr)
```

loadtxt() を使用して、保存したテキストファイルを素早く簡単に読み込むことができます。

```python
np.loadtxt('new_file.csv')
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/25407772-3b5c-7671-9d3f-6095f73e5cf0.png)

savetxt()とloadtxt()関数は、ヘッダ、フッタ、デリミタなどの追加のオプションパラメータを受け付けます。テキストファイルは共有しやすくなりますが、.npyや.npzファイルはより小さく、より速く読むことができます。テキストファイルをより高度に扱う必要がある場合（例えば、欠落した値を含む行を扱う必要がある場合など）、genfromtxt関数を使用することになります。

savetxtを使用すると、ヘッダ、フッタ、コメントなどを指定することができます。

入力および出力ルーチンの詳細については、[こちら](https://numpy.org/devdocs/reference/routines.io.html#routines-io)を参照してください。

# <font color="blue">CSVのインポートとエクスポート</font>  
  
既存の情報を含んだCSVで読み込むのが簡単です。一番簡単で良いのは[Pandas](https://pandas.pydata.org/)を使うことです。
  
<font color="gray">［補足］以降のコマンドを実行するためにカレントフォルダに「music.csv」を作成します。</font>
<font color="gray">データは下記です</font>  
>Artist,Genru,Listener,Plays  
>Billie Holiday,Jazz,1300000,27000000  
>Jimmie Hendrix,Rock,2700000,70000000  
>Miles Davis,Jazz,150000,48000000  
>SIA,Pops,2000000,74000000  

```python
# テストファイルを作成します
with open('music.csv', 'w') as f:
    f.write("Artist,Genru,Listener,Plays\n")
    f.write("Billie Holiday,Jazz,1300000,27000000\n")
    f.write("Jimmie Hendrix,Rock,2700000,70000000\n")
    f.write("Miles Davis,Jazz,150000,48000000\n")
    f.write("SIA,Pops,2000000,74000000\n")
    f.close
```

```python
import pandas as pd
# If all of your columns are the same type:
x = pd.read_csv('music.csv', header=0).values
print(x)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/ac174b90-4f2a-930c-a352-498a09fc1b3b.png)

```python
# You can also simply select the columns you need:
x = pd.read_csv('music.csv', usecols=['Artist', 'Plays']).values
print(x)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/3cbb9f70-9bf4-1683-2396-d5741ef8f504.png)

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/4d1b290a-81ca-4b79-b393-6f007173caed.png)

配列のエクスポートもPandasを使えば簡単です。NumPyに慣れていない方は、配列の値からPandasのデータフレームを作成して、PandasでCSVファイルに書き出してみるのもいいかもしれません。

以下の配列 "a "を作成した場合、

```python
a = np.array([[-2.58289208,  0.43014843, -1.24082018, 1.59572603],
              [ 0.99027828, 1.17150989,  0.94125714, -0.14692469],
              [ 0.76989341,  0.81299683, -0.95068423, 0.11769564],
              [ 0.20484034,  0.34784527,  1.96979195, 0.51992837]])
```

Pandsのデータフレームを作成することができます。

```python
df = pd.DataFrame(a)
print(df)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/28b3d1a2-df03-fba6-2320-72bb7811c2d2.png)

以下で、簡単にデータフレームを保存することができます。

```python
df.to_csv('pd.csv')
```

そして、以下でCSVを読み込み、

```python
data = pd.read_csv('pd.csv')
data
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/1340780c-9c76-0678-3c5d-429abd142236.png)

NumPyのsavetxtメソッドを使って配列を保存することもできます。

```python
np.savetxt('np.csv', a, fmt='%.2f', delimiter=',', header='1,  2,  3,  4')
```

コマンドラインを使っている場合は、次のようなコマンドでいつでも保存したCSVを読み込むことができます。  
<font color="gray">［補足］Windows学習環境でcatコマンドの代わりにWindowsのtypeコマンドで確認します</font>

```python
# cat np.csv   オリジナルコード
!type np.csv
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/b6fd3c80-0f94-b3e7-fed4-767e3e864367.png)

または、テキストエディタでいつでも開くことができます!

Pandasについて詳しく知りたい方は、[Pandasの公式ドキュメント](https://pandas.pydata.org/index.html)をご覧ください。[Pandasの公式インストール情報](https://pandas.pydata.org/pandas-docs/stable/getting_started/install.html)でPandasのインストール方法をご紹介します。

# <font color="blue">Matplotlibによる配列のプロット</font>
値のプロットを作成する必要がある場合，Matplotlibを使用すると非常に簡単です．
  
例えば、以下のような配列があれば、

```python
a = np.array([2, 1, 5, 7, 4, 6, 8, 14, 10, 9, 18, 20, 22])
```

すでにMatplotlibがインストールされている場合は、それを使ってインポートすることができます。

```python
import matplotlib.pyplot as plt

# If you're using Jupyter Notebook, you may also want to run the following
# line of code to display your code in the notebook:

%matplotlib inline
```

値をプロットするために必要なのは、実行することだけです。

```python
plt.plot(a)
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/1bafcea7-dedf-7c05-605e-cf80101d29a0.png)

コマンドラインから実行している場合は、以下の操作が必要になります。  
  `>>>plt.show() `

例えば、1次元配列をこのようにプロットすることができます。

```python
x = np.linspace(0, 5, 20)
y = np.linspace(0, 10, 20)
plt.plot(x, y, 'purple') # line
plt.plot(x, y, 'o')      # dots
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/86b143e6-37fa-abff-c369-83802a77f05a.png)

Matplotlibを使用すると、膨大な数の可視化オプションにアクセスすることができます。

```python
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = Axes3D(fig)
X = np.arange(-5, 5, 0.15)
Y = np.arange(-5, 5, 0.15)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

ax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap='viridis')
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/1413278/8c5ccf33-6b0d-5e94-5e2a-4039441d8ff1.png)

Matplotlibとそれができることについての詳細を読むには、[公式ドキュメント](https://matplotlib.org/)を見てください。Matplotlibのインストール方法については、[公式のインストールセクション](https://matplotlib.org/users/installing.html)を参照してください。

Image credits: Jay Alammar http://jalammar.github.io/

# <font color=blue>おわりに</font>

NPO法人AI開発推進協会では、本チュートリアルをiPythonやGoogleコラボ上で動かしながら学習するオンランセミナーや、さまざまなAIモデルをボタンを押すだけでAIを体験できるGUIツールを用いたセミナーも定期的に開催しています。　また、各種AIのモデルの解説も掲載しております。興味がありましたら当法人のホームページをご覧ください。

[@2021 NPO法人AI開発推進協会](https://sites.google.com/deepaelurus.com/aboutus/)