python学习笔记35：numpy_learn

numpy_learn

重要特点：N维数组对象，即ndarray对象
ndarray对象中存储的数据类型要是一致的

import numpy as np
data = np.arange(12).reshape(3,4)
data

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

# 维度个数
data.ndim

2

# 数组维度
data.shape

(3, 4)

# 数组元素总个数
data.size

12

# 数组元素类型
data.dtype

dtype('int64')

# 数组元素字节大小
data.itemsize

8

创建Numpy对象

array(),括号里面传入python数据类型，如list、tuple等

import numpy as np
data1 = np.array([1,2,3])  # 传入列表，构建一个1维数组
data1

array([1, 2, 3])

data1.ndim

1

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

array([[1, 2, 3],
       [2, 3, 4]])

# 括号里面传入元组
np.zeros((3,4))

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

np.ones((3,4))

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

# 空数组，里面的数据是随机的，默认的数据float64
np.empty((3,4)).dtype

dtype('float64')

# 返回的是一个数组，而不是列表
# 等差数组
np.arange(1,20,5)

array([ 1,  6, 11, 16])

# 可以申明元素数据类型
np.ones((3,4), int)

array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]])

ndarray对象的数据类型

int,float,bool,unicode,string,complex

data_one = np.array([1,2,3])
data_one.dtype.name

'int64'

数据类型转化
asdtype()

data_turn1 = data_one.astype('float64')
data_turn1.dtype

dtype('float64')

data_turn2 = data_one.astype(np.float32)
data_turn2.dtype

dtype('float32')

# 字符直接转数字
str_data = np.array(['1','2'])
str_data

array(['1', '2'], dtype='<U1')

str_data1 = str_data.astype(np.int)
str_data1

array([1, 2])

数组运算

# 对应元素相加、减、乘、除
data1 = np.array([1,2,3])
data2 = np.array([2,3,4])
data1 + data2

array([3, 5, 7])

# 数组广播，数组形状不同时，做运算会自动进行扩展
data3 = np.array([[1],[2],[3],[4]])
data3

array([[1],
       [2],
       [3],
       [4]])

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

array([1, 2, 3])

data3 + data4

array([[2, 3, 4],
       [3, 4, 5],
       [4, 5, 6],
       [5, 6, 7]])

data3 + 10

array([[11],
       [12],
       [13],
       [14]])

数组的索引与切片

1维数组

data1 = np.arange(10)
data1

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

data1[0]

0

data1[0:3]

array([0, 1, 2])

data1[:3]

array([0, 1, 2])

data1[:6:1]

array([0, 1, 2, 3, 4, 5])

data1[:6:2]

array([0, 2, 4])

2维数组

data2 = np.array([[1,2,3],[2,3,4],[3,4,5]])
data2

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

data2[0]

array([1, 2, 3])

data2[0:2] # 后不包

array([[1, 2, 3],
       [2, 3, 4]])

data2[0:2,0:2]

array([[1, 2],
       [2, 3]])

# 获取某一列时，行哪里要用：
data2[:,0:2]

array([[1, 2],
       [2, 3],
       [3, 4]])

花式索引

# 建立空数组
data1 = np.empty((4,4))
data1

array([[ 5.92878775e-323,  0.00000000e+000,  0.00000000e+000,
         0.00000000e+000],
       [ 0.00000000e+000,  0.00000000e+000,  0.00000000e+000,
         0.00000000e+000],
       [ 0.00000000e+000,  0.00000000e+000,  0.00000000e+000,
         0.00000000e+000],
       [ 2.68156159e+154, -1.49458022e-154,  2.68156159e+154,
        -4.34384816e-311]])

# 动态为数组添加元素
for i in range(4):
    data1[i] = np.arange(i, i+4)
    
data1

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

# 获取第0、2行数据
data1[[0,2]]

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

data1[[0,2], [0,1]]

array([0., 3.])

布尔索引

