總結numpy中的ndarray，非常齊全

numpy(Numerical Python)是一個開源的Python資料科學計算庫，支援對N維數組和矩陣的操作，用于快速處理任意次元的數組。

numpy庫的功能非常聚焦，專注于做好“一件事”。numpy主要使用ndarray來處理N維數組，numpy中的大部分屬性和方法都是為ndarray服務的。是以，掌握了ndarray的用法，基本就掌握了numpy的用法。

ndarray是一個N維數組類型的對象，與python的基本資料類型清單相比，同一個ndarray中所有元素的資料類型都相同，而清單中可以存儲不同類型的資料。ndarray在存儲的資料類型上做限制，換取了運算效率的提升和資料處理的便捷，在資料分析中非常實用。

一、ndarray的屬性

# coding=utf-8
import numpy as np


array_a = np.array([[1, 2, 3], [4, 5, 6]])
print(array_a)
print('ndarray的次元: ', array_a.ndim)
print('ndarray的形狀: ', array_a.shape)
print('ndarray的元素數量: ', array_a.size)
print('ndarray中的資料類型: ', array_a.dtype)
print(type(array_a))      

[[1 2 3]
 [4 5 6]]
ndarray的次元:  2
ndarray的形狀:  (2, 3)
ndarray的元素數量:  6
ndarray中的資料類型:  int32
<class 'numpy.ndarray'>      

ndarray有很多屬性和方法，可以用dir()内置方法将他們列印出來。本文先從屬性開始介紹。

shape屬性表示ndarray的形狀，是一個元組，表示數組有幾維，每個次元有多少個資料。ndim屬性表示數組的次元。size屬性表示數組中的元素個數，size可以通過shape中的值相乘得到。dtype屬性表示數組中儲存的資料類型。從Python解釋器的角度看，ndarray屬于numpy.ndarray對象。

二、ndarray的次元和形狀

為了更好地了解ndarray，可以先看它的次元和形狀。

array_b = np.array([1, 1, 1])
array_c = np.array([[2, 2, 2], [2, 2, 2]])
array_d = np.array([[[3, 3, 3], [3, 3, 3]], [[3, 3, 3], [3, 3, 3]]])
print(array_b, '\n{}'.format(array_c), '\n{}'.format(array_d))
print(array_b.shape, array_c.shape, array_d.shape)      

[1 1 1] 
[[2 2 2]
 [2 2 2]] 
[[[3 3 3]
  [3 3 3]]
 [[3 3 3]
  [3 3 3]]]
(3,) (2, 3) (2, 2, 3)      

array_b是一個一維數組，數組中有三個資料。array_c是一個二維數組，數組中有2*3個資料。array_d是一個三維數組，數組中有2*2*3個資料。是以它們的形狀分别是(3,) 、(2, 3)和 (2, 2, 3)。用圖形表示如下：

從一維到三維的變化，可以幫助我們了解ndarray的次元和形狀變化。ndarray的次元可以是N維，從4維開始，不友善用圖形來展示，會稍微抽象一點。

從Python中的資料表示方式來看，N維數組的顯示結果與清單相同，每多嵌套一層，就代表多一個次元。根據上面例子中的資料，依次類推，可以表示出更多元度的ndarray資料。

三、ndarray中的資料類型

前面已經提到，在一個ndarray對象中，存儲的是同一類型的資料，ndarray中常見的資料類型有下表這些。

名稱	描述	簡寫
np.bool	用一個位元組存儲的布爾類型(True或False)，在資料分析中很常用。	'b'
np.int8	一個位元組大小，-128至127，不常用。	'i'
np.int16	整數，-32768至32767，不常用。	'i2'
np.int32	整數，-2^31至2^32-1，常用。	'i4'
np.int64	整數，-2^63至2^63-1，常用，一般整數預設為np.int64或np.int32。	'i8'
np.uint8	無符号整數，0至255，不常用。	'u'
np.uint16	無符号整數，0至65535，不常用。	'u2'
np.uint32	無符号整數，0至2^32-1，常用。	'u4'
np.uint64	無符号整數，0至2^64-1，常用。	'u8'
np.float16	16位半精度浮點數，正負号1位，指數5位，精度10位，不常用。	'f2'
np.float32	32位單精度浮點數，正負号1位，指數8位，精度23位，不常用。	'f4'
np.float64	64位雙精度浮點數，正負号1位，指數11位，精度52位，常用。	'f8'
np.complex64	複數，分别用兩個32位浮點數表示實部和虛部，基本不會用。	'c8'
np.complex128	複數，分别用兩個64位浮點數表示實部和虛部，基本不會用。	'c16'
np.object_	python對象，常用。	'O'
np.string_	字元串，常用。	'S'
np.unicode_	unicode類型，不常用。	'U'

