numpy学习笔记
Numpy & Pandas
最近在看吴恩达机器学习以及机器学习实战，在做课后习题的过程中对numpy以及pandas的操作很不熟练，所以看了莫烦的numpy和pandas的教程，查阅了一些资料，做对numpy学习做了一些记录
numpy
numpy属性
numpy基本用法
import numpy as np
array = np.array([[1,2,3],[2,3,4]])个列表转换为矩阵num
print(array,array.ndim,array.shape,array.size)
#ndim 是维度，即shape返回元组中的元素数量
#shape 它是一个元组，返回各个维度的维数。
#size 返回矩阵大小
array和matrix区别
在学习numpy发现很多博客对matrix和array的使用都没有特殊的说明，实际上matrix是array的分支，matrix和array在很多时候都是通用的，你用哪一个都一样。但这时候，官方建议大家如果两个可以通用，那就选择array，因为array更灵活，速度更快，很多人把二维的array也翻译成矩阵。
但是matrix的优势就是相对简单的运算符号，比如两个矩阵相乘，就是用符号*，但是array相乘不能这么用，得用方法.dot()
array的优势就是不仅仅表示二维，还能表示3、4、5...维，而且在大部分Python程序里，array也是更常用的。
numpy基础运算
一维简单运算
import numpy as np
a = np.array([10,20,30,40])
b =np.arange(4,8)#返回一个有终点和起点的固定步长的排列，可以有三个属性，可以理解为（起点，终点，步长）
print(a,b)#[10 20 30 40] [4 5 6 7]
#常规运算
c=a+b#[14 25 36 47]
c=a-b#[ 6 15 24 33]
c=a*b#对应位置相乘
c=b**2# b^2 [16 25 36 49]
c=10*np.sin(a)#numpy自带求sin方法
print(c)
#逻辑判断，返回一个bool类型的矩阵
print(b<7) #[ True True True False]
print(a==2) #[False False False False]
多维矩阵运算
import numpy as np
a = np.array([[1,1],
[0,1]]) #2行2列的矩阵
b = np.arange(4).reshape((2,2))
#reshape()方法用于改变数组的形状(数组的形状会改变，但是数组中的值不会改变)
c_dot = np.dot(a,b) #矩阵相乘
c_dot_2 = a.dot(b) #两种方法等价
a = np.random.random((2,4)) #生成一个所有元素都是0到1的2行4列的随机数矩阵
print(a)
#[[0.62385337 0.99577629 0.555187 0.24056486][0.70766872 0.7260784 0.8494034 0.16935143]]
np.sum(a) #矩阵中所有元素求和
np.min(a) #矩阵中最小值
np.max(a) #矩阵中最大值
#分别计算每一行或者每一列的运算，用到axis=1,0；其中0表示按列，1表示按行
np.sum(a,axis=1)
# sum =[2.41538151 2.45250196]
np.min(a,axis=0)
# min = [0.62385337 0.7260784 0.555187 0.16935143]
np.max(a,axis=1)
# max = [0.99577629 0.8494034 ]
numpy中其他一些常用运算
import numpy as np
A = np.arange(2,14).reshape((3,4))
#构造[[ 2 3 4 5]
# [ 6 7 8 9]
# [10 11 12 13]]
-
argmin & argmax
print(np.argmin(A))#输出 0 输出最小值的索引 print(np.argmax(A))#输出 11 输出最大值的索引 print(np.argmax(A,axis=1))# 输出[3 3 3] axis=1代表横向 每一行的最大值索引 print(np.argmax(A,axis=0))# [2 2 2 2] axis=0 代表纵向 每一列的最大值索引 -
求平均值
print(np.mean(A)) print(A.mean()) print(np.average(A)) print(np.median(A))#求中位数mean和average都是计算均值的函数，在不指定权重的时候average和mean是一样的。指定权重后，average可以计算一维的加权平均值。具体如下：
import numpy as np b = np.array([1, 2, 3, 4]) wts = np.array([4, 3, 2, 1]) print( np.average(b)#2.5 print(np.mean(b)#2.5 print( np.average(b, weights=wts))# 设置了权重weight 输出2.0 -
累加和累差
print(np.cumsum(A)) #累加函数，生成的每一项矩阵元素均是从原矩阵首项累加到对应项的元素之和，得到1*12的矩阵 # [2 5 9 14 20 27 35 44 54 65 77 90] print(np.diff(A)) #累差函数，后一项与此项的差作为这一项的元素，得到3*3的矩阵 """" [[1 1 1] [1 1 1] [1 1 1]] """" -
nonzero()
返回非零元素索引的元组 元组中的数组数量取决于矩阵维度
print(np.nonzero(A)) #查找哪些位置上的元素非0，结果显示成行与列，一一对应 #(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64)) A = np.array([[0,1,2],[6,0,8],[9,5,0]]) print(np.nonzero(A)) #(array([0, 0, 1, 1, 2, 2], dtype=int64), array([1, 2, 0, 2, 0, 1], dtype=int64)) print(np.transpose(np.nonzero(A)))#改变序列 对于二维数组来说 transpose就是输出转置矩阵 """ [[0 1] [0 2] [1 0] [1 2] [2 0] [2 1]] """ -
排序
A = np.arange(14,2, -1).reshape((3,4)) # array([[14, 13, 12, 11], # [10, 9, 8, 7], # [ 6, 5, 4, 3]]) print(np.sort(A)) #行排序，从小到大 # array([[11,12,13,14] # [ 7, 8, 9,10] # [ 3, 4, 5, 6]]) -
转置
print(np.transpose(A)) print(A.T) -
clip()
clip(array,a,b)是一个截断函数，也就是将指定数组或数值的大小限制在你规定的范围[a,b]内。换句话说就是规定a<b,使矩阵中<a的元素全部变为a，>b的元素全部变为b
print(A) """" array([[14,13,12,11] [10, 9, 8, 7] [ 6, 5, 4, 3]]) """" print(np.clip(A,5,9)) """" array([[ 9, 9, 9, 9] [ 9, 9, 8, 7] [ 6, 5, 5, 5]]) """"
numpy索引
一维索引
import numpy as np
A = np.arange(3,15)
# array([3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
print(A[3]) #输出 6
A = np.arange(3,15).reshape((3,4))
"""
array([[ 3, 4, 5, 6]
[ 7, 8, 9, 10]
[11, 12, 13, 14]])
"""
#二维数组索引时
print(A[0]) #索引第0行
# [3 4 5 6]
二维索引
A = np.arange(3,15).reshape((3,4))
"""
array([[ 3, 4, 5, 6]
[ 7, 8, 9, 10]
[11, 12, 13, 14]])
"""
print(A[0][0]) # 输出3
print(A[0, 0]) # 输出3
print(A[1, 1:3]) # 输出[8 9] 其实就是python切片
#使用for循环，遍历成行向量
for row in A:
print(row)
"""
[ 3, 4, 5, 6]
[ 7, 8, 9, 10]
[11, 12, 13, 14]
"""
#使用for循环A的转置，即遍历成列向量
for column in A.T: #转置
print(column)
"""
[ 3, 7, 11]
[ 4, 8, 12]
[ 5, 9, 13]
[ 6, 10, 14]
"""
迭代输出
flatten()函数&flat函数
flatten()函数将数组的副本转换为一个维度，并返回
flat函数返回的是一个迭代器，可以用for访问数组每一个元素
import numpy as np
A = np.arange(3,15).reshape((3,4))
"""
array([[ 3, 4, 5, 6]
[ 7, 8, 9, 10]
[11, 12, 13, 14]])
"""
print(A.flatten()) #flatten是展开函数，将多维矩阵按行列顺序展开成1行的数列
# array([3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
for item in A.flat: #flat是一个迭代器，本身是一个object属性
print(item)
# 3
# 4
……
# 14
numpy array 合并
np.vstack()
垂直方向排列数组，列数不变，行数增加。一般用于三维以下的数组。
import numpy as np
A = np.array([1,1,1])
B = np.array([2,2,2])
print(np.vstack((A,B))) # vertical stack
"""
[[1,1,1]
[2,2,2]]
"""
C = np.vstack((A,B))
print(A.shape,C.shape)
# (3,) (2,3) A是一个数组，C是一个2行3列的矩阵
np.hstack()
水平方向排列数组，行数不变，列数增加。一般用于三维以下的数组。
D = np.hstack((A,B))
print(D)
# [1,1,1,2,2,2]
print(A.shape,D.shape)
# (3,) (6,) 都是一维数组/序列
np.stack()
stack()函数的原型是numpy.stack(arrays, axis=0)，即将一堆数组的数据按照指定的维度进行堆叠。
A = np.array([1,2,3])
B = np.array([2,3,4])
np.stack([A,B],axis=0)
"""
array([[1, 2, 3],
[2, 3, 4]])
"""
np.stack([A,B],axis=1)
"""
array([[1, 2],
[2, 3],
[3, 4]])
"""
#换成二维数组的情况下
A = np.array([[1,2,3]])
B = np.array([[2,3,4]])
np.stack([A,B],axis=0)
"""
array([[[1, 2, 3]],
[[2, 3, 4]]])
"""
#进行stack的两个数组必须有相同的形状，同时，输出的结果的维度是比输入的数组都要多一维的。
np.newaxis()
np.newaxis的作用就是选取部分的数据增加一个维度
A = np.array([1,1,1])
print(A[np.newaxis,:]) #冒号在前按列，冒号在后按行
# [[1 1 1]]
print(A[np.newaxis,:].shape)
# (1,3) 是一个矩阵/向量
print(A[:,np.newaxis])
"""
[[1]
[1]
[1]]
"""
print(A[:,np.newaxis].shape)
# (3,1)
np.concatenate()
np.concatenate()函数能够一次完成多个数组的拼接,传入的数组必须具有相同的形状，这里的相同的形状可以满足在拼接方向axis轴上数组间的形状一致即可
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6]])
print(np.concatenate((A, B), axis=0))
"""
[[1, 2],
[3, 4],
[5, 6]]
"""
print(np.concatenate((A,B.T),axis = 1))
"""
[[1, 2, 5],
[3, 4, 6]]
"""
numpy分割
np.split(A, 2, axis=1) #分成2份，保留行数
np.split(A, 2, axis=0) #保留列数
np.hsplit(A, 3) #保留行数
np.vsplit(A, 3) #保留列数
np.array_split(A, 3, axis=1) #分成3份，保留行数
import numpy as np
A = np.arange(12).reshape((3, 4))
print(A)
"""
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
"""
print(np.split(A, 2, axis=1)) #0保留列数 1保留行数
"""
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
"""
print(np.split(A, 3, axis=0))
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
print(np.vsplit(A, 3)) #等于 print(np.split(A, 3, axis=0))
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
print(np.hsplit(A, 2)) #等于 print(np.split(A, 2, axis=1))
"""
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
"""
print(np.split(A, 3, axis=1)) #不等量划分会报错
# ValueError: array split does not result in an equal division
#不等量分割
print(np.array_split(A, 3, axis=1))
"""
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
"""
numpy copy & deep copy
-
深拷贝
深拷贝就是在赋值的时候，不把同一个内存对象的引用赋值给另一个变量，令两个变量所指向的对象不一样，更改值的时候不相互影响，这种操作就是深拷贝
深拷贝使用copy()函数，copy()会创建一个一模一样的array对象，存储到内存的另一个地址中，然后将这个副本的地址赋值给拷贝对象
import numpy as np A = np.arange(4) #[0 1 2 3] B = A.copy() B[0]=9 print(A) #[0 1 2 3] -
浅拷贝
直接使用 = 时 并没有存储任何的值，它只是指向了一个内存地址，而这个地址里存储着array具体的内容。这种将内存引用赋值给另一个变量的操作叫做浅拷贝
import numpy as np A = np.arange(4) #[0 1 2 3] B = A B[0]=9 print(A) #[9 1 2 3]
第一次写博客，希望以后也能保持这个习惯
浙公网安备 33010602011771号