Python 数据科学-Numpy

NumPy

Numpy ：提供了一个在Python中做科学计算的基础库，重在数值计算，主要用于多维数组（矩阵）处理的库。用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多。本身是由C语言开发，是个很基础的扩展，Python其余的科学计算扩展大部分都是以此为基础。

高性能科学计算和数据分析的基础包
ndarray，多维数组（矩阵），具有矢量运算能力，快速、节省空间
矩阵运算，无需循环，可完成类似Matlab中的矢量运算
线性代数、随机数生成

使用以下语句导入 Numpy 库：

import numpy as np

NumPy 数组

创建数组

>>> a = np.array([1,2,3])

>>> b = np.array([(1.5,2,3), (4,5,6)], dtype = float)

>>> c = np.array([[(1.5,2,3), (4,5,6)], [(3,2,1), (4,5,6)]], dtype = float)

初始化占位符

>>> np.zeros((3,4))# 创建值为0数组

>>> np.ones((2,3,4),dtype=np.int16)# 创建值为1数组

>>> d = np.arange(10,25,5)# 创建均匀间隔的数组（步进值）

>>> np.linspace(0,2,9)# 创建均匀间隔的数组（样本数）

>>> e = np.full((2,2),7)# 创建常数数组

>>> f = np.eye(2)# 创建2x2单位矩阵

>>> np.random.random((2,2))# 创建随机值的数组

>>> np.empty((3,2))#创建空数组

输入/输出

保存与载入磁盘上的文件

>>> np.save('my_array', a)

>>> np.savez('array.npz', a, b)

>>> np.load('my_array.npy')

保存与载入文本文件

>>> np.loadtxt("myfile.txt")

>>> np.genfromtxt("my_file.csv", delimiter=',')

>>> np.savetxt("myarray.txt", a, delimiter=" ")

数据类型

>>> np.int64# 带符号的64位整数

>>> np.float32# 标准双精度浮点数

>>> np.complex# 显示为128位浮点数的复数 

>>> np.bool#  布尔值：True值和False值 

>>> np.object#Python对象 

>>> np.string_# 固定长度字符串

>>> np.unicode_# 固定长度Unicode

数组信息

>>> a.shape# 数组形状 几行几列 

>>> len(a) #数组长度

>>> b.ndim #几维数组

>>> e.size# 数组有多少元素

>>> b.dtype# 数据类型 

>>> b.dtype.name# 数据类型的名字

>>> b.astype(int) #数据类型转换

调用帮助

>>> np.info(np.ndarray.dtype)

数组计算

算数运算

减法减法加法加法除法除法乘法乘法幂平方根正弦余弦自然对数点积

>>> g = a - b array([[-0.5, 0. , 0. ], [-3. , -3. , -3. ]])

>>> np.subtract(a,b)

>>> b + a array([[ 2.5, 4. , 6. ], [ 5. , 7. , 9. ]])

>>> np.add(b,a)

>>> a / b array([[ 0.66666667, 1. , 1. ], [ 0.25 , 0.4 , 0.5 ]])

>>> np.divide(a,b)

>>> a * b array([[ 1.5, 4. , 9. ], [ 4. , 10. , 18. ]])

>>> np.multiply(a,b)

>>> np.exp(b)

>>> np.sqrt(b)

>>> np.sin(a)

>>> np.cos(b)

>>> np.log(a)

>>> e.dot(f)

array([[ 7., 7.], [ 7., 7.]])

比较

>>> a == b array([[False, True, True], [False, False, False]], dtype=bool)# 对比值

>>> a < 2 array([True, False, False], dtype=bool)# 对比值 

>>> np.array_equal(a, b)  # 对比数组

聚合函数

>>> a.sum()# 数组汇总

>>> a.min()#  数组最小值

>>> b.max(axis=0)#数组最大值

>>> b.cumsum(axis=1)# 按行 数组元素的累加值

>>> a.mean()# 平均数

>>> b.median()# 中位数 