四、修改ndarray的形狀和資料類型

1. 修改ndarray的形狀

array_e = np.array([[1, 2, 3], [4, 5, 6]])
print(array_e, array_e.shape)
array_e1 = array_e.reshape((3, 2))
print(array_e1, array_e1.shape)
array_e2 = array_e.T
print(array_e2, array_e2.shape)      

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

reshape(shape[, order]): 修改ndarray的形狀。修改數組的形狀時，不能改變數組中的元素個數，如上面的數組形狀是(2, 3)，可以修改成(3, 2)或(1, 6)、(6, 1)，修改形狀後仍然是6個元素。

ndarray.T: 将ndarray轉置(行和列交換，行變成列，列變成行)。 對比上面的兩次修改，reshape()和.T轉換後數組的形狀都是(3, 2)，但資料的排列方式不一樣，reshape()修改的結果沒有改變資料的先後順序，.T的結果是将行變成列，列變成行。

2. 修改ndarray的資料類型

array_f = np.array([[1, 2, 3], [4, 5, 6]])
print(array_f, array_f.dtype)
array_f1 = array_f.astype(np.int64)
print(array_f1, array_f1.dtype)      

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

astype(dtype[, order, casting, subok, copy]): 修改ndarray中的資料類型。傳入需要修改的資料類型，其他關鍵字參數可以不關注。

五、ndarray的多種生成和建立方法

1. 生成全為0或全為1的ndarray

array_g = np.ones((2, 3), order='F')
print(array_g, array_g.dtype)
array_h = np.zeros((3, 3), dtype='int64')
print(array_h, array_h.dtype)
array_i = np.ones_like([[1, 2, 3], [4, 5, 6]])
print(array_i, array_i.dtype)
array_j = np.zeros_like([[1, 2, 3], [4, 5, 6]])
print(array_j, array_j.dtype)      

[[1. 1. 1.]
 [1. 1. 1.]] float64
[[0 0 0]
 [0 0 0]
 [0 0 0]] int64
[[1 1 1]
 [1 1 1]] int32
[[0 0 0]
 [0 0 0]] int32      

ones(shape[, dtype, order]): 生成全為1的ndarray。shape為必傳參數，表示生成的數組的形狀。dtype表示數組中存儲的資料類型，預設為float64，可以指定資料類型。order表示數組的秩序，表示存儲的資料是以行為主還是以列為主(兩種風格)，通常不關注此參數。

zeros(shape[, dtype, order]): 生成全為0的ndarray。參數同ones()。

ones_like(a[, dtype, order, subok]): 生成全為1的ndarray，形狀與已知數組相同。a為必傳參數，傳入一個形似array的資料(array_like，通常是嵌套清單或數組)。dtype表示數組中存儲的資料類型，預設與傳入的數組相同。另外兩個參數通常不關注。

zeros_like(a[, dtype, order, subok]): 生成全為0的ndarray，形狀與已知數組相同。參數同ones_like()。

2. 生成全為指定值或全為空的ndarray

array_k = np.full((2, 3), 2)
print(array_k, array_k.dtype)
array_l = np.full_like([[1, 2, 3], [4, 5, 6]], 3)
print(array_l, array_l.dtype)
array_m = np.empty((2, 3))
print(array_m, array_m.dtype)
array_n = np.empty((2, 4))
print(array_n, array_n.dtype)      

[[2 2 2]
 [2 2 2]] int32
[[3 3 3]
 [3 3 3]] int32
[[1. 1. 1.]
 [1. 1. 1.]] float64
