前言

學習資料科學主要有幾個套件非常重要，重要和常用的套件如下：

• 數據統計
  • Numpy：Numberical Python的簡稱，提供一個高效的介面，用來在大量資料緩衝區中進行儲存和操作。某些時候Numpy的陣列就像是Python內建的list型態，但Numpy提供更有效率的儲存和操作。Numpy陣列幾乎是Python整個資料科學生態的核心。
  • Pandas：提供高效率，資料更容易使用的架構，且讓資料更容易分析的開源程式碼。想像Pandas是Numpy陣列的加強版。
  • SciPy：科學計算的另一個核心庫是 SciPy。它基於 NumPy，其功能也因此得到了擴展。SciPy 主數據結構又是一個多維數組，由 Numpy 實現。這個軟件包包含了幫助解決線性代數、概率論、積分計算和許多其他任務的工具。此外，SciPy 還封裝了許多新的 BLAS 和 LAPACK 函數。
  • StatsModels：Statsmodels 是一個 Python 模塊，它為統計數據分析提供了許多機會，例如統計模型估計、執行統計測試等。在它的幫助下，你可以實現許多機器學習方法並探索不同的繪圖可能性。
• 視覺化
  • Matplotlib：Matplotlib 是一個用於創建二維圖和圖形的底層庫。藉由它的幫助，你可以構建各種不同的圖標，從直方圖和散點圖到費笛卡爾座標圖。此外，有許多流行的繪圖庫被設計為與matplotlib結合使用。
  • Seaborn：Seaborn 本質上是一個基於 matplotlib 庫的高級 API。它包含更適合處理圖表的默認設置。此外，還有豐富的可視化庫，包括一些複雜類型，如時間串行、聯合分佈圖（jointplots）和小提琴圖（violin diagrams）。

但我的30天裡面只有針對以下四個套件Numpy、Pandas、Matplotlib、Seaborn有比較詳細的介紹，而今天要先來介紹Numpy。

前置作業

打開Anaconda Prompt看是否有安裝Numpy(使用「conda list」指令)，沒有就執行

pip install numpy

建立ndarray

numpy有很多內建函式可以建立ndarray，現在將相同性質的函式放在一起介紹

建立值全部都一樣的陣列

• zeros()：產生全部為零的陣列
• ones()：全部為1的陣列
• empty()：無初始值的陣列
• 語法：zeros(shape, dtype='dtype',*args)，zeros()可改成ones()或empty()
  示範建立上述四種陣列

import numpy as np
ironman_zeros = np.zeros(10, dtype=int) #建立一個內容為0 長度為10的整數陣列
ironman_ones = np.ones((3,5) ,dtype=float)  #建立一個內容為1 3x5 的浮點數陣列
ironman_empty = np.empty((3,2) )  #建立一個內容為1 3x2 的無初始值陣列
ironman_full = np.full((4,2), 2.2) #建立一個內容為2.2 4x2 的浮點數陣列

print('ironman_zeros---->', ironman_zeros)
print('ironman_ones---->', ironman_ones)
print('ironman_empty---->', ironman_empty)
print('ironman_full---->', ironman_full)

