numpy数据分析库

准备工作

win(windows图标）+r 输入cmd点击运行，输入pip install numpy安装numpy模块

>如果电脑中有多个python文件可能会报错，因为我自己原来也是装过很多版本的python，结果执行命令的时候直接报错（fatal error.....），卸载重装大概用时两分钟吧，python launcher可以不用卸

重装python之后的操作：

然后在自己新的安装路径下找到python.exe（python解释器），重新改一下pycharm中的解释器位置——打开pycharm-文件-项目-python解释器-（右上角）添加解释器-系统解释器-（点击"..."）填入你的python.exe所在位置然后确定即可

numpy库的基本使用

定义数组

import random
import numpy as np
#因为后面会频繁调用库，所以起别名能更方便代码的书写

myarray0 = np.array(1)
print(myarray0)
#输出1

myarray1 = np.array([1,2,3,4,5])
print(myarray1)
#输出[1 2 3 4 5]

#用range定义
myarray2 = np.array(range(0,5))
print(myarray2)
#输出[0 1 2 3 4]

#用arrange定义数组
start = 0
end = 5
myarray3 = np.arange(start,end,dtype="i1")
#myarray3 = np.array(range(start,end),dtype="i1")
#myarray3的这两种定义方式效果相同，在定义的同时规定数组中值的类型，可以方便规划占用的内存
print(myarray3)
#输出[0 1 2 3 4]

my_bool_array = np.array([1,1,-1,2,-2,0,0,0],dtype=bool)
print(my_bool_array)
#输出[ True  True  True  True  True False False False]，布尔类型中非零值都为True,为零的值为False

#用astype调整数据类型
my_changeType_array = my_bool_array.astype("int64")
print(my_changeType_array)
#输出[1 1 1 1 1 0 0 0],因为转换内部表示的布尔值是默认True转为1，False转为0

#随机生成10个小数
my_floatarray = np.array([random.random() for i in range(1,10)])
print(my_floatarray)
print(my_floatarray.dtype)
#输出[0.85412469 0.49893921 0.56049621 0.19426018 0.91148259 0.90606858 0.30036747 0.19746193 0.41540484]
#输出float64

#保留两位小数
my_floatarray_c = np.round(my_floatarray,2)
print(my_floatarray_c)
print(my_floatarray_c.dtype)
#输出[0.85 0.5  0.56 0.19 0.91 0.91 0.3  0.2  0.42]
#输出float64

关于数组形状及其运算

import numpy as np
# 数组的形状(几行几列)
n1 = np.array([1,2,3,4,5,6,7,8,9,10,11,12])
print(n1.shape)
# 输出(12,)
n1_plus = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(n1_plus.shape)
# 输出(3, 4)

# 改变形状
n2 = n1.reshape((3,4))
print(n2.shape)
# 输出(3,4),改变形状前后的数据总量应保持相等不然会报错

# 定义时改为指定形状
n3 = np.arange(24).reshape((2,3,4))
print(n3)
#  输出[[[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
#
# [[12 13 14 15]
#  [16 17 18 19]
#  [20 21 22 23]]]
n4 = n3.reshape(4,6)
print(n4)
# 输出[[ 0  1  2  3  4  5]
# [ 6  7  8  9 10 11]
# [12 13 14 15 16 17]
# [18 19 20 21 22 23]]

# 用flatten函数按行展开
n5 = n4.flatten()
print(n5)
# 输出[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]

# 对数组中值的统一运算变换(加减乘除均可)
n5 = n5+2
print(n5)
# 输出[ 2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25]

# 0除以0得到nan,其他数除以0得到inf
n6 = (n5-2)/0
print(n6)
# 输出[nan inf inf inf inf inf inf inf inf inf inf inf inf inf inf inf inf inf
# inf inf inf inf inf inf

# 形状相同的数组也可以直接进行运算，按照一一对应的关系进行运算
n7_a = np.arange(10,20)
n7_b = np.arange(40,50)
print(n7_b-n7_a)
# 输出[30 30 30 30 30 30 30 30 30 30]

# 具有包含关系的大小数组也可进行运算，同样按照位置对应关系
n8 = np.arange(16).reshape(4,4)
n8_small = np.arange(4).reshape(4,1)
# print("这是大减小的部分")
print(n8,'\n',n8_small)
print(n8-n8_small)
# 输出[[ 0  1  2  3]
#  [ 3  4  5  6]
#  [ 6  7  8  9]
#  [ 9 10 11 12]]
# ######## 总结：以下两点是不同形数组间运算条件
# ######## 1.有一个数组某一维度为1且这两个数组其它维度相同，则可以直接按维度为1的维度补充至两个数组同形再运算
# ######## 2.如果满足广播原则也可补充至同形进行运算

关于数组运算中的广播原则：

读取本地数据和索引（少用）（pandas库更方便）

具体函数及其参数设置

import numpy as np

t = np.loadtxt(file_path,dtype="int",delimiter=",",unpack=False,)
# file_path为文件在本地的路径，可以事先赋值到变量中(这里以file_path为例)
# dtype为解析出的数据类型,这里以整数类型为例
# delimiter为设置分隔符，这里设置为逗号
# unpack表示是否转置，不设置默认为False
# 还可以设置skiprows表示跳过前x行，一般跳过表头
# usecols读取指定的列，索引，元组类型

数组的切片

import numpy as np

a = np.arange(1,10).reshape(3,3)
print(a)

# 取出第一行的数据
print(a[:1],'操作1')

# 取出第一列的数据
# 我们使用:操作符对第一维度进行切片，即取出所有行，
# 然后使用0作为第二维度的索引，即取出第一列。最终得到的是一个形状为(3,)的一维数组，其中包含了第一列的所有元素。
print(a[:,0],'操作2')

# 取出第一行，第二列的元素
# 本质就是分为两个维度单独进行list切片，多个维度之间用逗号隔开
print(a[0:1,1:2],'操作3')

# 稍加修改切片区间就可以取出一个数组
# 取出第一行到二行，第二列到第三列的所有元素
print(a[0:2,1:3],'操作4')

# 创建一个3D数组(形状为2*3*3)
arr = np.array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                [[10, 11, 12], [13, 14, 15], [16, 17, 18]]])

