numpy基础学习

numpy基础学习

1、numpy介绍

numpy是python的一个扩展程序，支持大量的维数数组与矩阵运算，同时对数组运算提供大量的数学函数库。numpy是一个运行速度非常快的数学库，主要用于数组计算，包括：
1、强大的N维数组对象ndarray；
2、广播功能函数；
3、整合C/C++/Fortran代码的工具；
4、线性代数、傅里叶变换、随机数生成等功能。

2、ndarray对象介绍

numpy最重要的一个特点就是其N维数组对象ndarray，它是一些列同类型数据的集合，集合中元素的索引从0开始。

2.1 ndarray语法结构

numpy.array(object,dtype=None,copy=True,order=None,subok=False,ndmin=0)
object，被操作对象，即数组或嵌套的数列
dtype，被操作对象元素的数据类型，可选
copy，对象是否需要复制，可选
order，创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok，默认返回一个与基类类型一致的数组
ndmin，指定生成数组的最小维度

#创建一维数组
data=np.array([1,2,3,4,5],dtype=int,copy=True,subok=False,ndmin=0)
print('一维:',data)

data1=np.array([[1,23,5],[56,0,2]])
print('二维:',data1)

结果：
一维: [1 2 3 4 5]
二维: [[ 1 23 5]
[56 0 2]]

2.2 numpy基本数据类型

名称	描述
bool	布尔数据类型（True或False）
int_	默认的整数类型
intc	与C的int类型一样，一般是int32或int64
int_	默认的整数类型
intp	用于索引的整数类型，一般情况下仍然是int32或int64
int8	字节（-128 to127，-2^7 to 2^7-1）
int16	整数（-2^15 to 2^15-1）
int32	整数（-2^31 to 2^31-1）
int64	整数（-2^63 to 2^63-1））
uint8	无符号整数 0 to2^8-1
uint16	无符号整数 0 to 2^16-1
uint32	无符号整数 0 to 2^32-1
uint64	无符号整数 0 to 2^64-1
float_	flaot64类型的简写
float16	半精度浮点数，包括1个符号位，5个指数位，10个尾数位
float32	半精度浮点数，包括1个符号位，8个指数位，23个尾数位
float64	半精度浮点数，包括1个符号位，11个指数位，52个尾数位
complex_	complex128类型的简写，即128位复数
complex64	复数，表示双32位浮点数（实数部分和虚数部分
complex128	复数，表示双64位浮点数（实数部分和虚数部分

可以用dtype函数查看数据的类型

data=np.array([123456,34577856,6,68,-256,89.0])
print(data,data.dtype)

data1=np.array([1,2,3,5])
print(data1,data1.dtype)

[ 1.2345600e+05 3.4577856e+07 6.0000000e+00 6.8000000e+01 -2.5600000e+02 8.9000000e+01] float64
[1 2 3 5] int32

2.3 数组属性

属性	说明
ndarray.ndim	秩，即轴的数量或维度数量
ndarray.shape	数组的维度，对于矩阵n行m列
ndarray.size	数组元素的总个数，相当于shape中n*m的值
ndarray.dtype	ndarray对象中元素类型
ndarray.itemsize	nsarray对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray对象的内存信息
ndarray.real	ndarray元素的实部
ndarray.imag	ndarray元素的虚部
ndarray.data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这话属性

data=np.arange(1,10).reshape((3,3))
print(data)
print('秩，ndim:',data.ndim)
print('数组维度，shape：',data.shape)
print('数组元素个数，size:',data.size)
print('数组元素类型，dtype：',data.dtype)
print('数组每个元素的大小，itemsize:',data.itemsize)
print('数组内存信息，flags:',data.flags)
print('数组元素的实部，real：',data.real)
print('数组元素的虚部，imag:',data.imag)
print(data.data)

数组： [[1 2 3]
[4 5 6]
[7 8 9]]

秩，ndim: 2

数组维度，shape： (3, 3)

数组元素个数，size: 9

数组元素类型，dtype： int32

数组每个元素的大小，itemsize: 4

数组内存信息，flags: C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : False
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False

数组元素的实部，real： [[1 2 3]
[4 5 6]
[7 8 9]]

数组元素的虚部，imag: [[0 0 0]
[0 0 0]
[0 0 0]]

<memory at 0x000001D0C05A0790>

3、数组的创建

