字符串函數

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