# 取出第一个二维数组(该数组中总共两个二维数组)的第一行和第二列
sub_arr = arr[0, 0:1, 1:2]
print(sub_arr,'操作5')

# 创建一个4D数组
arr = np.array([[[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
                 [[10, 11, 12], [13, 14, 15], [16, 17, 18]]],
                [[[19, 20, 21], [22, 23, 24], [25, 26, 27]],
                 [[28, 29, 30], [31, 32, 33], [34, 35, 36]]]])

# 取出第一个三维数组的第一行和第二列
sub_arr = arr[0, 0, 0:1, 1:2]
print(sub_arr)


# 如何将一个2D数组沿着列的方向切分成两个子数组？
# 创建一个2D数组
arr = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8],
                [9, 10, 11, 12]])

# 将数组沿着列的方向均分成两个子数组
# 使用numpy.split()函数将一个2D数组沿着列的方向切分成两个子数组
# numpy.split(ary, indices_or_sections, axis=0)
# 其中，ary表示要切分的数组，indices_or_sections表示切分的位置，如果是一个整数，则表示将数组沿着axis轴均分成该数目的子数组，
# 如果是一个数组，则表示沿着axis轴按照给定的位置进行切分，axis表示要切分的方向，默认为0，即沿着行的方向切分。
sub_arr1, sub_arr2 = np.split(arr, 2, axis=1)

print(sub_arr1)  # 输出 [[1 2]
                 #      [5 6]
                 #      [9 10]]

print(sub_arr2)  # 输出 [[ 3  4]
                 #      [ 7  8]
                 #      [11 12]]

数组的转置

对于一个array,对其转置的核心代码就是array_name.T或者array.transpose()

import numpy as np