[[6.23042070e-307 4.67296746e-307 1.69121096e-306 1.33511562e-306]
 [1.37962660e-306 8.34441742e-308 1.42420481e-306 1.24612013e-306]] float64      

full(shape, fill_value[, dtype, order]): 生成全為指定值的ndarray。shape為必傳參數，表示生成的數組的形狀。fill_value為必傳參數，表示指定的填充值。

full_like(a, fill_value[, dtype, order, subok]): 生成全為指定值的ndarray，形狀與已知數組相同。a為必傳參數，傳入一個形似array的資料。fill_value為必傳參數，表示指定的填充值。

empty(shape[, dtype, order]): 生成全為空值的ndarray。如果記憶體空間中存在一個數組，與生成的空數組形狀和資料類型都相同，則生成的空數組會直接指向存在的數組。如果要生成一個完全為空的數組，需要先将記憶體中形狀和資料類型都相同的數組清除，或使空數組的形狀或資料類型與已存在的數組不同，這樣才能新開辟記憶體空間，生成真正的空數組，列印空數組的結果是記憶體編碼。與前面的函數相似，也有對應的empty_like(a[, dtype, order, subok])函數。

3. 生成指定範圍值的ndarray

array_o = np.arange(1, 10, 2)
array_p = np.linspace(0, 20, 5, retstep=True)
array_q = np.linspace(array_o, 5, 3)
array_r = np.logspace(0, 100, 6)
print(array_o, '\n{}'.format(array_p), '\n{}'.format(array_q), '\n{}'.format(array_r))      

[1 3 5 7 9] 
(array([ 0.,  5., 10., 15., 20.]), 5.0) 
[[1. 3. 5. 7. 9.]
 [3. 4. 5. 6. 7.]
 [5. 5. 5. 5. 5.]] 
[1.e+000 1.e+020 1.e+040 1.e+060 1.e+080 1.e+100]      

arange(start, stop, step[, dtype]): 給定起始值、結束值(不包含結束值)和步長，生成指定範圍的一維數組，效果相當于Python内置函數range()。

linspace(start, stop[, num, endpoint, retstep, dtype, axis]): 給定起始值、結束值，生成等間隔的一維數組。start表示數組的起始值。stop表示數組的終止值。num表示生成數組中的資料個數，預設為50。endpoint表示數組中是否包含stop值，預設為Ture。retstep表示是否傳回數組的步長，預設為False。dtype表示ndarray中的資料類型。

linspace()中的start或stop也可以傳入形似array的資料，此時可生成二維數組。axis參數此時可以派上用場，表示将array_like的資料作為行還是作為列來生成二維數組，預設為0時作為行，如果為-1則作為列。

logspace(start, stop[, num, endpoint, base, dtype, axis]): 給定起始值、結束值，生成等間隔的一維數組，資料為對數函數log的值。base表示log函數的底數，預設為10。其他參數同linspace()。

4. 生成随機值的ndarray

array_s = np.random.randint(1, 10, 5)
array_t = np.random.rand(5)
array_u = np.random.uniform(size=5)
array_v = np.random.randn(5)
array_w = np.random.normal(10, 1, 5)
print(array_s, '\n{}'.format(array_t), '\n{}'.format(array_u), '\n{}'.format(array_v), '\n{}'.format(array_w))      

[1 7 4 2 8] 
[0.68173299 0.92899918 0.01771993 0.03010565 0.74799694] 
[0.97895281 0.67811682 0.15493234 0.04435618 0.15152692] 
[ 1.24094827  1.27898853 -1.42507622  1.97560767 -0.43269307] 
[11.24927114 10.07827993  9.83908081 10.94827526 10.14160875]      

np.random.randint(low, high=None, size=None, dtype=None): 給定起始值、結束值(不包含結束值)和資料個數，從指定範圍内生成指定個數(每次生成一個，共size次)的整數，組成一個一維數組。

np.random.rand(): 生成一個0到1(不包含1)之間的随機數，如果傳入生成的資料個數，則生成一維數組，數組中的每個值都是0到1之間的随機數。

np.random.uniform(low=0.0, high=1.0, size=None): 給定起始值、結束值(不包含結束值)和資料個數，從指定範圍内生成指定個數的小數，組成一維數組。預設同rand()。

