Python数据分析–numpy总结
NumPy常用方法总结
文章目录
- Python数据分析--numpy总结
- 生成ndarray的几种方式
- 从已有数据中创建
- 利用random模块生成ndarray
- 创建特定形状的多维数组
- 利用arange函数
- 存取元素
- 矩阵操作
- 数据合并与展平
- 合并一维数组
- 多维数组的合并
- 矩阵展平
- 通用函数
- 使用math与numpy函数性能比较：
- 使用循环与向量运算比较：
- 广播机制
- shuffle和permutation
生成ndarray的几种方式
从已有数据中创建
import numpy as np
list1 = [3.14,2.17,0,1,2]
nd1 = np.array(list1)
print(nd1)
print(type(nd1))[3.14 2.17 0. 1. 2. ]
<class 'numpy.ndarray'>list2 = [[3.14,2.17,0,1,2],[1,2,3,4,5]]
nd2 = np.array(list2)
print(nd2)
print(type(nd2))[[3.14 2.17 0. 1. 2. ]
[1. 2. 3. 4. 5. ]]
<class 'numpy.ndarray'>利用random模块生成ndarray
import numpy as np
nd5 = np.random.random([3,3])
print(nd5)
print(type(nd5))[[0.31192569 0.3022696 0.48253531]
[0.38008201 0.59103878 0.98225759]
[0.54242215 0.14208123 0.59577163]]
<class 'numpy.ndarray'>import numpy as np
np.random.seed(123)
nd5_1 = np.random.randn(2,3)
print(nd5_1)
np.random.shuffle(nd5_1)
print("随机打乱后数据")
print(nd5_1)
print(type(nd5_1))[[-1.0856306 0.99734545 0.2829785 ]
[-1.50629471 -0.57860025 1.65143654]]
随机打乱后数据
[[-1.50629471 -0.57860025 1.65143654]
[-1.0856306 0.99734545 0.2829785 ]]
<class 'numpy.ndarray'>创建特定形状的多维数组
import numpy as np
#生成全是0的3x3矩阵
nd6 = np.zeros([3,3])
#生成全是1的3x3矩阵
nd7 = np.ones([3,3])
#生成3阶的单位矩阵
nd8= np.eye(3)
#生成3阶对角矩阵
print (np.diag([1, 2, 3]))[[1 0 0]
[0 2 0]
[0 0 3]]import numpy as np
nd9 = np.random.random([5,5])
np.savetxt(X=nd9,fname='./test2.txt')
nd10 = np.loadtxt('./test2.txt')利用arange函数
import numpy as np
print(np.arange(10))
print(np.arange(0,10))
print(np.arange(1, 4,0.5))
print(np.arange(9, -1, -1))[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
[1. 1.5 2. 2.5 3. 3.5]
[9 8 7 6 5 4 3 2 1 0]存取元素
import numpy as np
np.random.seed(2018)
nd11 = np.random.random([10])
#获取指定位置的数据，获取第4个元素
nd11[3]
#截取一段数据
nd11[3:6]
#截取固定间隔数据
nd11[1:6:2]
#倒序取数
nd11[::-2]
#截取一个多维数组的一个区域内数据
nd12=np.arange(25).reshape([5,5])
nd12[1:3,1:3]
#截取一个多维数组中，数值在一个值域之内的数据
nd12[(nd12>3)&(nd12<10)]
#截取多维数组中，指定的行,如读取第2,3行
nd12[[1,2]] #或nd12[1:3,:]
##截取多维数组中，指定的列,如读取第2,3列
nd12[:,1:3]array([[ 1, 2],
[ 6, 7],
[11, 12],
[16, 17],
[21, 22]])获取数组中的部分元素除通过指定索引标签外，还可以使用一些函数来实现，如通过random.choice函数可以从指定的样本中进行随机抽取数据。
import numpy as np
from numpy import random as nr
a=np.arange(1,25,dtype=float)
c1=nr.choice(a,size=(3,4)) #size指定输出数组形状
c2=nr.choice(a,size=(3,4),replace=False) #replace缺省为True，即可重复抽取。
#下式中参数p指定每个元素对应的抽取概率，缺省为每个元素被抽取的概率相同。
c3=nr.choice(a,size=(3,4),p=a / np.sum(a))
print("随机可重复抽取")
print(c1)
print("随机但不重复抽取")
print(c2)
print("随机但按制度概率抽取")
print(c3)随机可重复抽取
[[18. 1. 7. 14.]
[22. 23. 24. 1.]
[24. 9. 8. 10.]]
随机但不重复抽取
[[ 3. 20. 4. 10.]
[13. 22. 5. 17.]
[ 8. 15. 24. 2.]]
随机但按制度概率抽取
[[20. 5. 12. 18.]
[18. 15. 7. 14.]
[23. 21. 24. 18.]]矩阵操作
import numpy as np
nd14=np.arange(9).reshape([3,3])
#矩阵转置
np.transpose(nd14)
#矩阵乘法运算
a=np.arange(12).reshape([3,4])
b=np.arange(8).reshape([4,2])
a.dot(b)
#求矩阵的迹
a.trace()
#计算矩阵行列式
np.linalg.det(nd14)
#计算逆矩阵
c=np.random.random([3,3])
np.linalg.solve(c,np.eye(3))array([[ 0.38142768, -5.29433928, 6.34332256],
[ 1.76114014, 1.09115706, -4.37965093],
[-0.61650199, 4.92267848, -3.55057072]])数据合并与展平
合并一维数组
import numpy as np
a=np.array([1,2,3])
b=np.array([4,5,6])
c=np.append(a,b)
print(c)
#或利用concatenate
d=np.concatenate([a,b])
print(d)[1 2 3 4 5 6]
[1 2 3 4 5 6]多维数组的合并
import numpy as np
a=np.arange(4).reshape(2,2)
b=np.arange(4).reshape(2,2)
#按行合并
c=np.append(a,b,axis=0)
print(c)
print("合并后数据维度",c.shape)
#按列合并
d=np.append(a,b,axis=1)
print("按列合并结果:")
print(d)
print("合并后数据维度",d.shape)[[0 1]
[2 3]
[0 1]
[2 3]]
合并后数据维度 (4, 2)
按列合并结果:
[[0 1 0 1]
[2 3 2 3]]
合并后数据维度 (2, 4)矩阵展平
import numpy as np
nd15=np.arange(6).reshape(2,-1)
print(nd15)
#按照列优先，展平。
print("按列优先,展平")
print(nd15.ravel('F'))
#按照行优先，展平。
print("按行优先,展平")
print(nd15.ravel())[[0 1 2]
[3 4 5]]
按列优先,展平
[0 3 1 4 2 5]
按行优先,展平
[0 1 2 3 4 5]通用函数
使用math与numpy函数性能比较：
import time
import math
import numpy as np
x = [i * 0.001 for i in np.arange(1000000)]
start = time.clock()
for i, t in enumerate(x):
x[i] = math.sin(t)
print ("math.sin:", time.clock() - start )
x = [i * 0.001 for i in np.arange(1000000)]
x = np.array(x)
start = time.clock()
np.sin(x)
print ("numpy.sin:", time.clock() - start )使用循环与向量运算比较：
import time
import numpy as np
x1 = np.random.rand(1000000)
x2 = np.random.rand(1000000)
##使用循环计算向量点积
tic = time.process_time()
dot = 0
for i in range(len(x1)):
dot+= x1[i]*x2[i]
toc = time.process_time()
print ("dot = " + str(dot) + "\n for loop----- Computation time = " + str(1000*(toc - tic)) + "ms")
##使用numpy函数求点积
tic = time.process_time()
dot = 0
dot = np.dot(x1,x2)
toc = time.process_time()
print ("dot = " + str(dot) + "\n verctor version---- Computation time = " + str(1000*(toc - tic)) + "ms")广播机制
import numpy as np
a=np.arange(10)
b=np.arange(10)
#两个shape相同的数组相加
print(a+b)
#一个数组与标量相加
print(a+3)
#两个向量相乘
print(a*b)
#多维数组之间的运算
c=np.arange(10).reshape([5,2])
d=np.arange(2).reshape([1,2])
#首先将d数组进行复制扩充为[5,2],如何复制请参考图1-2，然后相加。
print(c+d)[ 0 2 4 6 8 10 12 14 16 18]
[ 3 4 5 6 7 8 9 10 11 12]
[ 0 1 4 9 16 25 36 49 64 81]
[[ 0 2]
[ 2 4]
[ 4 6]
[ 6 8]
[ 8 10]]shuffle和permutation
这两个方法都是打乱一个随机地打乱一个数组，他们的语法如下：
np.random.shuffle(x):这里的参数x要求为array-like或者是一个list，没有返回值
np.random.permutation(x): 这里的参数x可以是array-like或者是一个int，如果是int就等价与传入np.arange(x)，返回打乱的数组
他们二者的区别就在于shuffle是就地打乱数组，就是说传入的数组x被打乱，而permutation是打乱复制的x的数组，然后返回这个复制被打乱的数组，而传入的x不会被打乱。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
