eye()生成对角矩阵
from numpy import *
eye(4)
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.],
[0., 0., 0., 1.]])
numpy Ndarray对象
import numpy as np
a = np.array([1,2,3])
print(a)
[1 2 3]
# 多余一个维度
import numpy as np
a = np.array([[1,2],[3,4]]) #不要忘写外层的[],np.array([[],[]])
print(a)
[[1 2]
[3 4]]
# ndmin 指定生成数组的最小维度
a = np.array([1,2,3,4,5],ndmin=2)
print(a)
[[1 2 3 4 5]]
# dtype 数组元素的数据类型
a = np.array([1,2,3],dtype=complex)
print(a)
[1.+0.j 2.+0.j 3.+0.j]
数据类型对象（dtype）
# 使用标量类型
dt = np.dtype(np.int32)
print(dt)
int32
# int8,int16,int32,int64 四种数据类型可以使用字符串 ‘i1’,‘i2’,'i4','i8'代替
dt = np.dtype('i4')
print(dt)
int32
# 字节顺序标注
dt = np.dtype('<i4')
print(dt)
int32
# 首先创建结构化数据类型
dt = np.dtype([('age',np.int8)])
print(dt)
[('age', 'i1')]
# 将数据类型应用于ndarray对象
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)],dtype=dt)
print(a)
[(10,) (20,) (30,)]
# 类型字段名可以用于存取实际的age列
dt = np.dtype([('age',np.int8)])
a = np.array([(10,),(20,),(30,)],dtype=dt)
print(a['age'])
[10 20 30]
# 定义一个结构化数据类型student，包含字符串字段name,整数字段age,浮点字段marks
student = np.dtype([('name','S20'),('age','i1'),('marks','f4')])
print(student)
[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')]
student = np.dtype([('name','S20'),('age','i1'),('marks','f4')])
a = np.array([('Alice',20,50),('Bob',12,23)],dtype=student)
print(a)
[(b'Alice', 20, 50.) (b'Bob', 12, 23.)]
NumPy数组属性
a = np.arange(24)
# print(a)
print(a.ndim)
print('-'*20)
# 现在调整其大小
b = a.reshape(2,4,3)
# print(b)
print(b.ndim)
1
--------------------
3
a = np.array([[1,2,3],[4,5,6]])
print(a.shape)
(2, 3)
# 调整数组大小
a = np.array([[1,2,3],[4,5,6]])
a.shape = (3,2)
print(a)
[[1 2]
[3 4]
[5 6]]
# reshape也快可以调整数组大小
b = np.array([[1,2,3],[4,5,6]])
b.shape = (3,2)
print(b)
[[1 2]
[3 4]
[5 6]]
# ndarray.itemsize 以字节的形式返回数组中每一个元素的大小
x = np.array([1,2,3,4,5],dtype='i1')
print(x.itemsize)
y = np.array([1,2,3,4,5],dtype=np.float64)
print(y.itemsize)
1
8
# ndarray.flags返回ndarray对象的内存信息
x = np.array([1,2,3,4,5])
print(x.flags)
C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
NumPy创建数组
# numpy.empty()方法创建一个指定形状、数据类型且未初始化的数组
x = np.empty([3,2],dtype=int)
print(x)
[[ 544435809 1952540788]
[1701344288 538976266]
[1701798688 1667851878]]
# 默认为浮点数
x = np.zeros(5)
print(x)
# 设置类型为整数
y = np.zeros((5,),dtype=np.int8)
print(y)
# 自定义类型
z = np.zeros((2,2),dtype=[('x','i4'),('y','i4')])
print(z)
[0. 0. 0. 0. 0.]
[0 0 0 0 0]
[[0 0]
[0 0]]
# numpy.one()指定形状的数组，数组元素以1填充
# 默认浮点型
x = np.ones(5)
print(x)
# 自定义类型
x = np.ones((2,2),dtype=int)
print(x)
[1. 1. 1. 1. 1.]
[[1 1]
[1 1]]
从已有的数组创建数组
# 将列表转换为ndarray
x = [1,2,3]
a = np.asarray(x)
print(a)
[1 2 3]
# 将元组转换为ndarray
x = (1,2,3)
a = np.asarray(x)
print(a)
[1 2 3]
# 将元组列表转换为ndarray
x = [(1,2,3),(4,5)]
a = np.asarray(x)
print(a)
[(1, 2, 3) (4, 5)]
# 设置dtype参数
x = [1,2,3]
a = np.asarray(x, dtype=float)
print(a)
[1. 2. 3.]
# numpy.frombuffer用于实现动态数组
s = b'Hello World'
a = np.frombuffer(s,dtype='S1')
print(a)
[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd']
# numpy.fromiter 方法从可迭代对象中建立ndarray对象，返回一维数组
list = range(5)
it = iter(list)
# 使用迭代器创建 ndarray
x = np.fromiter(it,dtype=float)
print(x)
[0. 1. 2. 3. 4.]
# NumPy从数值范围创建数组
x = np.arange(10,20,2)
print(x)
[10 12 14 16 18]
a = np.linspace(1,10,10,retstep=True)
print(a)
(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
a = np.linspace(1,10,10)
print(a)
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
# 设置元素全部是1的等差数列
a = linspace(1,1,10)
print(a)
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
# 将endpoint设为false,不包括终止值
a = np.linspace(10,20,5,endpoint = False)
print(a)
[10. 12. 14. 16. 18.]
# 给实例设置间距
a = np.linspace(1,10,10,retstep=True)
print(a)
# 拓展例子
b = np.linspace(1,10,10).reshape([10,1])
print(b)
(array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]), 1.0)
[[ 1.]
[ 2.]
[ 3.]
[ 4.]
[ 5.]
[ 6.]
[ 7.]
[ 8.]
[ 9.]
[10.]]
# numpy.logspace用于创建一个于等比数列
a = np.logspace(1.0,2.0,num=10)
print(a)
[ 10. 12.91549665 16.68100537 21.5443469 27.82559402
35.93813664 46.41588834 59.94842503 77.42636827 100. ]
b = np.logspace(0,9,num=10,base=2)
print(b)
[ 1. 2. 4. 8. 16. 32. 64. 128. 256. 512.]
Numpy切片和索引
a = np.arange(10)
s = slice(2,7,2)
print(a[s])
[2 4 6]
a = np.arange(10)
b = a[2:7:2]
print(b)
[2 4 6]
# 多维数组同样适用
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
# 从某个索引处切割
print('从数组a[1:]处切割')
print(a[1:])
[[1 2 3]
[4 5 6]
[7 8 9]]
从数组a[1:]处切割
[[4 5 6]
[7 8 9]]
切片还可以包括省略号...,来使元组的长度与数组的维度相同。如果在行位置使用省略号，它将返回包括行中元素的ndarray。
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(a)
print('-'*10)
print(a[...,1]) # 第二列元素
print('-'*10)
print(a[1,...]) #第二行元素
print('-'*10)
print(a[...,1:]) #第二列及剩下的所有元素
[[1 2 3]
[4 5 6]
[7 8 9]]
----------
[2 5 8]
----------
[4 5 6]
----------
[[2 3]
[5 6]
[8 9]]
NumPy高级索引
整数数组索引
# 以下实例获取数组中(0,0),(1,1)和(2,0)位置处的元素
x = np.array([[1,2],[3,4],[5,6]])
print(x)
print('-'*10)
y = x[[0,1,2],[0,1,0]]
print(y)
[[1 2]
[3 4]
[5 6]]
----------
[1 4 5]
# 以下实例获取了4*3数组中的四个角的元素。行索引是[0,0]和[3,3],而列索引是[0,2]和[0,2]。
x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print('我们的数组是：')
print(x)
print()
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print('这个数组的四角元素是：')
print(y)
我们的数组是：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
这个数组的四角元素是：
[[ 0 2]
[ 9 11]]
# 可以借助切片`:` 或`...`与索引数组组合
a = np.array([[1,2,3],[4,5,6],[7,8,9]])
b = a[1:3,1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print()
print(c)
print()
print(d)
[[5 6]
[8 9]]
[[5 6]
[8 9]]
[[2 3]
[5 6]
[8 9]]
布尔索引
# 获取大于5的元素
x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print('我们的数组是：')
print(x)
print()
print('大于5的元素是：')
print(x[x>5])
我们的数组是：
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
大于5的元素是：
[ 6 7 8 9 10 11]
# 使用‘~’过滤NaN
a = np.array([np.nan,1,2,np.nan,4,5])
print(a[~np.isnan(a)])
[1. 2. 4. 5.]
# 从数组中过滤掉非复数元素
a = np.array([1,2+6j,5,3.6+5j])
print(a[np.iscomplex(a)])
[2. +6.j 3.6+5.j]
花式索引
# 花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。
x = np.arange(32).reshape((8,4))
print(x)
print(x[[4,2,1,7]])
[[ 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]]
# 传入倒序索引数组
x = np.arange(32).reshape((8,4))
print(x[[-4,-2,-1,-7]])
[[16 17 18 19]
[24 25 26 27]
[28 29 30 31]
[ 4 5 6 7]]
# 传入多个索引数组
x = np.arange(32).reshape((8,4))
print(x[np.ix_([1,5,7,2],[0,3,1,2])])
[[ 4 7 5 6]
[20 23 21 22]
[28 31 29 30]
[ 8 11 9 10]]
NumPy广播
# a.shape==b.shape,那么a*b的结果就是a与b数组对应位相乘。要求维数相同，且各维度的长度相同。
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a*b
print(c)
[ 10 40 90 160]
# 当运算中两个数组的维度不同时，numpy将自动触发广播机制
a = np.array([
[0,0,0],
[10,10,10],
[20,20,20],
[30,30,30]
])
b = np.array([1,2,3])
print(a+b)
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
a = np.array([
[0,0,0],
[10,10,10],
[20,20,20],
[30,30,30]
])
b = np.array([1,2,3])
bb = np.tile(b,(4,1))
print(a+bb)
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
Numpy迭代数组
# numpy.nditer提供了一种灵活访问一个或者多个数组元素的方式
import numpy as np
a = np.arange(6).reshape(2,3)
print('原始数组：')
print(a)
print('-'*20)
print('迭代输出元素：')
for x in np.nditer(a):
print(x,end=' ')
print()
原始数组：
[[0 1 2]
[3 4 5]]
--------------------
迭代输出元素：
0 1 2 3 4 5
以上实例不是按使用标准C或者Fortan顺序，选择的顺序是和数组内存布局一致的，这样做是为了提升访问效率，默认是行序优先。这反应了默认情况下只需访问每个元素，而无需考虑其特定顺序。
a = np.arange(6).reshape(2,3)
print('原始数组a：')
print(a)
print()
print('a的转置：')
print(a.T)
print()
print('(a.T)迭代输出元素：')
for x in np.nditer(a.T):
print(x,end=" ")
print()
print('(a.T.copy(order="C"))迭代输出元素：')
for x in np.nditer(a.T.copy(order='C')):
print(x,end=" ")
原始数组a：
[[0 1 2]
[3 4 5]]
a的转置：
[[0 3]
[1 4]
[2 5]]
(a.T)迭代输出元素：
0 1 2 3 4 5
(a.T.copy(order="C"))迭代输出元素：
0 3 1 4 2 5
a和a.T遍历顺序是一样的，也就是他们在内存中的存储顺序也是一样的，但a.T.copy(order=“C”)的遍历结果是不同的，那是因为它和前两种存储方式不一样，默认按行存储。
a=np.arange(0,60,5)
a = a.reshape(3,4)
print('原始数组：')
print(a)
print()
print('原始数组转置：')
b = a.T
print(b)
print()
print('以C风格顺序排序：')
c = b.copy(order='C')
print(c)
for x in np.nditer(c):
print(x,end=' ')
print('\n')
print('以F风格顺序排序：')
d = b.copy(order='F')
print(d)
for x in np.nditer(d):
print(x,end=' ')
print()
原始数组：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
原始数组转置：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
以C风格顺序排序：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55
以F风格顺序排序：
[[ 0 20 40]
[ 5 25 45]
[10 30 50]
[15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55
可以通过显式设置，来强制nditer对象使用某种顺序
a=np.arange(0,60,5)
a = a.reshape(3,4)
print('原始数组：')
print(a)
print('\n')
print('以C风格顺序排序：')
for x in np.nditer(a,order='C'):
print(x,end=' ')
print('\n')
print('以F风格顺序排序：')
for x in np.nditer(a,order='F'):
print(x,end=' ')
print('\n')
原始数组：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
以C风格顺序排序：
0 5 10 15 20 25 30 35 40 45 50 55
以F风格顺序排序：
0 20 40 5 25 45 10 30 50 15 35 55
# 修改数组中元素的值
a=np.arange(0,60,5)
a = a.reshape(3,4)
print('原始数组：')
print(a)
print('\n')
for x in np.nditer(a,op_flags=['readwrite']):
x[...] = 2*x
print('修改后的数组是：')
print(a)
原始数组：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
修改后的数组是：
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
# 迭代器遍历对应于每列，并组合为一维数组
a=np.arange(0,60,5)
a = a.reshape(3,4)
print('原始数组：')
print(a)
print('\n')
print('修改后的数组是：')
for x in np.nditer(a,flags=['erternal_loop'],order = 'F'):
print(x,end=' ')
原始数组：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
修改后的数组是：
0 20 40 5 25 45 10 30 50 15 35 55
# 广播迭代，如果两个数组是可广播的，nditer组合对象能够同时迭代它们。
a = np.arange(0,60,5).reshape(3,4)
print('第一个数组：')
print(a)
print('\n')
b = np.array([1,2,3,4],dtype=int)
print('第二个数组：')
print(b)
print('\n')
for x,y in np.nditer([a,b]):
print('%d:%d' %(x,y),end=', ')
第一个数组：
[[ 0 5 10 15]
[20 25 30 35]
[40 45 50 55]]
第二个数组：
[1 2 3 4]
0:1, 5:2, 10:3, 15:4, 20:1, 25:2, 30:3, 35:4, 40:1, 45:2, 50:3, 55:4,
NumPy数组操作
# numpy.ndarray.flat是一个数组元素迭代器
a = np.arange(9).reshape(3,3)
print('数组a：')
for row in a:
print(row)
print('\n')
for x in a.flat:
print(x)
数组a：
[0 1 2]
[3 4 5]
[6 7 8]
<numpy.flatiter object at 0x0000021A55B1E420>
0
1
2
3
4
5
6
7
8
# numpy.ndarray.flatten返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
a = np.arange(8).reshape(2,4)
print('原数组：')
print(a)
print('展开的数组：')
print(a.flatten())
print('\n')
print('以F风格顺序展开的数组：')
print(a.flatten(order='F'))
原数组：
[[0 1 2 3]
[4 5 6 7]]
展开的数组：
[0 1 2 3 4 5 6 7]
以F风格顺序展开的数组：
[0 4 1 5 2 6 3 7]
[[0 1 2 3]
[4 5 6 7]]
# numpy.ravel()展平的数组元素，通常是C风格，返回的是数组视图，修改会影响原始数组
a = np.arange(8).reshape(2,4)
print('原数组：')
print(a)
print('调用ravel之后：')
print(a.ravel())
print('以F风格调用ravel函数之后：')
print(a.ravel(order='F'))
原数组：
[[0 1 2 3]
[4 5 6 7]]
调用ravel之后：
[0 1 2 3 4 5 6 7]
以F风格调用ravel函数之后：
[0 4 1 5 2 6 3 7]
[[0 1 2 3]
[4 5 6 7]]
# numpy.transpose函数用于对换数组的维度
a = np.arange(12).reshape(3,4)
print('原数组：')
print(a)
print('对换数组：')
print(np.transpose(a))
原数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
对换数组：
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
a = np.arange(8).reshape(2,2,2)
print('原数组：')
print(a)
print('\n')
# 将轴2滚动到轴0(宽度到深度，数组下标排序由0,1,2变成了1,2,0)
print('调用rollaxis函数：')
print(np.rollaxis(a,2))
print('\n')
# 将轴2滚动到轴1(宽度到高度，数组下标排序由0,1,2变成了0,2,1)
print('调用rollaxis函数：')
print(np.rollaxis(a,2,1))
原数组：
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用rollaxis函数：
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
调用rollaxis函数：
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
# numpy.swapaxes函数用于交换两个数组的轴
a = np.arange(8).reshape(2,2,2)
print(a)
print('\n')
print('调用swapaxes函数后的数组：')
print(np.swapaxes(a,2,0))
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用swapaxes函数后的数组：
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
x = np.array([[1],[2],[3]])
y = np.array([4,5,6])
# 对y广播x
b = np.broadcast(x,y)
# 它拥有iterator属性，基于自身组建的迭代器元组
print('对y广播x:')
r,c = b.iters
print(next(r),next(c))
print(next(r),next(c))
print(next(r),next(c))
print('广播对象的形状：')
print(b.shape)
print('\n')
# 手动使用broadcast将x和y相加
b = np.broadcast(x,y)
c = np.empty(b.shape)
print('手动使用broadcast将x和y相加:')
print(c.shape)
print('\n')
c.flat= [ u+v for (u,v) in b]
print('调用flat函数：')
print(c)
print('\n')
# 获得了和numpy内建的广播支持相同的结果
print('x与y的和：')
print(x+y)
对y广播x:
1 4
1 5
1 6
广播对象的形状：
(3, 3)
手动使用broadcast将x和y相加:
(3, 3)
调用flat函数：
[[5. 6. 7.]
[6. 7. 8.]
[7. 8. 9.]]
x与y的和：
[[5 6 7]
[6 7 8]
[7 8 9]]
# broadcast_to函数将数组广播到新的形状
a = np.arange(4).reshape(1,4)
print('原数组：')
print(a)
print('调用broadcast_to函数后：')
print(np.broadcast_to(a,(4,4)))
原数组：
[[0 1 2 3]]
调用broadcast_to函数后：
[[0 1 2 3]
[0 1 2 3]
[0 1 2 3]
[0 1 2 3]]
# numpy.expand_dims函数通过在指定位置插入新的轴来扩展数组形状
x = np.array([[1,2],[3,4]])
print('数组x:')
print(x)
print('\n')
y=np.expand_dims(x,axis=0)
print('数组y:')
print(y)
print('\n')
print('数组x和数组y的形状：')
print(x.shape,y.shape)
print('\n')
# 在位置1插入轴
y = np.expand_dims(x,axis=1)
print('在位置1插入轴之后的数组y:')
print(y)
print('\n')
print('x.ndim和y.ndim:')
print(x.ndim,y.ndim)
print('\n')
print('x.shape和y.shape:')
print(x.shape,y.shape)
数组x:
[[1 2]
[3 4]]
数组y:
[[[1 2]
[3 4]]]
数组x和数组y的形状：
(2, 2) (1, 2, 2)
在位置1插入轴之后的数组y:
[[[1 2]]
[[3 4]]]
x.ndim和y.ndim:
2 3
x.shape和y.shape:
(2, 2) (2, 1, 2)
# numpy.squeeze函数从给定数组的形状中删除一维的条目
x = np.arange(9).reshape(1,3,3)
print('数组x:')
print(x)
print('\n')
y = np.squeeze(x)
print('数组y:')
print(y)
print('\n')
print('数组x和y的形状：')
print(x.shape,y.shape)
数组x:
[[[0 1 2]
[3 4 5]
[6 7 8]]]
数组y:
[[0 1 2]
[3 4 5]
[6 7 8]]
数组x和y的形状：
(1, 3, 3) (3, 3)
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
print(a)
print(b)
print('沿轴0连接两个数组：')
print(np.concatenate((a,b)))
print('\n')
print('沿轴1连接两个数组：')
print(np.concatenate((a,b),axis=1))
print('\n')
[[1 2]
[3 4]]
[[5 6]
[7 8]]
沿轴0连接两个数组：
[[1 2]
[3 4]
[5 6]
[7 8]]
沿轴1连接两个数组：
[[1 2 5 6]
[3 4 7 8]]
a = np.array([[1,2],[3,4]])
b = np.array([[5,6]])
print(a)
print(b)
print('沿轴0连接两个数组：')
print(np.concatenate((a,b)))
print('\n')
print('沿轴1连接两个数组：')
print(np.concatenate((a,b.T),axis=1))
print('\n')
[[1 2]
[3 4]]
[[5 6]]
沿轴0连接两个数组：
[[1 2]
[3 4]
[5 6]]
沿轴1连接两个数组：
[[1 2 5]
[3 4 6]]
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
print(a)
print(b)
print('沿轴0连接两个数组：')
print(np.stack((a,b),0))
print('\n')
print('沿轴1连接两个数组：')
print(np.stack((a,b),1))
print('\n')
[[1 2]
[3 4]]
[[5 6]
[7 8]]
沿轴0连接两个数组：
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
沿轴1连接两个数组：
[[[1 2]
[5 6]]
[[3 4]
[7 8]]]
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
print(a)
print(b)
print('水平堆叠：')
print(np.hstack((a,b)))
print('\n')
[[1 2]
[3 4]]
[[5 6]
[7 8]]
水平堆叠：
[[1 2 5 6]
[3 4 7 8]]
a = np.array([[1,2],[3,4]])
b = np.array([[5,6],[7,8]])
print(a)
print(b)
print('垂直堆叠：')
print(np.vstack((a,b)))
print('\n')
[[1 2]
[3 4]]
[[5 6]
[7 8]]
垂直堆叠：
[[1 2]
[3 4]
[5 6]
[7 8]]
# numpy.split函数沿特定的轴将数组分割为子数组
a = np.arange(9)
print(a)
print('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print(b)
print('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print(b)
[0 1 2 3 4 5 6 7 8]
将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
# numpy.hsplit函数用于水平分割数组
harr = np.floor(10*np.random.random((2,6)))
print('原array:')
print(harr)
print('拆分后：')
print(np.hsplit(harr,3))
原array:
[[1. 9. 3. 2. 5. 6.]
[7. 5. 4. 0. 2. 4.]]
拆分后：
[array([[1., 9.],
[7., 5.]]), array([[3., 2.],
[4., 0.]]), array([[5., 6.],
[2., 4.]])]
a = np.arange(16).reshape(4,4)
print('a:')
print(a)
print('竖直分割：')
b = np.vsplit(a,2)
print(b)
a:
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
竖直分割：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
a = np.array([[1,2,3],[4,5,6]])
b = np.resize(a,(3,2))
c = np.resize(a,(3,3))
print(b)
print('\n')
print(c)
[[1 2]
[3 4]
[5 6]]
[[1 2 3]
[4 5 6]
[1 2 3]]
# numpy.append函数在数组的末尾添加值。axis:默认为None。当无定义时，是横向加成，返回总是为一维数组
a = np.array([[1,2,3],[4,5,6]])
print('向数组添加元素：')
print(np.append(a,[7,8,9]))
print('\n')
print('沿轴0添加元素：')
print(np.append(a,[[7,8,9]],axis=0))
print('\n')
print('沿轴1添加元素：')
print(np.append(a,[[5,5,5],[7,8,9]],axis=1))
向数组添加元素：
[1 2 3 4 5 6 7 8 9]
沿轴0添加元素：
[[1 2 3]
[4 5 6]
[7 8 9]]
沿轴1添加元素：
[[1 2 3 5 5 5]
[4 5 6 7 8 9]]
# numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值
import numpy as np
a = np.array([[1,2],[3,4],[5,6]])
print ('第一个数组：')
print (a)
print ('\n')
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.insert(a,3,[11,12]))
print ('\n')
print ('传递了 Axis 参数。 会广播值数组来配输入数组。')
print ('沿轴 0 广播：')
print (np.insert(a,1,[11],axis = 0))
print ('\n')
print ('沿轴 1 广播：')
print (np.insert(a,1,11,axis = 1))
第一个数组：
[[1 2]
[3 4]
[5 6]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 1 2 3 11 12 4 5 6]
传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1 2]
[11 11]
[ 3 4]
[ 5 6]]
沿轴 1 广播：
[[ 1 11 2]
[ 3 11 4]
[ 5 11 6]]
# numpy.delete 函数返回从输入数组中删除指定子数组的新数组。
import numpy as np
a = np.arange(12).reshape(3,4)
print ('第一个数组：')
print (a)
print ('\n')
print ('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print (np.delete(a,5))
print ('\n')
print ('删除第二列：')
print (np.delete(a,1,axis = 1))
print ('\n')
print ('包含从数组中删除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print (np.delete(a, np.s_[::2]))
第一个数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0 1 2 3 4 6 7 8 9 10 11]
删除第二列：
[[ 0 2 3]
[ 4 6 7]
[ 8 10 11]]
包含从数组中删除的替代值的切片：
[ 2 4 6 8 10]
# numpy.unique 函数用于去除数组中的重复元素。
import numpy as np
a = np.array([5,2,6,2,7,5,6,8,2,9])
print ('第一个数组：')
print (a)
print ('\n')
print ('第一个数组的去重值：')
u = np.unique(a)
print (u)
print ('\n')
print ('去重数组的索引数组：')
u,indices = np.unique(a, return_index = True)
print (indices)
print ('\n')
print ('我们可以看到每个和原数组下标对应的数值：')
print (a)
print ('\n')
print ('去重数组的下标：')
u,indices = np.unique(a,return_inverse = True)
print (u)
print ('\n')
print ('下标为：')
print (indices)
print ('\n')
print ('使用下标重构原数组：')
print (u[indices])
print ('\n')
print ('返回去重元素的重复数量：')
u,indices = np.unique(a,return_counts = True)
print (u)
print (indices)
第一个数组：
[5 2 6 2 7 5 6 8 2 9]
第一个数组的去重值：
[2 5 6 7 8 9]
去重数组的索引数组：
[1 0 2 4 7 9]
我们可以看到每个和原数组下标对应的数值：
[5 2 6 2 7 5 6 8 2 9]
去重数组的下标：
[2 5 6 7 8 9]
下标为：
[1 0 2 0 3 1 2 4 0 5]
使用下标重构原数组：
[5 2 6 2 7 5 6 8 2 9]
返回去重元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]
# bitwise_and()函数对数组中整数的二进制形式执行位与运算
a,b = 13,17
print(bin(a),bin(b))
print('\n')
print('13与17的位与：')
print(np.bitwise_and(13,17))
0b1101 0b10001
13与17的位与：
1
# bitwise_or()函数对数组中整数的二进制形式执行位与运算。
a,b = 13,17
print(bin(a),bin(b))
print('\n')
print('13与17的位或：')
print(np.bitwise_or(13,17))
0b1101 0b10001
13与17的位或：
29
# invert() 函数对数组中整数进行位取反运算，即 0 变成 1，1 变成 0。
print('13的反转，其中ndarray的dtype是uint8：')
print(np.invert(np.array([13],dtype=np.uint8)))
print('\n')
print('13的二进制表示：')
print(np.binary_repr(13,width=8))
print('\n')
print('242的二进制表示：')
print(np.binary_repr(242,width=8))
13的反转，其中ndarray的dtype是uint8：
[242]
13的二进制表示：
00001101
242的二进制表示：
11110010
print(np.invert([13]))
[-14]
print(np.left_shift(10,2))
print('10的二进制：')
print(np.binary_repr(10,width=8))
print('40的二进制表示：')
print(np.binary_repr(40,width=8))
40
10的二进制：
00001010
40的二进制表示：
00101000
print(np.right_shift(40,2))
print('10的二进制：')
print(np.binary_repr(10,width=8))
print('40的二进制表示：')
print(np.binary_repr(40,width=8))
10
10的二进制：
00001010
40的二进制表示：
00101000
import numpy as np
print('连接两个字符串：')
print(np.char.add(['hello'],[' day']))
连接两个字符串：
['hello day']
print(np.char.add(['hello','nihao'],[' world',' shijie']))
['hello world' 'nihao shijie']
print(np.char.multiply('hello ',3))
hello hello hello
print(np.char.center('hello',20,fillchar='*'))
*******hello********
print(np.char.capitalize('hello'))
Hello
print(np.char.title('i like china'))
I Like China
print(np.char.upper('hello'))
HELLO
print(np.char.lower('HELLO'))
hello
# numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。
print(np.char.split('I like China'))
['I', 'like', 'China']
print(np.char.split('www.baidu.com',sep='.'))
['www', 'baidu', 'com']
# numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。\n，\r，\r\n 都可用作换行符。
print (np.char.splitlines('i\nlike runoob?'))
print (np.char.splitlines('i\rlike runoob?'))
['i', 'like runoob?']
['i', 'like runoob?']
# 移除字符串头尾的 a 字符
print (np.char.strip('ashok arunooba','a'))
# 移除数组元素头尾的 a 字符
print (np.char.strip(['arunooba','admin','java'],'a'))
shok arunoob
['runoob' 'dmin' 'jav']
print(np.char.join(':','hello'))
h:e:l:l:o
print(np.char.join([':','-'],['hello','google']))
['h:e:l:l:o' 'g-o-o-g-l-e']
# numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。
print(np.char.replace('foot','oo','ee'))
feet
# numpy.char.encode() 函数对数组中的每个元素调用 str.encode 函数。
a = np.char.encode('hello','cp500')
print(a)
print(np.char.decode(a,"cp500"))
b'\x88\x85\x93\x93\x96'
hello
Numpy三角函数
import numpy as np
a = np.array([0,30,45,60,90])
print('不同的正弦值：')
print(np.sin(a*np.pi/180))
print('不同的余弦值：')
print(np.cos(a*np.pi/180))
print('正切值：')
print(np.tan(a*np.pi/180))
不同的正弦值：
[0. 0.5 0.70710678 0.8660254 1. ]
不同的余弦值：
[1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
6.12323400e-17]
正切值：
[0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
1.63312394e+16]
a = np.array([0,30,45,60,90])
sin = np.sin(a*np.pi/180)
inv = np.arcsin(sin)
print(inv)
print(np.degrees(inv))
[0. 0.52359878 0.78539816 1.04719755 1.57079633]
[ 0. 30. 45. 60. 90.]
# numpy.around() 函数返回指定数字的四舍五入值。 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
a = np.array([1.0,5.55,123,0.567,25.532])
print('原数组：')
print(a)
print('舍入后：')
print(np.around(a))
print(np.around(a,decimals = 1))
print(np.around(a,decimals = -1))
原数组：
[ 1. 5.55 123. 0.567 25.532]
舍入后：
[ 1. 6. 123. 1. 26.]
[ 1. 5.6 123. 0.6 25.5]
[ 0. 10. 120. 0. 30.]
# numpy.floor() 返回数字的下舍整数。
a = np.array([-1.7,1.5,-0.2,0.6,10])
print('提供的数组：')
print(a)
print('修改后的数组')
print(np.floor(a))
提供的数组：
[-1.7 1.5 -0.2 0.6 10. ]
修改后的数组
[-2. 1. -1. 0. 10.]
# numpy.ceil() 返回数字的上入整数。
a = np.array([-1.7,1.5,-0.2,0.6,10])
print('提供的数组：')
print(a)
print('修改后的数组')
print(np.ceil(a))
提供的数组：
[-1.7 1.5 -0.2 0.6 10. ]
修改后的数组
[-1. 2. -0. 1. 10.]
Numpy算数函数
# NumPy 算术函数包含简单的加减乘除: add()，subtract()，multiply() 和 divide()。需要注意的是数组必须具有相同的形状或符合数组广播规则。
a = np.arange(9,dtype=np.float_).reshape(3,3)
print('数组a:')
print(a)
b = np.array([10,10,10])
print('数组b:')
print(b)
print('两个数组相加：')
print(np.add(a,b))
print('两个数组相减：')
print(np.subtract(a,b))
print('两个数组相乘：')
print(np.multiply(a,b))
print('两个数组相除：')
print(np.divide(a,b))
数组a:
[[0. 1. 2.]
[3. 4. 5.]
[6. 7. 8.]]
数组b:
[10 10 10]
两个数组相加：
[[10. 11. 12.]
[13. 14. 15.]
[16. 17. 18.]]
两个数组相减：
[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
两个数组相乘：
[[ 0. 10. 20.]
[30. 40. 50.]
[60. 70. 80.]]
两个数组相除：
[[0. 0.1 0.2]
[0.3 0.4 0.5]
[0.6 0.7 0.8]]
# numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。
a = np.array([0.25,1.33,1,100])
print('我们的数组是：')
print(a)
print('调用reciprocal函数：')
print(np.reciprocal(a))
我们的数组是：
[ 0.25 1.33 1. 100. ]
调用reciprocal函数：
[4. 0.7518797 1. 0.01 ]
a = np.array([10,100,1000])
print('我们的数组是：')
print(a)
print('调用power函数：')
print(np.power(a,2))
b = np.array([1,2,3])
print('数组b:')
print(b)
print('再次调用power函数：')
# 10**10,100**2,1000*3
print(np.power(a,b))
我们的数组是：
[ 10 100 1000]
调用power函数：
[ 100 10000 1000000]
数组b:
[1 2 3]
再次调用power函数：
[ 10 10000 1000000000]
# numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。
a = np.array([10,20,30])
b = np.array([3,5,7])
print('数组a:')
print(a)
print('数组b:')
print(b)
print('调用mod函数：')
print(np.mod(a,b))
print('调用remainder函数：')
print(np.remainder(a,b))
数组a:
[10 20 30]
数组b:
[3 5 7]
调用mod函数：
[1 0 2]
调用remainder函数：
[1 0 2]
NumPy 统计函数
# numpy.amin() 用于计算数组中的元素沿指定轴的最小值。numpy.amax() 用于计算数组中的元素沿指定轴的最大值。
a = np.array([[5,3,6],[8,3,9],[2,4,0]])
print('数组a:')
print(a)
print('数组中最小的值：')
print(np.amin(a))
print('数组中每行最小的值：')
print(np.amin(a,1)) # 横轴
print('数组中每列最小的值：')
print(np.amin(a,0)) # 纵轴
print('\n')
print('数组中最大的值：')
print(np.amax(a))
print('数组中每列最大的值：')
print(np.amax(a,0))
print('数组中每行最大的值：')
print(np.amax(a,1))
数组a:
[[5 3 6]
[8 3 9]
[2 4 0]]
数组中最小的值：
0
数组中每行最小的值：
[3 3 0]
数组中每列最小的值：
[2 3 0]
数组中最大的值：
9
数组中每行最大的值：
[8 4 9]
数组中每列最大的值：
[6 9 4]
a = np.array([[5,3,6],[8,3,9],[2,4,0]])
print('数组a:')
print(a)
print('该数组中最大差：')
print(np.ptp(a))
print('该数组中每列最大差：')
print(np.ptp(a,0))
print('该数组中每行最大差：')
print(np.ptp(a,1))
数组a:
[[5 3 6]
[8 3 9]
[2 4 0]]
该数组中最大差：
9
该数组中每列最大差：
[6 1 9]
该数组中每行最大差：
[3 6 4]
# numpy.percentile()，百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。
a = np.array([[10,7,4],[3,2,1]])
print('我们的数组是：')
print(a)
print('调用percentile()函数：')
print(np.percentile(a,50))
print(np.percentile(a,50,0))
print(np.percentile(a,50,1))
# 保持维度不变
print(np.percentile(a,50,1,keepdims=True))
我们的数组是：
[[10 7 4]
[ 3 2 1]]
调用percentile()函数：
3.5
[6.5 4.5 2.5]
[7. 2.]
[[7.]
[2.]]
a = np.array([[5,3,6],[8,3,9],[2,4,0]])
print('数组a:')
print(a)
print('调用median函数：')
print(np.median(a))
print(np.median(a,0))
print(np.median(a,1))
数组a:
[[5 3 6]
[8 3 9]
[2 4 0]]
调用median函数：
4.0
[5. 3. 6.]
[5. 8. 2.]
# numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
a = np.array([1,2,3,4])
print('我们的数组是：')
print(a)
print('调用average()函数:')
print(np.average(a))
wts = np.array([4,3,2,1])
print('再次调用average()函数:')
print(np.average(a,weights = wts))
print('权重的和：')
print(np.average(a,weights = wts,returned=True))
我们的数组是：
[1 2 3 4]
调用average()函数:
2.5
再次调用average()函数:
2.0
权重的和：
(2.0, 10.0)
print(np.std([1,2,3,4]))
1.118033988749895
print(np.var([1,2,3,4]))
1.25
NumPy 排序、条件刷选函数
a = np.array([[3,7],[8,4]])
print('数组a：')
print(a)
print('调用sort函数：')
print(np.sort(a))
print('按列排序：')
print(np.sort(a,0))
print('按行排序：')
print(np.sort(a,1))
dt = np.dtype([('name','S10'),('age',int)])
b = np.array([('werr',43),('ly',21),('nn',23),('yuan',26)],dtype=dt)
print('按name排序：')
print(np.sort(b,order='name'))
数组a：
[[3 7]
[8 4]]
调用sort函数：
[[3 7]
[4 8]]
按列排序：
[[3 4]
[8 7]]
按行排序：
[[3 7]
[4 8]]
按name排序：
[(b'ly', 21) (b'nn', 23) (b'werr', 43) (b'yuan', 26)]
# numpy.argsort() 函数返回的是数组值从小到大的索引值。
x = np.array([3,7,4])
print('我们的数组是：')
print(x)
print('对x调用argsort函数：')
y = np.argsort(x)
print(y)
print('已排序后的顺序重构原数组：')
print(x[y])
print('使用循环重构原数组：')
for i in y:
print(x[i],end=" ")
我们的数组是：
[3 7 4]
对x调用argsort函数：
[0 2 1]
已排序后的顺序重构原数组：
[3 4 7]
使用循环重构原数组：
3 4 7
a = np.sort_complex([5,4,3,2,1])
print(a)
b = np.sort_complex([7,3+2j,5+8j,5+4j,2])
print(b)
[1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]
[2.+0.j 3.+2.j 5.+4.j 5.+8.j 7.+0.j]
a = np.array([3,4,1,2,1])
b = np.partition(a,3)
print(b)
c = np.partition(a,(1,3))
print(c)
[1 1 2 3 4]
[1 1 2 3 4]
a = np.array([23,11,56,34,78,43,89,45])
b = a[np.argpartition(a,2)[2]]
c = a[np.argpartition(a,-2)[-2]]
d = a[np.argpartition(a,[2,3])[2]]
e = a[np.argpartition(a,[2,3])[3]]
print(b)
print(c)
print(d)
print(e)
34
78
34
43
a = np.array([[5,3,6],[8,3,9],[2,4,0]])
print('数组a:')
print(a)
print('调用argmax函数：')
print(np.argmax(a))
print('按轴0：')
print(np.argmax(a,0))
print('按轴1：')
print(np.argmax(a,1))
print('调用argmin函数：')
print(np.argmin(a))
print('按轴0：')
print(np.argmin(a,0))
print('按轴1：')
print(np.argmin(a,1))
数组a:
[[5 3 6]
[8 3 9]
[2 4 0]]
调用argmax函数：
5
按轴0：
[1 2 1]
按轴1：
[2 2 1]
调用argmin函数：
8
按轴0：
[2 0 2]
按轴1：
[1 1 2]
a = np.array([[5,0,6],[0,3,9],[2,4,0]])
print('数组a:')
print(a)
print('调用nonzero函数：')
y = np.nonzero(a)
print(y)
print(a[y])
数组a:
[[5 0 6]
[0 3 9]
[2 4 0]]
调用nonzero函数：
(array([0, 0, 1, 1, 2, 2], dtype=int64), array([0, 2, 1, 2, 0, 1], dtype=int64))
[5 6 3 9 2 4]
# numpy.where() 函数返回输入数组中满足给定条件的元素的索引。
a = np.array([[5,0,6],[0,3,9],[2,4,0]])
print('数组a:')
print(a)
print('调用where函数：')
y = np.where(a>3)
print(y)
print('满足条件的元素：')
print(a[y])
数组a:
[[5 0 6]
[0 3 9]
[2 4 0]]
调用where函数：
(array([0, 0, 1, 2], dtype=int64), array([0, 2, 2, 1], dtype=int64))
满足条件的元素：
[5 6 9 4]
# numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。
x = np.arange(9).reshape(3,3)
print('x:')
print(x)
condition = np.mod(x,2)==0
print('按元素的条件值：')
print(condition)
print(np.extract(condition,x))
x:
[[0 1 2]
[3 4 5]
[6 7 8]]
按元素的条件值：
[[ True False True]
[False True False]
[ True False True]]
[0 2 4 6 8]
Matplotlib
import numpy as np
from matplotlib import pyplot as plt
x = np.arange(1,11)
y = 2 * x + 5
plt.title("Matplotlib demo")
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x,y)
plt.show()
import numpy as np
from matplotlib import pyplot as plt
x = np.arange(1,11)
y = 2 * x + 5
plt.title("Matplotlib demo")
plt.plot(x,y,"ob")
plt.show()
绘制正弦波
x = np.arange(0,3*np.pi,0.1)
y = np.sin(x)
plt.title('Sin')
plt.xlabel("x axis caption")
plt.ylabel("y axis caption")
plt.plot(x,y)
plt.show()
x = np.arange(0,3*np.pi,0.1)
y_sin = np.sin(x)
y_cos = np.cos(x)
plt.subplot(2,1,1)
plt.title('Sin')
plt.plot(x,y_sin)
plt.subplot(2,1,2)
plt.title('Cos')
plt.plot(x,y_cos)
plt.show()
pyplot 子模块提供 bar() 函数来生成条形图。
x = [5,7,9]
x2 = [6,8,10]
y = [7,6,9]
y2 = [9,7,5]
plt.bar(x,y,align='center')
plt.bar(x2,y2,color='g',align='center')
plt.title('bar demo')
plt.xlabel('x axis')
plt.ylabel('y axis')
plt.show()
772
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
