安装

## 1.以管理员的身份打开cmd

 输入以下命令安装numpy

pip	install	numpy

输入一下代码查询是否安装成功

pip list

 

有numpy表示安装成功

数据创建

使用array创建

array语法

"""
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
"""
import numpy as np

#使用array创建一维数组
list01 = [1,2,3,4]
np01 = np.array(list01)
print(np01)
print(type(np01))
#使用array创建二维数组
list02 = [[1,2,3,4],[5,6,7,8]]
np02 = np.array(list02)
print(np02)
print(type(np02))
#使用array创建三维数组
list03 = [[[1,2,3,4],[5,6,7,8],[9,10,11,12]]]
np03 = np.array(list03)
print(np03)
print(type(np03))

 

array参数的使用

参数	参数及描述
Object	任何序列类型
dtype	数组的所需数据类型，可选。
copy	可选，默认为true，对象是否被复制。
order	C（按行）、F（按列）或A（任意，默认）。
subok	默认情况下，返回的数组被强制为基类数组。如果为true，则返回子类。
ndimin	指定返回数组的最小维数。

#  Object  任何序列类型  
tuple01 = (1,2,3)
list01= [1,2,3]
set01 = {5,6,7}
dict01 ={"张三":10,"李四":20}
np01= np.array(dict01)
print(np01)

#dtype    数组的所需数据类型，可选。  
list01 = [1,2,3]
np01= np.array(list01,dtype=float)
print(np01)

"""
说明 np02 是 np01 的副本，两个是不同的对象
所以np02 和 np01 的数据不同
"""
list01 = [1,2,3]
np01= np.array(list01)
np02=np.array(np01,copy=True)
np02[0]=10
print(np01)
print(np02)
"""
可以看到数据是一样的，说明np02和np01是同一个对象
"""
list01 = [1,2,3]
np01= np.array(list01)
np02=np.array(np01,copy=False)
np02[0]=10
print(np01)
print(np02)

#由于order效果不明显，也不常用，在这里作为了解

#subok    默认情况下，返回的数组被强制为基类数组。如果为true，则返回子类。 
#matrix 是矩阵 之后会给大家详细讲解先回用
np01 = np.matrix('1 2 7; 3 4 8; 5 6 9')
print(type(np01))
print(np01)
np02 = np.array(np01, subok=True)
np03 = np.array(np01, subok=False)
print(type(np02)) #<class 'numpy.matrix'> 如果是true返回矩阵
print(type(np03)) #<class 'numpy.ndarray'>如果是False，强制改为了数组

#ndimin    指定返回数组的最小维数。  
list01 = [1,2,3]
np01= np.array(list01,dtype=float,ndmin=3)
print(np01)
 

使用arange创建

先来复习以下range函数
"""
range(start,stop,step)  函数可创建一个整数列表
1.不写start，默认从0开始
2.左开右闭
3.step步长，不写默认是1
"""
for i in range(10):
    print(i)

"""
arange(start,stop,step,dtype) 
1.不写start，默认从0开始
2.左开右闭
3.step步长，不写默认是1
"""
#一维数组
a = np.arange(10) #[0 1 2 3 4 5 6 7 8 9]
a = np.arange(2,10) #[2 3 4 5 6 7 8 9]
a = np.arange(1,10,2) #[1 3 5 7 9]
a = np.arange(1,10,2,dtype=float)
print(a)
#二维数组
#切记前面的12，必须满足3*4
np01  = np.arange(12).reshape(3, 4)
print(np01)

使用 random 创建数组

常用的random函数

函数	描述
np.random.random(size)	生成0到1之间的随机数
np.random.randint(low,high=None,size=None,dtype="1")	生成随机的整数
np.random.randn(d0,d1,d2,d3.........)	生成标准正态的随机数(期望为0，方差为1)
np.random.normal(loc,scale,size)	生成正态分布(指定期望和方差)
np.random.uniform(low,high,size)	生成均勻分布的随机数
np.random.shuffle()	随机打乱顺序
np.random.seed()	设置随机数种子
np.random.sample(size)	生成随机的浮点数