函数	说明
array	将输入的数据（列表，元组，数组或其他序列类型）转换为ndarray
asarray	将输入的数据转换为ndarray，若输入的已经是ndarray则不需要复制
arange	根据给定范围直接返回ndarray数组，而不是列表
ones,ones_like	ones表示生成一个由1组成的数组；ones_like表示返回与指定数组具有相同形状和数据类型的数组，并且数组元素都为1
zeros,zeros_like	zeros表示生成一个由0组成的数组；zeros_like表示返回与指定数组具有相同形状和数据类型的数组，并且数组元素都为0
empty,empty_like	empty返回给定形状和类型的新数组，而不初始化，即将数组值设置为零，需要用户手动设置数组中的所有值；empty_like返回一个与给定数组具有相同形状和类型的新数组,相同的，该函数不初始化返回的数组；为此，改用 zeros_like 或 ones_like比设置数组值的函数稍微快一点。
full,full_likel	返回与给定数组具有相同形状和类型的数组，并且数组中元素的值是fill_value的值
eye,identity	创建一个N方单位矩阵

3.1 array 与 asarray

array与asarray将输入的数据转换成array

a=[1,2,3,4,5]
data=np.array(a)#将列表转换为array
print(data,data.dtype)
print('----------------------------')

tuple1=(12,35,67,89,32)
data=np.asarray(tuple1)#将元组转换成array
print(data)
print('----------------------------')

array1=np.arange(1,10).reshape((3,3))
array2=np.asarray(array1)
print(array1)
print('----------------------------')
print(array2)

----------结果--------------
[1 2 3 4 5] int32
----------------------------
[12 35 67 89 32]
----------------------------
[[1 2 3]
 [4 5 6]
 [7 8 9]]
----------------------------
[[1 2 3]
 [4 5 6]
 [7 8 9]]

3.2 arange

range 返回一个数组，其元素按间隔均匀间隔，与普通的内置range()函数相比，numpy.arange()可以生成非整数的数字序列。

data=np.arange(9)#间隔整数
print(data)
print(np.arange(1,5,0.5))#间隔为0.5

[0 1 2 3 4 5 6 7 8]
[1. 1.5 2. 2.5 3. 3.5 4. 4.5]

3.3 ones 和 ones_like

numpy.ones(shape, dtype)
ones表示生成一个由1组成的数组；ones_like表示返回与指定数组具有相同形状和数据类型的数组，并且数组元素都为1

data=np.ones(2,int)
data1=np.ones((2,2),float)
data2=np.ones([2,2],int)
print(data)
print('--------')
print(data1)
print('--------')
print(data2)

[1 1]

[[1. 1.]
[1. 1.]]

[[1 1]
[1 1]]

a=np.array([12,54,54])
b=np.array([[2,3,5],[6,8,7]])
a1=np.ones_like(a)

print(a1)
print(np.ones_like(b))

[1 1 1]

[[1 1 1]
[1 1 1]]

3.4 zeros 和 zeros_like

a=np.zeros(2,int)
b=np.zeros([3,3],float)

c=np.zeros_like([1,2,3])
aa=np.arange(9).reshape((3,3))
d=np.zeros_like(aa)

print(a)
print(b)
print(c)
print(d)

[0 0]

[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]

[0 0 0]

[[0 0 0]
[0 0 0]
[0 0 0]]

3.5 empty 和 empty_like

empty(shape, dtype)

a=np.empty(3,dtype=int)
b=np.empty([2,2],dtype=int)
c=np.empty([3,3],int)

print(a)
print(b)
print(c)

[-1107865200 464 0]

[[1 1]
[1 1]]

[[0 1 2]
[3 4 5]
[6 7 8]]

data=np.array([[1,2],[3,5]])
dada=np.array([1,2,3])
a=np.empty_like(data)
b=np.empty_like(dada)

print(a)
print(b)

[[1 2]
[3 5]]

[12 54 54]

3.6 full 和 full_like