>>> a.corrcoef()# 相关系数

>>> np.std(b)#  标准差

数组复制

>>> h = a.view()# 使用同一数据创建数组视图

>>> np.copy(a)# 创建数组的副本

>>> h = a.copy() #  创建数组的深度拷贝

数组排序

>>> a.sort()# 数组排序

>>> c.sort(axis=0) #  以轴为依据对数组排序

子集、切片、索引

a:b：

子集

>>> a[2]# 选择索引2对应的值

>>>b[1,2]#选择行1列2对应的值（等同于b[1][2]

6.0

切片

>>> a[0:2] #  选择索引为0与1对应的值 

array([1, 2])

>>> b[0:2,1]# 选择第1列中第0行、第1行的值

array([ 2., 5.])

>>> b[:1]#  选择第0行的所有值（等同于b[0:1,:1]

array([[1.5, 2., 3.]])

>>> c[1,...]#  等同于 [1,:,:]

array([[[ 3., 2., 1.], [ 4., 5., 6.]]])

>>> a[ : :-1]#  反转数组a

array([3, 2, 1])

条件索引

>>> a[a<2]#  选择数组a中所有小于2的值 

array([1])

花式索引

>>> b[[1, 0, 1, 0],[0, 1, 2, 0]]# 选择(1,0),(0,1),(1,2) 和(0,0)所对应的值

array([ 4. , 2. , 6. , 1.5])

>>> b[[1, 0, 1, 0]][:,[0,1,2,0]]# 选择矩阵的行列子集 

array([[ 4. ,5. , 6. , 4. ], [ 1.5, 2. , 3. , 1.5], [ 4. , 5. , 6. , 4. ], [ 1.5, 2. , 3. , 1.5]])

数组操作

转置数组

>>> i = np.transpose(b)# 转置数组

>>> i.T# 转置数组

改变数组形状

>>> b.ravel()# 拉平数组

>>> g.reshape(3,-2)# 改变数组形状，但不改变数据

添加或删除值

>>> h.resize((2,6))# 返回形状为(2,6)的新数组

>>> np.append(h,g)# 追加数据

>>> np.insert(a, 1, 5)# 插入数据

>>> np.delete(a,[1])# 删除数据

合并数组

>>> np.concatenate((a,d),axis=0)# 拼接数组

array([ 1, 2, 3, 10, 15, 20])

>>> np.vstack((a,b))# 纵向以行的维度堆叠数组 

array([[ 1. , 2. , 3. ], [ 1.5, 2. , 3. ], [ 4. , 5. , 6. ]])

>>> np.r_[e,f]# 纵向以行的维度堆叠数组

>>> np.hstack((e,f))# 横向以列的维度堆叠数组 

array([[ 7., 7., 1., 0.], [ 7., 7., 0., 1.]])

>>> np.column_stack((a,d))# 以列的维度创建堆叠数组

array([[ 1, 10], [ 2, 15], [ 3, 20]])

 >>> np.c_[a,d] # 以列的维度创建堆叠数组

分割数组

>>> np.hsplit(a,3)#  纵向分割数组为3等份
[array([1]),array([2]),array([3])]

>>> np.vsplit(c,2) # 横向分割数组为2等份

[array([[[ 1.5, 2. , 1. ], [ 4. , 5. , 6. ]]]), array([[[ 3., 2., 3.], [ 4., 5., 6.]]])]

ndarray的随机创建

通过随机抽样 (numpy.random) 生成随机数据。

示例代码：

# 导入numpy，别名np
import numpy as np

# 生成指定维度大小（3行4列）的随机多维浮点型数据（二维），rand固定区间0.0 ~ 1.0
arr = np.random.rand(3, 4)
print(arr)
print(type(arr))

# 生成指定维度大小（3行4列）的随机多维整型数据（二维），randint()可以指定区间（-1, 5）
arr = np.random.randint(-1, 5, size = (3, 4)) # 'size='可省略
print(arr)
print(type(arr))