# np.random.random()    生成0到1之间的随机数  
#创建一维数组   size生成几个数据，可直接写4
np01= np.random.random(size=4) #[0.13475357 0.8088961  0.52055803 0.49706622]
#创建二维数组  size=(3,4) 3行4列 可用()和[] ,效果一样
np01= np.random.random((3,4))
#创建三维数组  两个三行四列
np01= np.random.random((2,3,4))
print(np01) 

 

"""
np.random.randint(low,high=None,size=None,dtype="1")   生成随机的整数  
low:开始
high=None ：结束
size：长度
dtype数据类型,默认是int32  no01.dtype属性
1.左开右闭
2.不写low默认是0

"""
#创建一维数组
np01= np.random.randint(1,11,10)#1-10
#创建二维数组
np01= np.random.randint(1,11,(3,4))#1-10
#创建三维数组
np01= np.random.randint(1,11,(2,3,4))#1-10
print(np01)

 #创建标准的正态分布
#一维数组
np01=np.random.randn(4)
#二维数组
np01=np.random.randn(2,4)
#三维数组
np01=np.random.randn(3,2,4)
print(np01)

 """
np.random.normal(loc,scale,size)生成正态分布(指定期望和方差)
loc: 期望，默认0
scale: 方差，默认1.0
size: 长度
"""
np01= np.random.normal(size=5)
np01= np.random.normal(loc= 2,scale=3,size=5)
np01= np.random.normal(size=(2,3,5))
print(np01)

"""
np.random.uniform(low,high,size) 生成均勻分布的随机数
low: 不写默认是0,
high: 结尾,
: 长度
1.左开右闭
"""
np01= np.random.uniform(size= 4)#四个数据几乎不会相差太多，比较均匀
np01= np.random.uniform(size= (2,4))
np01= np.random.uniform(high=3)
print(np01)

 """
np.random.shuffle(ArrayLike)随机打乱顺序
"""
np01 = np.array([2,5,6,7,3])
print(np01)
np.random.shuffle(np01)
print(np01)

 """
np.random.seed()设置随机数种子
从每堆种子里选出来的数都是不会变的，从不同的堆里选随机种子每次都不一样，若想每次都能得到相同的随机数，每次产生随机数之前，都需要调用一次seed()
"""
np.random.seed(1)
np01= np.random.randint(1,10,size= 5)
np.random.seed(1)
np02= np.random.randint(1,10,size = 5)
print(np01)
print(np02)

"""
np.random.sample(size)  生成随机的浮点数
"""
np01= np.random.sample(size=2)
print(np01)
np02= np.random.sample(size=(2,3))
print(np02) 

 

使用zeros创建数组

 numpy.zeros(shaps,dtype=float,order="C") #创建指定大小的数组，数组以0填充

"""
numpy.zeros(shaps,dtype=float,order="C") #创建指定大小的数组，数组以0填充
shaps:维度
dtype：数据类型
order：按行按列
"""
np01= np.zeros(5) #[0. 0. 0. 0. 0.]
np01= np.zeros(5,dtype="int32")  #[0 0 0 0 0]
np01= np.zeros((2,5),dtype="int32") 
"""
[[0 0 0 0 0]
 [0 0 0 0 0]]
"""
print(np01) 

创建特定形状的多维数组

创建特定形状的多维数组

函数	描述
np.zeros((3, 4))	创建3×4的元素全为0的数组
np.ones((3, 4))	创建3×4的元素全为1的数组
np.empty((2, 3))	创建2×3的空数组，空数据中的值并不为0，而是未初始化的垃圾值
np.zeros_like(ndarr)	以ndarr相同维度创建元素全为0数组
np.ones_like(ndarr)	以ndarr相同维度创建元素全为1数组
np.empty_like(ndarr)	以ndarr相同维度创建空数组
np.eye(5)	该函数用于创建一个5×5的矩阵，对角线为1，其余为0
np.full((3,5), 10)	创建3×5的元素全为10的数组，10为指定值

np01= np.ones((2,5),dtype="int32")
np01= np.empty((2,5),dtype="int32")
print(np01) 