full(shape, fill_value, dtype）返回一个形状和类型与fill_value填充的给定数组相同的新数组

a=np.full([2, 1], 67, dtype=int)
b=np.full([2, 3], 2)
c=np.full_like(a,0)
d=np.full_like(b,1)


print(a)
print(b)
print(c)
print(d)

[[67]
[67]]

[[2 2 2]
[2 2 2]]

[[0]
[0]]

[[1 1 1]
[1 1 1]]

3.7 eye 和 identity

a=np.eye(3,dtype=int)
b=np.identity(3)

print(a)
print(b)

[[1 0 0]
[0 1 0]
[0 0 1]]

[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]

3.8 特殊数组的创建：0元素数组

使用zeros函数创建指定维数的数组
zeros(shape,dtype,drder)

e=np.zeros((3,3),dtype=int)
print(e)

[[0 0 0]
[0 0 0]
[0 0 0]]

3.9 特殊数组的创建：1元素数组

使用ones函数创建指定维数的1元素数组
ones(shape,dtype,drder)

one=np.ones((3,3),dtype=int)
print(one)

[[1 1 1]
[1 1 1]
[1 1 1]]

3.10 特殊数组的创建：等差数列数组

使用linspace函数创建一个一维等差数列的数组，也可以用arange函数，但linspace更便捷。

linspace(start,stop,num=,endpoint=True,restep=False,dtype)
staert，序列的起始值
stop，序列的终止值，但endpoint=Ture时，该值包含在序列中
num，要生成等步长的样本数量，默认为50
endpoint，默认为True
retstep，如果restep=True，生成的数组会显示间距，反之不显示
dtype，元素类型

lin=np.linspace(10,100,num=100,endpoint=True,retstep=True,dtype=int)
data=np.arange(10,101)

print(lin)
print(data)

(array([ 10, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40, 40, 41, 42, 43, 44,
45, 46, 47, 48, 49, 50, 50, 51, 52, 53, 54, 55, 56,
57, 58, 59, 60, 60, 61, 62, 63, 64, 65, 66, 67, 68,
69, 70, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 90, 91,
92, 93, 94, 95, 96, 97, 98, 99, 100]), 0.9090909090909091)

[ 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
100]

3.11 特殊数组的创建：等比数列数组

等比数列用函数logspace函数来创建
logspace(start,stop,num,endpoint,base,dtype)
staert，序列的起始值为basestart
stop，序列的终止值为basestop，但endpoint=Ture时，该值包含在序列中
num，要生成等步长的样本数量，默认为50
endpoint，默认为True
base，对数log的底数
dtype，元素类型

data=np.logspace(1,10,10,base=2)

print(data)

[ 2. 4. 8. 16. 32. 64. 128. 256. 512. 1024.]

4、数组数据索引与切片

ndarray对象的内容可以通过索引或切片来访问和修改。numpy切片语法与python列表的切片语法相同。索引与切片通常是联合运用。数组的索引总是使用方括号"[ ]"来索引数组的元素，以便对这些元素可以被单独引用。

4.1 put函数

put()函数用给定的元素去替换数组中的特定元素，是对原数组进行修改替换

语法结构：numpy.put(array, indices, p_array, mode = ‘raise’)
array :传入的数组
indices : 要获取的值的索引
p_array : 要放在目标数组中的值
mode : [{‘raise’, ‘wrap’, ‘clip’}, optional] 若索引越界，raise : [default]引发一个错误，wrap : 绕开，clip : 夹到范围内

da=np.array([1,46,7,4,9,2,8,72])
print(da)
a=np.put(da,[0,-1],[88,66])
print(da)#put函数是对原数组进行替换修改

data=np.array([[12,34,100],[56,78,99]])
print(data)
np.put(data,[3,4,0],[65,66,11])#多维数组时，以此为例[3,4，0]表示为索引为3,4,0的元素分别用65,66和11进行替换
print(data)

[ 1 46 7 4 9 2 8 72]

[88 46 7 4 9 2 8 66]

[[ 12 34 100]
[ 56 78 99]]

[[ 11 34 100]
[ 65 66 99]]

4.2 compress()函数？

compress()函数返回一个数组的选定切片

语法结构：compress(condition, array, axis = None, out = None)
condition :数组元素是由具有真值的。
array : 输入数组。用户在input_array元素上应用条件
axis : [optional, int]表示要选择的片断。默认情况下，是对扁平化的数组[1-D]工作。
out : [optional, ndarray]带有input_array元素的output_array。

a=np.arange(9).reshape((3,3))

print(a)
print(np.compress([1,0,1],a,axis=0))#截取第一行和第三行
print(np.compress([1,0,1],a,axis=1))#截取第一列和第三列

[[0 1 2]
[3 4 5]
[6 7 8]]

[[0 1 2]
[6 7 8]]

[[0 2]
[3 5]
[6 8]]

4.3 place()函数

place()函数根据参数-条件和值对数组进行更改，根据设置的掩码使用前n个值放入数组，其工作方式与numpy.extract()相反。

语法结构：place(array, mask, values)
array :输入需要修改的数组
mask :布尔值，必须与输入数组的大小相同。
values : 要放入数组的值。根据掩码条件，它只向数组添加N个元素。如果val中的值小于掩码，相同的值会被重复。

data=np.arange(1,10)
a=np.place(data, data>5, 0)

print(data)#对原数组进行操作
print(a)

[1 2 3 4 5 0 0 0 0]
None

4.4 diag_indices()函数-----访问数组的主对角线。

diag_indices返回一个对角线上的索引。接受两个参数，一个是n表示列表长度，一个是ndim，表示对角线索引的维度，默认为2.

语法结构：diag_indices(n, n_dim = 2)
n：数组的大小，每个维度都需要有二个元素的索引。
n_dim：维数的数目。

a=np.arange(9).reshape((3,3))
n= np.diag_indices(3)
print(n)

(array([0, 1, 2]), array([0, 1, 2]))

4.5 take()函数

take()根据提供的索引值将元素形成数组输出
语法结构：numpy.take（a，indices，axis = None，out = None，mode =‘raise’ ）

a=np.arange(9).reshape((3,3))
print(a)
print(np.take(a,(1,2),axis=0))#获取索引为1,2的行
print(np.take(a,(1,2),axis=1))#获取索引为1,2的列

[[0 1 2]
[3 4 5]
[6 7 8]]

[[3 4 5]
[6 7 8]]

[[1 2]
[4 5]
[7 8]]
​

4.6 nonzero()函数

nonzero函数是numpy中用于得到数组array中非零元素的位置（数组索引）的函数。它的返回值是一个长度为a.ndim(数组a的轴数)的元组，元组的每个元素都是一个整数数组，其值为非零元素的下标在对应轴上的值。

data1=np.nonzero([1,2,3,0,4,0])
print('一维：',data1)
 
data2=[[7, 8, 0],[0, 5, 0],[1, 0, 3]]
nz=np.nonzero(data)
print('二维：',nz)
 
data3=[[[0,0],[1,0]],
        [[0,0],[1,0]],
        [[0,0],[1,0]]]
print('三维：',np.nonzero(data3))

一维： (array([0, 1, 2, 4], dtype=int64),)
二维： (array([0, 0, 1, 2, 2], dtype=int64), array([0, 1, 1, 0, 2], dtype=int64))
三维： (array([0, 1, 2], dtype=int64), array([1, 1, 1], dtype=int64), array([0, 0, 0], dtype=int64))

4.7 where()函数

where()函数返回输入数组中满足指定条件的元素的索引。

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

print(aa)
print(a[aa])

(array([2, 3], dtype=int64),)
[[1 4 2]
[3 2 2]]

5、数组常见操作

5.1 修改数组形状

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

reshape

data=np.arange(12).reshape((3,4))
da=data.reshape(4,3)
d=np.reshape(data,(4,3))

print(data)
print(da)
print(d)

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]