data1 = np.arange(12).reshape(3,4)
data1

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

data1 == 1

array([[False,  True, False, False],
       [False, False, False, False],
       [False, False, False, False]])

data1[data1 == 2]

array([2])

数组转置和轴对称

data1 = np.arange(12).reshape(3,4)
data1

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

data1.T

array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])

numpy通用函数

• abs fabs 绝对值

• sqrt 平方根

• square 平方

• exp 指数幂

• log、log10、log2、log1p

• sign 符号函数，正数1，负数-1，0

• ceil 大于等于最小整数

• floor 小于等于最大整数

• rint 四舍五入后的最小整数

• modf 小数和整数分开为两个独立数组的形式返回

• isnan 是否为整数

• isfinite isinf 无穷和有穷

• sin sinh cos cosh tan tanh

• arcos arccosh arcsin

• add 加法

• substract 减法

• multiply 乘

• divide floor_divide 除和整除

• maximum fmax 最大

• minimum fmin 最小

• mod 求摸

• copysign 复制元素符号

data = np.array([4,9,16])

np.sqrt(data)

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

np.ceil(data)

array([ 4.,  9., 16.])

数据分析

条件逻辑转为数组运算

data1 = np.array([1,2,3])
data2 = np.array(['a','b','c'])
data3 = np.array([True, False, True])
# 当data3中为True时，从data1中取值，反之取data2
np.where(data3,data1,data2)

array(['1', 'b', '3'], dtype='<U21')

数组统计运算

data1 = np.arange(12)
data1

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

data1.sum()

66

data1.mean()

5.5

data1.min()

0

data1.max()

11

# 最小值索引
data1.argmin()

0

data1.argmax()

11

data1.cumsum()

array([ 0,  1,  3,  6, 10, 15, 21, 28, 36, 45, 55, 66])

# 累计求乘积
data1.cumprod()

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])

排序

data = np.arange(12).reshape(3,4).T
data

array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])

data.sort()
data

array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])

data.sort(0)
data

array([[ 0,  4,  8],
       [ 1,  5,  9],
       [ 2,  6, 10],
       [ 3,  7, 11]])

检查数组元素

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

array([1, 2, 3])

np.any(data>4)

False

np.all(data>0)

True

唯一化及其他集合逻辑

# unique取唯一值，并对数组进行排序
data = np.array([3,3,2,1])
np.unique(data)

array([1, 2, 3])

• np.in1d(a,b) 判断a数组元素是否在b数组里面，返回布尔结果
• np.intersect1d(a,b) 计算a,b中的公共元素，并返回排序结果
• np.union1d(a,b) 计算a,b的并集，并返回有序结果
• np.setdiff1d(a,b) 集合的差
• np.setxor1d(a,b) 集合的对称差，即存在一个数组中，但是不同时存在两个数组的元素

线性代数模块

numpy.linalg模块中有一组标准的矩阵分解以及逆和行列式之类的东西

x = np.array([[1],[2]])
y = np.array([3,4]).reshape(1,2)
x

array([[1],
       [2]])

y

array([[3, 4]])

np.dot(x,y)

array([[3, 4],
       [6, 8]])

• np.dot() 点积
• np.diag() 以1维数组的形式返回方阵的对角线，或将1维数组转化为方阵
• np.trace() 计算对角线元素的和
• np.linalg.det() 计算矩阵的行列式
• np.linalg.eig() 计算方阵的特征值和特征向量
• np.linalg.inv() 计算方阵的逆
• np.linalg.qr() 计算qr分解
• np.linalg.svd() 计算奇异值
• np.linalg.solve() 解线性方程组Ax=b,其中A是一个方阵
• np.linalg.lstsq() 计算Ax=b的最小二乘解

data = np.arange(16).reshape(4,4)
data

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

np.diag(data)

array([ 0,  5, 10, 15])

np.trace(data)

30

np.linalg.det(data)

-2.9582283945787796e-30