list01= [
    [1,2,3],
    [4,5,6]
]
np01= np.array(list01)
print(np01.shape)
np02= np.zeros_like(np01,dtype=float)
print(np02)
print(np02.shape) 

#  np.eye(5)    该函数用于创建一个5×5的矩阵，对角线为1，其余为0  
np01= np.eye(5)
print(np01) 

# np.full((3,5), 10)    创建3×5的元素全为10的数组，10为指定值  
#10是指定的，你可以指定任意值
np01= np.full((3,5),5)
print(np01) 

使用linspace创建数组

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数	描述
start	序列的起始值
stop	序列的终止值 ，如果endpoint=True，则证明数组包含于数列
num	生成样本数量，默认是50
endpoint	如果为ture则包含stop，否则不包含
retstep	如果retstep=Ture，生成的数组会显示间距，否则不显示
dtype	数据类型

"""
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
"""
np01= np.linspace(1,10,5)#从1-10，生成5个数据
np01= np.linspace(1,10,5,endpoint=True)#把10包含进去
np01= np.linspace(1,10,5,endpoint=False)#把10不包含进去
np01= np.linspace(1,10,5,retstep=True)#显示间距
np01= np.linspace(1,10,5,dtype="int32")
print(np01) 

使用logspace创建数组

np.logspace(start,stop,num=50,endpoint=Ture,base=10.0,dtype=None)

参数	描述
start	序列的起始值
stop	序列的终止值 ，如果endpoint=True，则证明数组包含于数列
num	生成样本数量，默认是50
endpoint	如果为ture则包含stop，否则不包含
base	对数log的底数,默认10.0
dtype	数据类型

数组的属性

属性	描述
ndarray.ndim	数组的轴（维度）的个数。在Python世界中，维度的数量被称为rank。
ndarray.shape	数组的维度。这是一个整数的元组，表示每个维度中数组的大小。对于有n行和m列的矩阵，shape将是(n,m)。因此，shape元组的长度就是rank或维度的个数 ndim。
ndarray.size	数组元素的总数。这等于shape的元素的乘积。
ndarray.dtype	一个描述数组中元素类型的对象。可以使用标准的Python类型创建或指定dtype。另外NumPy提供它自己的类型。例如numpy.int32、numpy.int16和numpy.float64。
ndarray.itemsize	数组中每个元素的字节大小。例如，元素为float64类型的数组的itemsize为8（=64/8），而int32类型的数组的itemsize为4（=32/8）。它等于ndarray.dtype.itemsize。
ndarray.T	数组转置，及行列调换
ndarray.nbytes	整个数组所需的字节数量，可以使用nbytes属性。其值等于数组的size属性值乘以 itemsize属性值。

np01 = np.array([1,2,3,4])
np01 = np.array([[1,2,3,4]])
#print(np01.ndim)
print(np01.shape)
print(np01.size)
print(np01.dtype)
print(np01.itemsize) #一个字节默认是8为  32/8 = 4
print(np01.nbytes)#一个数字字节4，4*4=16 

list01 = [
    [1,2],
    [3,4],
    [5,6]
]
np01=np.array(list01)
print(np01)
np02= np01.T
print(np02) 

数据的索引和切片

一维数组的索引

list01= [1,2,3,4,5]
np01 = np.array(list01,dtype="int32")
print(np01)
"""
正向递增索引 从0开始
1,  2,  3,  4,  5 数据
0   1   2   3   4 索引
1.左开右闭
2.不写startIndex默认从0开始
"""
print(np01[0]) #1
print(np01[1:4]) #[2 3 4]
print(np01[1:5]) #[2 3 4 5]
print(np01[:5]) #[1 2 3 4 5]

"""
反向递减索引 从-1开始
1,  2,  3,  4,  5 数据
-5  -4  -3  -2  -1 索引
1.左开右闭
2.不写startIndex默认从0开始
"""
print(np01[-1]) #5
print(np01[-5:-1]) #[1 2 3 4]
print(np01[-5:]) #[1 2 3 4 5]

一维数组的切片

语法[start:stop:step]

 

