NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库
安装：
pip3 install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：
一个强大的N维数组对象ndarray 广播功能函数 整合C/C++/Fortran代码的工具 线性代数、傅里叶变换、随机数生成等功能 eye()，函数名，产生m×n的单位矩阵
np.eye(N,M=None,k=0,dtype=<class ‘float’>,order='C) N表示输出的行数；M表示输出的列数，不给默认等于N；K默认等于0，表示主对角线，负数代表低对角，正数代表高对角；dtype表示输出数据的类型；order表示输出的数组的形式是按照C语言的行优先’C’，还是按照Fortran 形式的列优先‘F’存储在内存中import numpy as np
r = np. eye( 4 , dtype= int )
print ( r, type ( r) )
"""
[[1 0 0 0]
[0 1 0 0]
[0 0 1 0]
[0 0 0 1]] <class 'numpy.ndarray'>
"""
N维数组对象ndarray，它是一系列同类型数据的集合，以0为下标开始作为元素的索引
ndarray对象是用于存放同类型元素 的多维数组 ndarray中的每个元素在内存中都有相同存储大小的区域 dtype 数组元素的数据类型，可选ndmin 指定生成数组的最小维度 创建一个ndarray对象（调用Numpy的array函数 ） import numpy as np
a = np. array( [ 1 , 2 , 3 ] )
print ( a)
a = np. array( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
print ( a)
'''
[[1 2]
[3 4]]
'''
a = np. array( [ 1 , 2 , 3 , 4 , 5 ] , ndmin= 2 )
print ( a)
a = np. array( [ 1 , 2 , 3 , 4 , 5 ] , dtype= int )
print ( a)
数组属性
数组的维数成为秩(rank)，即数组维度
每一个线性的数组称为是一个轴（axis）
axis=0，表示沿着第0轴进行操作，对每一列 进行操作 axis=1，表示沿着第1轴进行操作，即对每一行 进行操作 ndarray对象属性（可以更改形状）
属性 说明 ndarray.ndim 秩，即轴的数量或维度的数量 ndarray.shape 数组的维度，对于矩阵，n行m列 ndarray.size 数组元素的总个数，相当于.shpae中n*m的值 ndarray.dtype ndarray对象的元素类型
a = np. array( [ 1 , 2 , 3 ] )
print ( a. ndim)
a = np. array( [ [ 1 , 2 , 3 ] ] )
print ( a. ndim)
a = np. array( [ [ 1. , 2. , 3. ] ] )
print ( a. dtype)
a = np. array( [ [ 1 , 2 , 3 ] ] )
print ( a. dtype)
a = np. array( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
print ( a. size)
a = np. array( [ 1 , 2 , 3 ] )
print ( a. shape)
a = np. array( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
print ( a. shape)
方法 说明 ndarray.arange (24) 创建了一个NumPy数组，该数组包含了从 0 到 23 的整数，总共 24 个元素 ndarray.reshape (2，4，3) reshape方法重新调整数组a的形状为2, 4, 3，将这个数组重新组织成一个三维数组，其中第一维有2个元素，第二维有4个元素，第三维有3个元素
a = np. arange( 24 )
b = a. reshape( 2 , 4 , 3 )
print ( b)
"""
[[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
[[12 13 14]
[15 16 17]
[18 19 20]
[21 22 23]]]
"""
x = np. empty( 5 , dtype= int )
print ( x)
y = np. empty( [ 3 , 2 ] , dtype= int )
print ( y)
x = np. zeros( 5 )
print ( x)
y = np. zeros( ( 5 , ) , dtype= int )
print ( y)
x = np. ones( 5 )
y = np. ones( [ 2 , 2 ] , dtype= int )
print ( x)
print ( y)
numpy.asarray 从已有数组创建数组
np.asarray(x) 函数用于将输入 x 转换为NumPy数组（如果 x 本身已经是一个NumPy数组，则返回其视图或副本，具体取决于是否满足条件以返回视图）。这个函数对于确保数据以NumPy数组的形式进行处理非常有用，尤其是在处理可能来自不同来源（如列表、元组或其他数组库）的数据时。x = [ 1 , 2 , 3 ]
a = np. asarray( x)
print ( a)
x = ( 1 , 2 , 3 )
a = np. asarray( x)
print ( a)
x = [ ( 1 , 2 , 3 ) , ( 4 , 5 , 6 ) ]
a = np. asarray( x)
print ( a)
x = [ 1 , 2 , 3 ]
a = np. asarray( x, dtype= float )
print ( a)
numpy.arange :从数值范围创建数组(左闭右开)x = np. arange( 5 )
print ( x)
x = np. arange( 5 , dtype= float )
print ( x)
x = np. arange( 10 , 20 , 2 )
print ( x)
与python中list的切片操作一样 切片对象可以通过内置的slice 函数 a = np. arange( 10 )
s = slice ( 2 , 7 , 2 )
print ( a[ s] )
a = np. arange( 10 )
b = a[ 2 : 7 : 2 ]
print ( b)
a = np. arange( 10 )
print ( a[ 2 : ] )
print ( a[ 2 : 5 ] )
a = np. array( [ [ 1 , 2 , 3 ] , [ 3 , 4 , 5 ] , [ 4 , 5 , 6 ] ] )
print ( a)
print ( a[ 1 : ] )
a = np. arange( 10 )
b = a[ 5 ]
print ( b)
a = np. array( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] , [ 3 , 4 , 5 ] ] )
print ( a)
print ( "-" * 30 )
print ( a[ . . . , 1 ] )
print ( "-" * 30 )
print ( a[ 1 , . . . ] )
print ( "-" * 30 )
print ( a[ . . . , 1 : ] )
print ( "-" * 30 )
print ( a[ 1 : 3 , 1 : 3 ] )
print ( "-" * 30 )
print ( a[ : , 1 : 3 ] )
"""
[[1 2 3]
[4 5 6]
[3 4 5]]
------------------------------
[2 5 4]
------------------------------
[4 5 6]
------------------------------
[[2 3]
[5 6]
[4 5]]
------------------------------
[[5 6]
[4 5]]
------------------------------
[[2 3]
[5 6]
[4 5]]
"""
是numpy对不同形状（shape）的数组进行数值计算的方式，对数组的算术运算通常在相应元素上进行 如果两个数组a和b形状相同，即满足a.shape == b.shape,那么a*b的结果就是a与b对数组对应位相乘，这要求维数相同，且各维度的长度相同 广播规则
规则1：如果两个数组在维度上不匹配，那么数组的形状会沿着长度为1的维度进行扩展以匹配另一个数组的形状 规则2：如果两个数组在任何维度上的大小不一致，并且二其中一个数组在该维度上的大小为1，则这个数组看起来会被复制扩展到另一个数组相同的大小 规则3：如果在所有维度上大小都不匹配，并且没有任何一个维度等于1，则会引发错误 a = np. array( [ 1 , 2 , 3 , 4 ] )
b = np. array( [ 10 , 20 , 30 , 40 ] )
c = a * b
print ( c)
a = np. array( [ [ 0 , 0 , 0 ] ,
[ 10 , 10 , 10 ] ,
[ 20 , 20 , 20 ] ,
[ 30 , 30 , 30 ] ] )
b = np. array( [ 0 , 1 , 2 ] )
c = a + b
print ( c)
"""
[[ 0 1 2]
[10 11 12]
[20 21 22]
[30 31 32]]
"""
a = np. array( [ [ 0 , 0 , 0 ] ,
[ 10 , 10 , 10 ] ,
[ 20 , 20 , 20 ] ,
[ 30 , 30 , 30 ] ] )
b = np. array( [ [ 0 ] , [ 1 ] , [ 2 ] , [ 3 ] ] )
c = a + b
print ( c)
"""
[[ 0 0 0]
[11 11 11]
[22 22 22]
[33 33 33]]
"""
a = np. array( [ [ 0 , 0 , 0 ] ,
[ 10 , 10 , 10 ] ,
[ 20 , 20 , 20 ] ,
[ 30 , 30 , 30 ] ] )
b = np. array( [ 1 ] )
c = a + b
print ( c)
"""
[[ 1 1 1]
[11 11 11]
[21 21 21]
[31 31 31]]
"""
Numpy中包含了一些韩叔叔用于处理数组，大概分类以下几类： 函数 描述 reshape 不改变数据的条件下修改形状 flat 数组元素迭代器 flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组 ravel 返回展开数组
a = np. arange( 8 )
print ( "原始数组为:" )
print ( a)
b = a. reshape( 4 , 2 )
print ( "修改后的数组为:" )
print ( b)
"""
原始数组为:
[0 1 2 3 4 5 6 7]
修改后的数组为:
[[0 1]
[2 3]
[4 5]
[6 7]]
"""
a = np. arange( 9 ) . reshape( 3 , 3 )
print ( "原始数组" )
for row in a:
print ( row)
print ( "迭代后的数组：" )
for element in a. flat:
print ( element)
"""
原始数组
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0
1
2
3
4
5
6
7
8
"""
a = np. arange( 8 ) . reshape( 2 , 4 )
print ( '原数组:' )
print ( a)
print ( "展开后的数组:" )
print ( a. flatten( ) )
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]
"""
a = np. arange( 8 ) . reshape( 2 , 4 )
print ( '原数组:' )
print ( a)
print ( "展开后的数组:" )
print ( a. ravel( ) )
print ( "以F风格调用ravel函数展开后的数组:" )
print ( a. ravel( order= 'F' ) )
"""
原数组:
[[0 1 2 3]
[4 5 6 7]]
展开后的数组:
[0 1 2 3 4 5 6 7]
以F风格调用raveel函数展开后的数组:
[0 4 1 5 2 6 3 7]
"""
函数 描述 transpose 对换数组的维度 ndarray.T 和self.transpose()相同
a = np. arange( 12 ) . reshape( 3 , 4 )
print ( "原数组：" )
print ( a)
print ( "对换数组：" )
print ( np. transpose( a) ) 两种写法
print ( a. transpose( ) )
"""
原数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
对换数组：
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
"""
a = np. arange( 12 ) . reshape( 3 , 4 )
print ( "原数组：" )
print ( a)
print ( "对换数组：" )
print ( a. T)
"""
原数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
对换数组：
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
"""
函数 描述 concatenate 连接沿着现有轴的数组序列,默认是0轴 stack 沿着新的轴加入一系列数组 hstack 水平堆叠序列中的数组 vstack 竖直堆叠序列中的数组
a = np. array( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
print ( '第一个数组：' )
print ( a)
b = np. array( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
print ( '第二个数组：' )
print ( b)
print ( '沿轴 0 连接两个数组：' )
print ( np. concatenate( ( a, b) ) )
print ( '沿轴 1 连接两个数组：' )
print ( np. concatenate( ( a, b) , axis = 1 ) )
"""
第一个数组：
[[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 ] ] )
print ( '第一个数组：' )
print ( a)
b = np. array( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
print ( '第二个数组：' )
print ( b)
print ( '沿轴 0 堆叠两个数组：' )
c = np. stack( ( a, b) , 0 )
print ( c)
print ( '沿轴 1 堆叠两个数组：' )
c = np. stack( ( a, b) , 1 )
print ( c)
"""
第一个数组：
[[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 ] ] )
print ( '第一个数组：' )
print ( a)
b = np. array( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
print ( '第二个数组：' )
print ( b)
print ( '水平堆叠：' )
c = np. hstack( ( a, b) )
print ( c)
"""
第一个数组：
[[1 2]
[3 4]]
第二个数组：
[[5 6]
[7 8]]
水平堆叠：
[[1 2 5 6]
[3 4 7 8]]
"""
a = np. array( [ [ 1 , 2 ] , [ 3 , 4 ] ] )
print ( '第一个数组：' )
print ( a)
b = np. array( [ [ 5 , 6 ] , [ 7 , 8 ] ] )
print ( '第二个数组：' )
print ( b)
print ( '竖直堆叠：' )
c = np. vstack( ( a, b) )
print ( c)
"""
第一个数组：
[[1 2]
[3 4]]
第二个数组：
[[5 6]
[7 8]]
竖直堆叠：
[[1 2]
[3 4]
[5 6]
[7 8]]
"""
函数 数组及操作 split(数组，[索引1，索引2]) 将一个数组分割为多个子数组(指定索引前面) hsplit 将一个数组水平分割为多个子数组（按列） vsplit 将一个数组垂直分割为多个子数组（按行）
a = np. arange( 9 )
print ( '第一个数组：' )
print ( a)
print ( '将数组分为三个大小相等的子数组：' )
b = np. split( a, 3 )
print ( b)
print ( type ( b[ 1 ] ) )
print ( '将数组在一维数组中表明的位置分割：' )
b = np. split( a, [ 4 , 7 ] )
print ( b)
a = np. arange( 16 ) . reshape( 4 , 4 )
print ( '第一个数组：' )
print ( a)
print ( '默认分割（0轴 :横向分割）：' )
b = np. split( a, 2 )
print ( b)
"""
第一个数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
默认分割（0轴：横向分割）：
[array([[0, 1, 2, 3],[4, 5, 6, 7]]),
array([[ 8, 9, 10, 11],[12, 13, 14, 15]])]
"""
print ( '沿水平方向分割：' )
c = np. split( a, 2 , 1 )
print ( c)
"""
沿水平方向分割：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
"""
a = np. arange( 16 ) . reshape( 4 , 4 )
print ( '沿水平方向分割：' )
d= np. hsplit( a, 2 )
print ( d)
"""
第一个数组：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]
[12 13 14 15]]
沿水平方向分割：
[array([[ 0, 1],
[ 4, 5],
[ 8, 9],
[12, 13]]), array([[ 2, 3],
[ 6, 7],
[10, 11],
[14, 15]])]
"""
harr = np. floor( 10 * np. random. random( ( 2 , 6 ) ) )
print ( '原array：' )
print ( harr)
print ( '拆分后：' )
print ( np. hsplit( harr, 3 ) )
"""
原array：
[[9. 7. 5. 9. 8. 4.]
[8. 6. 1. 1. 2. 5.]]
拆分后：
[array([[9., 7.],[8., 6.]]),
array([[5., 9.],[1., 1.]]),
array([[8., 4.],[2., 5.]])]
"""
a = np. arange( 16 ) . reshape( 4 , 4 )
print ( '第一个数组：' )
print ( a)
print ( '竖直分割：' )
b = np. vsplit( a, 2 )
print ( b)
"""
第一个数组：
[[ 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]])]
"""
函数 元素及描述 resize 返回指定形状的新数组 append 将值添加到数组末尾 insert 沿指定轴将值插入到指定下标之前 delete 删除某个轴的子数组，并返回删除后的新数组 unique 查找数组内的唯一元素（去重）
a = np. array( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
print ( "第一个数组：" )
print ( a)
print ( "第一个数组的形状" )
print ( a. shape)
b = np. resize( a, ( 3 , 2 ) )
print ( "第二个数组：" )
print ( b)
print ( "第二个数组的形状:" )
print ( b. shape)
print ( '修改第二个数组的大小：' )
b = np. resize( a, ( 3 , 3 ) )
print ( b)
"""
第一个数组：
[[1 2 3]
[4 5 6]]
第一个数组的形状
(2, 3)
第二个数组：
[[1 2]
[3 4]
[5 6]]
第二个数组的形状:
(3, 2)
修改第二个数组的大小：
[[1 2 3]
[4 5 6]
[1 2 3]]
"""
a = np. array( [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] ] )
print ( '第一个数组：' )
print ( a)
print ( '向数组添加元素：' )
print ( np. append( a, [ 7 , 8 , 9 ] ) )
print ( '沿轴 0 添加元素：' )
print ( np. append( a, [ [ 7 , 8 , 9 ] ] , axis = 0 ) )
print ( '沿轴 1 添加元素：' )
print ( np. append( a, [ [ 5 , 5 , 5 ] , [ 7 , 8 , 9 ] ] , axis = 1 ) )
"""
第一个数组：
[[1 2 3]
[4 5 6]]
向数组添加元素：
[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]]
"""
a = np. array( [ [ 1 , 2 ] , [ 3 , 4 ] , [ 5 , 6 ] ] )
print ( '第一个数组：' )
print ( a)
print ( '未传递 Axis 参数。 在删除之前输入数组会被展开。索引' )
print ( np. insert( a, 3 , [ 11 , 12 ] ) )
print ( '沿轴 0 广播：列数不够复制扩展,超出会报错' )
print ( np. insert( a, 1 , [ 11 ] , axis = 0 ) )
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]
沿轴 0 广播：列数不够复制扩展,超出会报错
[[ 1 2]
[11 11]
[ 3 4]
[ 5 6]]
沿轴 1 广播：自动扩展
[[ 1 11 2]
[ 3 11 4]
[ 5 11 6]]
"""
a = np. arange( 12 ) . reshape( 3 , 4 )
print ( '第一个数组：' )
print ( a)
print ( '未传递 Axis 参数。 在删除之前输入数组会被展开。' )
print ( np. delete( a, 6 ) )
print ( '删除第二列：' )
print ( np. delete( a, 1 , axis = 1 ) )
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 5 7 8 9 10 11]
删除第二列：
[[ 0 2 3]
[ 4 6 7]
[ 8 10 11]]
包含从数组中删除的替代值的切片：
[ 2 4 6 8 10]
"""
a = np. array( [ 5 , 2 , 6 , 2 , 7 , 5 , 6 , 8 , 2 , 9 ] )
print ( '第一个数组：' )
print ( a)
print ( '第一个数组的去重值：去重后顺序排序' )
u = np. unique( a)
print ( u)
print ( '去重数组的正向索引：（新数组中的元素在旧数组中的索引值，第一次）' )
u, indices = np. unique( a, return_index = True )
print ( u)
print ( indices)
print ( '去重数组的反向索引：（旧数组中的元素在新数组中的索引）' )
u, indices = np. unique( a, return_inverse = True )
print ( indices)
print ( '使用反向索引重构原数组：' )
print ( u[ indices] )
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]
去重数组的正向索引：（新数组中的元素在旧数组中的索引值，第一次）
[2 5 6 7 8 9]
[1 0 2 4 7 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]
"""
函数 描述 add() 对两个数组的逐个字符串元素进行拼接（相应元素进行相加） multiply() 返回按元素多重连接后的字符串 center() 居中字符串 capitalize() 将字符串第一个字母转换为大写 title() 将字符串的每个单词的第一个字母转换为大写 lower()/upper() 数组元素转换为小/大写 split() 指定分隔符（默认空格）对字符串进行分隔，并返回数组列表 splitlines (‘i\nlike\n baidu?’)按照换行符切割（[‘i’, ‘like’, ’ baidu?']） strip() 移除元素开头或者结尾处的特定字符 replace() 使用新字符串替换字符串中的所有子字符串 decode() 数组元素依次调用str.decode() 将每个字符串元素解码为字节字符串 encode() 数组元素依次调用str.encode() 将每个字节字符串元素编码为字符串
print ( np. char. add( [ 'hello' ] , [ ' xyz' ] ) )
print ( np. char. add( [ 'hello' , 'hi' ] , [ ' abc' , ' xyz' ] ) )
print ( np. char. center( 'Baidu' , 20 , fillchar= '*' ) )
print ( np. char. capitalize( 'baidu' ) )
print ( np. char. title( 'i like baidu' ) )
print ( np. char. lower( [ 'BAIDU' , 'GOOGLE' ] ) )
print ( np. char. lower( 'BAIDU' ) )
print ( np. char. upper( [ 'baidu' , 'google' ] ) )
print ( np. char. upper( 'baidu' ) )
print ( np. char. encode( 'baidu' , 'cp500' ) )
print ( np. char. decode( np. char. encode( 'baidu' , 'cp500' ) , 'cp500' ) )
"""
np.bytes_(b'\x82\x81\x89\x84\xa4')
baidu
"""
函数 描述 add() 返回两个数组的和 subtract() 返回两个数组的差 multiply() 返回两个数组的积 divide() 返回两个数组的商 mod()或者remainder() 返回两个数组的余数 reciprocal() 返回指定数组的倒数 power() 返回两个数组的幂 around() 返回指定数字的四舍五入值 floor() 返回小于或者等于在指定表达式的最大整数，即向下取整 ceil() 返回大于或者等于指定表达式的最小整数，即向上取整
a = np. array( [ 1.0 , 5.55 , 123 , 0.567 , 25.532 ] )
print ( np. around( a) )
print ( np. around( a, decimals= 1 ) )
print ( np. around( a, decimals= - 1 ) )
a = np. array( [ - 1.7 , 1.5 , - 0.2 , 0.6 , 10 ] )
print ( np. floor( a) )
print ( np. ceil( a) )
函数 说明 amin() 计算数组中的元素沿指定轴的最小值 amax() 计算数组中的元素沿指定轴的最大值 ptp() 计算数组中的元素最大值和最小值的差（机差） percentile() 表示小于百分值的观察值的百分比(50%表示中位数) median() 计算数组中元素的中位数（中值） mean() 返回数组中元素的算术平均值 average() 根据权重数组计算指定数组中元素的加权平均值 加权平均值 = (∑(数据 × 权重)) / ∑权重 std() 标准差是一组数据平均值分散程度的一种度量 var() 样本方差，标准差是方差的算术平方根（方差是标准差的平方）
a = np. array( [ [ 10 , 7 , 4 ] , [ 3 , 2 , 1 ] ] )
print ( np. percentile( a, 50 ) )
print ( np. percentile( a, 50 , axis= 0 ) )
print ( np. percentile( a, 50 , axis= 1 ) )
print ( np. percentile( a, 50 , axis= 1 , keepdims= True ) )
"""
[[7.]
[2.]]
"""
a = np. array( [ 1 , 2 , 3 , 4 ] )
print ( np. average( a) )
wts = np. array( [ 4 , 3 , 2 , 1 ] )
print ( np. average( a, weights = wts) )
print ( np. average( [ 1 , 2 , 3 , 4 ] , weights = [ 4 , 3 , 2 , 1 ] , returned = True ) )
"""(np.float64(2.0), np.float64(10.0)) 加权平均值， 权重之和"""
a = np. arange( 6 ) . reshape( 3 , 2 )
wt = np. array( [ 3 , 5 ] )
print ( np. average( a, axis = 1 , weights = wt) )
print ( np. average( a, axis = 1 , weights = wt, returned = True ) )
"""(array([0.625, 2.625, 4.625]), array([8., 8., 8.]))
"""
函数 说明 sort() 返回输入数组的排序副本，order指定排序字段，axis的默认值是1 argsort() 返回的是数组值从小到大的索引值 lexsort() 用于对多个序列进行排序，优先最右列，输出索引 argmax() 沿给定轴返回最大元素的索引 argmin() 沿给定轴返回最小元素的索引 nonzero() 返回输入数组中非零元素的索引(横轴和纵轴索引) where() 返回输入数组中满足给定条件的元素的索引(横轴和纵轴索引) extract() 返回满足条件的元素
dt = np. dtype( [ ( "name" , "S10" ) , ( "age" , int ) ] )
例子：
dt = np. dtype( [ ( "name" , "S10" ) , ( "age" , int ) ] )
a = np. array( [ ( "raju" , 21 ) , ( "anil" , 25 ) , ( "ravi" , 17 ) , ( "amar" , 27 ) ] , dtype = dt)
print ( np. sort( a, order = 'name' ) )
"""[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]"""
print ( np. sort( a, order = 'age' ) )
"""[(b'ravi', 17) (b'raju', 21) (b'anil', 25) (b'amar', 27)]"""
nm = ( 'raju' , 'anil' , 'ravi' , 'amar' )
dv = ( 'f.y' , 's.y' , 's.y.' , 'f.y.' )
ind = np. lexsort( ( dv, nm) )
print ( ind)
print ( '使用这个索引来获取排序后的数据：' )
print ( [ nm[ i] + ", " + dv[ i] for i in ind] )
"""['amar, f.y.', 'anil, s.y', 'raju, f.y', 'ravi, s.y.']"""
a = np. array( [ [ 30 , 40 , 0 ] , [ 0 , 20 , 10 ] , [ 50 , 0 , 60 ] ] )
print ( np. nonzero( a) )
"""(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))""" 返回的横轴纵轴索引
x = np. arange( 9. ) . reshape( 3 , 3 )
print ( "大于3 的元素的索引:" )
y = np. where( x> 3 )
print ( y)
print ( "使用这些索引来获取满足条件的元素:" )
print ( x[ y] )
x = np. arange( 9. ) . reshape( 3 , 3 )
condition = np. mod( x, 2 ) == 0
print ( '按元素的条件值' )
print ( condition)
"""
[[ True False True]
[False True False]
[ True False True]]
"""
print ( '使用条件提取元素:' )
print ( np. extract( condition, x) )
扫一扫
980
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
