numpy的介绍
numpy是一个python开源的科学计算库
使用numpy可以方便的使用数组、矩阵（列表套列表）进行计算
包括线性代数、傅里叶变换，随机数生成等大量函数
python源代码和numpy和的区别
import numpy as np
def func(n):
a = np.arange(n) **2
b = np.arange(n) **3
return a+b
print(func(10))
# python原生代码
def func(n):
a = [i**2 for i in range(n)]
b = [i**3 for i in range(n)]
num_ab = []
for i in range(n):
num_ab.append(a[i]+b[i])
return num_ab
print(func(10)
创建数组和参数介绍
numpy.array(object, dtype = None, copy = True, order = None,subok=False,ndmin = 0)
object 表示一个数组序列。 （可以是数组或元组）
dtype 可选参数，通过它可以更改数组的数据类型 （dtype='int'）
copy 可选参数，当数据源是ndarray时表示数组能否被复制，默认是 True。
# 复制之后 重新申请了一份内存地址 修改b的内存地址 并不会影响a的内存地址
order 可选参数，以哪种内存布局创建数组，有3个可选值，分别是 C(行序列)/F(列序列)/A(默认)。
ndmin 可选参数，用于指定数组的维度。
subok 可选参数，类型为bool值，默认False。为True，使用object的内部数据类型;False:使用object数组的数据类型。
# 数组介绍
一维数组 [1,2,3,2,3]
二维数组 [[1,5,6,8,],[45,485,4,85]]
三维数组 [1,23,[1,2[,4,5]],[1,12[4,4,5]]]
numpy可以使用生成器和类型转换成数组
import numpy as np
res = np.array([i//2!=0 for i in range(10)])
print(res)
res.ndim # 可以查看是几维的
# 默认转换 强制转换 dtype = n
# 列表中元素不相同
res = np.array([1,2,2,3,'5'])
print(res) # ['1','2','2','3','5'] 全部转为字符串
# 整形
res = array.([i for i in range(10)])
print(res) # [0,1,2,3,4,5,6,7,8,9]
# 浮点型 数组里面有浮点型 则全部转为浮点型
# 如果强制转换成整形 则没有四舍五入 直接取整数
res = array.([1,1.2,3,3.14,])
# 二维数组 可以是数组 可以是元组
res = ([[1,2,3,3],('a','b','c','d')])
print(res) [['1','2','3'],['a','b','c','d']]
# 如果嵌套数量不一样的情况下 会变成一维
res = ([[1,2,3,3],('a','b','c','d')])
print(res) [(['1','2','3']),(['a','b','c','d'])]
numpy.arange生成区间数组
根据start和stop指定的范围和step设定的步长 生成一个ndarray
import numpy
res = numpu.arange(start,stop,step,dtype)
# 参数介绍：
start 起始值 默认为0（包含起始值） 顾头不顾尾
stop 结束值 自定义（不包含介绍值）
step 步长
dtype 返回ndarray数据类型 如果没有提供 则默认使用传入的数据类型
res = np.arange(20,step=3) # 如果只传两个 第二个需要指定参数
linspace() 创建等差数列
'''
返回在间隔[开始，停止]上计算的num个均匀间隔的样本。数组是一个等差数列构成np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)参数说明
'''
参数说明：
start 必填项，序列的起始值，
stop 必填项，序列的终止值，如果endpoint为true，该值包含于数列中
num 要生成的等步长的样本数量，默认为50
endpoint 该值为 true 时，数列中包含stop值，反之不包含，默认是True.
retstep 如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype ndarray 的数据类型
# 1 到 10 之间 num就是分多少个值
res = np.linspace(1,10,10) # 顾头也顾尾
res
# array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
res = np.linspace(1,10,9) # 顾头也顾尾
res
# array([ 1. , 2.125, 3.25 , 4.375, 5.5 , 6.625, 7.75 , 8.875,10. ])
# 如果不包含终止值 endpoint=False
res = np.linspace(3,10,9,endpoint=False)
# 显示步长 retstep=True
res = np.linspace(3,10,9,endpoint=False,retstep=True)
logspace等比数列
'''
返回在间隔[开始，停止]上计算的num个均匀间隔的样本。数组是一个等比数列构成np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
'''
参数介绍
start 必填项，序列的起始值，
stop 必填项，序列的终止值，如果endpoint为true，该值包含于数列中
num 要生成的等步长的样本数量，默认为50
endpoint 该值为 true 时，数列中包含stop值，反之不包含，默认是True.
base 对数 log 的底数 base=次方
dtype ndarray 的数据类型
res = np.logspace(1,10,10,base=2)
res
# 一到十 分成十份 等到的数字*2的平方
# 练习题：
"""
一个穷人到富人那里去借钱，原以为富人不愿意，哪知富人一口答应了下来，但提出了如下条件:
1、在30天中，富人第一天借给穷人1万元，第二天借给2万，以后每天所借的钱数都比上一天的多一万;
2、但 借钱第一天，穷人还1分钱，第二天还2分钱，以后每天所还的钱数都是上一天的两倍。
3、思考下，如何用我们刚才学到的方法计算出结果，确定是否向富人借钱?
"""
全0数列 numpy.zeros 和全1数列numpy.ones
"""
创建指定大小的数组，数组元素以0来填充numpy.zeros(shape, dtype = float, order = 'C')
参数说明
"""
shape 数组形状
dtype 数据类型，可选
NumPy数组属性
NumPy 的数组中比较重要 ndarray 对象属性有:
ndarray.ndim 秩，即轴的数量或维度的数量（几维度）
ndarray.shape 数组的维度，对于矩阵，n行m列（）
ndarray.size 数组元素的总个数，相当于.shape 中 n'm 的值
ndarray.dtype ndarray对象的元素类型
ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位
1、 ndarray.shape 计算维度 列与行
返回一个包含数组维度的元组，对于矩阵，n行m列，它也可以用于调整数组维度
a= np.array([1,2,3,4,5,6])
print('一维数组:',a.shape)
# 一维数组: (6,) 打印的是数组内的元素
b= np.array([[1,2,3],[4,5,6]])
print('二维数组:',b.shape)
# 二维数组: (2, 3) 二维数组 里面有 2行3列
c = np.array([
[[1,2,3],[4,5,6]],
[[11,22,33],[44,55,66]]
])
print('三维数组',c.shape) # 三维数组 (2, 2, 3) 两个大列里面有两个小列 和三行
2. 调整维度 reshape
返回调整维度之后的副本 而不改变 ndarray
res = np.arange(0,20).reshape((4,5)) 只能整除 变成二维
array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14],
[15, 16, 17, 18, 19]])
# 实例：
res = np.array([1,2,3,4,5,6])
print('a的形状',a.shape)
print('a',a)
# 使用数组A 创建一个数组b 并且修改维度
b = a.reshape((2,3))
print('b的形状',b.shape)
print('b',b)
a的形状 (6,) 一维元素个数
a [1 2 3 4 5 6]
b的形状 (2, 3) 二维的列与行
b [[1 2 3]
[4 5 6]]
# 错误示范
res = np.arange(0,20).reshape((4,6))
# resize 修改维度的时候不够 则用0来填充 需要加上参数 refcheck=False
a=np. array([[0,1],[2,3]])
#a为原数组创建2行3列的新数组
b_2_3=np.resize(a,(3,4))
array([[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3]])
a.resize((3,4),refcheck=False)
array([[0, 1, 2, 3],
[0, 0, 0, 0],
[0, 0, 0, 0]])
# numpy数据类型转换，调用astype返回数据类型修改后的数据，但是源数据的类型不会变
# 查看数据类型大小 字节为单位 ndarray.itemsize
res = np.array([11,22,33,44,55])
print(res.itemsize) # 4 元素字节的大小 而不是全部元素
数组创建图片展示
数组属性展示图
切片和索引
ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中list 的切片操作一样。
ndarray 数组可以基于0-n的下标进行索引
注意：区别在于数组切片是原始数组视图(这就意味着，如果做任何修改，原始都会跟着更改)。这也意味着，如果不想更改原始数组，我们需要进行显式的复制，从而得到它的副本(.copy())。 copy重新申请一块内存空间
索引取值 （一维取值）
import numpy as np
res = np.arange(10) # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
res1 = res[2:7:2] # 从索引位置2开始 到7的位置 步长为2
res1[2] # 6
res1[-1] # 负数就是从后往前取值
"""
冒号的解释：
如 [2]，将返回与该索引相对应的单个元素。
如果为[2:]，表示从该索引开始以后的所有项都将被提取。
如果使用了两个参数，如[2:7]，那么则提取两个索引(不包括停止索引)之间的项。
如果使用了两个参数，如 [:7] 默认从0开始 到索引位置
res1 = res[::2] # 从索引位置开始 到结束的位置 步长为2
"""
二维数组取值
import numpy as np
res = np.arange(1,21).reshape((4,5))
res
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])
res1 = res[3][4]
res1 # 20
res1 = res[:2][1]
red # array([ 6, 7, 8, 9, 10])
# 进行列取值
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])
res2 = res[...,2] # ... 代表所有列
res2 # array([ 3, 8, 13, 18])
res = [...,1:]
array([[ 3, 4, 5],
[ 8, 9, 10],
[13, 14, 15],
[18, 19, 20]])
# 返回2行3列的数据 两种方式
res = [1,2] # 去出第一列的第 三个
res1 = res[1][2] # 虽然值相同 但是取值方式不一样
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])
res4 = res[[1,2,3],[1,2,2]]
res4 # array([ 7, 13, 18])
# 取出来的是一个一维的
"""
解释：第一个数组取的是行 第二个数组取的是列
1行 1列
2行 2列
3行 2列
"""
# 去出来之后 可以转换成二维的
res = np.arange(1,21).reshape((4,5))
r = np. array([[0,0],[3,3]]).reshape(4)
l = np. array([[0,2],[0,2]]).reshape (4)
s = res[r, l].reshape((2,2))
s
# 行跟列也可以切片
res = np.arange(1,21).reshape((4,5))
array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10],
[11, 12, 13, 14, 15],
[16, 17, 18, 19, 20]])
#行取得2行和3行，列取得2列和3列
b= res[1:3,1:3] # res[[l,2], [l,2]]
# 1:3 == [1,2]
b
# 练习
res = np.zeros(8*8,dtype='int').reshape((8,8))
array([[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0]])
res[0::2,::2] = 1 # 第一个代表的是行 第二个代表的是列
res[1::2,1::2] = 1
res
# 结果
array([[0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0, 1, 0]])
2.布尔数组索引和 and和or
当输出的结果需要经过布尔运算(如比较运算)时，此时会使用到另一种高级索引方式，即布尔数组索引。下面示例返回数组中大于6的的所有元素:
布尔索引 实现的是通过一维数组中的每个元素的布尔型数值对一个与一维数组有着同样行数或列数的矩阵进行符合匹配。这
种作用，其实是把一维数组中布尔值为True的相应行或列给抽取了出来
注意：一维数组的必须和想要切片的维度和轴必须一至
##返回所有大于6的数字组成的数组
x=np.array([[0,1,2],[3,4,5],[6,7,8],[ 9,10, 11]])
x.ndim # 二维数组也是
x[x>6] # array([ 7, 8, 9, 10, 11])
# 练习题·
1.提取出数组中所有奇数
2.修改奇数值修改为-1
x=np.array([[0,1,2],[3,4,5],[6,7,8],[ 9,10, 11]]).reshape((3,4))
x[0::1,0::2] = -1
x
# 筛选出指定区间内数据
&和
|或
x=np.array([[0,1,2],[3,4,5],[6,7,8],[9, 10,11]])#以上x中大于4并且小于9的数据x[(x>4) & (x<9)]
x=np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
#以上x中小于4或者大于9的数据
x[(x<4) | (x>9)]
True和False的形式表示需要和不需要的数据 但是要与数据行或者列对应
a3 = np.arange(12).reshape((3,4))
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
#行变量 存在3个元素
rowl = np.array([False, True, True])
#列变量存在4个元素
columnl = np.array([True, False, True, False])
a3[[False, True, True], [True, False, True, False]]
跟 a3[[1,2],[1,2]] 一样的
广播机制
"""
广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行。
如果两个数组a和b形状相同，即满足 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)
"""
但如果两个形状不同的数组呢?它们之间就不能做算术运算了吗?当然不是!为了保持数组形状相同
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补齐。
输出数组的形状是输入数组形状的各个维度上的最大值。(# 以最大维度为标准)
(可以相加的前提条件 要么维度的值相同 要么是值为1才行)
当输入数组的某个维度的长度为1时，沿着此维度运算时都用此维度上的第一组值。
如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为1时，这个数组能够用来计算，否则出错。
如下：
两个数组右对齐以后，对应维度里的数值要么相等，要么为1，要么缺失、取大值。
除此之外就会报错。像下面的两个数组就不能做运算。
数组a大小为(2，1，3)
数组b大小为(4，2)首先右对齐:
2 1 3
4 2
2跟3不匹配，此时就不能做运算 报错
# 对于广播规则另一种简单理解
将两个数组的维度大小右对齐，然后比较对应维度上的数值
如果数值相等或其中有一个为1或者为空，则能进行广播运算
输出的维度大小为取数值大的数值。否则不能进行数组运算。
"""
索引和切片的总结
函数统计
NumPy能方便的求出统计出常见的描述性统计量 （内置函数）
求平均值
import numpy as np
res = np.arange(0,20).reshape((4,5))
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
print(res)
res.mean() # 9.5
mean(axis=0)
# 0 代表的是列除array([ 7.5, 8.5, 9.5, 10.5, 11.5])
# 1 代表的是行除 array([ 2., 7., 12., 17.])
中位数 np.median
"""
又称中点数，中值
是按顺序排列的一组数据中居于中间位置的数，代表一个样本、种群或概率分布中的一个数值
平均数:是一个"虚拟"的数，是通过计算得到的，它不是数据中的原始数据.中位数:是一个不完全"虚拟"的数。
平均数:反映了一组数据的平均大小，常用来一代表数据的总体"平均水平".中位数:像一条分界线，将数据分成前半部分和后半部分，因此用来代表一组数据的"中等水平"
如果是奇数 则会取中间值
如果是偶数 则是中间的两个值相加再除以2 得到的就是中间值
"""
# 奇数
res = np.array([1,2,3,4,5])
np.median(res) # 3.0
# 偶数
res = np.array([1,2,3,4,5,6])
np.median(res) # 3.5
标准差 np.std()
简单来说，标准差是一组数据平均值分散程度的一种度量，
一个较大的标准差，代表大部分数值和其平均值之间差异较大;
一个较小的标准差，代表这些数值较接近平均值。
res = np.array([11,33,55,22,54])
np.std(res) # 17.378147196982766
方差ndarray.var()
衡量随机变量或一组数据时离散程度的度量
a= np.array([95,85,75, 65,55, 45])
b= np.array([73,72,71,69,68,67])
print( A组的方差为:’,a.var())
print('B组的方准差为:’,b.var())
求最大值、最小值、求和
# 最大值 max()
m1 = np.zeros(8*8,dtype='int').reshape((8,8))
print (m1)
print(m1 .max())
print('axis=0,从上往下査找:',m1.max(axis=0))
print('axis=1,从左往右査找:',m1.max(axis=1))
# 最小值 min()
print(m1)
print (ml.min())
print('axis=0,从上往下査找:’,m1.min(axis=0))
print('axis=1,从左往右査找：’,m1.min(axis=1))
# 求和 sum()
print (m1)
print(ml. sum())
print('axis=0,从上往下査找:’,ml.sum(axis=0))
print('axis=1,从左往右査找：’,m1.sum(axis=1))
数据类型
Numpy文件操作
操作文件 loadtxt
loadtxt读取txt文本、、csv文件
import numpy as np
res = np.loadtxt (fname, dtype=<type 'float'>, comments='#’, delimiter=None, converters=None, skiprows=0, usecounpack=False, ndmin=0,encoding='bytes’)
# 参数介绍
fname:指定文件名称或字符串。支持压缩文件，包括gz、bz格式。 (文件路径)
dtype:数据类型 默认float。 (可以根据文件数据类型来转数据类型)
comments:字符串或字符串组成的列表。表示注释字符集开始的标志，默认为#。 （注释的内容不会被读取）
delimiter:字符串。分隔符。 （读出来的数据可以自定义分割符）
converters:字典。将特定列的数据转换为字典中对应的函数的浮点型数据。例如将空值转换为0，默认为空。
# 取数据的时候 比如成绩 有的人没考 就是空 但是类型转换的时候就会报错 使用使用converters来设置一个默认值
def func(cuoser):
try:
return int(cuoser)
except:
return 0
res = np.loadtxt ('a.txt', dtype=object,skiprows=1,usecols=(0,1,2,3),encoding='utf-8',converters={key:func}) # 函数名不用加括号 等到的就是函数的返回结果
skiprows:跳过特定行数据。例如跳过前1行(可能是标题或注释)。默认为0。（读取文件的时候 从第几行开始读 前面的跳过去）
usecols:元组。用来指定要读取数据的列，第一列为0。例如(1，3，5)，默认为空。 （只读取列的内容）
unpack:布尔型。指定是否转置数组，如果为真则转置，默认为False。 （可以判断性别是男或者是女 返回布尔值显示）
ndmin:整数型。指定返回的数组至少包含特定维度的数组。值域为0、1、2，默认为0。 （数据是几维度）
encoding:编码,确认文件是gbk还是utf-8 格式
import numpy as np
data = np.dtype([('name','U10'),('age','i1'),('gender','U1'),('phone','U1')]) # 自定义数据类型
# usecols=(0,1,2,3) 要跟数据类型相匹配 比如那个字段名 下面就是那一列
res = np.loadtxt ('a.txt', dtype=data,usecols=(0,1,2,3),delimiter=" ",skiprows=1,encoding='utf-8')
res['name'] 可以直接取出字段名
res['age']
"""
# res = np.loadtxt ('a.txt', dtype=object,skiprows=1,usecols=(0,1,2,3),encoding='utf-8')
# res
# 如果不指定类型 就是所有
"""
随机模块
#返回[0,1)之间的整数，
所以只有0np.random.randint(2,size=5)
array([1,1,0,1,0])
#返回1个[1,5)之间的随机整数
np.random.randint(1.5)
#返回1个[1,5)时间的随机整数
np.random.randint(1.5)
array([[ 3,-1],[2,-2]])
随机种子np.random.seed()
使用相同的seed()值，则每次生成的随机数都相同,使得随机数可以预测
但是，只在调用的时候seed()一下并不能使生成的随机数相同，需要每次调用都seed()一下，表示种子相同，从而生成的随机数
相同。
np.random. seed(1)
L1 = np.random.randn(3, 3)
L2 = np.random.randn(3,3)
print(L1)
print(”-”*10)
print(2)
正态分布 numpy.random.nqrmal
numpy.random.normal(loc=0.0, scale=1.0, size=None)
作用:返回一个由size指定形状的数组，数组中的值服从 p=loc,o=scale 的正态分布。参数:
loc:float型或者float型的类数组对象，指定均值
scale:float型或者float型的类数组对象，指定标准差可
size:int型或者int型的元组，指定了数组的形状。如果不提供size，且loc和scale为标量(不是类数组对象)，则返回一个从该分布的随机数。
数组的其他函数
numpy.delect 删除数据
import numpy as np
a = np.arange(12).reshape (3, 4)
#不提供axis参数情况
res = np. delete(a, 5)
# 删除多个
# 注意不能使用切片的形式
print (np. delete(a, [1, 2, 3]))
res
# 删除的安装索引删除
#删除第二列 如果加了 axis参数 按索引删除列的数据
print(np.delete(a,1,axis =1))
numpy.argwhere() 取出元素的索引
该函数返回数组中非0元素的索引，若是多维数组则返回行、列索引组成的索引坐标。
x= np.arange(6).reshape(2,3)
print(x)
#返回所有大于1的元素索引 如果是取值 可以用[]
y=np.argwhere(x>1)
print(y,y.shape)
numpy.unique() 去重
用于删除数组中重复的元素，其语法格式如下:
numpy.unique(arr, return index, return inverse, return counts)
参数说明：
"""
arr:输入数组，若是多维数组则以一维数组形式展开;
return index:如果为 True，则返回新数组元素在原数组中的位置(索引)
return inverse:如果为 True，则返回原数组元素在新数组中的位置(索引);
return counts:如果为 True，则返回去重后的数组元素在原数组中出现的次数。
"""
#数组去重后的索引数组
a = np.array([1,2,4,2,4,45,2,42,4,2,32,3,1])
u,indices = np.unique(a, return_index = True)#打印去重后数组的索引print (u)
print(u) # 去重后的新数组
print(indices) # 去重之后新数组的索引位置
# [ 1 2 3 4 32 42 45]
# [ 0 1 11 2 10 7 5]
# 返回去重元素的重复数量
uc,indices =np.umique(a,return counts = True)
print(uc)#元素出现次数:print (indices)
#返回去重元素的重复数量
uc, indices = np.unique(a,return counts = True)
print(uc)
#元素出现次数:
print (indices)np.argmax(indices)
numpy.sort() 排序
对输入数组执行排序，并返回一个数组副本。numpy.sort(a, axis, kind, order)
# 参数说明:
"""
a:要排序的数组;
axis:沿着指定轴进行排序，如果没有指定 axis，默认在最后一个轴上排序，若 axis=0 表示按列排序，axis=1 表示按行排序;
kind:默认为 quicksort(快速排序);
order:若数组设置了字段，则 order 表示要排序的字段。
"""
#设置在sort函数中排序字段
dt = np. dtype([('name','S10'),('age',int)])
a= np.array([("raju",21),("anil",25),("ravi”,17),("amar",27)], dtype = dt)
#再次打印a数组
print(a)
#按name字段排序
print(np.sort(a,order='name'))
# numpy.argsort()
argsort()沿着指定的轴，对输入数组的元素值进行排序，并返回排序后的元素索引数组。示例如下
a=np.array([90,29,89,12])
print("原数组:”,a)
sort_ind = np.argsort(a)
print("打印排序元素索引值:”,sort_ind)
#使用索引数组对原数组排序
sort_a=alsort_ind
print("打印排序数组")
for i in sort_ind:
print(a[i],end ="")
265
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
