Numpy庫使用總結

一、總結

一句話總結：

NumPy：大數據量的純粹數組處理，以及復雜函數和線性代數等

 

1、numpy中創建矩陣的方法？

numpy中的數據結構主要是同構的多維數組，所以創建數組的方法主要有array和arange方法，當然還有其它的一些比如linspace等等

arr = np.array([[1,2,3],[4,5,6]])
arr = np.arange(6).reshape((2,3))

 

 

2、numpy庫中創建數組方法array和asarray的區別？

array和asarray都可以將結構數據轉化為ndarray，但是主要區別就是當數據源是ndarray時，【array仍然會copy出一個副本，占用新的內存，但asarray不會】

 

 

3、numpy中的特殊矩陣？

numpy中的特殊矩陣 主要有ones（全1）、zeros（全0）、eye（單位矩陣）、empty（未初始化）

np.ones((3,4))
np.zeros((3,4))
np.eye(2)
np.empty((6,4))

 

 

4、numpy中的常用屬性？

numpy的多維數組常用屬性主要有dtype（數據類型）、ndim（維度）、shape（性狀）、size（元素個數）

arr = np.arange(12).reshape((3,4))
print(arr)
# 數據類型
print(arr.dtype)
# 維數
print(arr.ndim)
# 行數和列數
print(arr.shape)
# 大小，也就是元素個數
print(arr.size)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
int32
2
(3, 4)
12

 

5、numpy中的基本計算？

numpy中的ndarray對象重載了許多運算符，使用這些運算符可以完成矩陣間對應元素的運算。如 +，-，*（內積），/，%，**（次方），@（矩陣階層）

# 矩陣內積：對應位置相乘
print(arr1*arr2)
# 矩陣乘法：
print(arr1@arr2)
print(np.dot(arr1,arr2))
print(arr1.dot(arr2))

 

6、numpy中的常用函數？

numpy常用多維函數有sin、sqrt、sort、transpose、max、

mean（average）、sum、median（中位數）、var（方差）、std（標准差）、cumsum（累加）、

np.clip(arr,5,9)（小於5的數全部讓它變成5，大於9的數全部是9）

 

 

7、numpy中axis為0為1表示的意思是什么？

axis為0表示對列進行操作，axis為1表示為行進行操作

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

# 平均數
print(arr.mean())
print(np.average(arr))
print(np.average(arr,axis=0)) # 0是列
print(np.average(arr,axis=1)) # 1是行

5.75
5.75
[4. 5. 7. 7.]
[1.5  6.25 9.5 ]

 

8、numpy中索引？

numpy中，可以像普通數組一樣用下標來訪問元素，比如a[1][1]、a[1,1]

 

 

9、numpy中訪問行列元素？

a[1,:]（打印下標為1的行所有數）

a[:,1]（打印下標為1的列的所有數）

a[1,1:3]（第1行 列從1-2）

 

10、numpy中迭代行循環打印即可，如何迭代列？

將矩陣轉置即可

# 迭代列 (轉置一下即可實現)
for i in a.T:
    print(i)

 

 

11、numpy中如何迭代多維數組的每一個數？

for i in a.flat: print(i)

 

12、numpy中數組合並？

numpy數組水平合並可以np.hstack((a,b))，類似於np.concatenate((a,b,a),axis=1)

numpy數組垂直合並可以np.vstack((a,b))，類似於np.concatenate((a,b,a),axis=0)

 

 

13、numpy中數組分割？

等量分割：水平分成兩塊np.split(a,2,axis=1)，vsplit和hsplit也可以等量分割

不等量分割：np.array_split(a,3,axis=1)

 

 

14、numpy中數組拷貝？

numpy 中的 copy方法是 deep copy：b = np.copy(a)

 

 

二、Numpy庫使用總結

博客對應課程的視頻位置：

 

一、numpy庫概述

numpy庫是做什么的

大數據量的純粹數組處理，以及復雜函數和線性代數等

NumPy的主要對象是同構多維數組。它是一個元素表（通常是數字），所有類型都相同，由非負整數元組索引。

---

numpy庫核心

numpy的結構是純粹的ndarray

---

numpy庫和pandas庫的關系

NumPy：大數據量的純粹數組處理，以及復雜函數和線性代數等 Pandas：處理非純粹的、混雜數組

