NumPy は Python 用のオープンソースの数値計算拡張ライブラリであり, 配列サポートと対応する効率的な処理関数を提供します. n 次元配列 () 行列の作成, 配列に対する関数演算の実行, 数値積分, 線形代数計算,フーリエ変換や乱数発生など
NumPy を使用する理由
標準的な Python は List (リスト) を使用して値を保存し、配列として使用できますが、リスト内の要素は任意のオブジェクトになる可能性があるため、CPU の計算時間とメモリが浪費されます。これらの欠点を補った NumPy の誕生により、次の 2 つの基本的なオブジェクトが提供されます。
- ndarry (n 次元配列オブジェクト): 単一のデータ型を格納する多次元配列です。
- ufunc（汎用関数オブジェクト）：配列を扱える関数です。
NumPy で一般的に使用されるインポート形式:
import numpy as np
まず、配列オブジェクトの作成
1. array 関数を使用して配列オブジェクトを作成します。
- 配列関数の形式:
np.array(object,dtype,ndmin)
配列関数の主なパラメーターと使用方法を次の表に示します。
| パラメータ名 | 例証する |
|---|---|
| 物体 | 作成する配列を示す配列を受け取ります |
| dtype | 配列に必要なデータ型を示す data-type を受け取ります。指定されていない場合は、データ オブジェクトを保存するために必要な最小の型を選択します。デフォルトは [なし] です。 |
| ndmin | 生成された配列の最小次元を指定する int を受け取ります。デフォルトは None です。 |
#创建ndarray数组：
import numpy as np
data1 = [1,3,5,7] #列表
w1 = np.array(data1)
print('w1:',w1)
data2 = (1,2,3,4) #元组
w2 = np.array(data2)
print('w2:',w2)
data3 = [[1,2,3,6],[5,6,7,8]] #多维数组
w3 = np.array(data3)
print('w3:',w3)
#Output
#w1: [1 3 5 7]
#w2: [1 2 3 4]
#w3: [[1 2 3 6]
# [5 6 7 8]]
配列を作成するとき、NumPy は新しく作成された配列に適したデータ型を推測し、それを dtype に保存します.シーケンスに整数と浮動小数点数がある場合、dtype は浮動小数点数型として定義されます.
import numpy as np
data1 = [1,3,5,7.3] #列表
w1 = np.array(data1)
print(w1.dtype)
print('w1:',w1)
#Output
#float64
#w1: [1. 3. 5. 7.3]
2. 特に配列を作成する関数
1)アレンジ機能
- arange 関数: 算術 1 次元配列を作成します. Arrange 関数は Python の組み込み関数 range に似ていますが、arrange は主に配列の作成に使用されます.
フォーマット: np.arange([開始, ]停止, [ステップ, ]dtype)
#使用arrange创建数组
kk = np.arange(10)
print(kk)
#Output
#[0 1 2 3 4 5 6 7 8 9]
アレンジ機能は、初期値、最終値、刻み幅を指定することで一次元配列を作成することができ、作成した配列には最終値は含まれません。
kk = np.arange(0,15,1.5)
print(kk)
#Output
#[ 0. 1.5 3. 4.5 6. 7.5 9. 10.5 12. 13.5]
2) linspace 関数
配列関数の引数が浮動小数点型の場合、浮動小数点の精度が限られているため、通常、配列要素の数を予測することはできません. このため、通常はより優れた関数 linspace が使用されます. [初期値、最終値、および要素形式を指定して、デフォルトで最終値を含む1 次元配列を作成する] を介して、要素の数をパラメーターとして受け入れます。
- linspace 関数: 要素数をパラメーターとして受け取り、算術 1 次元配列を作成します。
形式: np.linspace(start, stop, num, endpoint, retstep=False, dtype=None)
パラメーターの説明:
start: スカラー (スカラー)、シーケンスの開始点
stop: スカラー、エンドポイントに応じて変化します。エンドポイントが True の場合、False の場合は含まれません (生成されたシーケンスは、元の num に 1 を追加し、エンドポイント = True で生成するのと同じです。結果は、最後から 2 番目までの最初のもののみを表示します) num: int、オプション
(オプション)、サンプル数を生成、非負である必要があります
endpoint: bool、オプション、true の場合、stop が含まれます、false の場合、stop は含まれません
retstep: bool、オプション
dtype: dtype、オプション
#使用linspace函数创建数组
kk = np.linspace(1,10,4)
print(kk)
#Output
#[ 1. 4. 7. 10.]
3) ログスペース機能
- 関数 logspace は関数 linspace と似ていますが、等比数列配列を作成する点が異なります。
書式: np.logspace(start, stop, num, endpoint=True,
base=10.0, dtype=None))
ログスペースのパラメータのうち、**start、stop は 10 の累乗を表し、**デフォルトの base は 10 です。 3 番目のパラメーターは要素の数です。
#生成1~10的具有5个元素的等比数列数组
kk = np.logspace(0,1,5)
print(kk)
#Output
#[ 1. 1.77827941 3.16227766 5.62341325 10. ]
4) ゼロ機能
- zeros 関数: 指定された長さまたは形状ですべて 0 の配列を作成します フォーマット
: np.zeros(shape, dtype=float, order='C')
#使用zeros函数创建全零矩阵。
ll = np.zeros(4)
print(ll)
print("-----------------------")
kk = np.zeros(4,float)
print(kk)
print("-----------------------")
cc = np.zeros([3,3],int)
print(cc)
#Output
#[0. 0. 0. 0.]
#-----------------------
#[0. 0. 0. 0.]
#-----------------------
#[[0 0 0]
# [0 0 0]
# [0 0 0]]
zeros 関数のデフォルトの型が float64 であることがわかります。
5) ワンズ関数
- ones 関数: 指定された長さまたは形状ですべて 1 の配列を作成します フォーマット
: np.ones(shape, dtype=None, order='C')
6) 診断機能
- diag 関数: 対角行列を作成します。
形式: np.diag(v, k=0)
パラメーター: v は 1 次元または 2 次元の行列です。k<0 はスラッシュが行列の下にあることを意味し、k>0 はスラッシュが行列の上にあることを意味します。
kk = np.diag([1,2,3,4])
print(kk)
#Output
# [[1 0 0 0]
# [0 2 0 0]
# [0 0 3 0]
# [0 0 0 4]]
7) 目の機能
- eye(n) 関数は、対角が 1 で残りがすべて 0 の行列、つまり単位行列を作成できます。n は単位行列の次元です。
kk = np.eye(4)
print(kk)
#Output
#[[1. 0. 0. 0.]
# [0. 1. 0. 0.]
# [0. 0. 1. 0.]
# [0. 0. 0. 1.]]
3. ndarray オブジェクトのプロパティとデータ変換
NumPy で作成される ndarray オブジェクトの属性には、主に形状やサイズなどの属性が含まれます。詳細を次の表に示します。
| 属性 | 例証する |
|---|---|
| それは私です | ランク、データ軸の数 |
| 形 | 配列の次元数 |
| サイズ | 配列要素の数 |
| dtype | データの種類 |
| アイテムサイズ | 配列内の各要素のバイト単位のサイズ |
NumPy - データ型:
| シリアルナンバー | データ型と説明 |
|---|---|
| 1 | bool_ は、1 バイトのブール値 (true または false) として格納されます。 |
| 2 | int_ デフォルトの整数、C の long と同等、通常は int32 または int64 |
| 3 | intc は C の int と同等で、通常は int32 または int64 |
| 4 | intp インデックス付けに使用される整数。C size_t と同等。通常は int32 または int64 |
| 5 | int8 バイト (-128 ~ 127) |
| 6 | int16 16 ビット整数 (-32768 ~ 32767) |
| 7 | int32 32 ビット整数 (-2147483648 ~ 2147483647) |
| 8 | int64 64 ビット整数 (-9223372036854775808 ~ 9223372036854775807) |
| 9 | uint8 8 ビット符号なし整数 (0 ~ 255) |
| 10 | uint16 16 ビット符号なし整数 (0 ~ 65535) |
| 11 | uint32 32 ビット符号なし整数 (0 ~ 4294967295) |
| 12 | uint64 64 ビット符号なし整数 (0 ~ 18446744073709551615) |
| 13 | float_ float64 の省略形 |
| 14 | float16 半精度浮動小数点: 符号ビット、5 ビット指数、10 ビット仮数 |
| 15 | float32 単精度浮動小数点: 符号ビット、8 ビット指数、23 ビット仮数 |
| 16 | float64 倍精度浮動小数点: 符号ビット、11 ビット指数、52 ビット仮数 |
| 17 | complex_complex128 の省略形 |
| 18 | |
| 19 | complex128 2 つの 64 ビット浮動小数点数 (実数と虚数) で表される複素数 |
2. 乱数を生成する
NumPy.random モジュールでは、さまざまな乱数生成関数が提供されています。たとえば、関数 randint は、指定された範囲のランダムな整数を生成して、指定された形状の配列を形成します。
使用法: np.random.randint(low, high = None, size = None) は、ランダムな整数行列を生成することを意味し、low は最小値を意味し、high は最大値を意味し、size はタプル型 size = shape です。
#生成随机整数
kk = np.random.randint(100,200,size=(2,4)) #在100-200数据间生成一个2行4列的随机数数组
print(kk)
#Output
#[[167 189 168 135]
# [116 188 157 102]]
1). np.random.randn( ): 標準正規分布を生成します, 固定パラメータなし, 追加の各数値は追加の次元を表します, ガウス正規分布 = ガウス分布, 分布: 統計学習. 標準的なガウス分布の中央値は 0、最適な範囲は 1 ～ 1、範囲外の値は外れ値です。
2). np.random.random(size): 0-1 の間の要素の配列を生成し、サイズ テーブルの形状、ランダム生成の範囲は 0-1 の間、各乱数は次元です。
3). np.random.rand(): np.random.random と同じ機能を持つ 0 ～ 1 の要素の配列を生成します。random は形状を記述するためにサイズが必要で、rand は直接指定するだけで済みます。値、値番号を渡して形状を決定します。
4). np.random.normal(loc,scale,size): 正規分布の配列を生成し、location は場所の値、scale は変動値、size はデータ長です。
| 関数 | 例証する |
|---|---|
| シード | 乱数発生器のシードを決定します |
| 順列 | シーケンスのランダム順列を返すか、ランダム順列の範囲を返します |
| シャッフル | シーケンスをランダム化する |
| 二項式 | 二項分布から乱数を生成する |
| 普通 | 正規 (ガウス) 分布から乱数を生成します |
| ベータ | ベータ分布を生成する関数 |
| チスクエア | カイ二乗分布から乱数を生成 |
| ガンマ | ガンマ分布から乱数を生成 |
| ユニフォーム | [0,1] に一様に分布する乱数を生成する |
3.配列変換
3.1. 配列の再形成
定義された配列の場合、配列の次元は reshape メソッドで変更でき、入力パラメーターは新しい次元のタプルです。reshape のパラメーターの 1 つを -1 に設定できます。これは、配列の次元をデータ自体から推測できることを示します。
kk0 = np.arange(8)
print("kk0: ",kk0)
kk1 = kk0.reshape(2,4)
print("kk1: ",kk1)
#Output
#kk0: [0 1 2 3 4 5 6 7]
#kk1: [[0 1 2 3]
# [4 5 6 7]]
- reshape のパラメーターは -1 に設定できます。これは、配列の次元がデータ自体によって判断できることを示します。
kk0 = np.arange(15)
print("kk0: ",kk0)
kk1 = kk0.reshape(5,-1)
print("kk1: ",kk1)
#Output
#kk0: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk1: [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]
# [12 13 14]]
- 再形成の反対の方法は、データの拡散 (ravel) またはデータの平坦化 (flatten) です。
kk0 = np.arange(15)
print("kk0: ",kk0)
kk1 = kk0.reshape(5,-1)
print("kk1: ",kk1)
kk2 = kk1.ravel()
print("kk2: ",kk2)
kk3 = kk1.flatten()
print("kk3: ",kk3)
#Output
#kk0: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk1: [[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 9 10 11]
# [12 13 14]]
#kk2: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
#kk3: [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
- データの再形成は元の配列を変更しないことに注意してください。
3.2. 配列のマージ
配列マージは、複数の配列間の操作に使用されます. NumPy は、hstack 関数、vstack 関数、および concatenate 関数を使用して、配列のマージを完了します。
- hstack 関数: 水平結合を実現
- hstack 関数: 水平結合を実現
- Concatenate 関数: 配列の水平方向または垂直方向のマージを実現できます。パラメーター axis=1 の場合は水平方向のマージが実行され、axis=0 の場合は垂直方向のマージが実行されます。
#横向合并：
kk1 = np.arange(6).reshape(3,2)
print(kk1)
print("----------")
kk2 = kk1 * 2
print(kk2)
print("----------")
kk3 = np.hstack((kk1,kk2))
print(kk3)
#Output
#[[0 1]
# [2 3]
# [4 5]]
#----------
#[[ 0 2]
# [ 4 6]
# [ 8 10]]
#----------
#[[ 0 1 0 2]
# [ 2 3 4 6]
# [ 4 5 8 10]]
3.3. 配列のセグメンテーション
与数组合并相反，NumPy提供了hsplit函数、vsplit函数和split函数分别实现数组的横向、纵向和指定方向的分割。
arr = np.arange(16).reshape(4,4)
print('横向分割为:\n',np.hsplit(arr,2))
print('纵向组合为:\n',np.vsplit(arr,2))
#Output
#横向分割为:
# [array([[ 0, 1],
# [ 4, 5],
# [ 8, 9],
# [12, 13]]), array([[ 2, 3],
# [ 6, 7],
# [10, 11],
# [14, 15]])]
#纵向组合为:
# [array([[0, 1, 2, 3],
# [4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
# [12, 13, 14, 15]])]
同样，split在参数axis = 1时实现数组的横向分割，axis = 0时则进行纵向分割。
3.4.数组转置和轴对换
数组转置是数组重塑的一种特殊形式，可以通过transpose方法进行转置。transpose 方法需要传入轴编号组成的元组。除了使用transpose外，也可以直接利用数组的T属性进行数组转置。
kk = np.arange(6).reshape(3,2)
print('矩阵：',kk)
print('-------------')
print('转置矩阵：',kk.transpose(1,0)) //# np.transpose(kk))
#Output
# 矩阵： [[0 1]
# [2 3]
# [4 5]]
# -------------
# 转置矩阵： [[0 2 4]
# [1 3 5]]
数组的T属性转置：
kk = np.arange(6).reshape(3,2)
print('矩阵：',kk)
print('-------------')
print('转置矩阵：',kk.T)
#Output
# 矩阵： [[0 1]
# [2 3]
# [4 5]]
# -------------
# 转置矩阵： [[0 2 4]
# [1 3 5]]
ndarray 的 swapaxes 方法实现轴对换：
kk = np.arange(6).reshape(3,2)
print('矩阵：',kk)
print('-------------')
print('轴对换：',kk.swapaxes(0,1))
#Output
# 矩阵： [[0 1]
# [2 3]
# [4 5]]
# -------------
# 轴对换： [[0 2 4]
# [1 3 5]]
四、数组的索引和切片
4.1 一维数组的索引
一维数组的索引类似Python中的列表。
kk = np.arange(10)
print(kk)
print(kk[2])
print(kk[-1])
print(kk[2:5])
#Output
# [0 1 2 3 4 5 6 7 8 9]
# 2
# 9
# [2 3 4]
数组的切片返回的是原始数组的视图，不会产生新的数据，如果需要的并非视图而是要复制数据，则可以通过copy方法实现。
kk = np.arange(10)
print(kk)
kk1 = kk[1:3].copy()
print(kk1)
#Output
#[0 1 2 3 4 5 6 7 8 9]
#[1 2]
4.2 多维数组的索引
- 对于多维数组，它的每一个维度都有一个索引，各个维度的索引之间用逗号分隔。
- 也可以使用整数函数和布尔值索引访问多维数组。
kk = np.arange(12).reshape(3,4)
print(kk)
print(kk[0,1:3]) #索引第0行中第1列到第2列的元素
print(kk[ :,2]) #索引第2列元素
print(kk[:1,:1]) #索引第0行第0列元素
#Output
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# [1 2]
# [ 2 6 10]
# [[0]]
4.3 访问多维数组
kk = np.arange(12).reshape(3,4)
print(kk)
print('索引结果1: ',kk[(0,1),(1,3)]) #从两个序列的对应位置取出两个整数来组成下标:kk[0,1],kk[1,3]
print('索引结果2: ',kk[1:2,(0,2,3)]) #索引第一行中的0、2、3列元素
#Output
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
# 索引结果1: [1 7]
# 索引结果2: [[4 6 7]]
五、NumPy中的数据统计与分析
在NumPy中，数组运算更为简洁而快速，通常比等价的Python方式快很多，尤其在处理数组统计计算与分析的情况下。
5.1 排序
NumPy 的排序方式有直接排序和间接排序。直接排序是对数据直接进行排序，间接排序是指根据一个或多个键值对数据进行排序。在NumPy中，直接排序使用函数sort，间接排序使用argsort函数和lexsort函数。
- Sort函数对数据直接进行排序，调用改变原始数组，无返回值。
格式：numpy.sort(a, axis, kind, order)
主要参数及其说明见下表：
| 参数 | 使用说明 |
|---|---|
| a | 要排序的数组 |
| kind | 排序算法，默认为’quicksort’ |
| order | 排序的字段名，可指定字段排序，默认为None |
| axis | 使用sort函数可以沿着指定轴对数据集进行排序，axis = 1 为沿横轴排序，axis = 0 为沿纵轴排序，axis = None，将数组平坦化之后排序 |
例1：使用sort 函数进行排序。
kk = np.array([1,4,3,2,5,6,7,8,9])
print("原数组：",kk)
kk.sort()
print("排序后的数组：",kk)
#Output
#原数组： [1 4 3 2 5 6 7 8 9]
#排序后的数组： [1 2 3 4 5 6 7 8 9]
例2：带轴向参数的sort 排序。
kk = np.array([[4,2,9,5],[6,4,8,3],[1,6,2,4]])
print("原数组：",kk)
kk.sort(axis=1) #沿横向排序
print("排序后的数组：",kk)
#Output
# 原数组： [[4 2 9 5]
# [6 4 8 3]
# [1 6 2 4]]
# 排序后的数组： [[2 4 5 9]
# [3 4 6 8]
# [1 2 4 6]]
np.argsort函数和np.lexsort函数根据一个或多个键值对数据集进行排序。
- np.argsort(): 返回的是数组值从小到大的索引值。
- np.lexsort(): 返回值是按照最后一个传入数据排序的结果。
例3：使用argsort 函数进行排序。
kk = np.array([1,4,3,2,5,6,7,8,9])
print("原数组：",kk)
ll = kk.argsort()
print("排序后的数组：",kk)
print("数组下标：",ll) #返回值为数组排序后的下标排列
#Output
#原数组： [1 4 3 2 5 6 7 8 9]
#排序后的数组： [1 4 3 2 5 6 7 8 9]
#数组下标： [0 3 2 1 4 5 6 7 8]
可以看出来，argsort 函数仅仅只是将排序后数组的的下标进行展示，而原有数组不受影响。
例4：使用lexsort 函数进行排序。
a = [2,5,8,4,3,7,6]
b = [9,4,0,4,0,2,1]
c = np.lexsort((a,b))
print(c)
#Output
#[4 2 6 5 3 1 0]
lexsort()分为三个步骤
1.将索引与之一一对应。（a,b同时对应即可）
2. 因为lexsort((a,b))中，以b为基准，所以将b排序，再用索引与之对应。
3. 当索引遇见相同元素时，以a中元素的大小顺序排序。
5.2 重复数据与去重
在数理统计分析中，需要提前将重复数据剔除，在NumPy中，可以通过unique 函数找到数组中的唯一值并返回已排序的结果。
数组内数据去重。（unique(a)）
a = np.array(['red','blue','yellow','red','red','white'])
print("原数组：",a)
print("去重后的数组：",np.uni
#Output
#原数组： ['red' 'blue' 'yellow' 'red' 'red' 'white']
#去重后的数组： ['blue' 'red' 'white' 'yellow']
统计分析中有时候需要把一个数据重复若干次，使用tile和repeat函数即可实现此功能。
- tile函数的格式：np.tile(A, reps)
其中，参数A表示要重复的数组，reps表示重复次数。
- repeat函数的格式：np.repeat(A, reps, axis = None)
其中， “a”: 是需要重复的数组元素，“repeats”: 是重复次数， “axis”: 指定沿着哪个轴进行重复，axis = 0表示按行进行元素重复；axis = 1表示按列进行元素重复。
#使用tile 函数实现数据重复。
kk = np.array([1,2,3])
print(kk)
ll = np.tile(kk,3) #将kk数组重复三次
print(ll)
#Output
#[1 2 3]
#[1 2 3 1 2 3 1 2 3]
#使用repeat 函数实现数据重复。
kk = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(kk)
print('------------')
# ll = np.tile(kk,3) #将kk数组重复三次
# print(ll)
ll = np.repeat(kk,2,axis=1)
print(ll)
print('------------')
ss = np.repeat(kk,2,axis=0)
print(ss)
#Output
# [[1 2 3]
# [4 5 6]
# [7 8 9]]
# ------------
# [[1 1 2 2 3 3] #按列进行重复
# [4 4 5 5 6 6]
# [7 7 8 8 9 9]]
# ------------
# [[1 2 3] #按行进行重复
# [1 2 3]
# [4 5 6]
# [4 5 6]
# [7 8 9]
# [7 8 9]]
5.3 常用统计函数
NumPy中提供了很多用于统计分析的函数，常见的有sum、mean、std、var、min和max等。
几乎所有的统计函数在针对二维数组的时候需要注意轴的概念。axis=0时表示沿着纵轴进行计算，axis=1时沿横轴进行计算。用法:np.函数(数组)
| 函数 | 说明 |
|---|---|
| np.sum(a) | 数组的和 |
| np.sum(a,axis = 0) | 数组纵轴的和 |
| np.sum(a,axis = 0) | 数组横轴的和 |
| np.mean(a) | 数组的均值 |
| np.mean(a,axis = 0) | 数组纵轴的均值 |
| np.mean(a,axis = 1) | 数组横轴的均值 |
| np.std(a) | 数组的标准差 |
| np.var(a) | 数组的标准差 |
| np.average(a) | 数组的加权平均值 |
| np.percentile(a) | 数组的分位数 |
| np.ptp(a) | 数组的极差值 |
| np.median(a) | 数组的中位数 |