這三個函數在生成随機數組時，資料範圍内的每個數機率相等，資料是均勻分布的。

np.random.randn(): 按标準正太分布(均值為0，标準差為1)生成一個随機數。如果傳入生成的資料個數，則生成一維數組。

np.random.normal(loc=0.0, scale=1.0, size=None): 給定均值、标準差和資料個數，按正太分布的機率生成指定個數的數，組成一個一維數組。

randn()和normal()函數生成的随機數組中，資料是正太分布的。

5. ndarray的淺拷貝和深拷貝

除了直接建立新的數組，也可以複制已有的數組。

array_x = np.array([(5, 5, 5), [5, 5, 5]])
array_y = np.asarray(array_x)
array_z = np.copy(array_x)
print(array_x, '\n{}'.format(array_y), '\n{}'.format(array_z))      

[[5 5 5]
 [5 5 5]] 
[[5 5 5]
 [5 5 5]] 
[[5 5 5]
 [5 5 5]]      

array(object[, dtype, copy, order, subok, ndmin]): 建立一個數組，傳入一個形似array的資料。在最開始介紹ndarray屬性時，就是用array()建立數組。

asarray(a[, dtype, order]): 将輸入的資料轉換為一個數組，輸入一個嵌套清單或數組，可以用此函數來實作拷貝數組。asarray()還有幾個延伸的函數asanyarray(a[, dtype, order])，ascontiguousarray(a[, dtype])和asmatrix(data[, dtype])。

copy(a[, order]): 拷貝數組。copy()函數是深拷貝，asarray()函數是淺拷貝，下面驗證一下。

array_x[0][1] = 6
print(array_x, '\n{}'.format(array_y), '\n{}'.format(array_z))      

[[5 6 5]
 [5 5 5]] 
[[5 6 5]
 [5 5 5]] 
[[5 5 5]
 [5 5 5]]      

被拷貝的數組中所有資料都是5，用asarray()和copy()函數拷貝的數組也一樣。修改被拷貝數組中第一維第二個資料為6後，asarray()函數拷貝的數組中也變成了6，copy()函數拷貝的數組中還是5，說明asarray()函數是淺拷貝，copy()函數是深拷貝。

六、ndarray的索引、切片和去重

1. ndarray的索引和切片

array1 = np.array([[[1, 2, 3, 4], [3, 4, 5, 6]], [[7, 8, 9, 10], [9, 10, 11, 12]]])
print(array1, array1.shape)
print(array1[1])
print(array1[1][0])
print(array1[1, 0])
print(array1[0, :1, 1:3])      

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

ndarray的索引和切片與Python清單的方式相同，可以直接用清單的文法對ndarray進行索引和切片操作。另外，numpy中還有特殊的索引和切片文法，如array[1, 0]與array[1][0]的結果一樣。

2. ndarray的去重

array2 = np.unique(array1)
print(array2)      

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

unique(ar, [return_index, return_inverse, return_counts, axis]): 對ndarray去重。預設是對整個數組去重，傳回一個一維數組。也可以使用axis參數指定按行還是按列去重。

七、ndarray的運算

1. 邏輯運算

array3 = np.array([[1, 2, 3], [4, 5, 6]])
print(np.all(array3 > 1))
print(np.any(array3 > 1))      

False
True      

ndarray可以直接與整數進行比較，判斷大小，傳回布爾值。

all(a[, axis, out, keepdims]): 當ndarray中的所有元素都滿足邏輯判斷時，傳回真，否則傳回假。如數組[[1, 2, 3], [4, 5, 6]] > 1當且僅當所有數都大于1時，才為真。

any(a[, axis, out, keepdims]): 隻要ndarray中有一個元素滿足邏輯判斷，傳回真，全都不滿足時傳回假。如數組[[1, 2, 3], [4, 5, 6]] > 1隻要有一個數大于1，就為真。

2. 三目運算

array4 = np.where(array3 > 3, 1, 0)
print(array4)
array5 = np.where(np.logical_and(array3 > 2, array3 < 5), 1, 0)
print(array5)
array6 = np.where(np.logical_or(array3 < 2, array3 > 5), 1, 0)
print(array6)      

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

where(condition, x=None, y=None): 對ndarray中的所有資料進行邏輯運算，邏輯為真的位置指派為x，邏輯為假的位置指派為y，實作三目運算。如果需要進行複合邏輯運算，可以使用np.logical_and()、np.logical_not()、np.logical_or()或np.logical_xor()來連接配接，分别表示邏輯與、邏輯非、邏輯或和邏輯異或(同真同假為假，一真一假為真)。

3. 統計運算

array7 = np.array([[1, 3, 5], [7, 9, 11]])
print('最小值： ', np.min(array7), np.min(array7, axis=0))
print('最大值： ', np.max(array7), np.max(array7, axis=1))
print('中位數： ', np.median(array7))
print('平均值： ', np.mean(array7))
print('标準差： ', np.std(array7))
print('方差： ', np.var(array7))
print('最小值的索引： ', np.argmin(array7))
print('最大值的索引： ', np.argmax(array7))      

最小值：  1 [1 3 5]
最大值：  11 [ 5 11]
中位數：  6.0
平均值：  6.0
标準差：  3.415650255319866
方差：  11.666666666666666
最小值的索引：  0
最大值的索引：  5      

min(a[, axis, out, keepdims, initial, where]): 傳回ndarray中的最小值。實際調用的是amin()函數。如果設定axis為0，則計算每一列的最小值，axis為1，則計算每一行的最小值。

max(a[, axis, out, keepdims, initial, where]): 傳回ndarray中的最大值。實際調用的是amax()函數。

median(a[, axis, out, overwrite_input, keepdims]): 傳回ndarray中的中位數。

mean(a[, axis, dtype, out, keepdims]): 傳回ndarray的平均值。

std(a[, axis, dtype, out, ddof, keepdims]): 傳回ndarray的标準差。

var(a[, axis, dtype, out, ddof, keepdims]): 傳回ndarray的方差。

argmin(a[, axis, out]): 傳回ndarray中最小值的索引。

argmax(a[, axis, out]): 傳回ndarray中最大值的索引。

上面的所有函數中，axis參數的用法都相同。

八、ndarray之間的運算

1. ndarray與數字和ndarray之間的運算

array8 = np.array([[1, 2, 3], [4, 5, 6]])
print(array8 + 2)
array9 = np.array([[2, 2, 2], [2, 2, 2]])
print(array8 * array9)      

[[3 4 5]
 [6 7 8]]
[[ 2  4  6]
 [ 8 10 12]]      

ndarray可以直接與數字進行算術運算，注意乘法運算與清單的乘法運算不同，清單與數字相乘是拼接，而ndarray與數字相乘是數組中的每一個資料與數字相乘生成一個新數組。

兩個形狀相同的數組之間也可以直接進行算術運算，運算的結果是将兩個數組索引相同的資料進行算術運作，生成一個新數組。

2. ndarray的廣播機制

array10 = np.array([[[1, 1, 1], [1, 1, 1]], [[1, 1, 1], [1, 1, 1]]])
print(array8 * array10)      

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

當兩個數組的形狀不相同時，要将他們進行運算，numpy會嘗試進行廣播。廣播是将兩個數組的形狀元組值從後往前逐個進行比較，如果元組中的值相等、其中一個為1或其中一個不存在，則兩個數組可以進行運算，生成一個相容兩個數組的新數組。如上面的array8形狀是(2, 3)， array10的形狀是(2, 2, 3)，從末尾依次比較，3等于3，2等于2，最前面有一個值為空，滿足廣播的機制，相乘後得到一個形狀為(2, 2, 3)的新數組。下面看一個不能廣播的例子。

array11 = np.array([[1, 1, 1, 1], [1, 1, 1, 1]])
print(array8 * array11)      

ValueError: operands could not be broadcast together with shapes (2,3) (2,4)       

上面的array8形狀是(2, 3)， array11的形狀是(2, 4)，從末尾開始比較，一個為3，一個為4，不滿足廣播的三種條件，是以不能廣播，執行運算會報錯。

3. 矩陣相乘

array12 = np.array([[1, 10]])
array13 = np.array([[1, 2, 3], [4, 5, 6]])
print(array12.shape, array13.shape)
print(np.mat(array12) * np.mat(array13))
print(np.matmul(array12, array13))
print(np.dot(array12, array13))      