雖然NumPy有着以上的種種出色的特性，其本身則難以獨支數據分析這座大廈，這是一方面是由於NumPy幾乎僅專注於數組處理， 另一方面則是數據分析牽涉到的數據特性眾多，需要處理各種表格和混雜數據，遠非純粹的數組（NumPy）方便解決的，而這就是pandas發力的地方。

---

NumPy在大數組的數據處理方面進行的優化？

• 【連續的內存塊】：NumPy是在一個連續的內存塊中存儲數據，獨立於其他Python內置對象，如此便可以加速數據索引的速度。
• 【調用大量c語言算法庫】：NumPy調用了大量的用C語言編寫的算法庫，使得其可以直接操作內存，不必進行Python動態語言特性所含有的前期類型檢查工作，從而大大提高了運算速度。
• 【整數組直接計算】：NumPy所有獨有的可以在整個數組上執行復雜的計算也能夠大幅提高運算效率（基於NumPy的算法要比純Python快10到100倍，甚至會快更多）。

---

上百G的數據如何處理

Python處理幾個G的數據綽綽有余，至於幾十G也勉強可以，而上百G的數據這就算是Hadoop與Spark系列的任務，不是Python的NumPy與pandas可以應付的，也不是R語言某個第三方包可以處理的。

---

NumPy數組 和 原生Python Array（數組）之間有幾個重要的區別

• NumPy 數組在創建時具有固定的大小，與Python的原生數組對象（可以動態增長）不同。更改ndarray的大小將創建一個新數組並刪除原來的數組。
• NumPy 數組中的元素都需要具有相同的數據類型，因此在內存中的大小相同。 例外情況：Python的原生數組里包含了NumPy的對象的時候，這種情況下就允許不同大小元素的數組。
• NumPy 數組有助於對大量數據進行高級數學和其他類型的操作。通常，這些操作的執行效率更高，比使用Python原生數組的代碼更少。
• 越來越多的基於Python的科學和數學軟件包使用NumPy數組; 雖然這些工具通常都支持Python的原生數組作為參數，但它們在處理之前會還是會將輸入的數組轉換為NumPy的數組，而且也通常輸出為NumPy數組。

---

對應博客資料

如何通過一頓飯來說明NumPy與pandas的功用 - 范仁義 - 博客園 https://www.cnblogs.com/Renyi-Fan/p/13232318.html

二、創建矩陣

numpy庫中創建數組方法array和asarray的區別

array和asarray都可以將結構數據轉化為ndarray，但是主要區別就是當數據源是ndarray時，

【array仍然會copy出一個副本，占用新的內存，但asarray不會】

意思是對數據源進行重新賦值的話，array轉化后的數據不變，asarray轉化后的數據也會跟着數據源重新被賦值。

---

創建矩陣的方法

numpy中的數據結構主要是同構的多維數組，所以創建數組的方法主要有array和arange方法，當然還有其它的一些比如linspace等等

arr = np.array([[1,2,3],[4,5,6]])
arr = np.arange(6).reshape((2,3))

---

In [42]:

# 安裝庫
# pip install numpy # 查看安裝的庫 # pip list # 引入庫 import numpy as np 

1、array方法

In [4]:

# numpy的核心是n維數組，所以創建數組是array方法
arr = np.array([[1,2,3], [4,5,6]]) print(arr) 

[[1 2 3]
 [4 5 6]]

In [7]:

# 指定類型
arr = np.array([1,2,3],dtype=np.int64) print(arr) print(arr.dtype) 

[1 2 3]
int64

In [17]:

# 同構還是異構
# 原生python中 list1 = [1,True,"a",[1,23]] print(list1) # numpy中 arr = np.array([1,True,'a']) print(arr) print(arr.dtype) # 可以看到結果里面全部轉化成了字符串，也就是全部轉化為了同一類型 

[1, True, 'a', [1, 23]]
['1' 'True' 'a']
<U11

2、arange方法

為了創建數字組成的數組，NumPy提供了一個類似於range的函數arange，該函數返回數組而不是列表。

In [13]:

arr = np.arange(10) print(arr) # 指定起點和終點 arr = np.arange(10,20) print(arr) # 指定步長 arr = np.arange(10,20,3) print(arr) 

[0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]
[10 13 16 19]

In [15]:

# reshape方法改變維數
arr = np.arange(6).reshape((2,3)) print(arr) 