# 生成指定维度大小（3行4列）的随机多维浮点型数据（二维），uniform()可以指定区间（-1, 5）
arr = np.random.uniform(-1, 5, size = (3, 4)) # 'size='可省略
print(arr)
print(type(arr))

print('维度个数: ', arr.ndim)
print('维度大小: ', arr.shape)
print('数据类型: ', arr.dtype)

运行结果：

[[ 0.09371338  0.06273976  0.22748452  0.49557778]
 [ 0.30840042  0.35659161  0.54995724  0.018144  ]
 [ 0.94551493  0.70916088  0.58877255  0.90435672]]
<class 'numpy.ndarray'>

[[ 1  3  0  1]
 [ 1  4  4  3]
 [ 2  0 -1 -1]]
<class 'numpy.ndarray'>

[[ 2.25275308  1.67484038 -0.03161878 -0.44635706]
 [ 1.35459097  1.66294159  2.47419548 -0.51144655]
 [ 1.43987571  4.71505054  4.33634358  2.48202309]]
<class 'numpy.ndarray'>

维度个数:  2
维度大小:  (3, 4)
数据类型:  float64

ndarray的序列创建

`np.array(collection)`

collection 为序列型对象(list)、嵌套序列对象(list of list)。

示例代码：

# list序列转换为 ndarray
lis = range(10)
arr = np.array(lis)

print(arr)            # ndarray数据
print(arr.ndim)        # 维度个数
print(arr.shape)    # 维度大小

# list of list嵌套序列转换为ndarray
lis_lis = [range(10), range(10)]
arr = np.array(lis_lis)

print(arr)            # ndarray数据
print(arr.ndim)        # 维度个数
print(arr.shape)    # 维度大小

运行结果：

# list序列转换为 ndarray
[0 1 2 3 4 5 6 7 8 9]
1
(10,)

# list of list嵌套序列转换为 ndarray
[[0 1 2 3 4 5 6 7 8 9]
 [0 1 2 3 4 5 6 7 8 9]]
2
(2, 10)

`np.zeros()`

指定大小的全0数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。

`np.ones()`

指定大小的全1数组。注意：第一个参数是元组，用来指定大小，如(3, 4)。

`np.empty()`

初始化数组，不是总是返回全0，有时返回的是未初始的随机值（内存里的随机值）。

示例代码：

# np.zeros
zeros_arr = np.zeros((3, 4))

# np.ones
ones_arr = np.ones((2, 3))

# np.empty
empty_arr = np.empty((3, 3))

# np.empty 指定数据类型
empty_int_arr = np.empty((3, 3), int)

print('------zeros_arr-------')
print(zeros_arr)

print('\n------ones_arr-------')
print(ones_arr)

print('\n------empty_arr-------')
print(empty_arr)

print('\n------empty_int_arr-------')
print(empty_int_arr)

运行结果：

------zeros_arr-------
[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]

------ones_arr-------
[[ 1.  1.  1.]
 [ 1.  1.  1.]]

------empty_arr-------
[[ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]]

------empty_int_arr-------
[[0 0 0]
 [0 0 0]
 [0 0 0]]

5. `np.arange()` 和 `reshape()`

arange() 类似 python 的 range() ，创建一个一维 ndarray 数组。

reshape() 将重新调整数组的维数。

示例代码：

# np.arange()
arr = np.arange(15) # 15个元素的 一维数组
print(arr)
print(arr.reshape(3, 5)) # 3x5个元素的 二维数组
print(arr.reshape(1, 3, 5)) # 1x3x5个元素的 三维数组

运行结果：

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

[[[ 0  1  2  3  4]
  [ 5  6  7  8  9]
  [10 11 12 13 14]]]

6. `np.arange()` 和 `random.shuffle()`

random.shuffle() 将打乱数组序列（类似于洗牌）。

示例代码：

arr = np.arange(15)
print(arr)

np.random.shuffle(arr)
print(arr)
print(arr.reshape(3,5))

运行结果：

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