np.linalg.eig(data)

(array([ 3.24642492e+01, -2.46424920e+00,  1.92979794e-15, -4.09576009e-16]),
 array([[-0.11417645, -0.7327781 ,  0.54500164,  0.00135151],
        [-0.3300046 , -0.28974835, -0.68602671,  0.40644504],
        [-0.54583275,  0.15328139, -0.2629515 , -0.8169446 ],
        [-0.76166089,  0.59631113,  0.40397657,  0.40914805]]))

np.linalg.inv(data)

array([[ 9.00719925e+14, -4.50359963e+14, -1.80143985e+15,
         1.35107989e+15],
       [-2.40191980e+15,  2.70215978e+15,  1.80143985e+15,
        -2.10167983e+15],
       [ 2.10167983e+15, -4.05323966e+15,  1.80143985e+15,
         1.50119988e+14],
       [-6.00479950e+14,  1.80143985e+15, -1.80143985e+15,
         6.00479950e+14]])

np.linalg.qr(data)

(array([[ 0.        , -0.83666003,  0.48308786,  0.25812035],
        [-0.26726124, -0.47809144, -0.8365087 ,  0.01591196],
        [-0.53452248, -0.11952286,  0.22375381, -0.80618499],
        [-0.80178373,  0.23904572,  0.12966702,  0.53215267]]),
 array([[-1.49666295e+01, -1.65701970e+01, -1.81737645e+01,
         -1.97773319e+01],
        [ 0.00000000e+00, -1.19522861e+00, -2.39045722e+00,
         -3.58568583e+00],
        [ 0.00000000e+00,  0.00000000e+00, -1.71941189e-15,
         -5.12511879e-15],
        [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,
         -8.82043219e-16]]))

random模块

# 生成数组,每次运行出来的数组都不一样
np.random.rand(3,3)

array([[0.93921666, 0.42365706, 0.84692929],
       [0.08043763, 0.19183508, 0.59509369],
       [0.10962175, 0.58845541, 0.47584158]])

• np.random.seed() 生成随机数种子,如有参数，即每次生成的数值一样，没有则选择系统时间，每次生成的值不一样
• np.random.rand() 均匀分布的样本值
• np.random.randint() 从给定的上下限范围内随机选取整数
• np.random.normal() 正太分布
• np.random.uniform() [0,1]中均匀分布的样本值

np.random.uniform(1,5,20)

array([1.73527813, 4.37708175, 1.23993594, 3.11160917, 4.81709012,
       1.37763267, 4.08172748, 3.16229412, 4.83786832, 1.696155  ,
       2.17848768, 3.38546968, 3.34576086, 3.303562  , 1.16051986,
       3.37224742, 4.87527035, 2.48957213, 3.27498108, 1.46253374])

np.random.uniform(20)

6.760672905250747

np.random.randint(0,2,10)

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

np.random.normal(1,5,10)

array([-3.03222528,  1.00433415, -6.68152162, -7.8533515 , -3.10631387,
        4.76162682,  2.9385615 , -6.95958349, -5.98428693,  1.62605193])

案例：酒鬼漫步

原点启始，每走一步，方向不定，经过时间t后，计算酒鬼位置与原点位置的距离。

假设走了2000步，每步0.5米，向前走一步+1，后退1步-1，计算与原点的距离，就是将所有的步数进行累计求合

import numpy as np

steps = 2000
draws = np.random.randint(0,2,steps)
# draws=0时，derection=1
derection_steps = np.where(draws>0,1,-1)
# 计算距离
distance = derection_steps.cumsum()
distance

array([ -1,  -2,  -3, ..., -26, -25, -26])

# 最大前进步数
distance.max()

39

# 第几步最大
distance.argmax()

486

distance.min()

-55

distance.argmin()

1212

# 第几步时，距离原点距离=15米
dst = 15/0.5
(np.abs(distance)>=dst).argmax()

461