一、Numpy的使用
定义
- NumPy(Numerical Python) 是 Python语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。
- NumPy 是一个运行速度非常快的数学库，主要用于数组计算
- NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。
SciPy 是一个开源的 Python 算法库和数学工具包。
SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。
Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如
Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）。
numpy的主要对象是同种元素的多维数组
特点：这是一个所有元素都是一种类型，通过一个正整数元组索引的元素表格
ndim（秩）与 shape（维度）
import numpy as np
arr1 = np.array([1,2,3,])
#数组的秩
#轴的个数称为秩
#轴（axes）是数组的维度
print(arr1.ndim)#结论：一维数组秩为1，二维数组秩为二
#数组的维度
#此处数组的维度为1，4表示轴的长度
print(arr1.shape) #(4,)----》返回元素类型，会有一个元素的元组
#二维数组
arr2 = np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
print("元素的秩：",arr2.ndim)
print("元素的维度：",len(arr2.shape))
#测试shape改变维度
arr3 = np.array([1,2,3,4,5,6])
print(arr3.shape,arr3)#(6,) [1 2 3 4 5 6]
arr3.shape = (2,3)
print(arr3)
size（元素总和）
#size 元素总和
print(arr3.size)#6
if len(arr3.shape) ==2:
print("元素总个数：",arr3.shape[0]*arr3.shape[1])
elif len(arr3.shape) ==1:
print("元素总个数:",arr3.shape[0])
dtype（数组类型）
#dtype 一个用来描述组中元素类型的对象，可以通过指定或创造python类型
print(arr3.dtype)#int32
itemsize（元素大小）
#itemsize 数组中每个元素的字节大小
print(arr3.itemsize)#4个字节
data（数组内存地址）
#data --->数组的内存地址，是数组存储在内存中的缓冲区
print(arr3.data)# <memory at 0x0000021BD7268558>
print(arr3[0])
二、创建数组
1. array() 定义数组
import numpy as np
# array()
a1 = np.array([1,2,3,4])
a2 = np.array([(1,2),(3,4)])
a3 = np.array([[1,2],[3,4]])
#dtype
a4 = np.array([[1,2],[3,4]],dtype=np.float32)
# float32
print(a4.dtype)
2. arange() 生成数组
#arange()函数，创建一维数组
#格式：arange（起，止，步长）注意：起止时 左闭右开
a5 = np.arange(0,1,0.2)
# [0. 0.2 0.4 0.6 0.8]
print(a5)
3.linspace() 等差数列
#通常无法准确预估元素个数，使用linspace
#linspace()函数
#格式：
#闭区间[n,m]
a6=np.linspace(1,10,10)
# [ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
print(a6)
4. logspace() 等比数列
# logsapce()--等比数列
#生成10^1--10^3之间的3个等比数
a7 = np.logspace(1,3,3)
# [ 10. 100. 1000.]
print(a7)
#2^0--2^10 之间11个等比数
a8 = np.logspace(0,10,11,base=2,dtype=np.int)
# [ 1 2 4 8 16 32 64 128 256 512 1024]
print(a8)
5. zeros() 零矩阵
#zeros
a9 = np.zeros((2,3))
# [[0. 0. 0.]
# [0. 0. 0.]]
print(a9)
6. ones() 单位矩阵
#ones
a10 = np.ones((2,3))
# [[1. 1. 1.]
# [1. 1. 1.]]
print(a10)
7. empty() 随机数组
#empty()
#该函数创建一个内容随机并且依赖于之前状态的数组
a11 = np.empty((2,3))
# [[8.02326206e-315 8.02326657e-315 8.02353850e-315]
# [0.00000000e+000 0.00000000e+000 0.00000000e+000]]
print(a11)
8. eye() N阶矩阵
#eye() #生成N阶矩阵，对角线元素为1
a12 = np.eye(3)
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]
print(a12)
9. diag() 对角线矩阵
#diag() 对角线矩阵
# a13 = np.diag([[1,2,3,4],[11,12,13,14],[21,22,23,24]])
# [ 1 12 23]
a13 = np.diag([1,2,3,4])
# [[1 0 0 0]
# [0 2 0 0]
# [0 0 3 0]
# [0 0 0 4]]
print(a13)
三、随机数
1. random() 生成[0,1)之间的随机数
#格式：np.random.random(n)
#生成一个数组，值域[0,1),n代表元素个数
r1 = np.random.random(10)
print(r1)
2. rand() 生成若干维的数组
#格式：np.random.rand(M,N,...)
#生成M x N x...维的数组
r2 = np.random.rand(3,4,5)
print(r2)
3. randn() 生成正态随机数数组
#格式：np.random.randn(n)
#生成数组，数组元素为正态随机数,个数为n
r3 = np.random.randn(6)
print(r3)
#遵循大数定理
# import matplotlib.pyplot as plt
# plt.hist(r3)
# plt.show()
4. randint() 生成[a,b]之间的随机数组
#格式：np.random.randint(a,b,size=(i,j))
#值域：[a,b] 闭区间 size() 指定数组的维度
r4 = np.random.randint(2,10,size=(2,3))
#洗牌
print(r4)
np.random.shuffle(r4)
print(r4)
5. binomial 二项式
#二项式---伯努利--只有两种可能
r5 = np.random.binomial(5,0.5,size=(3,5))
print(r5)
四、数据类型
基本数据类型
import numpy as np
# 一、基本数据类型
# bool:由所在平台决定其精度的整数。int32、int64---字长
# int:~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~。int32、int64
# 另外：int8\int16\int32\float32\float64...
#二、数据类型转换
# eg: float64\int32.....
# np.float64(n)
# eg:
value1 = np.bool(10)
value2 = np.bool(0)
print(value1,value2)
#eg:
value3 = np.float64(True)
print(value3)
自定义数据类型
#定义数据类型（数据存储结构）
#eg:
#创建一个存储餐饮企业库存信息的数据类型。其中：
#（1）用一个长度为40个字符的字符串来记录商品名称
#（2）用一个64位的整数来记录商品的库存
#（3）用一个64位的单精度浮点数来记录商品的价格。
# (dataframe)
df = np.dtype([('name',np.str_,40),('numitems',np.int64),('price',np.float64)])
# items = np.array([('tomatoes',100,2),('cabbages',200,0.5),('apple',50,4.5)],dtype=df)
items = np.array([('tomatoes',100,2),('cabbages',200,0.5),('apple',50,4.5)],dtype=df)
print(items)
print(df['name'])#<U40
print(df['numitems'])#int64
print(type(df['name']))
五、数组元素的访问
数组元素的访问是通过“索引”来完成的。
import numpy as np
#数组元素的访问是通过“索引”来完成的。
a1 = np.arange(10)
print('a1:',a1)
print(a1[0])#0
print(a1[2:4])#[2,3]
print(a1[-1])#9
#修改
a1[0] = 100
a1[2:4]=200,300
print(a1[1::2])
#二维数组
a2 = np.arange(1,13,1).reshape(3,4)
print('a2:',a2)
print(a2[0][-1])#直接多下标来访问
print(a2[1,1])#
print(a2[1:,2:])#
print(a2[:,:])#全部行、列数据
print(a2[:,2])
print(a2[1:,0::2])
#python
# list001 = [[1,2,3,4],[5,6,7,8]]
# list001[0][-1]
六、变换数组形态
1. shape() 和reshape()
import numpy as np
#shape\reshape
a1 = np.arange(15).reshape(-1,5)
print(a1)
#注意：reshape(m,n),如果说有一个参数为-1时，
# 那么reshape函数会根据另一个参数的维度计算出数组的另外一个shape属性值
a2 = a1.reshape(-1)#将多维数组变换成一维数组
print(a2)
a3 = a1.reshape(-1,1)
print(a3)#生成的一定是个二维数组，行数会通过列数计算得来
a4 = a1.reshape(3,-1)
print(a4)
big_array = np.arange(10000).reshape(100,100)
print(big_array)
#注意：如果一个数组太大，在输出时Numpy自动省略中间部分而只打印两边元素。
#禁用Numpy的这种行为并强制打印整个数组，可以在打印之前设置如下：
# np.set_printoptions(threshold=np.NaN)
# print(big_array)
2.展平数组–ravel()函数
#是reshape()函数的逆操作。
a1 = np.arange(10)
a2 = a1.reshape(2,5)
print(a1)
print('a2:',a2)
# [0,1,2,3,4]
# [5,6,7,8,9]
a3 = a2.ravel()
print(a3)#[0 1 2 3 4 5 6 7 8 9]
3.展平数组–flatten()函数
# 默认为横向展平，纵向展平需要加‘F’参数，不是在原数组上修改，而创建一个新数组
a4 =a2.flatten()
print('a4:',a4)
a5 = a2.flatten('F')
print(a5)
ravel和flatten区别
- 都能够实现将多维数组降为一维数组，
- 区别在于返回的是拷贝（copy）还是返回的是视图（view）
- numpy.flatten()返回的是拷贝,对于拷贝所做的修改不会影响到原始数据。
- numpy.ravel()返回的是视图，会影响到原始数据
a1 = np.arange(10)
a2 = a1.reshape(2,5)
print('a2:',a2)
a5 = a2.flatten('F')
a5[0] = 100
print('a5:',a5)
print('a2:',a2)
# a3 = np.ravel(a2)
# a3[0] = 100
# print('a3:',a3)
# print('a2:',a2)
# a1 = [33,2,-1,22]
# print('a1_pre:',a1)
# # a1.sort()
# # print('a1_last:',a1)
# a2 = sorted(a1)
# print(a1)
# print(a2)
七、组合数组
1. hstack() 和 vstack() 函数
arr1 = np.arange(1,6,2)#[ 1 3 5]
arr2 = np.arange(7,12,2)#[7 9 11]
arr3 = np.hstack((arr1,arr2))
print('arr3:',arr3)
arr4 = np.vstack((arr1,arr2))
print('arr4:',arr4)
arr5 = arr1 + arr2
print('arr5:',arr5)
注意：
- 如果两个数组元素个数不相等，横向组合不受影响，但纵向组合会报错。
- 在stack函数中，使用圆括号和方括号都可以。
- 两个数组使用加号连接，其实是对应元素相加。
2. concatenate() 和 轴
#默认为：axis=0，纵向；axis=1横向
arr1 = np.array([[1,1],[2,2]])
arr2 = np.array([[3,3],[4,4]])
#横向
#方法一：
arr3 = np.hstack((arr1,arr2))
print(arr3)
'''
[[1 1 3 3]
[2 2 4 4]]'''
#方法二：
arr4 = np.concatenate((arr1,arr2),axis=1)
print('arr4:\n',arr4)
# temp1 = np.array([1,2,3,4])
# print(temp1.shape)#(4,)
#
# temp2 = np.array([[1,1],[2,2],[3,3]])
# print(temp2.shape)#(3,2)
#纵向
#方法一：
arr5 = np.vstack((arr1,arr2))
print(arr5)
#方法二：
arr6 = np.concatenate((arr1,arr2),axis=0)
print('arr6:\n',arr6)
八、切割数组
hsplit() 和 vsplit() 函数
arr1 = np.array([[1,1,3,3],[2,2,4,4]])
print('arr1:\n',arr1)
arr6_subarray = np.hsplit(arr1,2)
print(arr6_subarray,type(arr6_subarray))
a1 = arr6_subarray[0]
print(type(a1))
arr7_subarray = np.vsplit(arr1,2)
print(arr7_subarray)
九、创建矩阵
1.mat()函数
#方法一：
A = np.mat([[1,0,1,0],[-1,2,0,1],[1,0,4,1],[-1,-1,2,0]])
print(A)
#方法二：
B = np.mat('1 0 0 0;0 1 0 0; -1 2 1 0;1 1 0 1')
print(B)
2. bmat() 函数
通过分块矩阵创建大矩阵
A = np.mat([[1,1],[1,1]])
B = np.mat([[2,2],[2,2]])
C = np.mat([[3,3],[3,3]])
D = np.mat([[4,4],[4,4]])
big_mat = np.bmat([[A,B],[C,D]])
print(big_mat)
3. 矩阵运算
矩阵的加法及乘法运算
A = np.mat([[1,1],[1,1]])
B = np.mat([[2,2],[2,2]])
print(A*3)
print(A+B)
# A = np.mat([[1,2,3,4],[2,0,1,5]])
# B = np.mat([[1,0,2],[-1,1,3],[4,1,0],[2,3,4]])
# C = A*B
# print(C)
对应元素相乘
result = np.multiply(A,B)
print(result)
矩阵属性
#T--->matr1.T
A = np.mat([[1,2],[1,3]])
print(A.T)
H—>共轭转置
A—>返回是自身数据的2维数组的一个视图
十、通用函数
all() 和 any()
import numpy as np
x = np.array([1,3,5])
y = np.array([2,3,6])
result = x==y
print(result)#[False True False]
print(np.all(result))#False
print(np.any(result))#True
x = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
# y = np.array([1,2,3])
# z = x+y
# print(z)
y = np.array([1,2,3,4]).reshape((4,1))
z = x+y
print(z)
十一、文件读写
一、二进制读写
numpy文件读写主要有二进制的文件读写和文件列表形式的数据读写两种形式。
1. save() 函数
# save()函数---写--->硬盘
x = np.array([[0,0,0],[1,1,1],[2,2,2],[3,3,3]])
np.save('x.npy',x)
2. save()函数
注意：存储的时候可以省略扩展名，但是读取时不可以。
#load()函数---读
x_array = np.load('x.npy')
print(x_array)
3.savez()函数
保存多个数组
#savez()----可以将多个数组保存到一个文件当中
y = np.array([1,2,3,4,5,6])
np.savez('xy',x,y)
二、文本数据读取（txt,csv格式）
1.savetxt() 写
np.savetxt('x.txt',x,delimiter=',',fmt='%d')
2. loadtxt() 读
x_array = np.loadtxt('x.txt',delimiter=',')
print(x_array)
3. genfromtxt()函数
面向结构化数组和缺失数据。
jobInfo = np.dtype([('name',np.str_,40),('number',np.int32),('loca',np.str_,16)])
jobs = np.loadtxt('jobs.txt',dtype=jobInfo,delimiter=',')
print(jobs)
jobs2 = np.genfromtxt('jobs.txt',dtype=jobInfo,delimiter=',')
print(jobs2)
十二、统计分析
一、直接排序
1. sort()函数
# 用法：arr.sort()
# axis=0表示沿纵轴排序
# axis=1~~~~~~横轴~~~
arr = np.array([[4,3,2],[2,1,4]])
print(arr)
'4,3,2' \
'2,1,4'
# arr.sort()
# print(arr)
'[[2 3 4]'
'[1 2 4]]'
arr.sort(axis=0)
print(arr)
二、间接排序—不改变原始数据
1. argsort()函数
返回值为重新排序后值的下标
arr = np.array([2,1,0,5,3])
arr1 = arr.argsort()
print('原始数据：\n',arr)
print('排序后的数据：\n',arr1)
for i in arr1:
print(arr[i],end='~')
2.lexsort()函数
返回值是按照最后一个传入数据排序的数组的下标。
eg:np.lexsort((a,b,c))
a = np.array([3,2,6,4,5])
b = np.array([50,30,40,20,10])
c = np.array([400,300,600,100,200])
d = np.lexsort((a,b,c))#[3 4 1 0 2]
print(d)
十三、去重和重复
1. unique()函数 去重
通过unique函数 可以找出数组中的唯一值并返回已经排序的结果
a = np.array([1,2,3,1,6,2,3,4,5,4])
b = np.unique(a)
print(b)
2.tile() 函数 重复
主要有两个参数，参数"A",指定重复的数组，参数"reps"指定重复的次数
c = np.arange(5)
d = np.tile(c,3)
print(d)
3. repeat() 函数 重复
格式：def repeat(a, repeats, axis=None):
#axis=1,表示按列进行元素重复
e = np.random.randint(0,10,size=(3,3))
print("原始数据e：\n",e)
f = np.repeat(e,2,axis=1)
print("axis=1:\n",f)
#axis=0,表示按行进行元素重复
g = np.random.randint(0,10,size=(3,3))
h = np.repeat(e,2,axis=0)
print("axis=0:\n",h)
tile和repeat的区别
- 两个函数都是对数据进行“重复”
- tile是对整个数组进行重复，repeat是对数组中的每个元素进行重复
拓展
#另外一种写法
#g.repeat(2)
十四、聚合函数
统计分析函数
d1.count() #非空元素计算
d1.min() #最小值
d1.max() #最大值
d1.idxmin() #最小值的位置，类似于R中的which.min函数
d1.idxmax() #最大值的位置，类似于R中的which.max函数
d1.quantile(0.1) #10%分位数
d1.sum() #求和
d1.mean() #均值
d1.median() #中位数
d1.mode() #众数
d1.var() #方差
d1.std() #标准差
d1.mad() #平均绝对偏差
d1.skew() #偏度
d1.kurt() #峰度
d1.describe() #一次性输出多个描述性统计指标
1. sum 和
result_sum_0 = np.sum(a,axis=0)
result_sum_1 = np.sum(a,axis=1)#沿横轴计算
2.mean 均值
result_mean_0 = np.mean(a,axis=0)
result_mean_1 = np.mean(a,axis=1)
3.cumsum 累加和
result_cumsum_0 = np.cumsum(a,axis=0)
result_cumsum_1 = np.cumsum(a,axis=1)
4.cumprod 累乘积
result_cumprod_0 = np.cumprod(a,axis=0)
result_cumprod_1 = np.cumprod(a,axis=1)
5.min 最小值
print(np.min(a))
6.max 最大值
print(np.max(a))
7.var 方差
print(np.var(a))
8.std 标准差
print(np.std(a))
- sum()–axis缺失时，表示将整个数组展平，取整个数组的和
- mean()–axis缺失时，表示将整个数组展平，取整个数组的均值
- …
260
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