# 輸出結果
ironman_zeros----> [0 0 0 0 0 0 0 0 0 0]
ironman_ones----> [[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
ironman_empty----> [[1.37961302e-306 1.00136557e-307]
 [1.60218763e-306 1.69121367e-306]
 [6.23040373e-307 1.60219035e-306]]
ironman_full----> [[2.2 2.2]
 [2.2 2.2]
 [2.2 2.2]
 [2.2 2.2]]

建立等差數列

• arange(start, stop, step, dtype=None)：step為等差值
• linspace(start, stop, num, endpoint=True)：num代表陣列的大小
  示範建立上述兩種陣列

ironman_arange = np.arange(0,20,2) #建立一個依序填滿的陣列 0到20間隔為2
ironman_linspace = np.linspace(0,1,5) #建立一個5個值的陣列，在0到1間平均分布

print('ironman_arange---->', ironman_arange)
print('ironman_linspace---->', ironman_linspace)

# 輸出結果
ironman_arange----> [ 0  2  4  6  8 10 12 14 16 18]
ironman_linspace----> [0.   0.25 0.5  0.75 1.  ]

建立隨機數列

• 建立0~1的浮點數
  • random.random(size)
  • random.ranf(size)
  • random.sample(size)

ironman_random = np.random.random((3,3)) #建立一個3*3 陣列，在0到1間亂數值
ironman_ranf = np.random.ranf((5)) #建立一個5 陣列，在0到1間亂數值
ironman_sample = np.random.sample((2,3)) #建立一個2*3 陣列，在0到1間亂數值

print('ironman_random---->', ironman_random)
print('ironman_ranf---->', ironman_ranf)
print('ironman_sample---->', ironman_sample)

# 輸出結果
ironman_random----> [[0.64353867 0.04610781 0.78987197]
 [0.75626182 0.29991636 0.92585699]
 [0.63849181 0.16742412 0.2124621 ]]
ironman_ranf----> [0.94065174 0.76792842 0.58185392 0.51702131 0.13499956]
ironman_sample----> [[0.2181921  0.88624691 0.40748053]
 [0.72171909 0.2094024  0.58329048]]

• 建立常態分布又稱為高斯分布
  • random.normal(loc='loc', scale='scale', size=None)：loc為平均值、scale為標準差

ironman_normal = np.random.normal(0,1,(3,3)) #建立一個3*3陣列，內容為常態分佈的亂數值 平均0，標準差1
print('ironman_normal---->', ironman_normal)

# 輸出結果
ironman_normal----> [[ 0.29675527  0.5483744  -0.68793494]
 [-0.82978447 -0.14248656 -0.01019463]
 [-0.89532166 -0.0651036  -0.27911572]]

• 建立隨機整數陣列
  • random.randint(low, high, size)

ironman_randint = np.random.randint(0,10,(3,3)) #建立一個3*3陣列，內容介於0到10的整數
print('ironman_randint---->', ironman_randint)

# 輸出結果
ironman_randint----> [[3 0 7]
 [0 0 7]
 [1 7 8]]

Numpy 陣列屬性

剛剛示範了如何建立陣列，現在來看關於陣列，有什麼基本屬性可以使用。

• 陣列屬性
  • ndim()：取得陣列的維度數量
  • shape()：陣列的形狀
  • size()：陣列的數量
  • dtype()：資料型態
  • itemsize()：陣列中元素的大小(位元組為單位)
  • nbytes()：陣列的大小(位元組為單位) 一般來說 nbytes = itemsize * size

先建立三個陣列各別是一維陣列、二維陣列、三維陣列，再用此三個陣列來顯示屬性。

ironman_x1 = np.random.randint(10, size=6)    #一維陣列
ironman_x2 = np.random.randint(10, size=(3,4))     #二維陣列
ironman_x3 = np.random.randint(10, size=(2,3,2))   #三維陣列

print("ironman_x1---->", ironman_x1)
print("ironman_x2---->", ironman_x2)
print("ironman_x3---->", ironman_x3)

# 輸出結果
ironman_x1----> [2 3 9 7 5 3]
ironman_x2----> [[4 5 3 3]
 [7 9 9 9]
 [7 3 2 3]]
ironman_x3----> [[[9 7]
  [7 5]
  [1 2]]

 [[2 8]
  [1 5]
  [8 4]]]

ndim()

print("ironman_x1 ndim:     ", ironman_x1.ndim)
print("ironman_x2 ndim:     ", ironman_x2.ndim)
print("ironman_x3 ndim:     ", ironman_x3.ndim)

# 輸出結果
ironman_x1 ndim:      1
ironman_x2 ndim:      2
ironman_x3 ndim:      3

shape()

print("ironman_x1 shape:     ", ironman_x1.shape)
print("ironman_x2 shape:     ", ironman_x2.shape)
print("ironman_x3 shape:     ", ironman_x3.shape)

# 輸出結果
ironman_x1 shape:      (6,)
ironman_x2 shape:      (3, 4)
ironman_x3 shape:      (2, 3, 2)

size()

print("ironman_x1 size:     ", ironman_x1.size)  # 6 x 1
print("ironman_x2 size:     ", ironman_x2.size)  # 3 x 4
print("ironman_x3 size:     ", ironman_x3.size)  # 2 x 3 x 4

# 輸出結果
ironman_x1 size:      6
ironman_x2 size:      12
ironman_x3 size:      12

dtype()

print("ironman_x1 dtype:     ", ironman_x1.dtype)
print("ironman_x2 dtype:     ", ironman_x2.dtype)
print("ironman_x3 dtype:     ", ironman_x3.dtype)

# 輸出結果
ironman_x1 dtype:      int32
ironman_x2 dtype:      int32
ironman_x3 dtype:      int32

itemsize()

print("ironman_x1 itemsize:     ", ironman_x1.itemsize)
print("ironman_x2 itemsize:     ", ironman_x2.itemsize)
print("ironman_x3 itemsize:     ", ironman_x3.itemsize)

# 輸出結果
ironman_x1 itemsize:      4
ironman_x2 itemsize:      4
ironman_x3 itemsize:      4

nbytes()

print("ironman_x1 nbytes:     ", ironman_x1.nbytes)
print("ironman_x2 nbytes:     ", ironman_x2.nbytes)
print("ironman_x3 nbytes:     ", ironman_x3.nbytes)

# 輸出結果
ironman_x1 nbytes:      24
ironman_x2 nbytes:      48
ironman_x3 nbytes:      48

陣列索引

使用陣列的索引來取值和修改值

# 取得陣列值
print("ironman_x1[2]----->", ironman_x1[2])
print("ironman_x2[2,2]----->", ironman_x2[2,2])
print("ironman_x3[1,1,1]----->", ironman_x3[1,1,1])
# 修改陣列值
ironman_x1[2] = 7
ironman_x2[2,2] = 4
ironman_x3[1,1,1] = 3
print("ironman_x1[2]----->", ironman_x1[2])
print("ironman_x2[2,2]----->", ironman_x2[2,2])
print("ironman_x3[1,1,1]----->", ironman_x3[1,1,1])

# 輸出結果
ironman_x1[2]-----> 9
ironman_x2[2,2]-----> 2
ironman_x3[1,1,1]-----> 5
ironman_x1[2]-----> 7
ironman_x2[2,2]-----> 4
ironman_x3[1,1,1]-----> 3

陣列切片

可以使用切片的方式來取得元素和修改元素

一維陣列

ironman_x4 = np.arange(10)
print('ironman_x4---->', ironman_x4)
print('ironman_x4[:5]----->',ironman_x4[:5])         # 前面5個元素
print('ironman_x4[5:]----->',ironman_x4[5:])         # index5 之後的元素
print('ironman_x4[4:7]----->',ironman_x4[4:7])       # index 4~(7-1) 的元素
print('ironman_x4[::2]----->',ironman_x4[::2])       # 間隔2的所有元素
print('ironman_x4[1::2]----->',ironman_x4[1::2])     # index1開始 間隔2的所有元素
print('ironman_x4[::-1]----->',ironman_x4[::-1])     # 反轉元素

# 輸出結果
ironman_x4----> [0 1 2 3 4 5 6 7 8 9]
ironman_x4[:5]-----> [0 1 2 3 4]
ironman_x4[5:]-----> [5 6 7 8 9]
ironman_x4[4:7]-----> [4 5 6]
ironman_x4[::2]-----> [0 2 4 6 8]
ironman_x4[1::2]-----> [1 3 5 7 9]
ironman_x4[::-1]-----> [9 8 7 6 5 4 3 2 1 0]

二維陣列

ironman_x5 = np.random.randint(10, size=(3,4))     #二維陣列
print('ironman_x5---->', ironman_x5)
print('ironman_x5[:2, :3]----->',ironman_x5[:2, :3])         # 取得  2列        3欄
print('ironman_x5[:3, ::2]----->',ironman_x5[:3, ::2])       # 取得  3列        偶數欄
print('ironman_x5[:,0]----->',ironman_x5[:,0])               #取得 所有列      第(0+1)欄
print('ironman_x5[2,:]----->',ironman_x5[2,:])               #取得 第(2+1)列   所有欄

# 輸出結果
ironman_x5----> [[4 4 0 9]
 [3 7 3 2]
 [1 1 2 1]]
ironman_x5[:2, :3]-----> [[4 4 0]
 [3 7 3]]
ironman_x5[:3, ::2]-----> [[4 0]
 [3 3]
 [1 2]]
ironman_x5[:,0]-----> [4 3 1]
ironman_x5[2,:]-----> [1 1 2 1]

異動子陣列，原來的陣列會被異動，使用.copy()就可以複製一份資料

重塑(reshape)

示範建立一個一維陣列變成3*1

x = np.array([1,2,3])
print('x----->', x)
x_reshape = x.reshape((3,1))         # 透過reshape建立欄向量
print('x_reshape----->', x_reshape)

# 輸出結果
x-----> [1 2 3]
x_reshape-----> [[1]
 [2]
 [3]]

串接(concatenate,vstack,hstack)

• concatenate()：串接
• vstack()：垂直串接
• hstack()：水平串接
  示範用剛剛建立的x陣列串接另外建立的y陣列

y = np.array([4,5,6])
print('concatenate----->',np.concatenate([x,y]))    # 串接陣列
print('vstack----->',np.vstack([x,y]))              # 垂直串接
print('hstack----->',np.hstack([x,y]))              # 水平串接

# 輸出結果
concatenate-----> [1 2 3 4 5 6]
vstack-----> [[1 2 3]
 [4 5 6]]
hstack-----> [1 2 3 4 5 6]

分割(split,hsplit,vsplit)

• split()：分割
• vsplit()：垂直分割
• hsplit：水平分割

z = np.array([1,2,3,4,5,6,7,8,9])
z1,z2,z3 = np.split(z,[3,5])              # 分割3個陣列 [index 0~(3-1) ] [ index 3~(5-1)] [index (5~end)]
print("z1---->", z1)
print("z2---->", z2)
print("z3---->", z3)
z = np.array([[1,2,3],[4,5,6],[7,8,9]])
print('vsplit----->',np.vsplit(z,[2]))    # 垂直分割
print('hsplit----->',np.hsplit(z,[2]))    # 水平分割

# 輸出結果
z1----> [1 2 3]
z2----> [4 5]
z3----> [6 7 8 9]
vsplit-----> [array([[1, 2, 3],
       [4, 5, 6]]), array([[7, 8, 9]])]
hsplit-----> [array([[1, 2],
       [4, 5],
       [7, 8]]), array([[3],
       [6],
       [9]])]

心得分享

忍不住加上心得分享，最近已經寫完30天，所以打算來將之前的文章做排版，忽然間覺得Numpy看完第一天其實就可以了，= =a，我自己整理的時候看到今天這樣長，都有一種快放棄的感覺，現在看了一下後面的金融分析，恩，我覺得如果想要更進一步的才看Day8、Day9。不然其實看完Day7就綽綽有餘了.....。

之前的章節導覽

• 安裝環境
  • 安裝Anaconda
  • 安裝Jupyter notebook
• 基礎語法
  • 變數、資料型態、運算子
  • list、tuple、dict、迴圈
  • function、import
• 程式碼位置
  • github
    因為作者本身也是第一次學習Python和寫程式文章，所以編排上會有點亂，觀念可能也會錯誤，如果有疑問可以提出一起討論，等30天完成之後有其他時間會將之前寫的文章加入一些想法。