1、數組的連接

            
              # 1、連接數組操作；
# 方法1：通過將axis參數更改為0垂直和1水平 np.concatenate
# 方法2：和np.vstack垂直和np.hstack水平
# 方法3：和np.r_垂直和np.c_水平
# 推薦使用np.vstack([a, b])垂直疊加；np.hstack([a, b])水平連接
# 1.1連接一維數組；
a = np.arange(0, 5)
b = np.arange(5, 10)
print(np.vstack([a, b]))
# [[0 1 2 3 4]
#  [5 6 7 8 9]]
print(np.hstack([a, b]))
# [0 1 2 3 4 5 6 7 8 9]

# 1.2、連接二維數組
a = np.zeros([4, 4])
b = np.ones([4, 4])
print(np.vstack([a, b]))
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [1. 1. 1. 1.]
#  [1. 1. 1. 1.]
#  [1. 1. 1. 1.]
#  [1. 1. 1. 1.]]
print(np.hstack([a, b]))
# [[0. 0. 0. 0. 1. 1. 1. 1.]
#  [0. 0. 0. 0. 1. 1. 1. 1.]
#  [0. 0. 0. 0. 1. 1. 1. 1.]
#  [0. 0. 0. 0. 1. 1. 1. 1.]]

            
          

2、數組的排序

            
              # 2、數組的排序
np.random.seed(100)
arr = np.random.randint(1, 6, size=[8, 4])
print(arr)
# [[1 1 4 1]
#  [3 5 3 3]
#  [3 3 2 1]
#  [1 5 4 5]
#  [3 1 4 2]
#  [3 4 5 5]
#  [2 4 5 5]
#  [4 4 4 2]]
# 2.1一個有缺陷的方法，np.sort(arr, axis=0)，axis=0表示對每一列升序排序，默認也是axis=0;
# axis=1是對每一行進行升序排序
# 缺陷在于，該方法會對所有列進行排序，彼此獨立，導致結果會損害行項的完整性
arr_sort = np.sort(arr, axis=0)
print(arr_sort)
# [[1 1 2 1]
#  [1 1 3 1]
#  [2 3 4 2]
#  [3 4 4 2]
#  [3 4 4 3]
#  [3 4 4 5]
#  [3 5 5 5]
#  [4 5 5 5]]

# 2.2我們希望按照某一列對整個數組排序，使用np.argsort(arr)，該方法返回排序好的索引數組
# 根據arr的第一列對整個數組排序，返回索引;也可以寫成arr[:, 0].argsort()
arr_argsort = np.argsort(arr[:, 0])
print(arr_argsort)
# 注意，打印的是排序好的索引數組
# [0 3 6 1 2 4 5 7]
print(arr[arr_argsort])
# 打印排序好的數組
# [[1 1 4 1]
#  [1 5 4 5]
#  [2 4 5 5]
#  [3 5 3 3]
#  [3 3 2 1]
#  [3 1 4 2]
#  [3 4 5 5]
#  [4 4 4 2]]
# 當我們要獲取降序排列的數組，可以對升序的索引進行反轉
# print(arr[arr_argsort[::-1]])


# 2.3根據2列或更多列對數組進行排序,使用np.lexsort()
# 如下，是在第0列排序好的基礎上，再對第1列排序；即會先對元組最右側指定的列進行排序
arr_lexsort = np.lexsort((arr[:, 1], arr[:, 0]))
print(arr_lexsort)
# 返回的是最終排序好的第0列索引
# [0 3 6 4 2 5 1 7]
print(arr[arr_lexsort])
# [[1 1 4 1]
#  [1 5 4 5]
#  [2 4 5 5]
#  [3 1 4 2]
#  [3 3 2 1]
#  [3 4 5 5]
#  [3 5 3 3]
#  [4 4 4 2]]

            
          

3、datetime64對象

            
              # 3、Numpy中的時間對象datetime64
# 3.1將字符串轉化成datetime64對象
date_dt64 = np.datetime64('2018-02-04 23:10:10')
print(date_dt64)
# 2018-02-04T23:10:10

# 將時間對象轉化成字符串
strdate_dt64 = np.datetime_as_string(date_dt64)
print(strdate_dt64)
# 2018-02-04T23:10:10

# 3.2 對datetime64對象的操作
# 刪除時間組件
date = np.datetime64(date_dt64, 'D')
print(date)
# 2018-02-04