# 多维数组的转置：对于多维数组，可以通过传递一个元组来指定需要进行转置的轴顺序。
# 比如，对于一个2x3x4的三维数组，可以使用transpose方法将它转置为4x3x2的数组
arr = np.random.randn(2, 3, 4)
arr_transposed = arr.transpose((2, 1, 0))
print(arr_transposed.shape) # (4, 3, 2)

# 矩阵乘法：在进行矩阵乘法时，通常需要将一个数组进行转置，以满足乘法的规则。可以使用transpose方法或T属性来实现这个目的
arr1 = np.random.randn(3, 4)
arr2 = np.random.randn(4, 5)

# print(arr1,'\n',arr2)

# 使用transpose方法进行转置
arr1_transposed = arr1.transpose() #(4,3)
result1 = np.dot(arr2.transpose(),arr1_transposed) #(5,4)*(4,3)=(5,3)
# 使用T属性进行转置
arr2_transposed = arr2.T # (5,4)
result2 = np.dot(arr2_transposed,arr1_transposed) #(5,4)*(4,3)=(5,3)

print(result1.shape)# (5,3)
print(result2.shape)# (5,3)

# 求解线性方程组
# 定义系数矩阵A和常数向量b，将它们合并成增广矩阵(A|b)。
# 使用linalg.solve函数解线性方程组，该函数的输入为增广矩阵(A|b)，返回值为方程组的解向量。
# 考虑下面这个方程组
# x + y + z = 6
# 2y + 5z = -4
# 2x + 5y - z = 27
# 可以写出增广矩阵
# [1, 1, 1 | 6]
# [0, 2, 5 | -4]
# [2, 5, -1 | 27]
# 定义系数矩阵A和常数向量b
A = np.array([[1, 1, 1], [0, 2, 5], [2, 5, -1]])
b = np.array([6, -4, 27])

# 求解线性方程组
x = np.linalg.solve(A, b)
print(x)# [ 5.  3. -2.]
# 该线性方程组的解为x=5，y=3，z=-2

数组的合并

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

c = np.concatenate([a,b],axis=0)
print(c)
# [1 2 3 4 5 6]
# 不指定axis参数默认为0

d = np.concatenate([a.reshape(3,1),b.reshape(3,1)],axis=1)
print(d)
# [[1 4]
#  [2 5]
#  [3 6]]
# 在使用concatenate函数连接两个数组时，要确保它们在连接轴上的维度相同


f = np.vstack([a,b])
print(f)
# [[1 2 3]
#  [4 5 6]]
# vstack只有这一种合并方式，所以两个数组通过这种方式合并，维度必须完全相同

数组的排序

import numpy as np

a = np.arange(5)

# a.sort()
# print(a)# [0 1 2 3 4]

# np.argsort()返回按升序排序时的索引
b = np.array([1,5,3,2,4])
c = np.argsort(b)
print(c)
# 用法 --找原数组中的最大最小值，通过索引寻值
maxlen_index = b.shape[0]-1
max = b[c[maxlen_index]]
min = b[c[0]]
print(max,'****',min)# 5 **** 1

# 降序
b_ = np.sort(a)[::-1]
print(b_) #[4 3 2 1 0]

a[::-1].sort()
print(a,'****') #[4 3 2 1 0] ****

数组的统计方法

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

# 求最大最小值，平均值
b = np.max(a)
print(b)#6
c = np.min(a)
print(c)#1
d = np.mean(a)
print(d)#3.5

# 求总和，标准差
f = np.sum(a)
print(f)#21
g = np.std(a)
print(g)#1.707825127659933

# np.argmin,np.argmax 函数可以返回数组中的最小值，最大值对应的索引
# 以上所有的函数都可以添加axis参数对指定的轴进行对应操作

 数学函数

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

# 取e为底的指数
print(np.exp(x))#[ 2.71828183  7.3890561  20.08553692]

# 取e为底的对数
print(np.log(x))#[0.         0.69314718 1.09861229]
# 还有np.log2 , np.log10 取对应2为底，10为底的对数

# 还可以用np.pi表示 π 进行准确的三角函数的表示运算
# np.sin , np.cos , np.tan .....