[ 5  8  1  7  4  0 12  9 11  2 13 14 10  3  6]

[[ 5  8  1  7  4]
 [ 0 12  9 11  2]
 [13 14 10  3  6]]

ndarray的数据类型

1. `dtype`参数

指定数组的数据类型，类型名+位数，如float64, int32

2. `astype`方法

转换数组的数据类型

示例代码（1、2）：

# 初始化3行4列数组，数据类型为float64
zeros_float_arr = np.zeros((3, 4), dtype=np.float64)
print(zeros_float_arr)
print(zeros_float_arr.dtype)

# astype转换数据类型，将已有的数组的数据类型转换为int32
zeros_int_arr = zeros_float_arr.astype(np.int32)
print(zeros_int_arr)
print(zeros_int_arr.dtype)

运行结果：

[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]
float64

[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]
int32

ndarray的矩阵运算

数组是编程中的概念，矩阵、矢量是数学概念。

在计算机编程中，矩阵可以用数组形式定义，矢量可以用结构定义!

1. 矢量运算：相同大小的数组间运算应用在元素上

# 矢量与矢量运算
arr = np.array([[1, 2, 3],
                [4, 5, 6]])

print("元素相乘：")
print(arr * arr)

print("矩阵相加：")
print(arr + arr)

运行结果：

元素相乘：
[[ 1  4  9]
 [16 25 36]]

矩阵相加：
[[ 2  4  6]
 [ 8 10 12]]

2. 矢量和标量运算："广播" - 将标量"广播"到各个元素

# 矢量与标量运算
print(1. / arr)
print(2. * arr)

运行结果：

[[ 1.          0.5         0.33333333]
 [ 0.25        0.2         0.16666667]]

[[  2.   4.   6.]
 [  8.  10.  12.]]

ndarray的索引与切片

1. 一维数组的索引与切片

与Python的列表索引功能相似

# 一维数组
arr1 = np.arange(10)
print(arr1)
print(arr1[2:5])

运行结果：

[0 1 2 3 4 5 6 7 8 9]
[2 3 4]

2. 多维数组的索引与切片：

arr[r1:r2, c1:c2]

arr[1,1] 等价 arr[1][1]

[:] 代表某个维度的数据

# 多维数组
arr2 = np.arange(12).reshape(3,4)
print(arr2)

print(arr2[1])

print(arr2[0:2, 2:])

print(arr2[:, 1:3])

运行结果：

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

[4 5 6 7]

[[2 3]
 [6 7]]

[[ 1  2]
 [ 5  6]
 [ 9 10]]

3. 条件索引

布尔值多维数组：arr[condition]，condition也可以是多个条件组合。

注意，多个条件组合要使用 & | 连接，而不是Python的 and or。

# 条件索引

# 找出 data_arr 中 2005年后的数据
data_arr = np.random.rand(3,3)
print(data_arr)

year_arr = np.array([[2000, 2001, 2000],
                     [2005, 2002, 2009],
                     [2001, 2003, 2010]])

is_year_after_2005 = year_arr >= 2005
print(is_year_after_2005, is_year_after_2005.dtype)

filtered_arr = data_arr[is_year_after_2005]
print(filtered_arr)

#filtered_arr = data_arr[year_arr >= 2005]
#print(filtered_arr)

# 多个条件
filtered_arr = data_arr[(year_arr <= 2005) & (year_arr % 2 == 0)]
print(filtered_arr)

运行结果：

[[ 0.53514038  0.93893429  0.1087513 ]
 [ 0.32076215  0.39820313  0.89765765]
 [ 0.6572177   0.71284822  0.15108756]]

[[False False False]
 [ True False  True]
 [False False  True]] bool

[ 0.32076215  0.89765765  0.15108756]

[ 0.32076215  0.89765765  0.15108756]

[ 0.53514038  0.1087513   0.39820313]

ndarray的维数转换

二维数组直接使用转换函数：transpose()

高维数组转换要指定维度编号参数 (0, 1, 2, …)，注意参数是元组

arr = np.random.rand(2,3)    # 2x3 数组
print(arr)    
print(arr.transpose()) # 转换为 3x2 数组


arr3d = np.random.rand(2,3,4) # 2x3x4 数组，2对应0，3对应1，4对应3
print(arr3d)
print(arr3d.transpose((1,0,2))) # 根据维度编号，转为为 3x2x4 数组

运行结果：

# 二维数组转换
# 转换前：
[[ 0.50020075  0.88897914  0.18656499]
 [ 0.32765696  0.94564495  0.16549632]]

# 转换后：
[[ 0.50020075  0.32765696]
 [ 0.88897914  0.94564495]
 [ 0.18656499  0.16549632]]

# 高维数组转换
# 转换前：
[[[ 0.91281153  0.61213743  0.16214062  0.73380458]
  [ 0.45539155  0.04232412  0.82857746  0.35097793]
  [ 0.70418988  0.78075814  0.70963972  0.63774692]]

 [[ 0.17772347  0.64875514  0.48422954  0.86919646]
  [ 0.92771033  0.51518773  0.82679073  0.18469917]
  [ 0.37260457  0.49041953  0.96221477  0.16300198]]]

# 转换后：
[[[ 0.91281153  0.61213743  0.16214062  0.73380458]
  [ 0.17772347  0.64875514  0.48422954  0.86919646]]

 [[ 0.45539155  0.04232412  0.82857746  0.35097793]
  [ 0.92771033  0.51518773  0.82679073  0.18469917]]

 [[ 0.70418988  0.78075814  0.70963972  0.63774692]
  [ 0.37260457  0.49041953  0.96221477  0.16300198]]]

元素计算函数

ceil(): 向上最接近的整数，参数是 number 或 array
floor(): 向下最接近的整数，参数是 number 或 array
rint(): 四舍五入，参数是 number 或 array
isnan(): 判断元素是否为 NaN(Not a Number)，参数是 number 或 array
multiply(): 元素相乘，参数是 number 或 array
divide(): 元素相除，参数是 number 或 array
abs()：元素的绝对值，参数是 number 或 array
where(condition, x, y): 三元运算符，x if condition else y

# randn() 返回具有标准正态分布的序列。
arr = np.random.randn(2,3)

print(arr)

print(np.ceil(arr))

print(np.floor(arr))

print(np.rint(arr))

print(np.isnan(arr))

print(np.multiply(arr, arr))

print(np.divide(arr, arr))

print(np.where(arr > 0, 1, -1))

运行结果：

# print(arr)
[[-0.75803752  0.0314314   1.15323032]
 [ 1.17567832  0.43641395  0.26288021]]

# print(np.ceil(arr))
[[-0.  1.  2.]
 [ 2.  1.  1.]]

# print(np.floor(arr))
[[-1.  0.  1.]
 [ 1.  0.  0.]]

# print(np.rint(arr))
[[-1.  0.  1.]
 [ 1.  0.  0.]]

# print(np.isnan(arr))
[[False False False]
 [False False False]]

# print(np.multiply(arr, arr))
[[  5.16284053e+00   1.77170104e+00   3.04027254e-02]
 [  5.11465231e-03   3.46109263e+00   1.37512421e-02]]

# print(np.divide(arr, arr))
[[ 1.  1.  1.]
 [ 1.  1.  1.]]

# print(np.where(arr > 0, 1, -1))
[[ 1  1 -1]
 [-1  1  1]]

元素统计函数

np.mean(), np.sum()：所有元素的平均值，所有元素的和，参数是 number 或 array
np.max(), np.min()：所有元素的最大值，所有元素的最小值，参数是 number 或 array
np.std(), np.var()：所有元素的标准差，所有元素的方差，参数是 number 或 array
np.argmax(), np.argmin()：最大值的下标索引值，最小值的下标索引值，参数是 number 或 array
np.cumsum(), np.cumprod()：返回一个一维数组，每个元素都是之前所有元素的累加和和累乘积，参数是 number 或 array
多维数组默认统计全部维度，axis参数可以按指定轴心统计，值为0则按列统计，值为1则按行统计。

