目录
一.创建数组
1.array
import numpy as np
a1=np.array([1,2,3,4])
print(a,",type=",type(a))输出：
[1 2 3 4] ,type= <class ‘numpy.ndarray’>
2.arange
b=np.arange(1,10,2)#star,stop,step,左闭右开
print(b,",type=",type(b))输出：
[1 3 5 7 9] ,type= <class ‘numpy.ndarray’>
3.random:产生一个N行N列的数组，其中值都是0~1的随机数
c=np.random.random((2,2))
print(c)输出：
[[0.45313119 0.99503673]
[0.85987526 0.96949184]]
4.randint：前两个参数控制值的范围，size控制数组形式
d=np.random.randint(0,9,size=(4,4))#创建4行4列的数组，其中值介于[0,9)
print(d)输出：
[[8 0 3 4]
[4 3 5 1]
[1 6 0 5]
[4 5 0 2]]
5.特殊的数组：
全零数组zeros
单位矩阵数组eye
全一数组ones
注意不要漏了括号
e=np.zeros((3,3))#创建3行3列的数组，其中行和列要用括号括起来
print(e)
e1=np.eye(3)#参数3表示维度
print("e1:\n",e1)
e2=np.ones((3,3))#(3,3)表示数组形式，三行三列
print("e2:\n",e2)输出：
[[0. 0. 0.]
[0. 0. 0.]
[0. 0. 0.]]
e1:
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
e2:
[[1. 1. 1.]
[1. 1. 1.]
[1. 1. 1.]]
注意：数组中数据类型必须一致，不能同时出现多种数据类型
二.数据类型与数组类型
1.数据类型
| 数据类型 | 描述 | 唯一标识符 |
| bool |
用一个字节存储的布尔类型 （True或False） |
b |
| int8 | 一个字节大小，-128至127 | i1 |
| int16 | 整数，16位整数（-32768~32767） | i2 |
| int32 | 整数，32位整数（-2147483648~2147483647） | i4 |
| int64 |
整数，64位整数（-9223372036854775808~9223372036854775807） |
i8 |
| uint8 | 无符号整数，（0~255） | u1 |
| uint16 | 无符号整数，（0~65535） | u2 |
| uint32 | 无符号整数，（0~2^32-1） | u4 |
| uint64 | 无符号整数，（0~2^64-1） | u8 |
| float16 | 半精度浮点数，16位，正负号1位，指数5位，精度10位 |
f2 |
| float32 | 单精度浮点数，32位，正负号1位，指数8位，精度23位 | f4 |
| float64 |
单精度浮点数，64位，正负号1位，指数11位，精度52位 |
f8 |
| complex64 | 复数，实部 和虚部各用32位浮点数表示 | c8 |
| complex128 |
复数，实部和虚部各用64位浮点数表示 |
c16 |
| object_ | Python对象 | O |
| string_ | 字符串 | S |
| unicode_ | unicode类型 | U |
2.数据类型用dtype,数组类型用type
数据创建时指定和查询数据类型都用dtype
3.修改数据类型用astype
astype不改变原数组数据的类型
f=np.array([1,2,3,4],dtype='int32')
print(f,f.dtype,type(f))
#修改数据类型
g=f.astype('int64')
print("g.dtype:",g.dtype)
print("f.dtype:",f.dtype)输出：
[1 2 3 4] int32 <class ‘numpy.ndarray’>
g.dtype: int64
f.dtype: int32
三.多维数组
1.数组维度
2.数组形状
3.数组元素个数及所占内存
数组维度用ndim
查询数组形状用shape，改变数组形状用reshape，reshape不改变原数组形状，reshape改变形状时，表示形状的数要用括号括起来。如：reshape((3,2))
数组扁平化，即将多维数组转化为一维数组，用flatten函数，不改变原数组形状
查看数组元素个数用size，每个元素所占内存用itemsize
#查看数组维度
a1=np.array([[1,2,3],[4,5,6]])
print(a)
print("a1.ndim:",a1.ndim)
#查询数组形状
print(a1.shape)#a1是2行3列的数组
#改变数组形状
b1=a1.reshape(3,2)#b1是3行2列的数组
print(b1)
print(a1)
#多维数组的扁平化
c1=b1.flatten()
print(c1)
print(b1)
print(c1.size)#数组元素个数,用size
print(c1.itemsize)#每个元素所占内存输出：
[[1 2 3]
[4 5 6]]
a1.ndim: 2
(2, 3)
[[1 2]
[3 4]
[5 6]]
[[1 2 3]
[4 5 6]]
[1 2 3 4 5 6]
[[1 2]
[3 4]
[5 6]]
6
4
四.数组的索引、切片和替换
1.索引和切片
(1).一维数组
与Python列表的操作方法基本一致
a=np.arange(10)
print(a)
#索引
print(a[3])
print(a[-1])
#切片
print(a[:4])#前闭后开
#步长
print(a[::3])(2).多维数组
通过中括号进行索引，在中括号中使用逗号分隔，逗号前是行，逗号后是列，如果多维数组的索引中只有一个值，则这个值表示行
a1=np.random.randint(0,10,size=(4,6))
print(a1)
print(a1[0])#获取第一行元素
print(a1[1:4])#第一、二、三行元素
print(a1[1,2])#第一行第二列
#[[],[]]第一个中括号是表示行，第二个中括号表示列
print(a1[[1,2],[3,4]])#第一行第三列，第二行第四列,记得要用中括号
print(a1[:,1])#第一列全部数据
print(a1[:,[2,3]])#第二列、第三列全部数据
输出：
[[3 5 9 4 6 0]
[5 8 3 0 9 8]
[1 8 2 7 2 5]
[2 6 6 3 7 4]]
[3 5 9 4 6 0]
[[5 8 3 0 9 8]
[1 8 2 7 2 5]
[2 6 6 3 7 4]]
[[5 9]
[8 3]
[8 2]
[6 6]]
3
[0 2]
[5 8 8 6]
[[9 4]
[3 0]
[2 7]
[6 3]]
注意：特例布尔索引
| 表示或，&表示且
a2=np.arange(24).reshape((4,6))
print("a2:\n",a2)
print("a2中元素值小于10的元素:\n",a2[a2<10])
#当提取条件为多个时，要用括号括起来
print("a2中元素值小于5或大于10的元素:\n",a2[(a2<5)|(a2>10)])输出：
a2:
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]]
a2中元素值小于10的元素:
[0 1 2 3 4 5 6 7 8 9]
a2中元素值小于5或大于10的元素:
[ 0 1 2 3 4 11 12 13 14 15 16 17 18 19 20 21 22 23]
2.替换
(1).和Python的列表一样，用索引
(2)用布尔索引
(3)用函数where,where(condition,a,b)：符合条件condition的元素用a替换，其余的用b替换
a3=np.random.randint(10,size=(3,5))
print(a3)
#直接用索引替换
a3[2,3]=9
print(a3)
#利用布尔索引进行值的替换
a3[a3<4]=1#将小于5的值全部替换为1
print(a3)
#用函数where替换
result=np.where(a3<5,0,1)#将a3中小于5的元素换为0，其余的换为1
print(result)
五.数组的运算
1.数组与数字的运算
2.数组与数组运算（形状相同的数组、形状不同的数组）
1.数组与数字的运算
a1=np.random.random(size=(2,3))
print("a1:\n",a1)
print("a1*2:\n",a1*2)#每个元素都乘2
print("每个元素保留两位小数:\n",a1.round(2))#每个元素保留两位小数,round()不改变原数组输出：
a1:
[[0.59426871 0.81899562 0.34073919]
[0.78663529 0.0771657 0.93731944]]
a1*2:
[[1.18853742 1.63799124 0.68147838]
[1.57327059 0.15433141 1.87463889]]
每个元素保留两位小数:
[[0.59 0.82 0.34]
[0.79 0.08 0.94]]
2.数组与数组运算
（1）形状相同的数组进行运算
a2=np.random.randint(1,10,size=(2,3))
print("a2:\n",a2)
print("a1+a2:\n",a1+a2)输出：
a2:
[[1 4 1]
[4 8 3]]
a1+a2:
[[1.59426871 4.81899562 1.34073919]
[4.78663529 8.0771657 3.93731944]]
（2）形状不同且不满足数组广播机制
#形状不一致且不满足数组广播机制的数组不能相加减
a3=np.random.randint(1,5,size=(3,3))
a2+a3
#形状不一致但满足数组广播机制可以相加减
a4=np.random.randint(0,6,size=(2,1))#行数一样，列数为1
print("a4:\n",a4)
print("a4+a1:\n",a1+a4)
a5=np.random.randint(0,5,size=(1,3))#列数一样，行数为1
print("a5:\n",a5)
print("a5+a1:\n",a5+a1)输出：
a2+a3报错：operands could not be broadcast together with shapes (2,3) (3,3)
a4:
[[5]
[3]]
a4+a1:
[[5.59426871 5.81899562 5.34073919]
[3.78663529 3.0771657 3.93731944]]
a5:
[[2 0 0]]
a5+a1:
[[2.59426871 0.81899562 0.34073919]
[2.78663529 0.0771657 0.93731944]]
六.对数组形状的操作
1.改变形状reshape与重塑形状resize
2.两种展平flatten和ravel
3.两种转置T和transpose
4.数组的叠加
5.数组的切割
1.reshape和resize
reshape只是将数组形状改变，然后返回改变后的数组，不改变原数组形状
resize是将数组转化成指定的形状，改变原数组形状
a1=np.random.randint(0,10,size=(3,5))
a2=a1.reshape((5,3))
print("a2:\n",a2)
print("a1:\n",a1)
a1.resize((5,3))
print("a1:\n",a1)输出：
a2:
[[4 4 9]
[2 5 1]
[9 7 8]
[9 7 0]
[8 0 5]]
a1:
[[4 4 9 2 5]
[1 9 7 8 9]
[7 0 8 0 5]]
a1:
[[4 4 9]
[2 5 1]
[9 7 8]
[9 7 0]
[8 0 5]]
2.展平：将多维数组转换为一维数组
flatten 和 ravel都不会改变原数组形状，但是还是不同
flatten将修改后的数组拷贝回去，深拷贝，改变拷贝的数组元素不改变原数组元素
ravel只是将视图引用回去，是一种浅拷贝，修改数组元素会改变原数组元素
a3=np.random.randint(0,10,size=(3,4))
a4=a3.flatten()
a4[1]=15
print("a4:\n",a4)
print("a3:\n",a3)
a5=a3.ravel()
a5[1]=15
print("a5:\n",a5)
print("a3:\n",a3)输出：
a4:
[ 6 15 8 7 8 8 7 5 7 0 3 6]
a3:
[[6 6 8 7]
[8 8 7 5]
[7 0 3 6]]
a5:
[ 6 15 8 7 8 8 7 5 7 0 3 6]
a3:
[[ 6 15 8 7]
[ 8 8 7 5]
[ 7 0 3 6]]
3.两种转置
transpose函数返回的是一个view，所以对返回值进行修改会影响到原数组
矩阵相乘用dot
t1=np.random.randint(0,10,size=(3,4))
print("t1:\n",t1)
print(t1.T)
#矩阵相乘
print("t1*t1.T:\n",t1.dot(t1.T))
t2=t1.transpose()
t2[1,2]=15
print(t2)
print(t1)输出：
t1:
[[6 9 9 3]
[0 2 5 9]
[6 7 7 0]]
t1的转置:
[[6 0 6]
[9 2 7]
[9 5 7]
[3 9 0]]
t1*t1.T:
[[207 90 162]
[ 90 110 49]
[162 49 134]]
t2:
[[ 6 0 6]
[ 9 2 15]
[ 9 5 7]
[ 3 9 0]]
t1:
[[ 6 9 9 3]
[ 0 2 5 9]
[ 6 15 7 0]]
4.数组的叠加
方法一：vstack表示垂直方向上叠加（列数必须一致），hstack表示水平方向上叠加（行数必须一致）
方法二：concatenate通过axis控制是垂直方向叠加（axis=0）还是水平方向叠加（axis=1），运用这个函数时注意要两个参与运算的数组要用 [] 括起来
垂直方向叠加：
vstack1=np.random.randint(0,10,size=(3,4))
print("vstack1:\n",vstack1)
vstack2=np.random.randint(0,10,size=(2,4))
print("vstack2:\n",vstack2)
vstack3=np.vstack([vstack1,vstack2])#注意要两个参与运算的数组要用[]括起来
print("vstack3:\n",vstack3)
vstack4=np.concatenate([vstack1,vstack2],axis=0)
print("vstack4:\n",vstack4)输出：
vstack1:
[[8 8 2 6]
[4 7 4 6]
[8 6 5 9]]
vstack2:
[[2 5 6 6]
[5 2 2 2]]
vstack3:
[[8 8 2 6]
[4 7 4 6]
[8 6 5 9]
[2 5 6 6]
[5 2 2 2]]
vstack4:
[[8 8 2 6]
[4 7 4 6]
[8 6 5 9]
[2 5 6 6]
[5 2 2 2]]
水平方向叠加：
hstack1=np.random.randint(0,10,size=(2,3))
print("hstack1:\n",hstack1)
hstack2=np.random.randint(0,10,size=(2,4))
print("hstack2:\n",hstack2)
hstack3=np.hstack([hstack1,hstack2])#注意要两个参与运算的数组要用[]括起来
print("hstack3:\n",hstack3)
hstack4=np.concatenate([hstack1,hstack2],axis=1)
print("hhtack4:\n",hstack4)输出：
hstack1:
[[2 9 8]
[0 9 6]]
hstack2:
[[4 8 6 5]
[8 6 3 1]]
hstack3:
[[2 9 8 4 8 6 5]
[0 9 6 8 6 3 1]]
hhtack4:
[[2 9 8 4 8 6 5]
[0 9 6 8 6 3 1]]
5.数组的切割
按列切分（hsplit）、按行切分(vsplit)，均不改变原数组形状
切分（split）:通过控制axis的值决定是按行（axis=0）还是按列切分（axis=1）
如果只有一个参数n，则表示切割成n份，如果有多个参数（这n个参数要用括号括起来），则表示在每个参数前切割一次。
按列切分：
hs1=np.random.randint(0,10,size=(3,4))
print("hs1:\n",hs1)
#不改变原数组形状
print("按列切割为两份：\n",np.hsplit(hs1,2))#按列切分为2份
print("hs1:\n",hs1)
#按列切分为多个数
print("在第一列、第二列前分别切分:\n",np.hsplit(hs1,(1,2)))#在第一列前、第二列前分别切分一次
#均分为4份
print(np.split(hs1,4,axis=1))
#在第一列、第二列前分别切分一次
print(np.split(hs1,(1,2),axis=1))
输出：
hs1:
[[4 8 2 7]
[5 2 4 8]
[3 2 8 9]]
按列切割为两份：
[array([[4, 8],
[5, 2],
[3, 2]]), array([[2, 7],
[4, 8],
[8, 9]])]
hs1:
[[4 8 2 7]
[5 2 4 8]
[3 2 8 9]]
在第一列、第二列前分别切分:
[array([[4],
[5],
[3]]), array([[8],
[2],
[2]]), array([[2, 7],
[4, 8],
[8, 9]])]
均分为4份:
[array([[4],
[5],
[3]]), array([[8],
[2],
[2]]), array([[2],
[4],
[8]]), array([[7],
[8],
[9]])]
在第一列、第二列前切分:
[array([[4],
[5],
[3]]), array([[8],
[2],
[2]]), array([[2, 7],
[4, 8],
[8, 9]])]
按行切分：
vs1=np.random.randint(0,10,size=(4,3))
print("vs1:\n",vs1)
print("按行切分为两份:\n",np.vsplit(vs1,2))
print("在第一行、第二行前切分:\n",np.vsplit(vs1,(1,2)))
#切分为4份
print("均分为4份:\n",np.split(vs1,4,axis=0))
#在第一行、第二行前分别切分一次
print("在第一行、第二行前切分:\n",np.split(vs1,(1,2),axis=0))输出：
vs1:
[[6 0 7]
[4 2 8]
[4 3 4]
[0 0 9]]
按行切分为两份:
[array([[6, 0, 7],
[4, 2, 8]]), array([[4, 3, 4],
[0, 0, 9]])]
在第一行、第二行前切分:
[array([[6, 0, 7]]), array([[4, 2, 8]]), array([[4, 3, 4],
[0, 0, 9]])]
均分为4份:
[array([[6, 0, 7]]), array([[4, 2, 8]]), array([[4, 3, 4]]), array([[0, 0, 9]])]
在第一行、第二行前切分:
[array([[6, 0, 7]]), array([[4, 2, 8]]), array([[4, 3, 4],
[0, 0, 9]])]
七.拷贝
1.不拷贝
2.浅拷贝
3.深拷贝
1.不拷贝：简单的复制操作，不进行拷贝
a=np.arange(0,10)
b=a
print(b is a)输出：
True
2.浅拷贝（或者叫视图（View））：即两个变量所指向的内存空间是一致的，改变一个变量其中的值，另外一个也会变
a=np.arange(0,5)
print("a:\n",a)
b=a.view()
#判断a、b是否相等
print("b=a:",b is a)
#修改b的值，a的值也会变
b[1]=8
print("a:",a)输出：
a:
[0 1 2 3 4]
b=a: False
a: [0 8 2 3 4]
3.深拷贝：将数据复制一份到另外一个内存空间去，这样形成两个完全不同的变量
a=np.arange(5)
print("a:\n",a)
b=a.copy()
print("b=a:",b is a)
b[1]=9
print("a:",a,"b:",b)输出：
a:
[0 1 2 3 4]
b=a: False
a: [0 1 2 3 4] b: [0 9 2 3 4]
八.文件存储相关的操作
1.保存文件：savetxt
2.读取文件：loadtxt
1.保存文件
savetxt(frame,array,fmt,delimiter,header,footer,comments)
frame:要存为的文件名（可以用绝对地址），array:要存入的数组，fmt:写入文件的数据格式，
delimiter:分隔字符串，默认是空格，header（可选）:添加的表头，footer（可选）:写在文件最
末尾的字符串，comments:添加在header之前的字符串，encoding:编码格式
注意：header、footer的字符串中的标点符号也要用英文的
scores=np.random.randint(0,100,size=(10,2))
np.savetxt("scores.csv",scores,fmt="%.2f",delimiter=",",header="语文,英语",comments="")
2.读取文件
np.loadtxt(frame,dtype,delimiter,skiprows,usecols,unpack)
frame:要读取的文件名，dtype:数据类型（可选），delimiter:分隔字符串，默认是空格,skiprows
跳过前n行，usecols：读取指定列，用元组形式表示,unpack:如果为True，则读取出来的数组是转
置后的
b = np.loadtxt("scores.csv",dtype="i1",delimiter=",",skiprows=1)
print(b)
九.两个特殊值和处理缺失值
1.NAN和INF
2.处理缺失值
1.NAN和INF
NAN：Not A Number，不是一个数字，但是是浮点型的，且NAN !=NAN，NAN与任何值运算结果都是NAN
INF：Infinity，代表正无穷大，也是浮点型
2.处理缺失值
（1）删除缺失值
a=np.arange(0,12).reshape((3,4))
a=a.astype("float")#因为NAN 是float型，所以要将数组类型改为float
a[1,2]=np.NAN
print("a:\n",a)
#删除值
#删除后会变成一维数组，但不改变原数组
print("删除值后:\n",a[~np.isnan(a)])
print("a:\n",a)
#删除行
line=np.where(np.isnan(a))[0]#找出所有含NAN的行，取第一行
print("删除行后:\n",np.delete(a,line,axis=0))#按行删掉，axis=0表示按行输出：
a:
[[ 0. 1. 2. 3.]
[ 4. 5. nan 7.]
[ 8. 9. 10. 11.]]
删除值后:
[ 0. 1. 2. 3. 4. 5. 7. 8. 9. 10. 11.]
a:
[[ 0. 1. 2. 3.]
[ 4. 5. nan 7.]
[ 8. 9. 10. 11.]]
删除行后:
[[ 0. 1. 2. 3.]
[ 8. 9. 10. 11.]]
（2）替换值
与Python列表相似
十.axis的理解
n维数组就有n个[]，一般来说，最外面的括号axis=0，然后括号依次往内，axis就依次加1
如下：
但delete是个例外
delete的axis=0表示行
十一.random模块
1.随机数种子seed
np.random.seed(1)#设置随机数种子
a=np.random.random()
print(a)输出：
0.417022004702574
2.random.rand()：
生成一个[0,1)之间的数组，形状由参数指定。如果没有指定，则返回一个随机值
print(np.random.rand())
print(np.random.rand(2,5))输出：
0.6199065909147441
[[0.27723228 0.2796812 0.8439842 0.36089565 0.76347647]
[0.86237465 0.9138966 0.43732757 0.09929137 0.76975213]]
3.np.random.randn(n,m):
生成n行m列的数组，数组的值为均值为0，标准差为1的标准正态分布的数
a=np.random.randn(2,3)
print(a)输出：
[[ 0.44784896 0.41497648 -1.33217972]
[ 1.47191205 -0.23822925 0.1336013 ]]
4.random.randint()
生成指定范围内的随机数，并通过size控制数组形状
a=np.random.randint(0,9,size=(3,3))
print(a)
输出：
[[0 3 1]
[5 5 4]
[6 4 8]]
5.random.choice
从一个数组中随机采样，也可以从指定区间采样
注意：要求被采取的数组必须是一维数组，所以要先将多维数组扁平化
a=np.random.randint(0,9,size=(3,3))
print(a)
#直接采取三个数
print(np.random.choice(a.flatten(),3))
#随机采取数，组成新的三行四列数组
print(np.random.choice(a.flatten(),size=(3,4)))
#从指定的值[0,20)中随机抽取5个数
print(np.random.choice(20,5))输出：
a:
[[5 7 8]
[2 5 8]
[1 5 8]]
随机抽取的三个数：
[5 1 5]
新组成的数组：
[[5 8 5 5]
[5 2 5 2]
[8 5 2 8]]
随机抽取的指定范围内的5个数组成的数组：
[15 6 7 13 16]
6.random.shuffle
直接打乱原数组顺序无返回值，直接打乱原数组顺序
a=np.arange(10)
print(a)
np.random.shuffle(a)
print(a)
输出：
[0 1 2 3 4 5 6 7 8 9]
[1 5 2 8 3 9 7 4 6 0]
十二.常用函数
1.单个值运算
| 函数 | 描述 |
| np.abs(x) | x的绝对值 |
| np.sqrt(x) | 对x开方 |
| np.square(x) | x的平方 |
| np.exp(x) | 计算指数e^x |
|
np.log(x)、np.log10(x)、 np.log2(x)、np.log1p(x) |
以e、10、2、(1+x)为底，x的对数 |
| np.sign |
将数组中的值标签化(统一化)，大于0的变为1， 等于0的变为0，小于0的变为-1 |
| np.ceil | 向着无穷大的方向取整，6.1变为7，-6.1变为-6 |
| np.floor | 向着负无穷大取整，6.1变为6，-6.1变为-7 |
| np.rint，np.round | 四舍五入 |
| np.modf |
将整数和小数分开形成两个数组 要求：传入的必须是数组， 这里的数组元素类型都是float型 |
| np.isnan,np.isinf |
判断是否为NAN、INF |
|
np.cos,no.cosh,np.sin,np.sinh np.tan,np.tanh |
三角函数 |
| np.arccos,np.arcsin,np.arctan |
反三角函数 |
2.两个值运算
| 函数 | 描述 |
| np.add | 加法 |
| np.subtract | 减法 |
| np.negative | 取负数，如：6变为-6 |
| np.multiply | 乘法 |
| np.divide | 除法，相当于/，如：3/2=1 |
| np.floor_divide | 地板除 |
| np.mod | 取余数，% |
3.数组相关的运算
| 函数 | 描述 |
| np.sum |
计算元素的和 可以通过控制axis指定轴 |
| np.prod | 计算元素的积 |
| np.mean | 均值 |
| np.std | 标准差 |
| np.var | 方差 |
| np.min,np.max | 找到最小值、最大值 |
| np.argmin，np.argmax | 最小值的索引，最大值的索引 |
| np.median | 元素中位数 |
注意：np.median会先将数组排序，在找中位数
4.排序
| 函数 | 描述 |
| np.sort |
排序，默认是使用最后一个轴排序 可以通过控制axis改变指定的轴 默认是升序，要降序，则在数组前加负号- |
| np.argsort | 返回排序后的下标值 |
5.其他常用函数
| 函数 | 描述 |
| np.apply_along_axis | 沿某个轴执行指定的函数 |
| np.linspace(n,m,q) | 将区间(n,m)均分为q份 |
| np.unique(l) |
过滤掉数组l中的重复元素，只保留一次 使数组有唯一性 |
部分代码：
部分内容来源于网络，仅供交流学习。如有侵权，请联系删除