list01= [1,2,3,4,5]
np01 = np.array(list01,dtype="int32")
print(np01)
#正向索引切片
print(np01[:])#从0到0
print(np01[3:])#从3开始到结尾
print(np01[:5])#从0开始到5结尾
print(np01[1:5:2])#步长是2

#反向索引切片
print(np01[::-1])#-1证明是反向获取
print(np01[-5:-2])

#正负一起使用
print(np01[-5:4]) #[1 2 3 4]

 

二维数组的索引

#创建二维数组
list01= [
    [1,2],
    [3,4],
    [5,6],
    [7,8]
]
np01= np.array(list01)
print(np01)
#print(np01.ndim) #查看维数
print(np01[1])#获取第二行
print(np01[1][1])#获取第二行第一列 

二维数组的切片

[对行进行切片,对列的切片]
对行的切片：可以有start:stop:step
对列的切片：可以有start:stop:step 

#创建二维数组
list01= [
    [1,2],
    [3,4],
    [5,6],
    [7,8]
]
np01= np.array(list01)
print(np01)
print(np01[:,:])#所有行所有列
#所有行部分列
print(np01[:,1])#所有行第二列
print(np01[:,0:2])#所有行的第一列和第二列

#部分列所有行
print(np01[1,:])#获取第二行所有列
print(np01[0:2,:])#获取第一和二行所有列
print(np01[::2,:])#获取奇数行所有列

#部分行部分列
print(np01[1,1])#第二行第二列

#组合使用的时候改怎么办
#获取第三行第二列(6)，第四行第一列(7)
#行写成元组放在前面，列写成元组放在后面
a= np01[(2,3),(1,0)]
print(a)

#负索引的使用
print(np01[-1])#最后一行
print(np01[::-1])#行倒序
print(np01[::-1,::-1])#行倒序,列倒叙

 

数组的迭代

使用np.nditer迭代

最好no，知道常用的即可

op，flags，op_flags，op_dtypes，order={‘C’，‘F’，‘A’}， casting，op_axes， itershape， buffersize,

 

"""
flags ： str的序列，可选。用于控制迭代器行为的标志。
  “buffered”可在需要时启用缓冲。
  “c_index”导致跟踪C顺序索引。
  “f_index”导致跟踪Fortran-order索引。
  “multi_index”导致跟踪多个索引或每个迭代维度一个索引元组。
  
op_flags:tr列表，可选。这是每个操作数的标志列表。至少，必须定“readonly”，“readwrite”或“writeonly”中的一个
  “readonly”表示只读取操作数。
  “readwrite”表示将读取和写入操作数。
  “writeonly”表示只会写入操作数。
  “no_broadcast”阻止操作数被广播。
  “contig”强制操作数数据是连续的。
  
op_dtypes ： dtype的dtype 或tuple，可选。操作数所需的数据类型

order： {‘C’，‘F’，‘A’，‘K’}，

casting ：{‘no’, ‘equiv’, ‘safe’, ‘same_kind’, ‘unsafe’}，可选。控制进行复制或缓冲时可能出现的数据转换类型。建议不要将此设置为“unsafe”，因为它会对累积产生不利影响。
   “no”表示完全不应强制转换数据类型。
   “equiv”表示只允许更改字节顺序。
   “safe”表示只允许保留值的强制转换。
   “same_kind”意味着只允许安全的类型或类型内的类型，如float64到float32。
   “unsafe”表示可以进行任何数据转换。
   
op_axes ： 整数列表列表，可选。如果提供，则是每个操作数的int或None列表。操作数的轴列表是从迭代器的维度到操作数的维度的映射。可以为条目放置值-1，从而将该维度视为“newaxis”。

itershape ： 整数元组，可选。迭代器的理想形状。这允许“allocate”具有由op_axes映射的维度的操作数不对应于不同操作数的维度，以获得该维度不等于1的值。

buffersize ： int，可选。启用缓冲时，控制临时缓冲区的大小。设置为0表示默认值
"""

#创建一维数组
np01 = np.arange(12)
print(np01)
for x in np.nditer(np01):
    print(x, end=' ')
    
#创建二维数组
np01 = np.arange(12).reshape(3, 4)
print(np01)
for x in np.nditer(np01):
    print(x, end=' ')

顺序迭代

"""
C按照行排序   F按照列排序
"""
data = np.arange(12).reshape(3, 4)
print('原始数组：')
print(data)
print('以C语言风格输出：')
for x in np.nditer(data, order='C'):
    print(x, end=' ')
print('\n以F语言风格输出：')
for x in np.nditer(data, order='F'):
    print(x, end=' ')
 

修改数组的元素

"""
比如我们把数组里面的每个数据都加1
1. nditer 里面有这样op_flags的参数可以设置读写
"""
import numpy as np 
np01 = np.arange(12).reshape(3, 4)
print('原始数组：')
print(np01)
for i in np.nditer(np01, op_flags=['readwrite']):
    i[...] = i +1
print('修改后的数组：')
print(np01)

外部循环

nditer迭代器提供了flags参数

参数	描述
c_index	可以跟踪C顺序的索引
f_index	可以跟踪Fortran 顺序的索引
multi-index	多索引/组合索引输出。输出的是坐标
external_loop	给出的值是具有多个值的一维数组

data = np.arange(12).reshape(3, 4)
print('原始数组：')
print(data)
print('修改访问顺序C风格的结果：')
#按照C(行)的风格输出下标
it = np.nditer(data, flags=['c_index'])
while not it.finished:#是否已经结束迭代
     print('%d<%d>' % (it[0], it.index), end=' ')
    it.iternext()#进入下一次迭代
print('修改访问顺序F风格的结果：')
#按照F(列)的风格输出下标
it = np.nditer(data, flags=['f_index'])
while not it.finished:
    print('%d<%d>' % (it[0], it.index), end=' ')
    it.iternext()

data = np.arange(12).reshape(3, 4)
print('原始数组：')
print(data)
it = np.nditer(data, flags=['multi_index'])
while not it.finished:
    print('%d<%s>' % (it[0], it.multi_index), end=' ')
    it.iternext()

data = np.arange(12).reshape(3, 4)
print('原始数组：')
print(data)
print('修改后的结果：')
#合并数组为一维数组
#默认按行合并一维数组
nd = np.nditer(data, flags=['external_loop'], order='F')
for x in nd:
    print(x, end= ' ')

广播迭代

import numpy as np 
np01 = np.arange(0, 60, 5).reshape(3, 4)
print  ('第一个数组为：')
print (np01)
print  ('\n')
print ('第二个数组为：')
np02 = np.array([1,  2,  3,  4], dtype = int)  
print (np02)
print ('\n')
print ('修改后的数组为：')
for x,y in np.nditer([np01,np02]):  
    print("%d:%d"  %  (x,y), end=", ")

数组操作

数值操作（+ - * /）

要求数组的shape必须一样

#数组与一维数组和二维数组的相乘
np01 = np.arange(9)#一维数组
i = 2
np02 = np01 *i
print(np01)
print(np02)
np03 = np.arange(9).reshape(3,3)#二维数组
np04 = np03 *i
print(np03)
print(np04)
​
#一维数组与一维数组相乘
#列数要一样
np01 = np.array([1,2,3,4,5])
np02 = np.array([6,7,8,9,0])
np03 = np01 * np02
print(np03)
​
#二维数组与二维数组相乘
np01 = np.arange(9).reshape(3,3)
print(np01)
np02 = np.arange(9).reshape(3,3)
print(np02)
np03 = np01 * np02
print(np03)
​
#一维数组和二维数组相乘
#进行了广播
np01 = np.array([1,2,3])#一维数组
print(np01)
np02 = np.arange(9).reshape(3,3)#二维数组
print(np02)
np03 = np01 * np02
print(np03)

"""
加减乘除一样的操作
"""
import numpy as np
data = np.array([1,2])
ones = np.ones(2,dtype="int32")
print(data)
print(ones)
add = data+ones
add = data-ones
add = data*ones
add = data/ones
add = data%ones
add = data//ones
print(add)
​
data = np.array([1,2])
print(data)
#不光可以数组在一起相加，相乘，数组也可以和int数据相加
add = data*1.6
print(add)

练习

import numpy as np
#计算一维数组和二维数组的余数
np01 = np.array([1,2,3])#一维数组
print(np01)
np02 = np.arange(9).reshape(3,3)#二维数组
print(np02)
np03 = np02 % np01 #切记余数不能为0
print(np03)

形状相关操作

形状函数	描述
reshape	不改变数据的条件下修改形状
flat	数组元素迭代器
flatten	返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
ravel	返回展开的数组

"""
numpy.reshape(a, newshape, order='C') 这个函数在不改变数据的条件下修改形状
arr：要修改形状的数组    
newshape：整数或者整数数组，新的形状应当兼容原有形状  
order：'C'为C风格顺序，'F'为F风格顺序，'A'为保留原顺序。
"""
np01 = np.arange(10)#获取一个0-9的整数列表
print("原数组是：")
print(np01)
np02 = np.reshape(np01,(2,5),order="C")
np02 = np.reshape(np01,(2,5),order="F")
print(np02)

"""
numpy.ndarray.flat   该函数返回数组的一维迭代器
这是一个numpy.flatiter实例，其作用类似于Python的内置迭代器对象，但不是其子类
"""
​
import numpy as np
np01 = np.arange(9).reshape(3,3) 
print(type(np01)) #<class 'numpy.ndarray'>
print("原始数组")
for i in np01:
  print(i)
print("迭代后的数组")
itr = np01.flat#返回一个迭代器
print(itr)
#遍历后变成一个一个的数字
for i in itr:
  print(i,end=" ")

"""
np.ndarray.flatten(order='C') 就是把数组展开成一维数组
该函数返回一个一维的数组拷贝，对拷贝的修改对原始数组没有任何影响
Order：'C'--按行，'F'--按列，'A'--原顺序，'k'--元素在内存中的出现顺序。
"""
import numpy as np
np01 = np.arange(12).reshape(3,4)
print("原数组")
print(np01)
np02 = np01.flatten(order='C')
print("展开后，或者是变成一维数组后")
print(np02)
np02 = np01.flatten(order='F')
print("展开后，或者是变成一维数组后")
print(np02)

"""
函数返回展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同数据类型
numpy.ravel(a,order='C')
​
"""
import numpy as np
np01 = np.arange(12).reshape(3,4)
print("原数组")
print(np01)
print(type(np01))
np02= np.ravel(np01)
print("展开后")
print(np02)
print(type(np02))

ravel()和flatten()的区别

"""
ravel()返回的是一个数组的视图
flatten()是一个浅拷贝，生成一个新的shu'zu
"""
import numpy as np
np01 = np.arange(12).reshape(3,4)
np02= np.ravel(np01)
np03 = np01.flatten()
"""
print("原数组")
print(np01)
print("ravel")
print(np02)
print("flatten")
print(np03)
"""
"""
看着一样的效果，我们修改一下数据
ravel生成的数组，改变数据回把原数组也改变了
flatten生成的数组，改变数据，不会修改原数组数据
"""
np02[0] = 9
np03[1] = 10
print("原数组")#原数组中的第1个数据改变成了9
print(np01)
print("ravel")
print(np02)
print("flatten")
print(np03)

练习

"""
把list01展开，按照列进行展开，并且不能修改源文件数据
"""
list01 = [
    [1,2,3,4],
    [5,6,7,8]
]
np01 = np.array(list01)
print("原数组")
print(np01)
np02 = np01.flatten(order='C')
print("展开后，或者是变成一维数组后")
print(np02)
np02 = np01.flatten(order='F')
print("展开后，或者是变成一维数组后")
print(np02)

合并与分割操作

数组的合并

函数	描述
concatenate(arrays, axis=0)	连接沿着现有轴的数据序列
stack(arrays, axis=0)	沿着新的轴连接数组序列
hstack(tup)	水平堆叠序列中的数组（列方向）
vstack(tup)	竖直堆叠序列中的数组（行方向）

