Python模塊中的numpy，這是一個處理數(shù)組的強大模塊，而該模塊也是其他數(shù)據(jù)分析模塊(如pandas和scipy)的核心。

接下面將從這5個方面來介紹numpy模塊的內(nèi)容：

1)數(shù)組的創(chuàng)建

2)有關(guān)數(shù)組的屬性和函數(shù)

3)數(shù)組元素的獲取--普通索引、切片、布爾索引和花式索引

4)統(tǒng)計函數(shù)與線性代數(shù)運算

5)隨機數(shù)的生成

數(shù)組的創(chuàng)建

numpy中使用array()函數(shù)創(chuàng)建數(shù)組,array的首個參數(shù)一定是一個序列，可以是元組也可以是列表。

一維數(shù)組的創(chuàng)建

可以使用numpy中的arange()函數(shù)創(chuàng)建一維有序數(shù)組，它是內(nèi)置函數(shù)range的擴展版。

In [1]: import numpy as np

In [2]: ls1 = range(10)

In [3]: list(ls1)

Out[3]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [4]: type(ls1)

Out[4]: range

In [5]: ls2 = np.arange(10)

In [6]: list(ls2)

Out[6]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [7]: type(ls2)

Out[7]: numpy.ndarray

通過arange生成的序列就不是簡簡單單的列表類型了，而是一個一維數(shù)組。

如果一維數(shù)組不是一個規(guī)律的有序元素，而是人為的輸入，就需要array()函數(shù)創(chuàng)建了。

In [8]: arr1 = np.array((1,20,13,28,22))

In [9]: arr1

Out[9]: array([ 1, 20, 13, 28, 22])

In [10]: type(arr1)

Out[10]: numpy.ndarray

上面是由元組序列構(gòu)成的一維數(shù)組。

In [11]: arr2 = np.array([1,1,2,3,5,8,13,21])

In [12]: arr2

Out[12]: array([ 1, ?1, ?2, ?3, ?5, ?8, 13, 21])

In [13]: type(arr2)

Out[13]: numpy.ndarray

上面是由列表序列構(gòu)成的一維數(shù)組。

二維數(shù)組的創(chuàng)建

二維數(shù)組的創(chuàng)建，其實在就是列表套列表或元組套元組。

In [14]: arr3 = np.array(((1,1,2,3),(5,8,13,21),(34,55,89,144)))

In [15]: arr3

Out[15]:

array([[ ?1, ? 1, ? 2, ? 3],

[ ?5, ? 8, ?13, ?21],

[ 34, ?55, ?89, 144]])

上面使用元組套元組的方式。

In [16]: arr4 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])

In [17]: arr4

Out[17]:

array([[ 1, ?2, ?3, ?4],

[ 5, ?6, ?7, ?8],

[ 9, 10, 11, 12]])

上面使用列表套列表的方式。

對于高維數(shù)組在將來的數(shù)據(jù)分析中用的比較少，這里關(guān)于高維數(shù)組的創(chuàng)建就不贅述了，構(gòu)建方法仍然是套的方式。

上面所介紹的都是人為設定的一維、二維或高維數(shù)組，numpy中也提供了幾種特殊的數(shù)組，它們是：

In [18]: np.ones(3) ?#返回一維元素全為1的數(shù)組

Out[18]: array([ 1., ?1., ?1.])

In [19]: np.ones([3,4]) ?#返回元素全為1的3×4二維數(shù)組

Out[19]:

array([[ 1., ?1., ?1., ?1.],

[ 1., ?1., ?1., ?1.],

[ 1., ?1., ?1., ?1.]])

In [20]: np.zeros(3) #返回一維元素全為0的數(shù)組

Out[20]: array([ 0., ?0., ?0.])

In [21]: np.zeros([3,4]) #返回元素全為0的3×4二維數(shù)組

Out[21]:

array([[ 0., ?0., ?0., ?0.],

[ 0., ?0., ?0., ?0.],

[ 0., ?0., ?0., ?0.]])

In [22]: np.empty(3) #返回一維空數(shù)組

Out[22]: array([ 0., ?0., ?0.])

In [23]: np.empty([3,4]) #返回3×4二維空數(shù)組

Out[23]:

array([[ 0., ?0., ?0., ?0.],

[ 0., ?0., ?0., ?0.],

[ 0., ?0., ?0., ?0.]])