[[0 1 2]
 [3 4 5]]

In [18]:

# 等差數列
arr = np.linspace(1,3,5) print(arr) print(arr.dtype) 

[1.  1.5 2.  2.5 3. ]
float64

In [21]:

# 等比數列
arr = np.logspace(1,3,5) print(arr) print(arr.dtype) 

[  10.           31.6227766   100.          316.22776602 1000.        ]
float64

三、特殊矩陣

numpy中的特殊矩陣

numpy中的特殊矩陣 主要有ones（全1）、zeros（全0）、eye（單位矩陣）、empty（未初始化）

np.ones((3,4))
np.zeros((3,4))
np.eye(2)
np.empty((6,4))

In [23]:

# 參數是一個元組，來指定行列
arr = np.ones((3,4)) print(arr) 

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

In [25]:

arr = np.zeros((3,4)) print(arr) 

[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

In [35]:

help(np.eye) 

Help on function eye in module numpy:

eye(N, M=None, k=0, dtype=<class 'float'>, order='C')
    Return a 2-D array with ones on the diagonal and zeros elsewhere.
    
    Parameters
    ----------
    N : int
      Number of rows in the output.
    M : int, optional
      Number of columns in the output. If None, defaults to `N`.
    k : int, optional
      Index of the diagonal: 0 (the default) refers to the main diagonal,
      a positive value refers to an upper diagonal, and a negative value
      to a lower diagonal.
    dtype : data-type, optional
      Data-type of the returned array.
    order : {'C', 'F'}, optional
        Whether the output should be stored in row-major (C-style) or
        column-major (Fortran-style) order in memory.
    
        .. versionadded:: 1.14.0
    
    Returns
    -------
    I : ndarray of shape (N,M)
      An array where all elements are equal to zero, except for the `k`-th
      diagonal, whose values are equal to one.
    
    See Also
    --------
    identity : (almost) equivalent function
    diag : diagonal 2-D array from a 1-D array specified by the user.
    
    Examples
    --------
    >>> np.eye(2, dtype=int)
    array([[1, 0],
           [0, 1]])
    >>> np.eye(3, k=1)
    array([[0.,  1.,  0.],
           [0.,  0.,  1.],
           [0.,  0.,  0.]])

In [49]:

# 對角矩陣的行列肯定是一樣的
arr = np.eye(2) print(arr) 

[[1. 0.]
 [0. 1.]]

In [50]:

# empty為空，表示沒有初始化的意思
arr1 = np.empty((6,4)) print(arr1) 

[[4.624e-321 4.624e-321 4.190e-321 4.190e-321]
 [2.628e-321 2.628e-321 3.992e-321 3.992e-321]
 [4.585e-321 4.585e-321 4.427e-321 4.427e-321]
 [5.613e-321 5.613e-321 5.652e-321 5.652e-321]
 [5.454e-321 5.454e-321 2.174e-321 2.174e-321]
 [5.830e-321 5.830e-321 4.466e-321 4.466e-321]]

四、常用屬性

numpy的多維數組常用屬性主要有dtype（數據類型）、ndim（維度）、shape（性狀）、size（元素個數）

arr = np.arange(12).reshape((3,4))
print(arr)
# 數據類型
print(arr.dtype)
# 維數
print(arr.ndim)
# 行數和列數
print(arr.shape)
# 大小，也就是元素個數
print(arr.size)

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
int32
2
(3, 4)
12

In [52]:

arr = np.arange(12).reshape((3,4)) print(arr) # 數據類型 print(arr.dtype) # 維數 print(arr.ndim) # 行數和列數 print(arr.shape) # 大小，也就是元素個數 print(arr.size) 

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
int32
2
(3, 4)
12

五、基本計算

numpy中的ndarray對象重載了許多運算符，使用這些運算符可以完成矩陣間對應元素的運算。

如 +，-，*（內積），/，%，**（次方），@（矩陣階層）

# 矩陣內積：對應位置相乘
print(arr1*arr2)
# 矩陣乘法：
print(arr1@arr2)
print(np.dot(arr1,arr2))
print(arr1.dot(arr2))

In [61]:

arr1 = np.array([[0,1],[1,2]]) arr2 = np.arange(4).reshape((2,2)) ans = arr1 + arr2 print(arr1) print(arr2) print("===========================") print(ans) print(arr2-arr1) 

[[0 1]
 [1 2]]
[[0 1]
 [2 3]]
===========================
[[0 2]
 [3 5]]
[[0 0]
 [1 1]]

In [64]:

# 矩陣內積：對應位置相乘
print(arr1*arr2) # 矩陣乘法： print(arr1@arr2) print(np.dot(arr1,arr2)) print(arr1.dot(arr2)) 

[[0 1]
 [2 6]]
[[2 3]
 [4 7]]
[[2 3]
 [4 7]]
[[2 3]
 [4 7]]

In [65]:

print(arr1*3) 

[[0 3]
 [3 6]]

In [66]:

print(arr1/2) 

[[0.  0.5]
 [0.5 1. ]]

In [67]:

print(arr1**2) 

[[0 1]
 [1 4]]

In [69]:

print(arr2%3) 

[[0 1]
 [2 0]]

六、常用函數

numpy常用多維函數有sin、sqrt、sort、transpose、max、

mean（average）、sum、median（中位數）、var（方差）、std（標准差）、cumsum（累加）、

np.clip(arr,5,9)（小於5的數全部讓它變成5，大於9的數全部是9）

---

axis為0為1表示的意思是什么

axis為0表示對列進行操作，axis為1表示為行進行操作

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

# 平均數
print(arr.mean())
print(np.average(arr))
print(np.average(arr,axis=0)) # 0是列
print(np.average(arr,axis=1)) # 1是行

5.75
5.75
[4. 5. 7. 7.]
[1.5  6.25 9.5 ]

In [71]:

arr = np.arange(12).reshape((3,4)) print(arr) print(np.sin(arr)) print(np.sqrt(arr)) 

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0.          0.84147098  0.90929743  0.14112001]
 [-0.7568025  -0.95892427 -0.2794155   0.6569866 ]
 [ 0.98935825  0.41211849 -0.54402111 -0.99999021]]