import numpy as np 
np01 = np.array([[1,2],[3,4]])
print('第一个数组：') 
print(np01) 
np02 = np.array([[5,6],[7,8]])
print('第二个数组：') 
print(np02) 
​
#vstack(tup)竖直堆叠序列中的数组（行方向）
#按照行进行竖直的堆在一起
#vstack((np01,np02)) 里面是一个参数，所以两个数组必须用括号括起来
np03 = np.vstack((np01,np02))
print(np03)

#hstack(tup)水平堆叠序列中的数组（列方向）
#按照列进行合并
np03 = np.hstack((np01,np02))
print(np03)

"""
concatenate(arrays, axis=0 ) 连接沿着现有轴的数据序列
1.axis=0 默认是0
"""
np03 = np.concatenate((np01,np02),axis=0) #按照行方向进行拼接，相当于vstack(tup)
np04 = np.concatenate((np01,np02),axis=1) #按照列方向进行拼接，相当于hstack(tup)
print(np03)
print(np04)

"""
stack沿着新的轴连接数组序列
保持数组的原样,拼接起来
"""
np03 = np.stack((np01,np02),axis = 0) 
print(np03)
print(np03.shape)
​
np03 = np.stack((np01,np02),axis= 1) #按照行进行拼接
print(np03)
print(np03.shape)
​
np03 = np.stack((np01,np02),axis= 2) #按照列进行拼接
print(np03)
print(np03.shape)

数组的切分

把一个数组切割成多个数组

函数	描述
split	将一个数组分割为多个子数组
hsplit (array,i)	将一个数组水平分割为多个子数组（按列）
vsplit(array,i)	将一个数组垂直分割为多个子数组（按行）

import numpy as np 
list01 = [
    [1,2,3,4],
    [5,6,7,8],
    [9,10,11,12]
]
np01 = np.array(list01)
print('源数组：') 
print(np01) 
"""
numpy.split(ary, indices_or_sections, axis)
ary：被分割的数组
indices_or_sections：如果是一个整数，就用该数平均切分数组，如果是一个数组，为沿轴切分的位置
axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分
"""
np03,np04,np05 = np.split(np01,3)
print("=============================================")
print(np03)
print(np04)
print(np05)
print("=============================================")
np06 = np.split(np01,[3,4]) #按照数字3和4进行切分
np06 = np.split(np01,2,axis=1) #按照列进行切分
np06 = np.split(np01,3,axis=0) #按照横进行切分
print(np06)

import numpy as np 
list01 = [
    [1,2],
    [3,4],
    [5,6],
    [7,8],
    [9,10],
    [11,12],
]
np01 = np.array(list01)
print('源数组：') 
print(np01) 
#  `vsplit`    将一个数组垂直分割为多个子数组（按行）  
np03,np04,np05 =np.vsplit(np01,3)
print("==========================")
print(np03)
print("==========================")
print(np04)
print("==========================")
print(np05)

#  hsplit (array,i)  将一个数组水平分割为多个子数组（按列）  
np03,np04 =np.hsplit(np01,2)
print("==========================")
print(np03)
print("==========================")
print(np04)

数组的点乘

点乘（点积）：也叫内积和数量积，是指两个数组进行乘积之后相加的运行算

比如

a = np.array([1, 2, 3, 4])

b = np.array([5, 6, 7, 8])

乘积 输出结果：70 = 1 * 5 + 2 * 6 + 3 * 7 + 4 * 8

import numpy as np
#数组与一维数组和二维数组的点乘
#如果是这种情况他和相乘效果一样
np01 = np.arange(9)#一维数组
i = 2
np02 = np.dot(np01 ,i)
print(np01)
print(np02)
np03 = np.arange(9).reshape(3,3)#二维数组
np04 = np.dot(np03 ,i)
print(np03)
print(np04)

#一维数组与一维数组点乘
#切记shape必须一样
np01 = np.array([1,2,3,4,5])
np02 = np.array([6,7,8,9,0])
np03 = np.dot(np01, np02)
print(np03)

#二维数组与二维数组点乘
#列和另一个数组的安行数一样
np01 = np.arange(8).reshape(2,4)
print(np01)
np02 = np.arange(9).reshape(4,2)
print(np02)
np03 = np.dot(np01 , np02)
print(np03)