有關(guān)數(shù)組的屬性和函數(shù)

當一個數(shù)組構(gòu)建好后，我們看看關(guān)于數(shù)組本身的操作又有哪些屬性和函數(shù)：

In [24]: arr3

Out[24]:

array([[ ?1, ? 1, ? 2, ? 3],

[ ?5, ? 8, ?13, ?21],

[ 34, ?55, ?89, 144]])

In [25]: arr3.shape ?#shape方法返回數(shù)組的行數(shù)和列數(shù)

Out[25]: (3, 4)

In [26]: arr3.dtype ?#dtype方法返回數(shù)組的數(shù)據(jù)類型

Out[26]: dtype('int32')

In [27]: a = arr3.ravel() ? ?#通過ravel的方法將數(shù)組拉直(多維數(shù)組降為一維數(shù)組)

In [28]: a

Out[28]: array([ ?1, ? 1, ? 2, ? 3, ? 5, ? 8, ?13, ?21, ?34, ?55, ?89, 144])

In [29]: b = arr3.flatten() ?#通過flatten的方法將數(shù)組拉直

In [30]: b

Out[30]: array([ ?1, ? 1, ? 2, ? 3, ? 5, ? 8, ?13, ?21, ?34, ?55, ?89, 144])

兩者的區(qū)別在于ravel方法生成的是原數(shù)組的視圖，無需占有內(nèi)存空間，但視圖的改變會影響到原數(shù)組的變化。而flatten方法返回的是真實值，其值的改變并不會影響原數(shù)組的更改。

通過下面的例子也許就能明白了：

In [31]: b[:3] = 0

In [32]: arr3

Out[32]:

array([[ ?1, ? 1, ? 2, ? 3],

[ ?5, ? 8, ?13, ?21],

[ 34, ?55, ?89, 144]])

通過更改b的值，原數(shù)組沒有變化。

In [33]: a[:3] = 0

In [34]: arr3

Out[34]:

array([[ ?0, ? 0, ? 0, ? 3],

[ ?5, ? 8, ?13, ?21],

[ 34, ?55, ?89, 144]])

a的值變化后，會導致原數(shù)組跟著變化。

In [35]: arr4

Out[35]:

array([[ 1, ?2, ?3, ?4],

[ 5, ?6, ?7, ?8],

[ 9, 10, 11, 12]])

In [36]: arr4.ndim ? #返回數(shù)組的維數(shù)

Out[36]: 2

In [37]: arr4.size ? #返回數(shù)組元素的個數(shù)

Out[37]: 12

In [38]: arr4.T ?#返回數(shù)組的轉(zhuǎn)置結(jié)果

Out[38]:

array([[ 1, ?5, ?9],

[ 2, ?6, 10],

[ 3, ?7, 11],

[ 4, ?8, 12]])

如果數(shù)組的數(shù)據(jù)類型為復數(shù)的話，real方法可以返回復數(shù)的實部，imag方法返回復數(shù)的虛部。

介紹完數(shù)組的一些方法后，接下來我們看看數(shù)組自身有哪些函數(shù)可操作：

In [39]: len(arr4) #返回數(shù)組有多少行

Out[39]: 3

In [40]: arr3

Out[40]:

array([[ ?0, ? 0, ? 0, ? 3],

[ ?5, ? 8, ?13, ?21],

[ 34, ?55, ?89, 144]])

In [41]: arr4

Out[41]:

array([[ 1, ?2, ?3, ?4],

[ 5, ?6, ?7, ?8],

[ 9, 10, 11, 12]])

In [42]: np.hstack((arr3,arr4))

Out[42]:

array([[ ?0, ? 0, ? 0, ? 3, ? 1, ? 2, ? 3, ? 4],

[ ?5, ? 8, ?13, ?21, ? 5, ? 6, ? 7, ? 8],

[ 34, ?55, ?89, 144, ? 9, ?10, ?11, ?12]])

橫向拼接arr3和arr4兩個數(shù)組，但必須滿足兩個數(shù)組的行數(shù)相同。

In [43]: np.vstack((arr3,arr4))

Out[43]:

array([[ ?0, ? 0, ? 0, ? 3],

[ ?5, ? 8, ?13, ?21],

[ 34, ?55, ?89, 144],

[ ?1, ? 2, ? 3, ? 4],

[ ?5, ? 6, ? 7, ? 8],

[ ?9, ?10, ?11, ?12]])

縱向拼接arr3和arr4兩個數(shù)組，但必須滿足兩個數(shù)組的列數(shù)相同。

In [44]: np.column_stack((arr3,arr4)) ? ?#與hstack函數(shù)具有一樣的效果

Out[44]:

array([[ ?0, ? 0, ? 0, ? 3, ? 1, ? 2, ? 3, ? 4],

[ ?5, ? 8, ?13, ?21, ? 5, ? 6, ? 7, ? 8],

[ 34, ?55, ?89, 144, ? 9, ?10, ?11, ?12]])

In [45]: np.row_stack((arr3,arr4)) ? ?#與vstack函數(shù)具有一樣的效果

Out[45]:

array([[ ?0, ? 0, ? 0, ? 3],

[ ?5, ? 8, ?13, ?21],

[ 34, ?55, ?89, 144],

[ ?1, ? 2, ? 3, ? 4],

[ ?5, ? 6, ? 7, ? 8],

[ ?9, ?10, ?11, ?12]])

reshape()函數(shù)和resize()函數(shù)可以重新設置數(shù)組的行數(shù)和列數(shù)：

In [46]: arr5 = np.array(np.arange(24))

In [47]: arr5 ? ?#此為一維數(shù)組

Out[47]:

array([ 0, ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, 10, 11, 12, 13, 14, 15, 16,

17, 18, 19, 20, 21, 22, 23])

In [48]: a = arr5.reshape(4,6)

In [49]: a

Out[49]:

array([[ 0, ?1, ?2, ?3, ?4, ?5],

[ 6, ?7, ?8, ?9, 10, 11],

[12, 13, 14, 15, 16, 17],

[18, 19, 20, 21, 22, 23]])

通過reshape函數(shù)將一維數(shù)組設置為二維數(shù)組，且為4行6列的數(shù)組。

In [50]: a.resize(6,4)

In [51]: a

Out[51]:

array([[ 0, ?1, ?2, ?3],

[ 4, ?5, ?6, ?7],

[ 8, ?9, 10, 11],

[12, 13, 14, 15],

[16, 17, 18, 19],

[20, 21, 22, 23]])

通過resize函數(shù)會直接改變原數(shù)組的形狀。

數(shù)組轉(zhuǎn)換：tolist將數(shù)組轉(zhuǎn)換為列表，astype()強制轉(zhuǎn)換數(shù)組的數(shù)據(jù)類型，下面是兩個函數(shù)的例子：

In [53]: b = a.tolist()

In [54]: b

Out[54]:

[[0, 1, 2, 3],

[4, 5, 6, 7],

[8, 9, 10, 11],

[12, 13, 14, 15],

[16, 17, 18, 19],

[20, 21, 22, 23]]

In [55]: type(b)

Out[55]: list

In [56]: c = a.astype(float)

In [57]: c

Out[57]:

array([[ ?0., ? 1., ? 2., ? 3.],

[ ?4., ? 5., ? 6., ? 7.],

[ ?8., ? 9., ?10., ?11.],

[ 12., ?13., ?14., ?15.],

[ 16., ?17., ?18., ?19.],

[ 20., ?21., ?22., ?23.]])

In [58]: a.dtype

Out[58]: dtype('int32')

In [59]: c.dtype

Out[59]: dtype('float64')

數(shù)組元素的獲取

通過索引和切片的方式獲取數(shù)組元素，一維數(shù)組元素的獲取與列表、元組的獲取方式一樣：

In [60]: arr7 = np.array(np.arange(10))

In [61]: arr7

Out[61]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In [62]: arr7[3] ? ? #獲取第4個元素

Out[62]: 3

In [63]: arr7[:3] ? ?#獲取前3個元素

Out[63]: array([0, 1, 2])

In [64]: arr7[3:] ? ?#獲取第4個元素即之后的所有元素

Out[64]: array([3, 4, 5, 6, 7, 8, 9])

In [65]: arr7[-2:] ? #獲取末尾的2個元素

Out[65]: array([8, 9])

In [66]: arr7[::2] ? #從第1個元素開始，獲取步長為2的所有元素