[[0.         1.         1.41421356 1.73205081]
 [2.         2.23606798 2.44948974 2.64575131]
 [2.82842712 3.         3.16227766 3.31662479]]

In [77]:

# 隨機數 排序  轉置  求平均數  
arr = np.random.random(12).reshape((3,4)) print(arr) # 默認每行排序 print(np.sort(arr)) 

[[0.14680654 0.45555777 0.20272618 0.80548907]
 [0.0580613  0.59622315 0.14429785 0.50518877]
 [0.7277057  0.26036975 0.71367339 0.64882704]]
[[0.14680654 0.20272618 0.45555777 0.80548907]
 [0.0580613  0.14429785 0.50518877 0.59622315]
 [0.26036975 0.64882704 0.71367339 0.7277057 ]]

In [79]:

arr = np.random.random(12).reshape((3,4)) print(arr) # 指定列排序 print(np.sort(arr,axis=0)) 

[[0.28404892 0.16859485 0.40676585 0.82394419]
 [0.13459384 0.35249053 0.43333728 0.09445943]
 [0.80790859 0.13132432 0.17725597 0.90638246]]
[[0.13459384 0.13132432 0.17725597 0.09445943]
 [0.28404892 0.16859485 0.40676585 0.82394419]
 [0.80790859 0.35249053 0.43333728 0.90638246]]

In [83]:

# 轉置
arr = np.arange(12).reshape((3,4)) print(arr) print(arr.T) print(arr.transpose()) 

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]
[[ 0  4  8]
 [ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]]

In [101]:

# max,min
# 0是列（一列來操作），1是行（一行來操作） arr = np.arange(12).reshape((3,4)) arr[1][2]=9 print(arr) print(np.max(arr)) print(np.max(arr,axis=0)) print(np.max(arr,axis=1)) 

[[ 0  1  2  3]
 [ 4  5  9  7]
 [ 8  9 10 11]]
11
[ 8  9 10 11]
[ 3  9 11]

In [102]:

# 平均數
print(arr.mean()) print(np.average(arr)) print(np.average(arr,axis=0)) # 0是列 print(np.average(arr,axis=1)) # 1是行 

5.75
5.75
[4. 5. 7. 7.]
[1.5  6.25 9.5 ]

In [103]:

# 中位數
print(np.median(arr)) print(np.median(arr,axis=0)) # 0是列 print(np.median(arr,axis=1)) # 1是行 