练习

#一维数组和二维数组点乘
#列和另一个数组的安行数一样
np01 = np.array([1,2,3])#一维数组
print(np01)
np02 = np.arange(9).reshape(3,3)#二维数组
print(np02)
np03 =np.dot( np01 , np02)
print(np03)
​

数学操作

函数	描述
mean()	计算元素的均值
median()	计算中位数
std()	计算元素标准差
max()	计算元素的最大值或每一个横轴的最大值
min()	计算元素的最小值
count_nonzero()	计数
cumsum（）	计算所有元素的累计和或每一个横轴按元素累加
sum()	所有元素求和或横轴元素求和

import numpy as np
a = np.array([[1, 2, 3],
              [4, 5, 6]])
#切记没有axis=3，只有0，1
#mean(array,axis=None)   计算元素的均值  
np02 = np.mean(a) 
np02 = np.mean(a,axis=1)#[2. 5.] 按照行
np02 = np.mean(a,axis=0)#[2.5 3.5 4.5]  按照列
                          
# median()   计算中位数  
np02 = np.median(a) 
                               
# std()      计算元素标准差   
np02 = np.std(a)
                       
# max()    计算元素的最大值或每一个横轴的最大值    
np02 = np.max(a)
np02 = np.max(a,axis=1)# 按照行
np02 = np.max(a,axis=0)# 按照列
 
# min()     计算元素的最小值 
np02 = np.max(a)
np02 = np.max(a,axis=1)# 按照行
np02 = np.max(a,axis=0)# 按照列
                          
# count_nonzero() | 计数     
np02 = np.count_nonzero(a)
np02 = np.count_nonzero(a,axis=1)# 按照行
np02 = np.count_nonzero(a,axis=0)# 按照列
                                   
# cumsum     计算所有元素的累计和或每一个横轴按元素累加
#如果axis不写
#先把数组变成一维数组[1, 2, 3,4, 5, 6]
#对数组进行累加0+1   1+2  3+3
np02 = np.cumsum(a)
np02 = np.cumsum(a,axis=1)# 按照行
np02 = np.cumsum(a,axis=0)# 按照列
​
# sum()      所有元素求和或横轴元素求和  
np02 = np.sum(a)    
np02 = np.sum(a,axis=1)          
np02 = np.sum(a,axis=0)     
print(np02) 

比较和逻辑操作

函数	描述
==	等于
>	大于
<	小于
!=	不等于
logical_and(a, b)	和
logical_or(a, b)	或者
logical_not(a)	否

#数字和一维数组或者二维数组的比较
#和每一个数值相比较
a = 3
b = np.array([1,2,3,4])
print(a == b)
a = 3
b = np.array([
       [1, 3],
       [9, 6]
])
print(a == b)
import numpy as np 
#一维数组和二维数组的比较
#一维数组的列和二维数组一样，那么比较每一个数据是否相等
a = np.array([9,6])
b = np.array([
       [1, 3],
       [9, 6]
])
print(a == b)
​
​
​
#二维数组和二维数组比较
a = np.array([
       [1, 5],
       [2, 6]
])
b = np.array([
       [1, 3],
       [9, 6]
])
print(a == b)
​

#一维数组和二维数组的比较
a = np.array([True,False])
b = np.array([
       [True,False],
       [True, True]
])
​
print(np.logical_and(a,b))
a = np.array([1,2])
b = np.array([
       [1,2],
       [1,0]
])
print(np.logical_and(a,b))

#数字和一维数组或者二维数组的比较
"""
a = 2
b = np.array([1,2,3,4])
print(np.logical_and(a,b))
a = True
b = np.array([True,False,False,False])
print(np.logical_and(a,b))
​
a = 3
b = np.array([
       [1, 3],
       [9, 6]
])
print(np.logical_and(a,b))
"""
#二维数组和二维数组比较
a = np.array([
       [True, False],
       [False, True]
])
b = np.array([
       [True, False],
       [True, True]
])
print(np.logical_and(a,b))
#很有可能0代表false