字符串函数
# 在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 返回符合要求的元素
