numpy函数

字符串函数

# 在numpy中使用 numpy.char调用函数处理字符串
import numpy as np
a = np.char.add(['ss','zz'],['yy','xx'])        # add(),将两个数组对应位置的元素逐个连接
print(a)                                        # 结果为['ssyy','zzxx']

b = np.char.multiply(['sy','sz'],3)             # multiply(),将元素重复指定次数连接
print(b)                                        # 结果为['sysysy','szszsz']

c = np.char.center('call',10,fillchar='#')      # center(),将元素在指定宽度内居中，fillchar指定用什么填充
print(c)

d = np.char.capitalize(['cool boy','base'])     # capitalize()，将每个元素首字母大写
print(d)

e = np.char.title('hello world')                # title(),将每个单词的首字母大写
print(e)

f = np.char.lower('HELLO')                      # lower()，将每个大写的字母转换成小写
print(f)

g = np.char.upper('hello')                      # upper(),将每个小写的字母转换成大写
print(g)

h = np.char.split('www.baidu.com',sep='.')      # split(),按照指定的符号分割，默认是按空格分割，返回值放在一个数组内
print(h)                                        # splitlines(),按照换行符分割

i = np.char.strip('hello world ',chars='h')     # strip(),移除首尾指定的字符，默认移除空格
print(i)

j = np.char.join(['-','*'],['hello','world'])   # join(),用指定的字符插入到元素的每个字符之间
print(j)                                        # 结果为['h-e-l-l-o' 'w*o*r*l*d']

k = np.char.replace('hello','ello','i')         # replace(),新的字符替换原字符
print(k)

p = np.char.encode('hello','gbk')               # encode(),设置编码格式
p1 = np.char.decode(p,'gbk')                    # decode(),解码
print(p)
print(p1)

数学函数

import numpy as np
# 三角函数
a = np.array([0,30,60,90])
a1 = np.sin(a*np.pi/180)                    # 正弦函数,np.pi 表示符号π，用弧度求值
a2 = np.cos(a*np.pi/180)                    # 余弦函数
a3 = np.tan(a*np.pi/180)                    # 正切函数
# 反三角函数
arc_a1 = np.arcsin(a1)                      # 反正弦函数
print(np.degrees(arc_a1))                   # degrees 将弧度转换成角度
arc_a2 = np.arccos(a2)                      # 反余弦函数
arc_a3 = np.arctan(a3)                      # 反正切函数

# 舍入函数
# around()四舍五入，decimals的值表示保留几位，默认为0，当为负值时，则从小数点左边的整数位舍入
b = np.array([1.0,12.456,25.77,11,52.32])
print(np.around(b))                         # 结果为[1. 12. 26. 11. 52.]
print(np.around(b,decimals=1))              # 结果为[ 1. 12.5 25.8 11. 52.3]
print(np.around(b,decimals=-1))             # 结果为[0. 10. 30. 10. 50.]，  -1按整数的个位四舍五入

c = np.array([1.2,-2.3,-0.7,2.6])
print(np.floor(c))                          # floor()向下取整，结果为[ 1. -3. -1.  2.]
print(np.ceil(c))                           # ceil()向上取整，结果为[ 2. -2. -0.  3.]

# 算术函数
d1 = np.arange(9).reshape(3,3)
d2 = np.array([5,11,22])
print(np.add(d1,d2))                        # add() 加法运算
print(np.subtract(d1,d2))                   # subtract() 减法运算
print(np.multiply(d1,d2))                   # multiply() 乘法运算
print(np.divide(d1,d2))                     # divide() 除法运算

e = np.array([0.25,1,10])
print(np.reciprocal(e))                     # reciprocal() 倒数

f1 = np.array([2,9,10])
f2 = np.array([3,2,4])
print(np.power(f1,f2))                      # power() 求幂，第一个数组中的元素为底，第二个数组对应位置的元素为幂

g1 = np.array([15,11,27])
g2 = np.array([3,2,4])
print(np.mod(g1,g2))                        # mod() 取余
print(np.remainder(g1,g2))                  # remainder() 与 mod()一样

统计函数

import numpy as np
a = np.array([[11,6,12],[5,22,6],[23,9,12]])
print(np.amin(a,0))                         # amin()输出指定轴上的最小值,结果为[5 6 6]
print(np.amax(a,0))                         # amax()输出指定轴上的最大值，结果为[23 22 12]

print(np.ptp(a,axis=0))                     # ptp()输出指定轴上的最大和最小的差值，结果为[18 16  6]

print(np.median(a,axis=0))                  # median()指定轴上的中值

print(np.mean(a,axis=0))                    # mean()算术平均值

print(np.average(a,axis=0))                 # average()加权平均值，权重是该轴上的元素个数，每次取出一个数，权重减一