(1, 2) (2, 3)
[[41 52 63]]
[[41 52 63]]
[[41 52 63]]      

與ndarray相比，矩陣一定是二維的。矩陣相乘的條件是第一個矩陣的列與第二個矩陣的行相等，(M行 * N列) * (N行 * L列) = (M行 * L列)。

mat(): 将二維的數組轉換成矩陣。将兩個數組轉換成矩陣後，如果滿足矩陣的相乘條件，即可将它們相乘。

matmul(x1, x2): 矩陣相乘，傳入兩個滿足相乘條件的矩陣，也可以是二維數組或清單，會自動轉換成矩陣。

dot(a, b[, out]): 矩陣相乘，傳入兩個滿足相乘條件的矩陣，也可以是二維數組或清單，會自動轉換成矩陣。

九、ndarray的合并和分割

1. ndarray的合并

array14 = np.array([[1, 2, 3], [4, 5, 6]])
array15 = np.array([[1, 1, 1], [2, 2, 2]])
print(np.concatenate([array14, array15], axis=1))
print(np.concatenate([array14, array15], axis=0))
print(np.hstack([array14, array15]))
print(np.vstack([array14, array15]))      

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

concatenate(arrays[, axis, out]): 合并兩個數組，将需要合并的數組放到一個可疊代對象(清單或元組)中。axis為1表示水準合并，axis為0表示垂直合并，預設為0。

hstack(tup): 水準合并兩個數組，h是horizontally的縮寫。

vstack(tup): 垂直合并兩個數組，v是vertically的縮寫。

2. ndarray的分割

array16 = np.array([1, 2, 3, 4, 5, 6])
print(np.split(array16, 2))
print(np.split(array16, [2, 3, 5]))      

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

split(ary[, indices_or_sections, axis]): 分割數組。split函數會把數組當成一維數組來分割，即使傳入的是多元數組。第二個參數如果傳入一個整數，則會進行等分，無法等分時報錯。第二個參數如果傳入由指定分割點組成的可疊代對象，則按指定的分割點進行分割，分割點如果超出被分割數組的資料範圍，超出部分傳回空數組。

十、ndarray讀寫檔案

提前準備一個叫array.csv的檔案，資料如下。

data1,data2,data3,data4
1,2,3,4
5,6,,7
8,,9,10      

array17 = np.genfromtxt('array.csv', delimiter=',', skip_header=1)
print(array17)
np.savetxt('save.csv', array17, fmt='%.0f', delimiter=',')      

[[ 1.  2.  3.  4.]
 [ 5.  6. nan  7.]
 [ 8. nan  9. 10.]]      

genfromtxt(fname[, delimiter, skip_header, skip_footer, ...]): 從txt檔案或csv檔案中讀取資料，生成一個數組。fname為必傳參數，表示讀取的檔案名，要根據情況帶上相對路徑。delimiter表示讀取資料時的分割點，預設為None，csv檔案通常是以逗号分割的，txt檔案則可能以空格或逗号分割。skip_header表示跳過資料的前幾行，預設為0，通常用來跳過表頭。這個函數的參數特别多，其他的根據需要點進源碼檢視即可。

讀取的資料中很可能有缺失值，也就是空值，讀取後，ndarray中将空值顯示為nan。在資料分析過程中，要對缺失值做處理，一般情況，如果缺失值不多，可以直接删除有缺失的行，也可以用缺失值所在列的平均值進行填充。根據業務的不同，還有其他合理的填充方式，本文就不展開了。

savetxt(fname, X[, fmt, delimiter]): 将資料儲存到txt檔案中。fname參數表示儲存的檔案名。X傳入一維或二維的形似array的資料，表示要儲存到檔案中的資料。delimiter參數同genfromtxt()，還有幾個參數按需檢視。将上面讀出來的資料儲存到新檔案save.csv中，結果如下。

1,2,3,4
5,6,nan,7
8,nan,9,10      

十一、總結

numpy庫主要用于處理ndarray，也就是多元數組。

實際應用中需要的各種功能基本上都有，使用時隻需要調對應的函數或方法就行了，非常友善。