[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]

flat
flat返回的是一个迭代器，可以用for访问数组每一个元素

a = np.arange(9).reshape(3,3)
print(a)
for i in a.flat:
    print(i)
    
#迭代器可以用list进行输出
print(list(a.flat),type(a.flat))#返回类型为 numpy.flatiter

b=a.flat[3]#可以用索引对迭代器进行引号
print(b)

[[0 1 2]
[3 4 5]
[6 7 8]]

0
1
2
3
4
5
6
7
8

[0, 1, 2, 3, 4, 5, 6, 7, 8] <class ‘numpy.flatiter’>

3

faltten
faltten 将数组的副本转换为一个维度，并返回，返回一个折叠成一维的数组。但是该函数只能适用于numpy对象，即array或者mat，普通的list列表是不行的。
flatten(order=’C’),可选参数，order：{‘C’,‘F’,‘A’,‘K’}
'C’行序优先
‘F’：列序优先
‘A’：if a is Fortran contiguous in memory ,flatten in column_major order
‘K’：按照元素在内存出现的顺序进行排序
默认为’C’

a = np.array([[4,5],[4,9]])
print(a)

b= a.flatten()#默认按行转换
print('默认C',b)

c = a.flatten('F')#换成列来划分
print('F',c)

d=a.flatten('A')#如果 a 在内存中是连续的 Fortran，则按column_major顺序平展
print('A',d)

e=a.flatten('K')#按照元素在内存出现的顺序进行排序
print('K',e)

[[4 5]
[4 9]]

默认C [4 5 4 9]

F [4 4 5 9]

A [4 5 4 9]

K [4 5 4 9]

ravel
ravel函数的作用是让多维数组变成一维数组

a = np.array([[4,5],[8,9],[1,2]])
print(a)

b=a.ravel()
print(b)

c=np.ravel(a)
print(c)

[[4 5]
[8 9]
[1 2]]

[4 5 8 9 1 2]

[4 5 8 9 1 2]

5.2 翻转数组

函数	描述
transpose 、ndarray	对换数组的维度，即转置
rollaxis	向后滚动指定的轴
swapaxes	对换数组的两个轴

transpose 、ndarray

import numpy as np
a = np.array([[4,5],[8,9],[1,2]])
print(a)
print(np.transpose(a))
print(a.T)

[[4 5]
[8 9]
[1 2]]

[[4 8 1]
[5 9 2]]

[[4 8 1]
[5 9 2]]

rollaxis
rollaxis(a, axis, start=0) 向后滚动指定的轴，直到它位于给定位置。