arr = np.arange(12).reshape(3,4)
print(arr)

print(np.cumsum(arr)) # 返回一个一维数组，每个元素都是之前所有元素的 累加和

print(np.sum(arr)) # 所有元素的和

print(np.sum(arr, axis=0)) # 数组的按列统计和

print(np.sum(arr, axis=1)) # 数组的按行统计和

运行结果：

# print(arr)
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

# print(np.cumsum(arr)) 
[ 0  1  3  6 10 15 21 28 36 45 55 66]

# print(np.sum(arr)) # 所有元素的和
66

# print(np.sum(arr, axis=0)) # 0表示对数组的每一列的统计和
[12 15 18 21]

# print(np.sum(arr, axis=1)) # 1表示数组的每一行的统计和
[ 6 22 38]

元素判断函数

np.any(): 至少有一个元素满足指定条件，返回True
np.all(): 所有的元素满足指定条件，返回True

arr = np.random.randn(2,3)
print(arr)

print(np.any(arr > 0))
print(np.all(arr > 0))

运行结果：

[[ 0.05075769 -1.31919688 -1.80636984]
 [-1.29317016 -1.3336612  -0.19316432]]

True
False

元素去重排序函数

np.unique():找到唯一值并返回排序结果，类似于Python的set集合

arr = np.array([[1, 2, 1], [2, 3, 4]])
print(arr)

print(np.unique(arr))

运行结果：

[[1 2 1]
 [2 3 4]]

[1 2 3 4]

最后补充一个库Scipy

Scipy ：基于Numpy提供了一个在Python中做科学计算的工具集，专为科学和工程设计的Python工具包。主要应用于统计、优化、整合、线性代数模块、傅里叶变换、信号和图像处理、常微分方程求解、稀疏矩阵等，在数学系或者工程系相对用的多一些，和数据处理的关系不大，我们知道即可，这里不做讲解。

在NumPy库的基础上增加了众多的数学、科学及工程常用的库函数
线性代数、常微分方程求解、信号处理、图像处理
一般的数据处理numpy已经够用
import scipy as sp

posted @ 2019-08-22 08:28 Timcode 阅读(547) 评论(0) 编辑收藏举报

刷新页面返回顶部

Timcode

Python 数据科学-Numpy

NumPy

NumPy 数组

创建数组

初始化占位符

输入/输出

保存与载入磁盘上的文件

保存与载入文本文件

数据类型

数组信息

调用帮助

数组计算

算数运算

减法 减法 加法 加法 除法 除法 乘法 乘法 幂 平方根 正弦 余弦 自然对数 点积

比较

聚合函数

数组复制

数组排序

子集、切片、 索引

子集

切片

条件索引

花式索引

数组操作

转置数组

改变数组形状

添加或删除值

合并数组

分割数组

ndarray的随机创建

ndarray的序列创建

np.array(collection)

np.zeros()

np.ones()

np.empty()

5. np.arange() 和 reshape()

6. np.arange() 和 random.shuffle()

ndarray的数据类型

1. dtype参数

2. astype方法

ndarray的矩阵运算

1. 矢量运算：相同大小的数组间运算应用在元素上

2. 矢量和标量运算："广播" - 将标量"广播"到各个元素

ndarray的索引与切片

1. 一维数组的索引与切片

2. 多维数组的索引与切片：

3. 条件索引

ndarray的维数转换

元素计算函数

元素统计函数

元素判断函数

元素去重排序函数

最后补充一个库Scipy

公告

减法减法加法加法除法除法乘法乘法幂平方根正弦余弦自然对数点积

子集、切片、索引

`np.array(collection)`

`np.zeros()`

`np.ones()`

`np.empty()`

5. `np.arange()` 和 `reshape()`

6. `np.arange()` 和 `random.shuffle()`

1. `dtype`参数

2. `astype`方法