# 添加單位
m = np.timedelta64(10, 'm')
s = np.timedelta64(10, 's')
ns = np.timedelta64(10, 'ns')
print(m)
print(s)
print(ns)
# 10 minutes
# 10 seconds
# 10 nanoseconds

# 時間的增加
print(date + 10)
print(date + m)
print(date + s)
print(date + ns)
# 2018-02-14
# 2018-02-04T00:10
# 2018-02-04T00:00:10
# 2018-02-04T00:00:00.000000010

# 3.3 工作日的處理
# 過濾工作日
print(np.is_busday(date))  # False
# 增加2個工作日，滾動到最近的工作日
print(np.busday_offset(date, 2, roll='forward'))  # 2018-02-07
# 增加2個工作日，向后滾動至最近的工作日
print(np.busday_offset(date, 2, roll='backward'))  # 2018-02-06

# 創建日期序列
dates = np.arange(np.datetime64('2018-02-01'), np.datetime64('2018-02-10'))
print(dates)
# ['2018-02-01' '2018-02-02' '2018-02-03' '2018-02-04' '2018-02-05'
#  '2018-02-06' '2018-02-07' '2018-02-08' '2018-02-09']
print(np.is_busday(dates))
# [ True  True False False  True  True  True  True  True]

# 3.4 將numpy.datetime64轉換為datetime.datetime對象,方式1
date_dt = date_dt64.tolist()
print(type(date_dt), date_dt)
# 
              
                 2018-02-04 23:10:10

# 將numpy.datetime64轉換為datetime.datetime對象，方式2
from datetime import datetime
date_dt = date_dt64.astype(datetime)

              
            
          

4、vectorize - 使標量函數適用于向量

            
              # 函數foo（見下面的代碼）接受一個數字，如果它是'奇數'則將其平方，否則它將它除以2
# 在標量（單個數字）上應用此函數時，它可以正常工作，但在應用于數組時會失敗
# 使用numpy.vectorize() ，你可以神奇地使它在數組上工作。
def foo(x):
    if x % 2 == 1:
        return x**2
    else:
        return x/2

print(foo(10))  # 5.0
print(foo(11))  # 121
# print(foo([10, 11, 12])) # Error

# 對標量函數進行矢量化，以便標量函數可以在數組上運行; otypes提供輸出的數據類型
foo_v = np.vectorize(foo, otypes=[float])
print(foo_v([10, 11, 12]))
# [  5. 121.   6.]

print(foo_v([[10, 11, 12], [1, 2, 3]]))
# [[  5. 121.   6.]
#  [  1.   1.   9.]]

            
          

5、np.apply_along_axis按列或行應用函數

            
              # 按列或行應用函數；numpy.apply_along_axis
np.random.seed(100)
arr_x = np.random.randint(1, 10, size=[4, 10])
print(arr_x)
# [[9 9 4 8 8 1 5 3 6 3]
#  [3 3 2 1 9 5 1 7 3 5]
#  [2 6 4 5 5 4 8 2 2 8]
#  [8 1 3 4 3 6 9 2 1 8]]
#
# # 如何找到每一行或每一列中最大值和最小值的差值？
def max_minus_min(x):
    return np.max(x) - np.min(x)
#
# 參數1表示max_minus_min函數應用于數組arr_x的行
print(np.apply_along_axis(max_minus_min, 1, arr=arr_x))
# [8 8 6 8]

# 參數0表示max_minus_min函數應用于數組arr_x的列
print(np.apply_along_axis(max_minus_min, 0, arr=arr_x))
# [7 8 2 7 6 5 8 5 5 5]

            
          

6、其他函數

            
              # 6.1 searchsorted - 找到要插入的位置，以便數組保持排序狀態
x = np.arange(10)
# 打印5應該插入到哪個位置；默認side是left，即會插在相同元素的左邊
print(np.searchsorted(x, 5))  # 5
print(np.searchsorted(x, 5, side='right'))  # 6

# 6.2 np.newaxis將一維數組轉化為二維數組/列向量
x = np.arange(5)
x_col = x[:, np.newaxis]
print(x_col)
# [[0]
#  [1]
#  [2]
#  [3]
#  [4]]

# 6.3 np.digitize(arr, bins)返回每個元素所屬的bin的索引位置
x = np.arange(10)
bins = np.array([0, 1, 4, 9])
print(np.digitize(x, bins))
# bins劃分了4個區間，[0,1) [1,4) [4,9) [9,+)，如下返回的就是數組x中的每個元素對應的區間索引，從1開始
# [1 2 2 2 3 3 3 3 3 4]