Out[66]: array([0, 2, 4, 6, 8])

二維數(shù)組元素的獲取：

In [67]: arr8 = np.array(np.arange(12)).reshape(3,4)

In [68]: arr8

Out[68]:

array([[ 0, ?1, ?2, ?3],

[ 4, ?5, ?6, ?7],

[ 8, ?9, 10, 11]])

In [69]: arr8[1] ? ? #返回數(shù)組的第2行

Out[69]: array([4, 5, 6, 7])

In [70]: arr8[:2] ? ?#返回數(shù)組的前2行

Out[70]:

array([[0, 1, 2, 3],

[4, 5, 6, 7]])

In [71]: arr8[[0,2]] ? ? #返回指定的第1行和第3行

Out[71]:

array([[ 0, ?1, ?2, ?3],

[ 8, ?9, 10, 11]])

In [72]: arr8[:,0] ?#返回數(shù)組的第1列

Out[72]: array([0, 4, 8])

In [73]: arr8[:,-2:] ? ?#返回數(shù)組的后2列

Out[73]:

array([[ 2, ?3],

[ 6, ?7],

[10, 11]])

In [74]: arr8[:,[0,2]] ? #返回數(shù)組的第1列和第3列

Out[74]:

array([[ 0, ?2],

[ 4, ?6],

[ 8, 10]])

In [75]: arr8[1,2] ? #返回數(shù)組中第2行第3列對應的元素

Out[75]: 6

布爾索引，即索引值為True和False，需要注意的是布爾索引必須輸數(shù)組對象。

In [76]: log = np.array([True,False,False,True,True,False])

In [77]: arr9 = np.array(np.arange(24)).reshape(6,4)

In [78]: arr9

Out[78]:

array([[ 0, ?1, ?2, ?3],

[ 4, ?5, ?6, ?7],

[ 8, ?9, 10, 11],

[12, 13, 14, 15],

[16, 17, 18, 19],

[20, 21, 22, 23]])

In [79]: arr9[log] ? #返回所有為True的對應行

Out[79]:

array([[ 0, ?1, ?2, ?3],

[12, 13, 14, 15],

[16, 17, 18, 19]])

In [80]: arr9[-log] ?#通過負號篩選出所有為False的對應行

Out[80]:

array([[ 4, ?5, ?6, ?7],

[ 8, ?9, 10, 11],

[20, 21, 22, 23]])

舉一個場景，一維數(shù)組表示區(qū)域，二維數(shù)組表示觀測值，如何選取目標區(qū)域的觀測？

In [81]: area = np.array(['A','B','A','C','A','B','D'])

In [82]: area

Out[82]:

array(['A', 'B', 'A', 'C', 'A', 'B', 'D'],

dtype='

In [83]: observes = np.array(np.arange(21)).reshape(7,3)

In [84]: observes

Out[84]:

array([[ 0, ?1, ?2],

[ 3, ?4, ?5],

[ 6, ?7, ?8],

[ 9, 10, 11],

[12, 13, 14],

[15, 16, 17],

[18, 19, 20]])

In [85]: observes[area == 'A']

Out[85]:

array([[ 0, ?1, ?2],

[ 6, ?7, ?8],

[12, 13, 14]])

返回所有A區(qū)域的觀測。

In [86]: observes[(area == 'A') | (area == 'D')] #條件值需要在&(and),|(or)兩端用圓括號括起來

Out[86]:

array([[ 0, ?1, ?2],

[ 6, ?7, ?8],

[12, 13, 14],

[18, 19, 20]])

返回所有A區(qū)域和D區(qū)域的觀測。

當然，布爾索引也可以與普通索引或切片混合使用：

In [87]: observes[area == 'A'][:,[0,2]]

Out[87]:

array([[ 0, ?2],

[ 6, ?8],

[12, 14]])

返回A區(qū)域的所有行，且只獲取第1列與第3列數(shù)據(jù)。

花式索引：實際上就是將數(shù)組作為索引將原數(shù)組的元素提取出來

In [88]: arr10 = np.arange(1,29).reshape(7,4)

In [89]: arr10

Out[89]:

array([[ 1, ?2, ?3, ?4],

[ 5, ?6, ?7, ?8],

[ 9, 10, 11, 12],

[13, 14, 15, 16],

[17, 18, 19, 20],

[21, 22, 23, 24],

[25, 26, 27, 28]])

In [90]: arr10[[4,1,3,5]] ?#按照指定順序返回指定行

Out[90]:

array([[17, 18, 19, 20],

[ 5, ?6, ?7, ?8],

[13, 14, 15, 16],

[21, 22, 23, 24]])

In [91]: arr10[[4,1,5]][:,[0,2,3]] #返回指定的行與列

Out[91]:

array([[17, 19, 20],

[ 5, ?7, ?8],

[21, 23, 24]])

In [92]: arr10[[4,1,5],[0,2,3]]

Out[92]: array([17, ?7, 24])

請注意！這與上面的返回結(jié)果是截然不同的，上面返回的是二維數(shù)組，而這條命令返回的是一維數(shù)組。

如果想使用比較簡單的方式返回指定行以列的二維數(shù)組的話，可以使用ix_()函數(shù)

In [93]: arr10[np.ix_([4,1,5],[0,2,3])]

Out[93]:

array([[17, 19, 20],

[ 5, ?7, ?8],

[21, 23, 24]])

這與arr10[[4,1,5]][:,[0,2,3]]返回的結(jié)果是一致的。

統(tǒng)計函數(shù)與線性代數(shù)運算

統(tǒng)計運算中常見的聚合函數(shù)有：最小值、最大值、中位數(shù)、均值、方差、標準差等。首先來看看數(shù)組元素級別的計算：

In [94]: arr11 = 5-np.arange(1,13).reshape(4,3)

In [95]: arr12 = np.random.randint(1,10,size = 12).reshape(4,3)

In [96]: arr11

Out[96]:

array([[ 4, ?3, ?2],

[ 1, ?0, -1],

[-2, -3, -4],

[-5, -6, -7]])

In [97]: arr12

Out[97]:

array([[1, 3, 7],

[7, 3, 7],

[3, 7, 4],

[6, 1, 2]])

In [98]: arr11 ** 2 ? ?#計算每個元素的平方

Out[98]:

array([[16, ?9, ?4],

[ 1, ?0, ?1],

[ 4, ?9, 16],

[25, 36, 49]])

In [99]: np.sqrt(arr11) ?#計算每個元素的平方根

Out[99]:

array([[ 2. ? ? ? ?, ?1.73205081, ?1.41421356],

[ 1. ? ? ? ?, ?0. ? ? ? ?, ? ? ? ? nan],

[ ? ? ? ?nan, ? ? ? ? nan, ? ? ? ? nan],

[ ? ? ? ?nan, ? ? ? ? nan, ? ? ? ? nan]])

由于負值的平方根沒有意義，故返回nan。

In [100]: np.exp(arr11) ? #計算每個元素的指數(shù)值

Out[100]:

array([[ ?5.45981500e+01, ? 2.00855369e+01, ? 7.38905610e+00],

[ ?2.71828183e+00, ? 1.00000000e+00, ? 3.67879441e-01],

[ ?1.35335283e-01, ? 4.97870684e-02, ? 1.83156389e-02],

[ ?6.73794700e-03, ? 2.47875218e-03, ? 9.11881966e-04]])

In [101]: np.log(arr12) ? #計算每個元素的自然對數(shù)值

Out[101]:

array([[ 0. ? ? ? ?, ?1.09861229, ?1.94591015],

[ 1.94591015, ?1.09861229, ?1.94591015],

[ 1.09861229, ?1.94591015, ?1.38629436],

[ 1.79175947, ?0. ? ? ? ?, ?0.69314718]])

In [102]: np.abs(arr11) ? #計算每個元素的絕對值

Out[102]:

array([[4, 3, 2],

[1, 0, 1],

[2, 3, 4],

[5, 6, 7]])

相同形狀數(shù)組間元素的操作：

In [103]: arr11 + arr12 ? #加

Out[103]:

array([[ 5, ?6, ?9],

[ 8, ?3, ?6],

[ 1, ?4, ?0],

[ 1, -5, -5]])

In [104]: arr11 - arr12 ? #減

Out[104]:

array([[ ?3, ? 0, ?-5],

[ -6, ?-3, ?-8],

[ -5, -10, ?-8],

[-11, ?-7, ?-9]])

In [105]: arr11 * arr12 ? #乘

Out[105]:

array([[ ?4, ? 9, ?14],

[ ?7, ? 0, ?-7],

[ -6, -21, -16],

[-30, ?-6, -14]])

In [106]: arr11 / arr12 ? #除

Out[106]:

array([[ 4. ? ? ? ?, ?1. ? ? ? ?, ?0.28571429],

[ 0.14285714, ?0. ? ? ? ?, -0.14285714],

[-0.66666667, -0.42857143, -1. ? ? ? ?],

[-0.83333333, -6. ? ? ? ?, -3.5 ? ? ? ]])

In [107]: arr11 // arr12 ?#整除

Out[107]:

array([[ 4, ?1, ?0],

[ 0, ?0, -1],

[-1, -1, -1],

[-1, -6, -4]], dtype=int32)

In [108]: arr11 % arr12 ? #取余

Out[108]:

array([[0, 0, 2],

[1, 0, 6],

[1, 4, 0],

[1, 0, 1]], dtype=int32)

接下來我們看看統(tǒng)計運算函數(shù)：

In [109]: np.sum(arr11) ? #計算所有元素的和

Out[109]: -18

In [110]: np.sum(arr11,axis = 0) ? ?#對每一列求和

Out[110]: array([ -2, ?-6, -10])

In [111]: np.sum(arr11, axis = 1) #對每一行求和

Out[111]: array([ ?9, ? 0, ?-9, -18])

In [112]: np.cumsum(arr11) #對每一個元素求累積和(從上到下，從左到右的元素順序)

Out[112]: array([ ?4, ? 7, ? 9, ?10, ?10, ? 9, ? 7, ? 4, ? 0, ?-5, -11, -18], dtype=int32)

In [113]: np.cumsum(arr11, axis = 0) #計算每一列的累積和，并返回二維數(shù)組

Out[113]:

array([[ ?4, ? 3, ? 2],

[ ?5, ? 3, ? 1],

[ ?3, ? 0, ?-3],

[ -2, ?-6, -10]], dtype=int32)

In [114]: np.cumprod(arr11, axis = 1) #計算每一行的累計積，并返回二維數(shù)組

Out[114]:

array([[ ? 4, ? 12, ? 24],

[ ? 1, ? ?0, ? ?0],

[ ?-2, ? ?6, ?-24],

[ ?-5, ? 30, -210]], dtype=int32)

In [115]: np.min(arr11) ? #計算所有元素的最小值

Out[115]: -7

In [116]: np.max(arr11, axis = 0) #計算每一列的最大值

Out[116]: array([4, 3, 2])

In [117]: np.mean(arr11) ?#計算所有元素的均值

Out[117]: -1.5

In [118]: np.mean(arr11, axis = 1) #計算每一行的均值

Out[118]: array([ 3., ?0., -3., -6.])

In [119]: np.median(arr11) ? #計算所有元素的中位數(shù)

Out[119]: -1.5

In [120]: np.median(arr11, axis = 0) ? #計算每一列的中位數(shù)

Out[120]: array([-0.5, -1.5, -2.5])

In [121]: np.var(arr12) ? #計算所有元素的方差

Out[121]: 5.354166666666667

In [122]: np.std(arr12, axis = 1) ? #計算每一行的標準差

Out[122]: array([ 2.49443826, ?1.88561808, ?1.69967317, ?2.1602469 ])

numpy中的統(tǒng)計函數(shù)運算是非常靈活的，既可以計算所有元素的統(tǒng)計值，也可以計算指定行或列的統(tǒng)計指標。還有其他常用的函數(shù)，如符號函數(shù)sign，ceil(>=x的最小整數(shù))，floor(<=x的最大整數(shù))，modf(將浮點數(shù)的整數(shù)部分與小數(shù)部分分別存入兩個獨立的數(shù)組)，cos，arccos，sin，arcsin，tan，arctan等。

讓我很興奮的一個函數(shù)是where()，它類似于Excel中的if函數(shù)，可以進行靈活的變換：

In [123]: arr11

Out[123]:

array([[ 4, ?3, ?2],

[ 1, ?0, -1],

[-2, -3, -4],

[-5, -6, -7]])

In [124]: np.where(arr11 < 0, 'negtive','positive')

Out[124]:

array([['positive', 'positive', 'positive'],

['positive', 'positive', 'negtive'],

['negtive', 'negtive', 'negtive'],

['negtive', 'negtive', 'negtive']],

dtype='

當然，np.where還可以嵌套使用，完成復雜的運算。

其它函數(shù)

unique(x):計算x的唯一元素，并返回有序結(jié)果

intersect(x,y)：計算x和y的公共元素，即交集

union1d(x,y):計算x和y的并集

setdiff1d(x,y):計算x和y的差集，即元素在x中，不在y中

setxor1d(x,y):計算集合的對稱差，即存在于一個數(shù)組中，但不同時存在于兩個數(shù)組中

in1d(x,y):判斷x的元素是否包含于y中

線性代數(shù)運算

同樣numpu也跟R語言一樣，可以非常方便的進行線性代數(shù)方面的計算，如行列式、逆、跡、特征根、特征向量等。但需要注意的是，有關(guān)線性代數(shù)的函數(shù)并不在numpy中，而是numpy的子例linalg中。

In [125]: arr13 = np.array([[1,2,3,5],[2,4,1,6],[1,1,4,3],[2,5,4,1]])

In [126]: arr13

Out[126]:

array([[1, 2, 3, 5],

[2, 4, 1, 6],

[1, 1, 4, 3],

[2, 5, 4, 1]])

In [127]: np.linalg.det(arr13) ? ?#返回方陣的行列式

Out[127]: 51.000000000000021

In [128]: np.linalg.inv(arr13) ? ?#返回方陣的逆

Out[128]:

array([[-2.23529412, ?1.05882353, ?1.70588235, -0.29411765],

[ 0.68627451, -0.25490196, -0.7254902 , ?0.2745098 ],

[ 0.19607843, -0.21568627, ?0.07843137, ?0.07843137],

[ 0.25490196, ?0.01960784, -0.09803922, -0.09803922]])

In [129]: np.trace(arr13) #返回方陣的跡(對角線元素之和)，注意跡的求解不在linalg子例程中

Out[129]: 10

In [130]: np.linalg.eig(arr13) ? ?#返回由特征根和特征向量組成的元組

Out[130]:

(array([ 11.35035004, ?-3.99231852, ?-0.3732631 , ? 3.01523159]),

array([[-0.4754174 , -0.48095078, -0.95004728, ?0.19967185],

[-0.60676806, -0.42159999, ?0.28426325, -0.67482638],

[-0.36135292, -0.16859677, ?0.08708826, ?0.70663129],

[-0.52462832, ?0.75000995, ?0.09497472, -0.07357122]]))

In [131]: np.linalg.qr(arr13) #返回方陣的QR分解

Out[131]:

(array([[-0.31622777, -0.07254763, -0.35574573, -0.87645982],

[-0.63245553, -0.14509525, ?0.75789308, -0.06741999],

[-0.31622777, -0.79802388, -0.38668014, ?0.33709993],

[-0.63245553, ?0.580381 ?, -0.38668014, ?0.33709993]]),

array([[-3.16227766, -6.64078309, -5.37587202, -6.95701085],

[ 0. ? ? ? ?, ?1.37840488, -1.23330963, -3.04700025],

[ 0. ? ? ? ?, ?0. ? ? ? ?, -3.40278524, ?1.22190924],

[ 0. ? ? ? ?, ?0. ? ? ? ?, ?0. ? ? ? ?, -3.4384193 ]]))

In [132]:np.linalg.svd(arr13) ? ?#返回方陣的奇異值分解

Out[132]:

(array([[-0.50908395, ?0.27580803, ?0.35260559, -0.73514132],

[-0.59475561, ?0.4936665 , -0.53555663, ?0.34020325],

[-0.39377551, -0.10084917, ?0.70979004, ?0.57529852],

[-0.48170545, -0.81856751, -0.29162732, -0.11340459]]),

array([ 11.82715609, ? 4.35052602, ? 3.17710166, ? 0.31197297]),

array([[-0.25836994, -0.52417446, -0.47551003, -0.65755329],

[-0.10914615, -0.38326507, -0.54167613, ?0.74012294],

[-0.18632462, -0.68784764, ?0.69085326, ?0.12194478],

[ 0.94160248, -0.32436807, -0.05655931, -0.07050652]]))

In [133]: np.dot(arr13,arr13) ? ? #方陣的正真乘積運算

Out[133]:

array([[18, 38, 37, 31],

[23, 51, 38, 43],

[13, 25, 32, 26],

[18, 33, 31, 53]])

In [134]:arr14 = np.array([[1,-2,1],[0,2,-8],[-4,5,9]])

In [135]: vector = np.array([0,8,-9])

In [136]: np.linalg.solve(arr14,vector)

Out[136]: array([ 29., ?16., ? 3.])

隨機數(shù)生成

統(tǒng)計學中經(jīng)常會講到數(shù)據(jù)的分布特征，如正態(tài)分布、指數(shù)分布、卡方分布、二項分布、泊松分布等，下面就講講有關(guān)分布的隨機數(shù)生成。

正態(tài)分布直方圖

In [137]: import matplotlib #用于繪圖的模塊

In [138]: np.random.seed(1234) ? ?#設置隨機種子

In [139]: N = 10000 ? #隨機產(chǎn)生的樣本量

In [140]: randnorm = np.random.normal(size = N) ? #生成正態(tài)隨機數(shù)

In [141]: counts, bins, path = matplotlib.pylab.hist(randnorm, bins = np.sqrt(N), normed = True, color = 'blue') ?#繪制直方圖

以上將直方圖的頻數(shù)和組距存放在counts和bins內(nèi)。

In [142]: sigma = 1; mu = 0

In [143]: norm_dist = (1/np.sqrt(2*sigma*np.pi))*np.exp(-((bins-mu)**2)/2) ? ?#正態(tài)分布密度函數(shù)

In [144]: matplotlib.pylab.plot(bins,norm_dist,color = 'red') #繪制正態(tài)分布密度函數(shù)圖

使用二項分布進行賭博

同時拋棄9枚硬幣，如果正面朝上少于5枚，則輸?shù)?元，否則就贏8元。如果手中有1000元作為賭資，請問賭博10000次后可能會是什么情況呢？

In [146]: np.random.seed(1234)

In [147]: binomial = np.random.binomial(9,0.5,10000) ?#生成二項分布隨機數(shù)

In [148]: money = np.zeros(10000) #生成10000次賭資的列表

In [149]: money[0] = 1000 #首次賭資為1000元

In [150]: for i in range(1,10000):

...: ? ? if binomial[i] < 5:

...: ? ? ? ? money[i] = money[i-1] - 8

#如果少于5枚正面，則在上一次賭資的基礎(chǔ)上輸?shù)?元

...: ? ? else:

...: ? ? ? ? money[i] = money[i-1] + 8

#如果至少5枚正面，則在上一次賭資的基礎(chǔ)上贏取8元

In [151]: matplotlib.pylab.plot(np.arange(10000), money)

使用隨機整數(shù)實現(xiàn)隨機游走

一個醉漢在原始位置上行走10000步后將會在什么地方呢？如果他每走一步是隨機的，即下一步可能是1也可能是-1。

In [152]: np.random.seed(1234) ? ?#設定隨機種子

In [153]: position = 0 ? ?#設置初始位置

In [154]: walk = [] ? #創(chuàng)建空列表

In [155]: steps = 10000 ? #假設接下來行走10000步

In [156]: for i in np.arange(steps):

...: ? ? step = 1 if np.random.randint(0,2) else -1 ?#每一步都是隨機的

...: ? ? position = position + step ?#對每一步進行累計求和

...: ? ? walk.append(position) ? #確定每一步所在的位置

In [157]: matplotlib.pylab.plot(np.arange(10000), walk) ? #繪制隨機游走圖

上面的代碼還可以寫成(結(jié)合前面所講的where函數(shù)，cumsum函數(shù))：

In [158]: np.random.seed(1234)

In [159]: step = np.where(np.random.randint(0,2,10000)>0,1,-1)

In [160]: position = np.cumsum(step)

In [161]: matplotlib.pylab.plot(np.arange(10000), position)

避免for循環(huán)，可以達到同樣的效果。

＃＃＃＃感謝劉順祥作者分享……Y(^_^)Y＃＃＃＃

總結(jié)

以上是生活随笔為你收集整理的python数据分析numpy_(转)Python数据分析之numpy学习的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。