6.0
[4. 5. 9. 7.]
[1.5 6.  9.5]

In [93]:

# 方差和標准差
# 方差的函數為var(),方差函數var()相當於函數mean(abs(x - x.mean())**2),其中x為矩陣。 print(np.var(arr)) # 標准差的函數為std()， std()相當於sqrt(mean(abs(x - x.mean())**2))，或相當於sqrt(x.var())。 print(np.std(arr)) 

11.916666666666666
3.452052529534663

In [95]:

# 求和
print(np.sum(arr)) 

66

In [97]:

# 累加
print(arr) print(np.cumsum(arr)) 

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[ 0  1  3  6 10 15 21 28 36 45 55 66]

In [105]:

# 小於5的數全部讓它變成5
# 大於9的數全部是9 print(np.clip(arr,5,9)) 

[[5 5 5 5]
 [5 5 9 7]
 [8 9 9 9]]

In [106]:

help(np.clip) 

Help on function clip in module numpy:

clip(a, a_min, a_max, out=None, **kwargs)
    Clip (limit) the values in an array.
    
    Given an interval, values outside the interval are clipped to
    the interval edges.  For example, if an interval of ``[0, 1]``
    is specified, values smaller than 0 become 0, and values larger
    than 1 become 1.
    
    Equivalent to but faster than ``np.maximum(a_min, np.minimum(a, a_max))``.
    No check is performed to ensure ``a_min < a_max``.
    
    Parameters
    ----------
    a : array_like
        Array containing elements to clip.
    a_min : scalar or array_like or None
        Minimum value. If None, clipping is not performed on lower
        interval edge. Not more than one of `a_min` and `a_max` may be
        None.
    a_max : scalar or array_like or None
        Maximum value. If None, clipping is not performed on upper
        interval edge. Not more than one of `a_min` and `a_max` may be
        None. If `a_min` or `a_max` are array_like, then the three
        arrays will be broadcasted to match their shapes.
    out : ndarray, optional
        The results will be placed in this array. It may be the input
        array for in-place clipping.  `out` must be of the right shape
        to hold the output.  Its type is preserved.
    **kwargs
        For other keyword-only arguments, see the
        :ref:`ufunc docs <ufuncs.kwargs>`.
    
        .. versionadded:: 1.17.0
    
    Returns
    -------
    clipped_array : ndarray
        An array with the elements of `a`, but where values
        < `a_min` are replaced with `a_min`, and those > `a_max`
        with `a_max`.
    
    See Also
    --------
    ufuncs-output-type
    
    Examples
    --------
    >>> a = np.arange(10)
    >>> np.clip(a, 1, 8)
    array([1, 1, 2, 3, 4, 5, 6, 7, 8, 8])
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> np.clip(a, 3, 6, out=a)
    array([3, 3, 3, 3, 4, 5, 6, 6, 6, 6])
    >>> a = np.arange(10)
    >>> a
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> np.clip(a, [3, 4, 1, 1, 1, 4, 4, 4, 4, 4], 8)
    array([3, 4, 2, 3, 4, 5, 6, 7, 8, 8])

七、索引和迭代

numpy中，可以像普通數組一樣用下標來訪問元素，比如a[1][1]、a[1,1]

---

numpy中訪問行列元素

a[1,:]（打印下標為1的行所有數）

a[:,1]（打印下標為1的列的所有數）

a[1,1:3]（第1行 列從1-2）

---

numpy中迭代行循環打印即可，如何迭代列

將矩陣轉置即可

# 迭代列 (轉置一下即可實現)
for i in a.T:
    print(i)

---

numpy中如何迭代多維數組的每一個數

for i in a.flat: print(i)

In [125]:

a = np.arange(3,15) print(a) # 索引像數組一樣 print(a[3]) 

[ 3  4  5  6  7  8  9 10 11 12 13 14]
6

In [108]:

# 二維數組
a = np.arange(3,15).reshape((3,4)) print(a) # 索引像數組一樣 print(a[1]) print(a[1][1]) print(a[1,1]) 

[[ 3  4  5  6]
 [ 7  8  9 10]
 [11 12 13 14]]
[ 7  8  9 10]
8
8

In [109]:

# 打印下標為1的行所有數
print(a[1,:]) # 打印下標為1的列的所有數 print(a[:,1]) # 第1行 列從1-2 print(a[1,1:3]) 

