Numpy其实就是一个多维的数组对象
import numpy as np
data = [1,2,3,4,5]
#把列表data转换成numpy格式的数组
n = np.array(data)
#其实数据打印出来是一样的
print(data)
print(n)
[1, 2, 3, 4, 5]
[1 2 3 4 5]
每一个np的数组都有一个shape和一个叫做dtype的属性
n.shape #shape属性表示获取到np数组的维度（长度）
(5,)
n.dtype #dtype表示获取到数组的类型
dtype('int32')
Numpy数组的创建
嵌套序列：是由一组等长列表组成的列表
arr = [[1,2,3,4],[5,6,7,8]]
arr2 = np.array(arr)
print(arr2)
print(arr2.ndim)#ndim代表维度
print(arr2.shape)
#如果列表长度不一样的话
[[1 2 3 4]
[5 6 7 8]]
2
(2, 4)
np对数据类型的一个判断
arr = [['1','2',3,4],[5,6,7,8]]
arr2 = np.array(arr)
print(arr2)
#如果数据类型不统一，而且含有字符类型，会全部转换成字符类型
#因为做判断的时候，字符类型不一定可以换成int，int可以转成字符。
#所以numpy会对数据类型进行一个比较合理的运算
print(arr2.dtype) #<U1是指unicode类型
[['1' '2' '3' '4']
['5' '6' '7' '8']]
<U1
arr = [[1,2,3,4],[5,6,7,8]]
arr2 = np.array(arr)
print(arr2.dtype)
int32
arr = [[1.1,2,3,4],[5,6,7,8]]
arr2 = np.array(arr)
print(arr2.dtype)#当成员当中有一个为float时，那么numpy将会推断成为float64类型，也会把其他数据也转成float64类型
print(arr2)
float64
[[ 1.1 2. 3. 4. ]
[ 5. 6. 7. 8. ]]
Numpy进行指定长度数组的创建
np.zeros(10)
array([ 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
np.zeros((3,5))
array([[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 0.]])
np.ones((5,8))
array([[ 1., 1., 1., 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1., 1., 1., 1.]])
np.empty((2,3,4))
array([[[ 1.35717430e+131, 2.43902456e-154, 2.93573416e+222,
8.90210855e+252],
[ 8.03046085e-096, 1.12958007e+277, 1.06112833e-153,
1.92709888e-110],
[ 1.96086529e+243, 2.99938058e-067, 1.87725413e-009,
1.18324733e+243]],
[[ 1.69375610e+190, 5.95750259e+271, 5.95915351e+271,
5.43256360e-096],
[ 1.06259729e+223, 1.14489505e-095, 7.16006779e-062,
9.13544126e+242],
[ 1.05135744e-153, 2.00007403e+174, 7.36191050e+223,
6.01334434e-154]]])
np.arange(10)#arange是range函数的
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#类型转换，float型转换成int，会把小数点的后面全部舍弃掉
arr = np.array([1.2,1.6,-2.3,-5.8])
print(arr)
print(arr.dtype)
print(arr.astype(np.int64))#转成想要的类型
[ 1.2 1.6 -2.3 -5.8]
float64
[ 1 1 -2 -5]
矢量化
数组通常不用在编写循环的情况下就可以进行批量运算
也就是进行一些运算，比如加减乘除等
#两个array想加
arr1 = np.array([1,2,3,4,5])
arr2 = np.array([5,6,7,8,9])
arr1+arr2
array([ 6, 8, 10, 12, 14])
#多维的两个array想加
arr1 = np.array([[1,2,3,4,5],[1,2,3,4,5]])
arr2 = np.array([[5,6,7,8,9],[5,6,7,8,9]])
arr1+arr2
array([[ 6, 8, 10, 12, 14],
[ 6, 8, 10, 12, 14]])
#多维的两个array想减
arr1 = np.array([[1,2,3,4,5],[1,2,3,4,5]])
arr2 = np.array([[5,6,7,8,9],[5,6,7,8,9]])
arr1-arr2
array([[-4, -4, -4, -4, -4],
[-4, -4, -4, -4, -4]])
#多维的两个array想乘
arr1 = np.array([[1,2,3,4,5],[1,2,3,4,5]])
arr2 = np.array([[5,6,7,8,9],[5,6,7,8,9]])
arr1*arr2
array([[ 5, 12, 21, 32, 45],
[ 5, 12, 21, 32, 45]])
#多维的两个array想乘
arr1 = np.array([[1,2,3,4,5],[1,2,3,4,5]])
arr2 = np.array([[5,6,7,8,9],[5,6,7,8,9]])
arr1/arr2
array([[ 0.2 , 0.33333333, 0.42857143, 0.5 , 0.55555556],
[ 0.2 , 0.33333333, 0.42857143, 0.5 , 0.55555556]])
numpy矢量化广播
arr = np.array([[1,2,3,4,5],[5,6,7,8,9]])
5*arr #5进行广播给array的每个元素，这就叫做广播
array([[ 5, 10, 15, 20, 25],
[25, 30, 35, 40, 45]])
花式索引，是Numpy中的术语，指的是利用整数数组进行索引
#二维的切片操作
arr = np.arange(24).reshape((8,3))
# print(arr)
#表示获取第二行的第二个数据
# print(arr[2,2])
#通过整数数组的形式获取列表种的行
#以一个特定的顺序来选取一个子集，我们传入用于指定顺序的整数列表或数组。
#这里也可以用负数来从末尾开始获取
print(arr[[5,3,1,7]])
#后面的整数列表代表的是对应的行选择第几个元素，输出组成所有行的第几个元素作为一维的一组数组
#比如选择第5行的第1个数据，选择第3行的第3个数据，以此类推得到一组数组
#后面整数列表的个数要跟前面的行数一样的个数。
print(arr[[5,3,1,7],[0,2,1,2]])
#[15 11 4 23]
#如果只是调换列表的顺序的话，就需要下面的这种实现方式
#先选择行的数据后，然后再对列进行选择，选择输出对应列的数据
print(arr[[5,3,1,7]][:,[0,2,1,2]])
#想实现这样子的操作，np有一个对应的方法去实现
print(arr[np.ix_([5,3,1,7],[0,2,1,2])])
out：
[[15 16 17]
[ 9 10 11]
[ 3 4 5]
[21 22 23]]
[15 11 4 23]
[[15 17 16 17]
[ 9 11 10 11]
[ 3 5 4 5]
[21 23 22 23]]
[[15 17 16 17]
[ 9 11 10 11]
[ 3 5 4 5]
[21 23 22 23]]
Numpy数组的转置和轴对换
1、transpose(arr, axes) arr：要操作的数组,axes：整数列表，对应维度，通常所有维度都会对换。
2、arr.T
3、transpose((1,0,2)) 这个参数的意思是，比如我们正常的2，3，4置换后应该是4，3，2，如果我们要置换的对应维度改变，改成3，2，4，那就是对应的下标是1，0，2
所以下面的结果就很明显的出来
arr = np.arange(24).reshape(2,3,4)
print(arr)
print('-'*100)
print(arr.transpose())
print('-'*100)
print(arr.transpose((2,1,0)))
print('-'*100)
print(arr.transpose((1,0,2)))# 3,2,4
out:[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
----------------------------------------------------------------------------------------------------
[[[ 0 12]
[ 4 16]
[ 8 20]]
[[ 1 13]
[ 5 17]
[ 9 21]]
[[ 2 14]
[ 6 18]
[10 22]]
[[ 3 15]
[ 7 19]
[11 23]]]
----------------------------------------------------------------------------------------------------
[[[ 0 12]
[ 4 16]
[ 8 20]]
[[ 1 13]
[ 5 17]
[ 9 21]]
[[ 2 14]
[ 6 18]
[10 22]]
[[ 3 15]
[ 7 19]
[11 23]]]
----------------------------------------------------------------------------------------------------
[[[ 0 1 2 3]
[12 13 14 15]]
[[ 4 5 6 7]
[16 17 18 19]]
[[ 8 9 10 11]
[20 21 22 23]]]
arr = np.arange(24).reshape(6,4)
arr.transpose()
#二维的也是跟三维同样的意思，置换成多少行和列，取决于原来的行列数目，下面列表是行列数目的列表下表，如果0，1结果就是没有置换
print(arr.transpose(1,0))
print(arr.transpose(0,1))
条件逻辑转换数组，根据条件，输出对应的数组
np.where等同于 x if condition else y 矢量化的一个版本 x if condition else y表示的意思是当条件condition成立时，表达式的返回值是x，不成立时返回值是y
是np.where的写法，一般用于根据条件把一个数组产生一个新的数组，跟python中函数式变成中的map，reduce函数类似
#用普通的实现方法
x_arr = [1.1,1.2,1.3]
y_arr = [2.1,2.2,2.3]
condition = [True,False,True]
result = [x if c else y for x,y,c in zip(x_arr,y_arr,condition)]
#zip 接收的参数是可迭代对象
#zip（）函数用于将可迭代对象作为参数，将对象中对应的元素转换成元祖，然后返回符号条件的元祖的数据作为列表输出
print(result)
#如果用np.where可以实现等价的操作，而且简洁
result1 = np.where(condition,x_arr,y_arr)
print(result1)
out:
[1.1, 2.2, 1.3]
[1.1, 2.2, 1.3]
[ 1.1 2.2 1.3]
值替换，其实也是类似转换啦哈哈哈哈，
arr = np.random.randn(4,4)
arr_1 = np.where(arr>0,2,-2)
print(arr_1)
#其实2会产生一个广播的形式，2的维度跟arr是一样的
arr_2 = np.where(arr>0,2,arr)
print(arr_2)
#哈哈哈，搞定吃饭
out:
[[ 2 -2 2 2]
[ 2 -2 -2 2]
[ 2 -2 2 2]
[ 2 2 -2 2]]
[[ 2. -0.3394422 2. 2. ]
[ 2. -1.98995006 -0.20768662 2. ]
[ 2. -2.4886569 2. 2. ]
[ 2. 2. -1.52357648 2. ]]
Numpy的数学操作
arr = np.random.randn(4,4)
print(arr)
#计算平均值
print(arr.mean())
#求和
print(arr.sum())
#计算标准差
print(arr.std())
out:
[[ 0.98999571 0.7161278 1.27152314 1.04647328]
[-0.8013141 0.76256068 -0.42723409 -0.75889407]
[ 2.10650679 0.29345102 0.14957078 0.51364334]
[-0.61171082 -0.42874417 -0.24624597 0.97561434]]
0.346957728674
5.55132365878
0.815511454935
#在一个轴上进行运行
#计算轴1上的平均值
print(arr.mean(axis = 1))
#计算轴0上求和
print(arr.sum(0))
out:
[ 1.00602998 -0.30622039 0.76579298 -0.07777166]
[ 1.68347758 1.34339533 0.74761387 1.77683689]
排序方法
arr = np.random.randn(4,4)
print(arr)
arr.sort()
print(arr)#从小到大的排序
#按轴号进行排序
arr.sort(1)
print(arr)
out:
[[ 1.04452092 0.12122071 0.56001955 -0.08934808]
[-0.8790024 -0.36883127 0.35692466 0.15982961]
[ 0.22316491 -0.40406737 -1.17930964 0.58793927]
[ 1.97961455 0.26991169 0.20957944 -0.61771775]]
[[-0.08934808 0.12122071 0.56001955 1.04452092]
[-0.8790024 -0.36883127 0.15982961 0.35692466]
[-1.17930964 -0.40406737 0.22316491 0.58793927]
[-0.61771775 0.20957944 0.26991169 1.97961455]]
[[-0.08934808 0.12122071 0.56001955 1.04452092]
[-0.8790024 -0.36883127 0.15982961 0.35692466]
[-1.17930964 -0.40406737 0.22316491 0.58793927]
[-0.61771775 0.20957944 0.26991169 1.97961455]]
Numpy 文件操作
Numpy可以读写磁盘的文件或者二进制文件 主要应用的函数就是np.save和np.load，默认情况下数据是以未压缩的原始二进制格式保存在扩展名为.npy的文件中（如果不指定的文件格式的话）
savexx和loadxx是同步的(除了压缩文件)，下面展开来讲
arr = np.arange(10)
np.save('arrage_file',arr)#返回的格式是.npy后缀的文件
#访问np.load()
a = np.load('arrage_file.npy')
print(a)
out:[0 1 2 3 4 5 6 7 8 9]
#保存为压缩文件
arr = np.arange(10)
np.savez('arrage_file',a = arr)#返回的格式是.npz后缀的文件
#访问np.load()
a = np.load('arrage_file.npz')['a']
print(a)
out:[0 1 2 3 4 5 6 7 8 9]
#保存在txt
arr = np.arange(10)
np.savetxt('arrage_file.txt',arr,delimiter=':')
#访问np.load() delimiter分隔符 获取每个值
np.loadtxt('arrage_file.txt',delimiter=',')
# a = np.loadtxt('arrage_file.txt',delimiter=',')
# print(a)
out:array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])
线性代数
dot 矩阵的乘法运算
vdot 两个向量的点积
trace 计算对角线元素的和
det 计算矩阵的行列式
eig 计算方针 的本征值和本征向量
inv 计算方针的逆
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
a.dot(b)
out:
array([[37, 40],
[85, 92]])
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
# vdot 将数组展开计算内积
print (np.vdot(a,b))
130
随机漫步的例子
求什么时候第一次，距离初始点10步远
import matplotlib.pyplot as plt
position = 0
walk = [position]
steps = 1000 #步数1000次
for i in range(steps):
#np.random.randint(0,2) 获得的值是0或者1
x = 1 if np.random.randint(0,2) else -1
position+=x
walk.append(position)
#这是因为如果只传入一个list或array给plot()，它会认为这是y的值，并自动生成x的值
plt.plot(walk)
plt.show()
#求什么时候第一次，距离初始点10步远
np.argmax()
print(np.abs(walk)>=10)
print((np.abs(walk)>=10).argmax())
#argmax 是找到第一个符号条件的下标，比如有很多个相同的值，那就返回第一个，所以下面就是返回第一个True的下标，正是我们第一次距离初始点10步远的点
print(walk[(np.abs(walk)>=10).argmax()])
image.png
网友评论