a = np.array([[[1,2,3],[4,5,6]],[[11,22,33],[44,55,66]]])
print(a)
print('1',np.where(a==1))
print('2',np.where(a==2))
print('3',np.where(a==3))
print('4',np.where(a==4))
print('5',np.where(a==5))
print('6',np.where(a==6))

b=np.rollaxis(a,1)
print(b)
print('1',np.where(b==1))
print('2',np.where(b==2))
print('3',np.where(b==3))
print('4',np.where(b==4))
print('5',np.where(b==5))
print('6',np.where(b==6))

[[[ 1 2 3]
[ 4 5 6]]

[[11 22 33]
[44 55 66]]]

1 (array([0], dtype=int64), array([0], dtype=int64), array([0], dtype=int64))
2 (array([0], dtype=int64), array([0], dtype=int64), array([1], dtype=int64))
3 (array([0], dtype=int64), array([0], dtype=int64), array([2], dtype=int64))
4 (array([0], dtype=int64), array([1], dtype=int64), array([0], dtype=int64))
5 (array([0], dtype=int64), array([1], dtype=int64), array([1], dtype=int64))
6 (array([0], dtype=int64), array([1], dtype=int64), array([2], dtype=int64))

[[[ 1 2 3]
[11 22 33]]

[[ 4 5 6]
[44 55 66]]]

1 (array([0], dtype=int64), array([0], dtype=int64), array([0], dtype=int64))
2 (array([0], dtype=int64), array([0], dtype=int64), array([1], dtype=int64))
3 (array([0], dtype=int64), array([0], dtype=int64), array([2], dtype=int64))
4 (array([1], dtype=int64), array([0], dtype=int64), array([0], dtype=int64))
5 (array([1], dtype=int64), array([0], dtype=int64), array([1], dtype=int64))
6 (array([1], dtype=int64), array([0], dtype=int64), array([2], dtype=int64))

swapaxes

a = np.arange(24).reshape((2,3,4))
print(a)

print(a.swapaxes(2,0))

[[[ 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]]]
​

5.3 修改数组维度

函数	描述
broadcast	产生模仿广播的对象
broadcast_to	将数组广播到新形状
expand_dims	扩展数组的形状
squeeze	从数组的形状中删除一维条目

broadcast
广播规则：
1、如果两个数组的形状在任何一个维度上都不匹配，那么数组的形状会沿着维度为1的维度扩展以匹配另一个数组的形状
2、如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
3、如果两个数组的形状在任何一个维度上都不匹配且没有任何一个维度等于 1 时，那么将会引发异常。

a=np.arange(9).reshape((3,3))
print(a)
b=np.array([10,20,30])

c=a+b
print(c)

[[0 1 2]
[3 4 5]
[6 7 8]]

[[10 21 32]
[13 24 35]
[16 27 38]]

broadcast_to

a=np.arange(6).reshape((1,6))
b=np.arange(6).reshape((6,1))

print(np.broadcast_to(a,(3,6)))
print(np.broadcast_to(b,(6,3)))

[[0 1 2 3 4 5]
[0 1 2 3 4 5]
[0 1 2 3 4 5]]

[[0 0 0]
[1 1 1]
[2 2 2]
[3 3 3]
[4 4 4]
[5 5 5]]
​
expand_dims
expand_dims(array, axis=0) 的主要作用，就是增加一个维度。
现在我们假设有一个数组a，数组a是一个两行三列的矩阵。设置axis为0，矩阵从23的二维矩阵变成了12*3的三维矩阵。

a=np.arange(6).reshape((2,3))
b=np.expand_dims(a, axis=1)

print(a)
print(b)

[[0 1 2]
[3 4 5]]

[[[0 1 2]]

[[3 4 5]]]

squeeze
squeeze(a,axis = None)函数可以删除数组形状中的单维度条目，即把shape中为1的维度去掉，否则将会报错，axis的取值可为None 或 int 或 tuple of ints, 可选。若axis为空，则删除所有单维度的条目；

5.4 连接数组

函数	描述
concatenate	连接现有轴的数组序列
stack	沿新的轴加入一系列数组
hstack	水平堆叠序列中的数组（列方向）
vstack	竖直堆叠序列中的数组（行方向）

concatenate
concatenate((a1,a2,…), axis=0)函数。能够一次完成多个数组的拼接，适合大规模的数据拼接 。其中a1,a2,…是数组类型的参数

a=np.array([[1,2,3],[4,5,6]])
b=np.array([[11,21,31],[7,8,9]])

print(np.concatenate((a,b),axis=0))
print(np.concatenate((a,b),axis=1))  #axis=1表示对应行的数组进行拼接

[[ 1 2 3]
[ 4 5 6]
[11 21 31]
[ 7 8 9]]

[[ 1 2 3 11 21 31]
[ 4 5 6 7 8 9]]

stack、hstack、vstack
stack()会增加数组的维度,axis等于几就说明在哪个维度上进行堆叠

a=np.arange(1,7).reshape((2,3))
b=np.arange(7,13).reshape((2,3))
c=np.arange(13,19).reshape((2,3))

print(np.stack([a,b,c],axis=0))
print(np.stack([a,b,c],axis=0).shape)

print(np.stack([a,b,c],axis=1))
print(np.stack([a,b,c],axis=1).shape)

print(np.stack([a,b,c],axis=2))
print(np.stack([a,b,c],axis=2).shape)

[[[ 1 2 3]
[ 4 5 6]]

[[ 7 8 9]
[10 11 12]]

[[13 14 15]
[16 17 18]]]
(3, 2, 3)

[[[ 1 2 3]
[ 7 8 9]
[13 14 15]]

[[ 4 5 6]
[10 11 12]
[16 17 18]]]
(2, 3, 3)

[[[ 1 7 13]
[ 2 8 14]
[ 3 9 15]]

[[ 4 10 16]
[ 5 11 17]
[ 6 12 18]]]
(2, 3, 3)

a=np.arange(1,7).reshape((2,3))
b=np.arange(7,13).reshape((2,3))
c=np.arange(13,19).reshape((2,3))

print(np.hstack([a,b,c]))
print(np.vstack([a,b,c]))

[[ 1 2 3 7 8 9 13 14 15]
[ 4 5 6 10 11 12 16 17 18]]

[[ 1 2 3]
[ 4 5 6]
[ 7 8 9]
[10 11 12]
[13 14 15]
[16 17 18]]
​

5.5 分割数组

函数	描述
split	将一个数组从左到右按顺序切分成多个数组
hsplit	将一个数组水平分割成多个子数组（按列）
vsplit	将一个数组垂直分割成多个子数组（按行）

split
语法结构：split(ary, indices_or_sections, axis=0)
ary:要切分的数组
indices_or_sections:如果是一个整数，spli函数只能用于均等分割，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：沿着哪个维度进行切向，默认为0，横向切分。为1时，纵向切分

a=np.arange(1,10).reshape((3,3))

print(a)
print(np.split(a,3,axis = 0))#按行分割
print(np.split(a,3,axis = 1))#按列分割
print(np.split(a,[1,2,4],axis=1))#分割为(:,1]、(1,2]、(2,4],(4,:]4个数组左开右闭

#axis=1,代表列，是要把data数据集中的所有数据按第二、三列之间分割为X集和Y集。
x, y = np.split(a, (2,), axis=1)
print(x)
print(y)

[[1 2 3]
[4 5 6]
[7 8 9]]

[array([[1, 2, 3]]), array([[4, 5, 6]]), array([[7, 8, 9]])]

[array([[1],
[4],
[7]]), array([[2],
[5],
[8]]), array([[3],
[6],
[9]])]

[array([[1],
[4],
[7]]), array([[2],
[5],
[8]]), array([[3],
[6],
[9]]), array([], shape=(3, 0), dtype=int32)]

[[1 2]
[4 5]
[7 8]]

[[3]
[6]
[9]]

hsplit、vsplit

A=np.arange(9).reshape((3,3))

print(np.hsplit(A,3))# 水平方向分割
print(np.vsplit(A,3))

[array([[0],
[3],
[6]]), array([[1],
[4],
[7]]), array([[2],
[5],
[8]])]

[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

5.6 数组元素的添加与删除

函数	描述
resize	返回指定形状的数组
append	将值添加到数组末尾
insert	沿指定轴将值插入指定下标之前
delete	删除某个轴的子数组，并返回删除后的新数组
unique	查找数组类唯一的元素，用于删除数组中重复元素

resize
resize改变数组的尺寸大小，reshape给数组一个新的形状而不改变其数据

a=np.arange(16).reshape((4,4))

#有返回值，不对原始数据进行修改
new=np.resize(a,(2,3))
print(new)
print(a)

[[0 1 2]
[3 4 5]]

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]

append
axis=0，行数增加，列数不变，列数必须保持相同。
axis=1拓展列，行数不变，行数需要相同。
append规定，要么一个数组和一个数值；要么两个数组，不能三个及以上数组直接append拼接。

a=np.arange(4).reshape((2,2))

print(np.append(a,[[1,1]],axis=0))#维数要保持相同
print(np.append(a,[[1,1],[0,0]],axis=1))

[[0 1]
[2 3]
[1 1]]

[[0 1 1 1]
[2 3 0 0]]

insert
语法结构：insert(arr，obj，values，axis)：
arr，需要插值的数组
obj，元素插入的位置
values，插入的数值
axis，默认为先对arr进行flatten操作，变为一维数组，然后再在对应的位置上插入对应的值。

a=np.arange(4).reshape((2,2))

b=np.insert(a,1,3)
print(a)
print(b)

c=np.insert(a, [1,2], [[6,3],[9,8]], axis=0)
print(c)

d= np.insert(a,(2,4),9)
print(d)

[[0 1]
[2 3]]

[0 3 1 2 3]

[[0 1]
[6 3]
[2 3]
[9 8]]

[0 1 9 2 3 9]

delete
语法结构：delete(array, object, axis = None)

a=np.arange(6).reshape((2,3))
b=np.delete(a,[1])
print(b)
print(np.delete(a,1))
print(np.delete(a,[2,3]))

[0 2 3 4 5]

[0 2 3 4 5]

[0 1 4 5]

unique
语法结构：unique(arr, return_index, return_inverse, return_counts, axis)
arr：输入的数组，如果不是一维数组则会展开
return_index：如果为True，返回新列表元素在旧列表中的位置(下标)，并以列表形式储存
return_inverse：如果为True，返回旧列表元素在新列表中的位置(下标)，并以列表形式储存
return_counts：如果为True，返回去重数组中的元素在原数组中出现的次数
axis

a=np.array([1,2,3,4,3,2,1,4,5,3,4,2,1,4])
print(a)
b=np.unique(a,return_index=True, return_inverse=True, return_counts=True)
print(b)

[1 2 3 4 3 2 1 4 5 3 4 2 1 4]
(array([1, 2, 3, 4, 5]), array([0, 1, 2, 3, 8], dtype=int64), array([0, 1, 2, 3, 2, 1, 0, 3, 4, 2, 3, 1, 0, 3], dtype=int64), array([3, 3, 3, 4, 1], dtype=int64))
​

5.7 数组排序

5.7.1 sort

语法结构：sort(arr,axis=-1,kind=‘quicksort’,order=None)
arr :要排序的数组。
axis :排序开始的轴，沿着数组的方法排序，0表示按行，1表示按列
kind :排序算法，快排[‘quicksort’{default},混排 ‘mergesort’, 堆排‘heapsort’]
order :如果数组包含字段，则要排序的字段，指定了要先比较哪些字段。

a=np.array([[12, 21], [5, 1]])
b=np.sort(a,axis =0)#按行
b1=np.sort(a,axis=1)#按列

print(b)
print(b1)

[[ 5 1]
[12 21]]

[[12 21]
[ 1 5]]

5.7.2 argsort

argsort函数返回的是数组值从小到大的索引值，其语法结构、参数说明与sort函数一致，其作用是对数组进行排序，犯回一个排序后的索引，数据没有改变

a=np.array([[12, 21], [5, 1]])
b=np.argsort(a,axis =0)#按列
b1=np.argsort(a,axis=1)#按行

print(a)
print(b)
print(b1)

[[12 21]
[ 5 1]]

[[1 1]
[0 0]]

[[0 1]
[1 0]]

5.7.3 lexsort

lexsort用于对多个序列进行排序，排序是优先照顾靠后的列，比如查看某个班级学生的总成绩排序时，若总成绩相同时，则根据数学成绩进行排序。

names=np.array(['A','B','C','D'])
ages=np.array([12,14,13,12])
total_scores=np.array([160,178,180,178])
math_scores=np.array([98,100,91,88])
index_lexsorted=np.lexsort((math_scores,total_scores))#按总成绩排序

print(index_lexsorted)
names_lexsorted=names[np.lexsort((math_scores,total_scores))]
print(names_lexsorted)

[0 3 1 2] # []中的数值为原数组的索引
[‘A’ ‘D’ ‘B’ ‘C’]#B和D的总成绩相同，但B的数学成绩比D高，因此B的排名比D高

6、函数

6.1 字符串函数

函数	描述
add	对两个数组的逐个字符串进行连接
multiply	返回按元素多重连接后的字符串
center	居中字符串
capitalize	将字符串的第一个字母转换为大写
title	将字符串的每个单词的第一个字母转换为大写
lower	将数组元素转换为小写
upper	将数组元素转换为大写
split	按指定分隔符对字符串进行分隔，并返回数组列表
splitlines	返回元素中的列表，以换行符分隔
strip	移除元素开头或结尾处的特定字符
join	通过指定分隔符来连接数组中的元素
replace	使用新字符串代替字符串中的所有字符串
decode	数组元素依次调用str.decode
encode	数组元素依次调用str.encode

print(np.char.add('hello',['world']))	#add---['helloworld']
print(np.char.multiply('hello ',3))		#multiply---hello hello hello 
print(np.char.center('hello',10, fillchar = '*'))	#center---**hello***
print(np.char.capitalize(['hello world','java']))	#capitalize---['Hello world' 'Java']
print(np.char.title(['hello world','java']))	#title---['Hello World' 'Java']
print(np.char.lower(['Hello WorlD', 'Java'])	)	#lower---['hello wreld' 'java']
print(np.char.upper(['hello woeld', 'java']))	#upper---['HELLO WOELD' 'JAVA']
print(np.char.split('hello,how are you', sep = ','))		#split---['hello', 'how are you']
print(np.char.splitlines('hello\ngood monring'))	#splitlines---['hello', 'good monring']
print(np.char.strip(['good','god','going'],'g'))		#strip---['ood' 'od' 'oin']
print (np.char.join([':','-'],['good','job']))	#join---['g:o:o:d' 'j-o-b']
print(np.char.replace('she is good','good','beautiful'))	#replace---she is beautiful
print(np.char.encode('hello','GBK'))		#encode---b'hello'
print(np.char.decode(b'hello','GBK'))	#decode---hello

6.2 数学函数

函数	描述
abs,fabs	绝对值
squrt	开方
square	平方
exp	指数
log,log10,log2,log1p	对数
sign	符号函数
ceil	计算每个元素的上限整数
floor	计算每个元素的下限整数
isnan	返回布尔数组，指示每个值是否为NaN（不是一个数）
isfinite,isinf	返回布尔阵列，指示每个元素是否为有限或无限
cos,cosh,sin,sinh,tan,tanh	三角函数
arccos,arccosh,arcsin,arcsinh,arctan,arctanh	反三角函数

6.3 算术函数

函数	描述
add	加法
subtract	减法
multiply	乘法
divide,floor_divide	除法
power	将第一个数组中的元素提升到第二个数组中指定的幂
maximum,fmax	最大值
minimum,fmin	最小值
mod	除法余数
copysign	将第二个参数中的值的符号复制到第一个参数中的值
greater,greater_equal,less,less_equal,equal,not_equal	执行元素比较，生成布尔组（相当于插入操作符，>,>=,<,<=,==,!=）
logical_and,logical_or,logical_xor	计算逻辑运算的元素真值（等价于运算符&，

6.4 统计函数

函数	描述
amin	计算数组中的元素沿指定轴的最小值
amax	计算数组中的元素沿指定轴的最大值
ptp	计算数组中的元素最大值与最小值之差
percentile	计算数组的百分位数
median	计算数组中元素的中位数
mean	计算数组中元素的算术平均数
average	根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值
std	计算数组中元素的标准差
var	计算数组中元素的方差

7、矩阵

numpy中包含一个矩阵库numpy.matlib，该模块中的函数返回的是一个矩阵，而不是ndarray

7.1 空矩阵

语法结构：np.matlib.empty(shape,dtype,order)
shape：定义新矩阵形状的整数或整数元组
dtype：可选，数据类型
order：C（行优先）或F（列优先）
矩阵元素输出是随机变量

import numpy.matlib
import numpy as np
a=np.matlib.empty((3,3),dtype=int)
print(a)

[[ 98 101 97]
[117 116 105]
[102 117 108]]

7.2 零矩阵

numpy.matlib.zeros函数创建一个以0填充的矩阵

print(np.matlib.zeros((3,4)))

[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]

7.3 全1矩阵

numpy.matlib.ones函数创建一个以1填充的矩阵

print(np.matlib.ones((3,4)))

[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]

7.4 单位矩阵

numpy.matlib.identity函数返回一个给定的单位矩阵

print(np.matlib.identity(4))

[[1. 0. 0. 0.]
[0. 1. 0. 0.]
[0. 0. 1. 0.]
[0. 0. 0. 1.]]

7.5 对角矩阵

numpy.matlib.eye函数返回一个对角元素全为1，其他位置为0的矩阵
语法结构：numpy.matlib.eye(n,m,k,dtype)
n：返回矩阵的行数
m：返回矩阵的列数，默认为n
k：对角线的索引
dtype：数据类型

print(np.matlib.eye(n=3,M=5,k=-1,dtype=float))
print(np.matlib.eye(n=4,M=5,k=0,dtype=float))
print(np.matlib.eye(n=5,M=5,k=1,dtype=float))

[[0. 0. 0. 0. 0.]
[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]]

[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]]

[[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]
[0. 0. 0. 0. 0.]]

7.6 随机矩阵

numpy.matlib.rand函数创建一个给定大小的矩阵，数据是随机填充的

print(np.matlib.rand((4,4)))

[[0.88129619 0.06966126 0.97488963 0.63595235]
[0.65913145 0.71170856 0.81599032 0.32102196]
[0.80852689 0.81151333 0.33323786 0.79308415]
[0.44776359 0.28596506 0.64932724 0.03875443]]

本文仅供学习交流