[ 7  8  9 10]
[ 4  8 12]
[8 9]

In [110]:

# 迭代行
a = np.arange(3,15).reshape((3,4)) print(a) for i in a: print(i) 

[[ 3  4  5  6]
 [ 7  8  9 10]
 [11 12 13 14]]
[3 4 5 6]
[ 7  8  9 10]
[11 12 13 14]

In [111]:

# 迭代列 (轉置一下即可實現)
for i in a.T: print(i) 

[ 3  7 11]
[ 4  8 12]
[ 5  9 13]
[ 6 10 14]

In [112]:

# 迭代每一個數
print(a.flatten()) # flatten() 和 flat的區別 # flat是一個迭代器 for i in a.flat: print(i) 

[ 3  4  5  6  7  8  9 10 11 12 13 14]
3
4
5
6
7
8
9
10
11
12
13
14

八、數組合並

numpy數組水平合並可以np.hstack((a,b))，類似於np.concatenate((a,b,a),axis=1)

numpy數組垂直合並可以np.vstack((a,b))，類似於np.concatenate((a,b,a),axis=0)

In [113]:

a = np.array([1,2,3]) b = np.array([4,5,6]) # 合並數組 # 上下合並 vertical stack c = np.vstack((a,b)) print(c) print(a.shape) print(c.shape) 

[[1 2 3]
 [4 5 6]]
(3,)
(2, 3)

In [114]:

# 左右合並 horizontal
c = np.hstack((a,b)) print(c) 

[1 2 3 4 5 6]

In [115]:

# 如何實現把一個橫向的數列變成一個豎向的數列
a = np.array([1,2,3]) # 在行上加了一個維度 print(a[np.newaxis,:]) # 在列上加了一個維度 print(a[:,np.newaxis]) 

[[1 2 3]]
[[1]
 [2]
 [3]]

In [116]:

a = np.array([1,2,3])[:,np.newaxis] b = np.array([4,5,6])[:,np.newaxis] print(a) print(b) print("====================") c = np.concatenate((a,b,a),axis=0) print(c) print("====================") d = np.concatenate((a,b,a),axis=1) print(d) 

[[1]
 [2]
 [3]]
[[4]
 [5]
 [6]]
====================
[[1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [1]
 [2]
 [3]]
====================
[[1 4 1]
 [2 5 2]
 [3 6 3]]

九、數組分割

等量分割：水平分成兩塊np.split(a,2,axis=1)，vsplit和hsplit也可以等量分割

不等量分割：np.array_split(a,3,axis=1)

In [128]:

a = np.arange(12).reshape((3,4)) print(a) print("====================") # 分割 # 每行分割成兩個 # axis=1表示對水平進行操作 print(np.split(a,2,axis=1)) 

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
====================
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

In [118]:

# 縱向分割成3塊
print(np.split(a,3,axis=0)) 

[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

In [119]:

# 不等量分割
# ValueError: array split does not result in an equal division # print(np.split(a,3,axis=1)) # 行的四個元素分成3個會出錯 print(np.array_split(a,3,axis=1)) # 這樣分成了 2 1 1 

[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2],
       [ 6],
       [10]]), array([[ 3],
       [ 7],
       [11]])]

In [131]:

print(np.vsplit(a,3)) print(np.hsplit(a,2)) 

[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]
[array([[0, 1],
       [4, 5],
       [8, 9]]), array([[ 2,  3],
       [ 6,  7],
       [10, 11]])]

十、數組拷貝

numpy 中的 copy方法是 deep copy：b = np.copy(a)

In [121]:

a = np.arange(4) b = a print(a) print(b) 

[0 1 2 3]
[0 1 2 3]

In [122]:

a[0] = 199 b[1:3] = [7,8] print(a) print(b) print(id(a)) print(id(b)) print(b is a) 

[199   7   8   3]
[199   7   8   3]
2190570709120
2190570709120
True

In [132]:

# numpy 中的 copy方法是 deep copy
# 文檔中說的非常詳細 a = np.arange(4) # b = a.copy() b = np.copy(a) print(a) print(b) print(id(a)) print(id(b)) 

[0 1 2 3]
[0 1 2 3]
2190587830880
2190587831440

In [133]:

a[0] = 199 b[1:3] = [7,8] print(a) print(b) 

[199   1   2   3]
[0 7 8 3]

In [ ]: