利用Python进行数据分析笔记－Numpy基础
跟着教程学习了一段时间数据分析，越学感觉坑越多。于是花了一个星期仔细看了下《利用Python进行数据分析》。写在这里主要是记录下，方便自己查看。
import matplotlib.pyplot as plt
import numpy as np创建n维数组
1、使用array函数
最简单的方法使用array函数，输入一个序列即可，比如list
# 随机生成数据
data = np.random.randn(2, 3)
dataarray([[ 1.8878077 , -0.09071248, -0.17286876],
[-1.39093014, -1.82384125, 0.82493751]])
每一个数组都有一个shape，来表示维度大小。而dtype，用来表示data type：
# 多维数组
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr2 = np.array(data2)
arr2array([[1, 2, 3, 4],
[5, 6, 7, 8]])
print('维度大小：',arr2.shape)
print('维度值：', arr2.ndim)
print('数据类型：',arr2.dtype)维度大小： (2, 4)
维度值： 2
数据类型： int32
除非主动声明，否则np.array会自动给data搭配适合的类型，并保存在dtype里
也可以指定数据类型
arr1 = np.array([1, 2, 3], dtype=np.float64)
arr2 = np.array([1, 2, 3], dtype=np.int32)
print('arr1数据类型：',arr1.dtype)
print('arr2数据类型：',arr2.dtype)arr1数据类型： float64
arr2数据类型： int32
用astype来转换类型，astype总是会返回一个新的数组
- 把float变为int，小数点后的部分会被丢弃
int_arr1 = arr1.astype(np.int)
int_arr1.dtypedtype('int32')
2、其它方法
除了np.array，还有一些其他函数能创建数组。比如zeros,ones,另外还可以在一个tuple里指定shape
np.zeros((3, 6))array([[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0.]])
# np.empty并不能保证返回所有是0的数组，某些情况下，会返回为初始化的垃圾数值，如下面
np.empty((2, 3, 2))array([[[5.63e-322, 0.00e+000],
[0.00e+000, 0.00e+000],
[0.00e+000, 0.00e+000]],
[[0.00e+000, 0.00e+000],
[0.00e+000, 0.00e+000],
[0.00e+000, 0.00e+000]]])
np.arange(10)array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
数组计算
数组之所以重要，是因为不用写for循环就能表达很多操作，这种特性叫做vectorization(向量化)。任何两个大小相等的数组之间的运算，都是element-wise（点对点）
data = np.arange(5)
print('*:', data*10)
print('+:',data+data)*: [ 0 10 20 30 40]
+: [0 2 4 6 8]
# 两个数组的比较会产生布尔数组：
arr1 = np.array([[1., 2., 3.], [4., 5., 6.]])
arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])
arr2 > arr1array([[False, True, False],
[ True, False, True]])
索引和切片
一维数组操作同list，array的切片后的结果只是一个views（视图），用来代表原有array对应的元素，而不是创建了一个新的array。但list里的切片是产生了一个新的list
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
arr2d[2]array([7, 8, 9])
arr2d[2][1]8
arr2d[:2]array([[1, 2, 3],
[4, 5, 6]])
# 前两行，第二列之后
arr2d[:2, 1:]array([[2, 3],
[5, 6]])
arr2d[:2, 2]array([3, 6])
# 冒号表示提取整个axis（轴）
arr2d[:, :1]array([[1],
[4],
[7]])
# 多维数组
arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
arr3darray([[[ 1, 2, 3],
[ 4, 5, 6]],
[[ 7, 8, 9],
[10, 11, 12]]])
arr3d[1, 0] # 该操作相当于 x = arr3d[1]， x[0]的结果array([7, 8, 9])
布尔索引
data = np.random.randn(7, 4)
dataarray([[-1.33904841, -1.4637553 , -1.377123 , 0.09439955],
[ 1.40173772, 2.63681109, -2.11408761, -1.19171294],
[-1.58056578, 0.22323485, 1.85082002, -0.76870622],
[ 0.18076579, -0.24595339, 1.21591539, 0.30617942],
[-0.80319239, 0.64991022, -0.46159542, -1.23788867],
[ 1.16571902, 0.98157039, -1.3452736 , 0.22940809],
[-0.01013532, -0.31661346, 1.57364789, 0.05199267]])
# 让所有负数变为0
data[data < 0] = 0
dataarray([[0. , 0. , 0. , 0.09439955],
[1.40173772, 2.63681109, 0. , 0. ],
[0. , 0.22323485, 1.85082002, 0. ],
[0.18076579, 0. , 1.21591539, 0.30617942],
[0. , 0.64991022, 0. , 0. ],
[1.16571902, 0.98157039, 0. , 0.22940809],
[0. , 0. , 1.57364789, 0.05199267]])
# ~表示反转
data[~(data < 0)] = 0
dataarray([[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.],
[0., 0., 0., 0.]])
花式索引
不论数组有多少维，花式索引的结果总是一维，要记住，fancy indexing和切片不同，得到的是一个新的array。
# 创建一个8 x 4的空数组
arr = np.empty((8, 4))
for i in range(8):
arr[i] = i
arrarray([[0., 0., 0., 0.],
[1., 1., 1., 1.],
[2., 2., 2., 2.],
[3., 3., 3., 3.],
[4., 4., 4., 4.],
[5., 5., 5., 5.],
[6., 6., 6., 6.],
[7., 7., 7., 7.]])
# 按一定顺序选出几行，索引值
arr[[4, 3, 0, 6]]array([[4., 4., 4., 4.],
[3., 3., 3., 3.],
[0., 0., 0., 0.],
[6., 6., 6., 6.]])
# 负号来从后选择
arr[[-3, -5, -7]]array([[5., 5., 5., 5.],
[3., 3., 3., 3.],
[1., 1., 1., 1.]])
arr = np.arange(32).reshape((8, 4))
arrarray([[ 0, 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]])
# 可以看到[ 4, 23, 29, 10]分别对应(1, 0), (5, 3), (7, 1), (2, 2)
arr[[1, 5, 7, 2], [0, 3, 1, 2]]array([ 4, 23, 29, 10])
arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
上面的意思是，先从arr中选出[1, 5, 7, 2]这四行：
array([[ 4, 5, 6, 7],
[20, 21, 22, 23],
[28, 29, 30, 31],
[ 8, 9, 10, 11]])
然后[:, [0, 3, 1, 2]]表示选中所有行，但是列的顺序要按0,3,1,2来排。于是得到：
array([[ 4, 7, 5, 6],
[20, 23, 21, 22],
[28, 31, 29, 30],
[ 8, 11, 9, 10]])
数组转置和轴交换
转置也是返回一个view，而不是新建一个数组。有两种方式，一个是transpose方法，一个是T属性：
arr = np.arange(15).reshape((3, 5))
arrarray([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])
arr.Tarray([[ 0, 5, 10],
[ 1, 6, 11],
[ 2, 7, 12],
[ 3, 8, 13],
[ 4, 9, 14]])
arr = np.arange(8).reshape((4, 2))
print('转换后',arr.T)
print('原始值',arr)转换后 [[0 2 4 6]
[1 3 5 7]]
原始值 [[0 1]
[2 3]
[4 5]
[6 7]]
np.dot(arr.T, arr)array([[56, 68],
[68, 84]])
上面的例子是 (2x4) x (4x2) = (2x2)。得到的结果是2x2维，就是普通的矩阵乘法。
对于多维数组，transpose会接受由轴数字组成的tuple，来交换轴：
arr = np.arange(16).reshape((2, 2, 4))
arrarray([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
arr.transpose((1, 0, 2))array([[[ 0, 1, 2, 3],
[ 8, 9, 10, 11]],
[[ 4, 5, 6, 7],
[12, 13, 14, 15]]])
这里，secode axis(1)被设为第一个，first axis(0)第二个，最后的axis没边。
使用.T来转置swapping axes(交换轴)的一个特殊情况。ndarray有方法叫做swapaxes, 这个方法取两个axis值，并交换这两个轴：
arrarray([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7]],
[[ 8, 9, 10, 11],
[12, 13, 14, 15]]])
# 直交换second axis和last axis
# swapaxes也是返回view，不生成新的data。
arr.swapaxes(1, 2) array([[[ 0, 4],
[ 1, 5],
[ 2, 6],
[ 3, 7]],
[[ 8, 12],
[ 9, 13],
[10, 14],
[11, 15]]])
通用函数
1、一元通用函数
arr = np.arange(10)
arrarray([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
# 取根号
np.sqrt(arr)array([0. , 1. , 1.41421356, 1.73205081, 2. ,
2.23606798, 2.44948974, 2.64575131, 2.82842712, 3. ])
# 指数
np.exp(arr)array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,
5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,
2.98095799e+03, 8.10308393e+03])
2、二元通用函数
x = np.random.randn(8)
y = np.random.randn(8)
print('x=',x)
print('y=',y)x= [ 1.62629116 0.50042105 0.88487288 -0.51454008 -0.89496779 -0.08716105
-0.89026276 -0.15930902]
y= [ 1.20995668 1.57812313 0.75357992 0.27981496 -1.21836378 -2.21635872
0.46375206 0.12810278]
# 取最大值
np.maximum(x, y)array([ 1.62629116, 1.57812313, 0.88487288, 0.27981496, -0.89496779,
-0.08716105, 0.46375206, 0.12810278])
尽管不常见，但ufunc也能返回多个数组。例如modf，这是一个向量版的divmod（python内建函数），modf会返回小数部分和整数部分：
本函数是实现a除以b，然后返回商与余数的元组。如果两个参数a,b都是整数，那么会采用整数除法，结果相当于（a//b, a % b)。如果a或b是浮点数，相当于（math.floor(a/b), a%b)。
arr = np.random.randn(7) * 5
arrarray([ 0.23231361, 1.94750024, -5.65093763, -7.51480076, -0.34334917,
6.57644177, 1.85733655])
remainder, whole_part = np.modf(arr)
# 返回小数部分
remainderarray([ 0.23231361, 0.94750024, -0.65093763, -0.51480076, -0.34334917,
0.57644177, 0.85733655])
# 返回整数部分
whole_partarray([ 0., 1., -5., -7., -0., 6., 1.])
伪随机数
之所以称之为伪随机数，是因为随机数生成算法是根据seed来生成的。也就是说，只要seed设置一样，每次生成的随机数是相同的：
相对的，python内建的random模块一次只能生成一个样本。在生成大量样本方法，numpy.random是非常快的：
np.random.seed(2018)
samples = np.random.normal(size=(4, 4))
samplesarray([[-0.2767676 , 0.581851 , 2.14839926, -1.279487 ],
[ 0.50227689, 0.8560293 , -0.14279008, 0.11007867],
[-0.68806479, 0.43356408, 0.510221 , -0.16513097],
[-1.35177905, 0.54663075, 1.23065512, 1.0764461 ]])
seed是全局的，如果想要避免全局状态，可以用numpy.random.RandomState来创建一个独立的生成器
rng = np.random.RandomState(2017)
samples = np.random.normal(size=(4, 4))
samplesarray([[-1.21062488, -0.30667657, -1.05741884, 0.40205692],
[ 0.28916512, 1.28273322, -1.0656958 , -1.70663287],
[-0.17279739, 0.06371017, 0.37062839, -1.60454294],
[-2.16572937, 0.38037013, -0.27650109, -0.57568194]])
下面是是写numpy.random里的函数：
数组导向编程
# [X,Y] = meshgrid(x,y) 将向量x和y定义的区域转换成矩阵X和Y
# 其中矩阵X的行向量是向量x的简单复制，而矩阵Y的列向量是向量y的简单复制
m, n = (5, 3)
x = np.linspace(0, 1, m) # linspace() 线性等分向量（linear space）
y = np.linspace(0, 1, n)
X, Y = np.meshgrid(x, y)
print('x=',x)
print('y=',y)
print()
print('X=',X)
print('Y=',Y)x= [0. 0.25 0.5 0.75 1. ]
y= [0. 0.5 1. ]
X= [[0. 0.25 0.5 0.75 1. ]
[0. 0.25 0.5 0.75 1. ]
[0. 0.25 0.5 0.75 1. ]]
Y= [[0. 0. 0. 0. 0. ]
[0.5 0.5 0.5 0.5 0.5]
[1. 1. 1. 1. 1. ]]
逻辑条件
np.where(a,b,c)
np.where中第二个和第三个参数不用必须是数组
- a为真返回b
- a为假返回c
xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])
yarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])
cond = np.array([True, False, True, True, False])
result = np.where(cond, xarr, yarr)
resultarray([1.1, 2.2, 1.3, 1.4, 2.5])
# 把所有的正数变为2，所有的负数变为-2
arr = np.random.randn(4, 4)
print('arr= ', arr)
np.where(arr > 0, 2, -2)arr= [[-1.69790361 1.14692981 2.01866833 1.19685501]
[-1.29768641 0.96410493 0.51591302 -0.04725618]
[ 0.97338591 -0.88312949 0.53144571 1.0647404 ]
[-0.60385003 -1.21294763 0.70985062 0.23991391]]
array([[-2, 2, 2, 2],
[-2, 2, 2, -2],
[ 2, -2, 2, 2],
[-2, -2, 2, 2]])
# 只把整数变为2，其他仍未原来的数字
np.where(arr > 0, 2, arr)array([[-1.69790361, 2. , 2. , 2. ],
[-1.29768641, 2. , 2. , -0.04725618],
[ 2. , -0.88312949, 2. , 2. ],
[-0.60385003, -1.21294763, 2. , 2. ]])
数学和统计方法
arr = np.random.randn(5, 4)
arrarray([[ 0.42185431, 0.7047803 , 0.04540116, 0.53069007],
[ 0.13812536, 0.37046313, -0.0538778 , 1.072796 ],
[ 0.41525259, -0.79155701, -0.80337487, 0.00400008],
[ 0.8381884 , 0.04708372, -2.22118689, 0.44879045],
[-0.01343378, 0.78704248, 0.18833414, -1.58023087]])
print('平均值：', arr.mean())
print('平均值：', np.mean(arr)) # 同上
print('中位数：', np.median(arr))
print('求和：', arr.sum())
print('方差：',arr.var())
print('标准差', arr.std())
print('最小值：',arr.min())
print('最大值：',arr.max())
print('最大值与最小值之间的差值：', np.ptp(arr))
print()
print('数组中最小元素的索引值：',arr.argmin())
print('数组中最大元素的索引值：',arr.argmax())
print('\n绝对值：\n', np.abs(arr))
print()
print('返回一个由相邻数组元素的差值构成的数组：\n', np.diff(arr))平均值： 0.02745704812129939
平均值： 0.02745704812129939
中位数： 0.16322975085704675
求和： 0.5491409624259878
方差： 0.6344954097327102
标准差 0.7965522015114328
最小值： -2.2211868856516417
最大值： 1.0727959997704182
最大值与最小值之间的差值： 3.29398288542206
数组中最小元素的索引值： 14
数组中最大元素的索引值： 7
绝对值：
[[0.42185431 0.7047803 0.04540116 0.53069007]
[0.13812536 0.37046313 0.0538778 1.072796 ]
[0.41525259 0.79155701 0.80337487 0.00400008]
[0.8381884 0.04708372 2.22118689 0.44879045]
[0.01343378 0.78704248 0.18833414 1.58023087]]
返回一个由相邻数组元素的差值构成的数组：
[[ 0.28292599 -0.65937913 0.48528891]
[ 0.23233777 -0.42434094 1.1266738 ]
[-1.2068096 -0.01181786 0.80737495]
[-0.79110468 -2.26827061 2.66997733]
[ 0.80047625 -0.59870834 -1.76856501]]
# axis作为参数来计算统计数字
print('横向：',arr.mean(axis=1)) # 横向
print('横向：',arr.mean(1))
print()
print('纵向：',arr.mean(axis=0)) # 纵向
print('纵向：',arr.mean(0))
print()
print('横向：',arr.sum(axis=1)) # 横向
print('纵向：',arr.sum(0)) # 纵向横向： [-1.47618477 -0.40924536 0.27245489 0.22881218 1.1980545 ]
横向： [-1.47618477 -0.40924536 0.27245489 0.22881218 1.1980545 ]
纵向： [-0.22275301 0.02190233 -0.6217432 0.67370703]
纵向： [-0.22275301 0.02190233 -0.6217432 0.67370703]
横向： [-5.90473907 -1.63698144 1.08981957 0.91524871 4.79221799]
纵向： [-1.11376504 0.10951164 -3.10871598 3.36853515]
# 元素累计和
arr = np.array([0, 1, 2, 3, 4, 5, 6, 7])
arr.cumsum()array([ 0, 1, 3, 6, 10, 15, 21, 28], dtype=int32)
arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
arrarray([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
# 纵向相加
arr.cumsum(axis=0) # 纵向array([[ 0, 1, 2],
[ 3, 5, 7],
[ 9, 12, 15]], dtype=int32)
# 横向相乘
arr.cumprod(axis=1) # 横向array([[ 0, 0, 0],
[ 3, 12, 60],
[ 6, 42, 336]], dtype=int32)
布尔数组的方法
# 数组中大于0的个数
arr = np.random.randn(100) # 返回符合正态分布的数值
(arr > 0).sum()56
- any检测数组中只要有一个ture返回就是true
- all检测数组中都是true才会返回true
bools = np.array([False, False, True, False])
print('any结果：', bools.any())
print('all结果：', bools.all())any结果： True
all结果： False
排序
- 直接调用数组的arr.sort()方法，会改变原有数组的顺序。
- 如果使用np.sort(arr)函数的话，会生成一个新的排序后的结果。
arr = np.random.randn(10)
print('排序前：\n', arr)
arr.sort()
print('排序后：\n', arr)排序前：
[ 1.59249466 0.6515314 -0.22653 -2.09396182 1.98428654 -0.41047994
0.4461693 0.53309987 0.50317313 0.45538713]
排序后：
[-2.09396182 -0.41047994 -0.22653 0.4461693 0.45538713 0.50317313
0.53309987 0.6515314 1.59249466 1.98428654]
如果是多维数组，还可以按axis来排序：
arr = np.random.randn(5, 3) # 5行3列
arrarray([[ 0.64807367, 0.64734467, -0.57956506],
[ 1.30009271, -1.0096845 , -0.90608046],
[ 0.96544172, -0.82934629, -0.1372017 ],
[ 1.2585547 , 0.90157093, 1.55362495],
[-1.22715482, -1.68016336, -1.31421393]])
# arr.sort(1) # 横向
# arr.sort(0) # 纵向
arr.sort(axis=1) # 同上
arrarray([[-0.57956506, 0.64734467, 0.64807367],
[-1.0096845 , -0.90608046, 1.30009271],
[-0.82934629, -0.1372017 , 0.96544172],
[ 0.90157093, 1.2585547 , 1.55362495],
[-1.68016336, -1.31421393, -1.22715482]])
# 一个计算分位数的快捷方法是先给数组排序，然后选择某个排名的值：
large_arr = np.random.randn(1000)
large_arr.sort()
large_arr[int(0.05 * len(large_arr))] # 5% quantile-1.5947780268732517
Numpy也有一些基本的集合操作用于一维数组。np.unique，能返回排好序且不重复的值：
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
np.unique(names)array(['Bob', 'Joe', 'Will'], dtype='ints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])
np.unique(ints)array([1, 2, 3, 4])
线性代数
矩阵乘法
# 矩阵乘法
x = np.array([[1., 2., 3.], [4., 5., 6.]])
y = np.array([[6., 23.], [-1, 7], [8, 9]])
print('x:\n',x)
print('y:\n',y)
# x.dot(y)等同于np.dot(x, y)
x.dot(y)x:
[[1. 2. 3.]
[4. 5. 6.]]
y:
[[ 6. 23.]
[-1. 7.]
[ 8. 9.]]
array([[ 28., 64.],
[ 67., 181.]])
一个二维数组和一个一维数组的矩阵乘法，得到一个一维数组：
np.dot(x, np.ones(3))
# 这里应该是用狂了boradcasting，x中的每一行与[1, 1, 1]点对点乘积后求和array([ 6., 15.])
# @作为一个中缀计算符，也能实现矩阵乘法：
x @ np.ones(3)array([ 6., 15.])
矩阵分解
np.linalg能用来做矩阵分解，以及比如转置和求秩之类的事情：
from numpy.linalg import inv, qr
# X = np.round(np.random.randn(5, 5), 3) # 这里我们用np.round控制小数点后的位数，看起来更舒服一些
X = np.random.randn(5, 5)
Xarray([[-0.24821301, -0.73158913, 1.89565751, -1.23795063, -0.63359619],
[ 0.29635489, 0.50478366, -0.31098479, -1.34502933, 0.17482175],
[ 2.02590827, -1.15869345, -0.8894822 , 0.266318 , 1.07333646],
[-1.31303883, -1.40763291, -0.4048509 , -1.92894314, -0.86348757],
[ 0.2866783 , 0.73102305, 0.11381171, -1.74766983, 0.77151067]])
# X.T.dot(X)计算的是X和X的转置的矩阵乘法。
mat = X.T.dot(X)
np.round(mat, 2)array([[ 6.06, 0.04, -1.8 , 2.48, 3.74],
[ 0.04, 4.65, 0.14, 1.36, 1.09],
[-1.8 , 0.14, 4.66, -1.58, -1.77],
[ 2.48, 1.36, -1.58, 10.19, 1.15],
[ 3.74, 1.09, -1.77, 1.15, 2.92]])
np.round(inv(mat), 2)array([[ 2.22, 0.9 , -0.58, -0.37, -3.38],
[ 0.9 , 0.62, -0.3 , -0.18, -1.48],
[-0.58, -0.3 , 0.45, 0.13, 1.07],
[-0.37, -0.18, 0.13, 0.17, 0.55],
[-3.38, -1.48, 1.07, 0.55, 5.65]])
np.round(mat.dot(inv(mat)), 2)array([[ 1., 0., 0., 0., -0.],
[-0., 1., 0., 0., 0.],
[ 0., -0., 1., 0., 0.],
[-0., -0., 0., 1., -0.],
[ 0., 0., -0., -0., 1.]])
q, r = qr(mat)
np.round(r, 2)array([[-7.75, -0.98, 3.85, -6.13, -5.12],
[ 0. , -4.87, -0.19, -3.13, -0.96],
[ 0. , 0. , -3.97, 1.72, 0.59],
[ 0. , 0. , 0. , -8.08, 0.83],
[ 0. , 0. , 0. , 0. , 0.15]])
一些常用的numpy.linalg函数：