【数据分析】一、初探 Numpy

目录

• 前言
• [1. 一维 array 的生成](#1. 一维 array 的生成)
• [2. 一维 array 的基本操作](#2. 一维 array 的基本操作)
• • [2.1. 查看属性](#2.1. 查看属性)
  • [2.2. 花式索引](#2.2. 花式索引)
  • [2.3. 条件筛查](#2.3. 条件筛查)
  • [2.4. 数据统计](#2.4. 数据统计)
• [3. n 维 array 的生成](#3. n 维 array 的生成)
• [4. n 维 array 的基本操作](#4. n 维 array 的基本操作)
• • [4.1. 查看属性](#4.1. 查看属性)
  • [4.2. 查询和切片](#4.2. 查询和切片)
  • [4.3. 花式索引](#4.3. 花式索引)
  • [4.4. 矩阵](#4.4. 矩阵)

前言

Numpy是Python的常用开源数值计算扩展 库，用于高效存储和处理大型矩阵。本文主要介绍Numpy的数组 array的操作及其相关函数的使用。

以下对Numpy库函数的介绍中，已传入的参数为默认值 ，并且无返回值的函数不会以赋值形式演示。

1. 一维 array 的生成

• array(p_object, dtype)：引用 一个列表 或元组 ，生成类型 为dtype的一维数组
• arange(start, stop, step)：生成相当于array(range(start, stop, step))的整数序列
• linspace(start, stop, num=50, endpoint=True, retstep=False, dtype='float64')：生成长度 为num，类型 为dtype，在[start, stop]上的等差序列 ；endpoint表示区间右端 是否封闭 ，retstep=True时则返回一个元组(array, step)，即等差数列和步长
• empty(shape, dtype='float64')：生成长度 为shape，类型 为dtype，元素的值 全为空值的一维数组
• zeros(shape, dtype='float64')：生成长度 为shape，类型 为dtype，元素的值 全为0的一维数组
• ones(shape, dtype='float64')：生成*长度为shape，类型 为dtype，元素的 值**全为1的一维数组
• fill(value)：将value转换为原数组的数据类型 后，把原数组的元素的值 全部填充 为value
• random.rand(d)：在区间[0, 1)生成随机浮点数 ，返回长度 为d的一维数组
• random.randn(d)：生成服从正态分布 的随机浮点数 ，返回长度 为d的一维数组
• random.randint(low, high, size, dtype='int')：在区间[low, high)生成类型 为dtype的随机数 ，返回长度 为size的一维数组

import numpy as np

# 引用创建
l = [1, 2, 3, 4]
a = np.array(l, dtype='float')  # [1. 2. 3. 4.]

# 整数序列
a = np.arange(1, 10, 2)         # [1 3 5 7 9]

# 等差数列
a = np.linspace(1, 10, 4)       # [ 1.  4.  7. 10.]

# 全0填充 
a = np.zeros(3, dtype='bool')   # [False False False]

# 全1填充
a = np.ones(4, dtype='int')     # [1 1 1 1]

# 任意值填充
a.fill(2.5)                     # [2 2 2 2]

# 随机浮点数
a = np.random.rand(3)           # [0.39581995 0.13435102 0.31592101]

# 随机正态分布值
a = np.random.randn(3)          # [ 1.62916156  0.44159883 -1.85375949]

# 随机数
a = np.random.randint(1, 3, 5)  # [1 1 2 1 1]

2. 一维 array 的基本操作

2.1. 查看属性

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

# 查看类型：即元素的数据类型
print(a.dtype)              # int32

# 查看维度
print(a.ndim)               # 1

# 查看长度：即元素数目
print(a.size)               # 4

# 查看尺寸：返回一个元组，值为对应维度的元素数目
print(a.shape)              # (4,)

# 类型转换
# a = np.array(a, dtype='float64')
a = a.astype('float64')     # [1. 2. 3. 4.]

2.2. 花式索引

import numpy as np
a = np.arange(1, 20, 2)
'''[ 1  3  5  7  9 11 13 15 17 19]'''

# 索引列表：获取对应索引的元素
print(a[[2, 2, -3, 6, -1]])
'''[ 5  5 15 13 19]'''

# 布尔数组：和numpy数组长度相等，获取布尔值为True的对应位置上的元素
print(a[np.array([1, 1, 0, 1, 0, 1, 1, 0, 1, 0], dtype='bool')])
'''[ 1  3  7 11 13 17]'''

2.3. 条件筛查

import numpy as np
a = np.arange(1, 20, 2)
'''[ 1  3  5  7  9 11 13 15 17 19]'''

# 对数组中的所有元素做条件判断，并在对应位置返回布尔值
print(a > 10)
'''[False False False False False  True  True  True  True  True]'''

# 以元组形式，返回所有符合条件的元素的索引
print(np.where(a > 10))
'''(array([5, 6, 7, 8, 9], dtype=int64),)'''

# 返回所有符合条件的元素的数组
print(a[a > 10])
print(a[np.where(a > 10)])
'''[11 13 15 17 19]'''

2.4. 数据统计

import numpy as np
a = np.array([-5, -2, 3, 1, 4])

'''排列'''
# 正序排列
b = np.sort(a)      # [-5 -2  1  3  4]

# 排列后的元素在原数组中的索引
b = np.argsort(a)   # [0 1 3 2 4]


'''运算'''
# 应用于所有元素
b = a+1             # [-4 -1  4  2  5]

# 应用于对应元素
b = b*a             # [20  2 12  2 20]

# 绝对值
abs = np.abs(a)     # [5 2 3 1 4]

# 指数
exp = np.exp(a)     # [6.73794700e-03 1.35335283e-01 2.00855369e+01 2.71828183e+00 5.45981500e+01]


'''统计'''
# 求和
# s = a.sum()
s = np.sum(a)       # 1

# 最小值
# m = a.min()
m = np.min(a)       # -5

# 最大值
# M = a.max()
M = np.max(a)       # 4

# 均值
# avg = a.mean()
avg = np.mean(a)    # 0.2

# 中值
#
mid = np.median(a)  # 1.0

# 累计和(前缀和)
cs = np.cumsum(a)   # [-5 -7 -4 -3  1]

# 标准差
# std = a.std()
std = np.std(a)     # 3.3105890714493698

3. n 维 array 的生成

• array(p_object, dtype)：引用 一个由 n个相同长度的列表 或元组 构成的元组 ，生成类型 为dtype的n维数组
• empty((*dn), dtype='float64')：生成尺寸 为(d0, d1, ..., dn)，类型 为dtype，元素的值 全为空值 的n维数组
• zeros((*dn), dtype='float64')：生成尺寸 为(d0, d1, ..., dn)，类型 为dtype，元素的值 全为0的n维数组
• ones((*dn), dtype='float64')：生成尺寸 为(d0, d1, ..., dn)，类型 为dtype，元素的值 全为1的n维数组
• fill(value)：将value转换为原数组的数据类型 后，把原数组的元素的值 全部填充 为value
• random.rand(*dn)：在区间[0, 1)生成随机浮点数 ，返回尺寸 为(d0, d1, ..., dn)的n维数组
• random.randn(*dn)：生成服从正态分布 的随机浮点数 ，返回尺寸 为(d0, d1, ..., dn)的n维数组
• random.randint(low, high, (*dn), dtype='int')：在区间[low, high)生成类型 为dtype的随机数 ，返回尺寸 为(d0, d1, ..., dn)的n维数组

import numpy as np

# 引用创建
a = np.array(([1, 2, 3, 4], (5, 6, 7, 8)))
'''
[[1 2 3 4]
 [5 6 7 8]]
'''

# 全0填充
a = np.zeros((2, 4))
'''
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]]
'''

# 全1填充
a = np.ones((2, 4))
'''
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]]
'''

# 任意值填充
a.fill(False)
'''
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]]
'''

# 随机浮点数
a = np.random.rand(2, 2)
'''
[[0.11188812 0.83587679]
 [0.98262527 0.79479766]]
'''

# 随机正态分布值
a = np.random.randn(2, 2)
'''
[[-0.79453966 -1.5958028 ]
 [ 0.89898492 -0.9779685 ]]
'''

# 随机数
a = np.random.randint(1, 10, (2, 4))
'''
[[9 7 3 9]
 [3 7 4 8]]
'''

4. n 维 array 的基本操作

以二维数组为例。

4.1. 查看属性

import numpy as np
a = np.array(([1, 2, 3, 4], (5, 6, 7, 8)))
'''
[[1 2 3 4]
 [5 6 7 8]]
'''

# 查看类型
print(a.dtype)              # int32

# 查看维度
print(a.ndim)               # 2

# 查看数目
print(a.size)               # 8

# 查看尺寸
print(a.shape)              # (2, 4)

# 对数组所有元素进行运算
a = a+1
'''
[[2 3 4 5]
 [6 7 8 9]]
'''

# 两个数组的对应元素进行运算
a = a*(a-1)
'''
[[ 2  6 12 20]
 [30 42 56 72]]
'''

4.2. 查询和切片

import numpy as np
a = np.array(([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]))
'''
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]]
'''
print(a)
# 单元查询：对于a[x, y]，x是行索引，y是列索引
print(a[1, 0])              # 5

# 单行查询
print(a[1])                 # [5 6 7 8]

# 单列查询
print(a[:, 1])              # [ 2  6 10 14]

# 连续区域切片
print(a[1:3, 1:3])
'''
[[ 6  7]
 [10 11]]
'''

# 离散区域切片
print(a[1::2, 1::2])
'''
[[ 6  8]
 [14 16]]
'''

# 不完全索引：只给出行索引范围时，默认对整行切片
print(a[:3])
'''
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
'''

与列表不同的是，Numpy数组的切片是对原数组的引用 ，即它们共同指向一处内存空间，这意味元素的修改会同时作用到数组和它的切片上。可以用copy()方法进行拷贝，申请新的内存。

import numpy as np

a = np.array([1, 2, 3, 4])
b = a[1: 3]
b[0] = '0'
print(a)    # [1 0 3 4]

a = [1, 2, 3, 4]
b = a[1: 3]
b[0] = '0'
print(a)    # [1, 2, 3, 4]

4.3. 花式索引

花式索引 是对原数组的拷贝而非引用。

import numpy as np
a = np.array(([1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]))
'''
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]
 [13 14 15 16]]
'''

# 索引列表
print(a[[0, 1, 2, 3], [0, 1, 2, 3]])
'''[ 1  6 11 16]'''

# 布尔数组：需要指定列
mask = np.array([0, 1, 0, 1], dtype='bool')
print(a[mask])
'''
[[ 5  6  7  8]
 [13 14 15 16]]
'''
print(a[mask, 1])   # [ 6 14]
print(a[1, mask])   # [6 8]

# 配合切片使用花式索引
print(a[1: 3, [0, 3]])
'''
[[ 5  8]
 [ 9 12]]
'''
'''

4.4. 矩阵

import numpy as np
x = np.array([1, 3, 2, 4, 6, 9])
y = np.array([13, 25, 37, 42, 54, 69])

# 相关系数矩阵
cov = np.cov(x, y)
'''
[[  8.56666667  55.        ]
 [ 55.         400.8       ]]
'''

# 变形
x = x.reshape(2, 3)
'''
[[1 3 2]
 [4 6 9]]
'''
y.shape = (2, 3)
print(y)                # 原矩阵发生改变
'''
[[13 25 37]
 [42 54 69]]
'''

# 转置
# x_T = x.T
x_T = x.transpose()     # 原矩阵不发生改变
'''
[[1 4]
 [3 6]
 [2 9]]
'''

# 连接
'''沿行方向，即第一维（默认）'''
# z = np.vstack((x, y))
z = np.concatenate((x, y), axis=0)
'''
[[ 1  3  2]
 [ 4  6  9]
 [13 25 37]
 [42 54 69]]
'''

'''沿列方向，即第二维'''
# z = np.hstack((x, y))
z = np.concatenate((x, y), axis=1)
'''
[[ 1  3  2 13 25 37]
 [ 4  6  9 42 54 69]]
'''

'''沿垂直方向，即第三维'''
z = np.array((x, y))
print(z)
'''
[[[ 1  3  2]
  [ 4  6  9]]

 [[13 25 37]
  [42 54 69]]]
'''
z = np.dstack((x, y))
'''
[[[ 1 13]
  [ 3 25]
  [ 2 37]]

 [[ 4 42]
  [ 6 54]
  [ 9 69]]]
'''