print(np.var(a,axis=0))                     # var()方差

print(np.std(a,axis=0))                     # std()标准差

print(np.percentile(a,30,axis=0))           # percentile()指定轴上的百分位数
"""
percentile():第一个参数是数组，第二个参数是百分位（范围是0-100），第三个参数指定轴
    这个函数是求指定百分位的数
    如例：以30%作为基准位，则在这个数组中有30%的元素小于这个百分位数
        在指定axis=0时的结果为[ 8.6  7.8  9.6]
    原理：
        percentile(a,q,axis=0)  a:数组，q:百分位
        调用时会将数组在指定轴上做一个排序，不指定axis则所有元素排序
        num = len（a）          得到数组指定轴上的元素个数
        n = num - 1
        i = n/100*q
        floor1 = np.floor(i)    向下取整得到下限
        ceil1 = np.ceil(i)      向上取整得到上限
        if floor1 == ceil1:
            floor1 -= 1         当上限和下限相等时，下限减一
        P = a[floor1] + (a[ceil1] - a[floor1]) * (n/100*q - floor1)
        得到这个 P 值就是指定的百分位数
"""
"""
这种比较大小的方式，按照指定轴，将轴上相应位置的元素相互比较
如例：axis=0时：比较的是[11,5,23]，[6,22,9]，[12,6,12]
      axis=1时：则是比较[11,6,12]，[5,22,6]，[23,9,12]
三维或以上数组，指定轴时，与之一样，比较该轴对应位置的元素
如例：三维数组形状是（2,3,4）
      按照轴0比较大小，则轴0上的 2 项中对应位置元素比较，得到一个形状为（3,4）的二维数组
      按轴1比较时，则轴1上的 3 项中对应位置元素比较，得到一个形状为（2，4）的二维数组
      。。。
当不指定轴时，所有元素比较出 一个 最大/最小值
"""

排序函数

import numpy as np
"""
排序算法：quicksort（快速排序），mergesort（归并排序），heapsort（堆排序）
"""
a = np.array([[2,5,6],[7,1,3]])
print(np.sort(a,axis=0))                                # sort() 排序，不指定axis时默认按最后的轴排序，kind默认quicksort

dt = np.dtype([('name','S10'),('age',int)])             # 设置字段数据类型
b = np.array([('sy',22),('ask',25),('kt',18)],dtype=dt)
print(np.sort(b,order='name'))                          # order指定按照以哪个字段排序

print(np.argsort(a))                                    # arfsort()返回数组在指定轴上从小到大排序后的索引

c1 = ('sy','kt','ask')
c2 = ('rb','ya','rb')
print(np.lexsort((c1,c2)))                              # lexsort()对多个序列从小到大排序，返回索引
# 规则：如例：先对c2排序，如c2中的两个元素大小相同，则再将c1中对应位置的两个元素进行比较

print(np.msort(a))                                      # msort()按照第一个轴进行排序，相当于sort(a,axis=0)

print(np.sort_complex([1,4,7]))                         # sort_complex对数组先实部后虚部排序，如例：[ 1.+0.j  4.+0.j  7.+0.j]

d = np.array([3,6,11,2,8,22])
print(np.partition(d,2))
"""
partition 将数组从小到大排序后，再按照指定索引位置的数值分区，小于该索引位置的值放在这个值前面，大的放在后面
注意这个索引是排序后数组的索引
"""
print(np.partition(d,(1,3)))                            # 小于索引1的值在前面，大于索引3的在后面，其余的在1,3中间

print(np.argpartition(d,3))                             # argpartition 返回已排序好的数组元素在原数组中的索引

e = np.array([[11,66,22],[33,17,55],[15,35,43]])
print(np.argmax(e,axis=0))                              # argmax 返回指定轴最大值的索引，不指定axis则全元素索引
print(np.argmin(e,axis=1))                              # argmin 返回指定轴最小值的索引

f = np.array([[12,0,11],[8,11,0],[0,3,9]])
print(np.nonzero(f))
"""
nonzero 返回数组中元素不等于0的值的索引
    当数组是二维的时候，返回的是长度为2的一个元祖
    这个元祖中的元素一一对应标出不为0的数组元素
    如例：得到的结果为(array([0, 0, 1, 1, 2, 2], dtype=int64), array([0, 2, 0, 1, 1, 2], dtype=int64))
    则索引（0,0）（0,2）（1,0）（1,1）。。。。。标注出了不是0的元素
"""
print(np.where(f>9))                                    # where 返回符合要求的元素索引，二维数组会返回长度为2的元祖

mm = np.mod(f,2) == 0
print(np.extract(mm,f))                                 # extract 返回符合要求的元素