numpy

NumPy的數組類被稱做ndarray

ndarry的建立：

建立一維數組：類型爲ndarray

array是一個相似ones的函數

import numpy as np

a=np.array([1,2,3])
print(a)
print(type(a))

 

結果：

[1 2 3]
<class 'numpy.ndarray'>

建立二維數組：

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

 

結果：

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

建立三維數組：

a=np.array([
    [[1,2,3],
     [4,5,6],
     [7,8,9]
     ],
    [
        [9,8,7],
        [6,5,4],
        [3,2,1]
    ]
])
print(a)

 

結果：

[[[1 2 3]
[4 5 6]
[7 8 9]]

[[9 8 7]
[6 5 4]
[3 2 1]]]

建立0數組：(3,2)表明二維數組，第一維有三個數組，第二維有二個

a=np.zeros((3,2))
print(a)

 

結果：

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

建立全1數組：

a=np.zeros((3,2,2))
print(a)

結果：

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

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

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

 

empty：調用和上一個同樣大小的矩陣，上一個3*3是全1下面的也是全1，上面的變全0下面的也是全0

arr_one=np.ones((3,3))
print('arr_one:')
print(arr_one)
arr=np.empty((3,3),dtype='i1')
print('arr:')
print(arr)
arr_zeros=np.zeros((3,3))
print('arr_zeros:')
print(arr_zeros)
arr3=np.empty((3,3),dtype='i1')
print(arr3)
print(arr3)

 

arr_one:
[[ 1. 1. 1.]
[ 1. 1. 1.]
[ 1. 1. 1.]]
arr:
[[1 1 1]
[1 1 1]
[1 1 1]]
arr_zeros:
[[ 0. 0. 0.]
[ 0. 0. 0.]
[ 0. 0. 0.]]
[[0 0 0]
[0 0 0]
[0 0 0]]
[[0 0 0]
[0 0 0]
[0 0 0]]

 

arange函數: 相似python的range函數，經過指定開始值、終值和步長來建立一個一維數組，注意：最終建立的數組不包含終值

a=np.arange(20)
b=np.arange(1,20)
c=np.arange(10,20,2)
d=np.arange(20,15,-1)
print(a)
print(b)
print(c)
print(d)

 

結果：

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

linspace函數：經過指定開始值、終值和元素個數來建立一個一維數組，數組的數據元素符合等差數列，

endpoint爲True表示包含最後的值，不然不包含，若是包含的話步長爲終值-初始值再除以個數-1，不包含就不用減1

retstep爲True顯示步長

arr=np.linspace(0,10,5,endpoint=False,retstep=True)
print(arr)
arr2=np.linspace(0,10,6)
print(arr2)
arr3=np.linspace(0,10,5,endpoint=True)
print(arr3)

(array([ 0., 2., 4., 6., 8.]), 2.0)
[ 0. 2. 4. 6. 8. 10.]
[ 0. 2.5 5. 7.5 10. ]

 

logspace函數：和linspace函數相似，不過建立的是等比數列數組，0和2表示10的0次方和10的2次方 能夠指定底數爲2

步長是終值除以初值再開個數的次方

能夠用來控制學習率，一開始很大後來很小

a=np.logspace(0,2,5)
b=np.logspace(0,2,5,base=2)
print(a)
print(b)

 

使用隨機數填充數組：即便用numpy.random中的random()函數來建立0-1之間的隨機元素，數組包含的元素數量由參數決定

random.rand()和它有相似的效果 這個和上面的用的少主要用來加噪音

random.randn()生成正太分佈的值，用來生成初始權重的值 這個和下面的用的比較多

random.randint():生成指定範圍整數形式

a=np.random.random((3,2,3))
print(a)

b=np.random.randint(0,9,size=([3,2,3]))
print(b)

 [[[ 0.16457832 0.62392568 0.12147039]

[ 0.93102204 0.94546256 0.89936897]]

[[ 0.76421283 0.76901106 0.85803104]
[ 0.78047088 0.12490645 0.20241544]]

[[ 0.81234778 0.1706378 0.46777206]
[ 0.46362101 0.65915849 0.81233809]]]

 

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

[[4 8 3]
[2 2 1]]

[[4 5 8]
[3 5 6]]]

ndarray對象屬性：

shape： 數組的維度, 例如一個2排3列的矩陣，它的shape屬性將是(2,3),這個元組的長度顯然是秩，即維度或者ndim屬性

size ：數組元素的總個數，等於shape屬性中元組元素的乘積

dtype： 一個用來描述數組中元素類型的對象

itemsize： 數組中每一個元素的字節大小

ndim：維數

a=np.random.random((3,2,3))
print(a)
print(a.shape)
print(a.size)
print(a.dtype)
print(a.ndim)

結果：

[[[ 0.69687113 0.64635635 0.33509638]
[ 0.89577043 0.52402303 0.14022035]]

[[ 0.75843167 0.97081013 0.27377149]
[ 0.55884246 0.51996251 0.13923623]]

[[ 0.54949654 0.09005034 0.42206612]
[ 0.94917494 0.38606105 0.79835506]]]
(3, 2, 3)
18
float64
3

 

Numpy基本數據類型：int_默認整型，int8-i1(1個字節2的0次方，一個字節是8位，2的8次方是-127-128)  int16-i2...

uint8-u1(u就是無符號，簡單來講就是正整數) 

float16-f2  float32-f4(1個符號位+8位指數+23位小數)

既有數字又有數字定義object

String_-S 字節  一個字符一個字節

Unicode_-U 字符串 每一個字符佔用字節數由平臺決定

修改數據類型：

修改實際上是新的數組原來的數組沒有變

a=np.array([1,2,3,4])
print(a.dtype)
b=a.astype(float)
print(a.dtype)
print(b.dtype)

int32
int32
float64

 

ndarray修改形狀

直接使用reshape函數建立一個改變尺寸的新數組，原數組的shape保持不變，可是新數組和原數組共享一個內存空間，也就是修改任何一個數組中的值都會對另一個產生影響，另外要求新數組的元素個數和原數組一致

a=np.arange(0,20,2)
b=a.reshape(5,2)
print(a)
print(b)
b[0][1]=100
print(a)
print(b)

 [ 0 2 4 6 8 10 12 14 16 18]

[[ 0 2]
[ 4 6]
[ 8 10]
[12 14]
[16 18]]
[ 0 100 4 6 8 10 12 14 16 18]
[[ 0 100]
[ 4 6]
[ 8 10]
[ 12 14]
[ 16 18]]

當指定某一個軸爲-1的時候，表示將根據數組元素的數量自動計算該軸的長度值

reshape修改複製以後的形狀，a.shape修改原數組的形狀

a=np.arange(0,20,2)
b=a.reshape(5,-1)
print(a)
print('-'*20)
print(b)
print('-'*20)
a.shape=(2,-1)
print(a)

 [ 0 2 4 6 8 10 12 14 16 18]

--------------------
[[ 0 2]
[ 4 6]
[ 8 10]
[12 14]
[16 18]]
--------------------
[[ 0 2 4 6 8]
[10 12 14 16 18]]

 

Numpy基本操做

ndarray-數組與標量、數組之間的運算：數組不用循環便可對每一個元素執行批量的算術運算操做，這個過程叫作矢量化，即用數組表達式代替循環的作法

1.矩陣與數之間的運算

a=np.arange(1,6)
print(a)
print(a+2)
print(a-2)
print(a*2)
print(a/2)
print(1/a)
print(a**2)
print(2**a)

[1 2 3 4 5]

[3 4 5 6 7]
[-1 0 1 2 3]
[ 2 4 6 8 10]
[ 0.5 1. 1.5 2. 2.5]
[ 1. 0.5 0.33333333 0.25 0.2 ]
[ 1 4 9 16 25]
[ 2 4 8 16 32]

本質上是前面的np.arange(20)，只要裏面的數字相同便可,結果和維度多的那個同樣

a=np.arange(20).reshape(1,4,5)
print('a=')
print(a)
print('-'*20)
b=np.arange(20).reshape(4,5)
print('b=')
print(b)
print('-'*20)
print('a+b=')
print(a+b)

a=
[[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]]
--------------------
b=
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]
[15 16 17 18 19]]
--------------------
a+b=
[[[ 0 2 4 6 8]
[10 12 14 16 18]
[20 22 24 26 28]
[30 32 34 36 38]]]

2.矩陣與矩陣之間的運算

arr1=np.array([[1,2,3],[4,5,6]])
arr2=np.array([[4.6,3.2,2.1],[5.2,4.3,3.4]])
print('arr1+arr2=')
print(arr1+arr2)
print('arr1-arr2=')
print(arr1-arr2)
print('arr1*arr2=')
print(arr1*arr2)
print('arr1/arr2=')
print(arr1/arr2)

 arr1+arr2=

[[ 5.6 5.2 5.1]
[ 9.2 9.3 9.4]]
arr1-arr2=
[[-3.6 -1.2 0.9]
[-1.2 0.7 2.6]]
arr1*arr2=
[[ 4.6 6.4 6.3]
[ 20.8 21.5 20.4]]
arr1/arr2=
[[ 0.2173913 0.625 1.42857143]
[ 0.76923077 1.1627907 1.76470588]]

不一樣形狀的數組進行運算，經過廣播能力,4和4要對應上才能夠乘

a=np.array([1,2,3,4])#(4,)
b=np.array([[10,20,30,40],[1,2,3,4]])#(2,4)
print(a*b)

 

[[ 10 40 90 160]
[ 1 4 9 16]]

 

3.數組的矩陣積：dot和inner在二維上是同樣的，三維上有區別

arr1=np.array([[1,2],[4,5]])
arr2=np.array([[4.6,3.2],[5.2,4.3]])
print(arr1.dot(arr2))
arr3=np.dot(arr1,arr2)
print(arr3)

 [[ 15. 11.8]

[ 44.4 34.3]]
[[ 15. 11.8]
[ 44.4 34.3]]

 

矩陣索引

arr=np.array([
    [
        [2,3,4,5],[1,3,4,9]
    ],
    [
        [0,3,4,8],[2,4,9,4]
    ],
    [
        [1,4,5,8],[2,5,6,8]
    ],
    [
        [2,3,6,8],[3,4,8,9]
    ]
])
print(arr[3])
print('-'*20)
print(arr[3,1])
print('-'*20)
print(arr[3][1][2])
print('-'*20)
print(arr[3,1,2])

 

結果：

[[2 3 6 8]
[3 4 8 9]]
--------------------
[3 4 8 9]
--------------------
8
--------------------
8

在各維度上單獨切片，若是某維度都保留，則直接使用：，不指定起始值和終止值

注意：Numpy中經過切片獲得的新數組，只是原來數組的一個試圖，所以對新數組進行操做也會影響原數組，不能使用arr[:][:][1:3]若是這樣，第一個[]就默認把數組取完了

arr=np.array([
    [
        [2,3,4,5],[1,3,4,9]
    ],
    [
        [0,3,4,8],[2,4,9,4]
    ],
    [
        [1,4,5,8],[2,5,6,8]
    ],
    [
        [2,3,6,8],[3,4,8,9]
    ]
])
print(arr[3][1][1:3])
print('-'*20)
print(arr[3,1,1:3])

 

結果：

[4 8]
--------------------
[4 8]

利用布爾類型的數組進行數據索引，最終返回的結果是對應索引數組中數據爲True位置的值

arr=np.random.random((4,4))
arr2=arr<0.5
print(arr2)
arr3=arr[arr2]
print(arr3,arr3.shape)

 [[False False False False]

[ True False True False]
[False True False False]
[ True False True True]]
[ 0.2886168 0.49285157 0.09925616 0.00371036 0.0282944 0.20428113] (6,)

Numpy中不能使用and、or和not，相應的替代爲| & ~

names=np.array(['Gerry','Tom','John'])
scores=np.array([
    [98,87,86,95],
    [58,56,54,51],
    [78,85,85,77]
])
classes=np.array(['語文','數學','英語','科學'])
print('Gerry score is:',scores[names=='Gerry'].reshape((-1)))
print('Gerry math score is:',scores[names=='Gerry'].reshape((-1))[classes=='數學'])
print('Gerry and Tom scores are: ',scores[(names=='Gerry')|(names=='Tom')])
print('not Gerry and Tom scores are: ',scores[(names!='Gerry')&(names!='Tom')])

 Gerry score is: [98 87 86 95]

Gerry math score is: [87]
Gerry and Tom scores are: [[98 87 86 95]
[58 56 54 51]]
not Gerry and Tom scores are: [[78 85 85 77]]

 

花式索引：花式索引(Fancy indexing)指的是利用整數數組進行索引的方式

arr=np.arange(32).reshape(8,4)
print(arr)
print('獲取第0,3,5行數據')
print(arr[[0,3,5]])
print('獲取第（0,0）、（3,3）、（5,2）這三個位置的數據')
print(arr[[0,3,5],[0,3,2]])
print('獲取第0、三、5行的第0、二、3列的數據')
print(arr[np.ix_([0,3,5],[0,2,3])])

 [[ 0 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 29 30 31]]
獲取第0,3,5行數據
[[ 0 1 2 3]
[12 13 14 15]
[20 21 22 23]]
獲取第（0,0）、（3,3）、（5,2）這三個位置的數據
[ 0 15 22]
獲取第0、三、5行的第0、二、3列的數據
[[ 0 2 3]
[12 14 15]
[20 22 23]]

 

矩陣的轉置

arr=np.arange(32).reshape(8,4)
print(arr,arr.shape)
arr1=arr.transpose()
print('轉置後的數據')
print(arr1,arr1.shape)
print('第二種方法：')
print(arr.T,arr.T.shape)

 [[ 0 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 29 30 31]] (8, 4)
轉置後的數據
[[ 0 4 8 12 16 20 24 28]
[ 1 5 9 13 17 21 25 29]
[ 2 6 10 14 18 22 26 30]
[ 3 7 11 15 19 23 27 31]] (4, 8)
第二種方法：
[[ 0 4 8 12 16 20 24 28]
[ 1 5 9 13 17 21 25 29]
[ 2 6 10 14 18 22 26 30]
[ 3 7 11 15 19 23 27 31]] (4, 8)

多維度轉置,(3,4,2)對應的位置分別是0,1,2，transpose(1,0,2)對應的就是4,3,2能夠本身計算，好比一個位置是(2,3,1) 轉置事後的位置就是（3,2,1）

a=np.arange(24).reshape(3,4,2)
print(a)
print(a.shape)
a=a.transpose(1,0,2)
print(a)
print(a.shape)

 

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

[[ 8 9]
[10 11]
[12 13]
[14 15]]

[[16 17]
[18 19]
[20 21]
[22 23]]]
(3, 4, 2)
[[[ 0 1]
[ 8 9]
[16 17]]

[[ 2 3]
[10 11]
[18 19]]

[[ 4 5]
[12 13]
[20 21]]

[[ 6 7]
[14 15]
[22 23]]]
(4, 3, 2)

 Ndarray經常使用函數

abs/fabs:去絕對值，fabs快一點

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.abs(arr))
print(np.fabs(arr))

 [ 5.3 6.2 5. 0. 4.2 5. 3. 2. 1. ]

[ 5.3 6.2 5. 0. 4.2 5. 3. 2. 1. ]

sqrt:平方更，要求每一個元素大於等於0

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.sqrt(np.fabs(arr)))

 [ 2.30217289 2.48997992 2.23606798 0. 2.04939015 2.23606798

1.73205081 1.41421356 1. ]

square:計算每一個元素的評分，至關於arr**2

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.square(arr))

  [ 28.09  38.44  25.     0.    17.64  25.     9.     4.     1.  ]

 exp：計算每一個元素的指數e的x次方

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.exp(arr))

 [ 4.99159391e-03 2.02943064e-03 6.73794700e-03 1.00000000e+00

6.66863310e+01 1.48413159e+02 2.00855369e+01 7.38905610e+00
2.71828183e+00]

log、log十、log二、log1p：分別計算天然對數、底數爲10的log、底數爲2的log以及log(1+x)；要求arr中的每一個元素必須爲正數

numpy作不了以2和10其餘之外的底數的計算

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
arr=np.fabs(arr+1)
arr=np.fabs(arr)
print(np.log(arr))
print(np.log10(arr))
print(np.log2(arr))
print(np.log1p(arr))

 [ 1.45861502 1.64865863 1.38629436 0. 1.64865863 1.79175947

1.38629436 1.09861229 0.69314718]
[ 0.63346846 0.71600334 0.60205999 0. 0.71600334 0.77815125
0.60205999 0.47712125 0.30103 ]
[ 2.10433666 2.37851162 2. 0. 2.37851162 2.5849625 2.
1.5849625 1. ]
[ 1.66770682 1.82454929 1.60943791 0.69314718 1.82454929 1.94591015
1.60943791 1.38629436 1.09861229]

sign：計算每一個元素的符號1表示正 0:0 -1表示負號

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.sign(arr))

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

ceil：計算大於等於該值得最小整數

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.ceil(arr))

 [-5. -6. -5.  0.  5.  5.  3.  2.  1.]

floor：與ceil對應，去小於或等於該值得最大整數

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.floor(arr))

 [-6. -7. -5.  0.  4.  5.  3.  2.  1.]

rint：四捨五入最接近的整數

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.rint(arr))

 [-5. -6. -5.  0.  4.  5.  3.  2.  1.]

modf：將數組中的整數和小數分兩個數組返回

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.modf(arr))

 (array([-0.3, -0.2, -0. ,  0. ,  0.2,  0. ,  0. ,  0. ,  0. ]), array([-5., -6., -5.,  0.,  4.,  5.,  3.,  2.,  1.]))

isnan：不是數字的bool值isnan是is not a number縮寫

arr=np.array([-5.3,-6.2,-5,0,4.2,5,3,2,1])
print(np.isnan(arr))

 [False False False False False False False False False]

isfinte:判斷是不是無窮的

isinf：判斷是不是有限的

arr=np.array([np.pi,3])
print(np.isfinite(arr))
print(np.isinf(arr))

 [ True True]

[False False]

sin、cos、tan、sinh、cosh、tanharccos、arccosh、arcsin、arcsinh、arctan、arctanh:：雙曲正弦sinhx=[e^x-e^(-x)]/2,雙曲餘弦coshx=[e^x+e^(-x)]/2，雙曲正切tanh=(e^(-x)-e^x)/(e^(-x)+e^x)

arr=np.array([np.pi/2,np.pi/3,np.pi/4])
print(np.sin(arr))
print(np.cos(arr))
print(np.tan(arr))
print(np.sinh(arr))
print(np.cosh(arr))
print(np.tanh(arr))

 [ 1. 0.8660254 0.70710678]

[ 6.12323400e-17 5.00000000e-01 7.07106781e-01]
[ 1.63312394e+16 1.73205081e+00 1.00000000e+00]
[ 2.3012989 1.24936705 0.86867096]
[ 2.50917848 1.60028686 1.32460909]
[ 0.91715234 0.78071444 0.6557942 ]

mod:元素級取餘
greater:arr2>arr1
greater_equal:arr2>=arr1
less:arr2<arr1
less_equal:arr2<=arr1
equal:arr2==arr1
not_equal:arr2!=arr1

arr1=np.array([1,2,8,1])
arr2=np.array([4,5,6,1])
print('np.mod(arr2,arr1)=',np.mod(arr2,arr1))
print('greater:arr2>arr1:',np.greater(arr2,arr1))
print('greater:arr2>=arr1:',np.greater_equal(arr2,arr1))
print('greater:arr2<arr1:',np.less(arr2,arr1))
print('greater:arr2<=arr1:',np.less_equal(arr2,arr1))
print('greater:arr2==arr1:',np.equal(arr2,arr1))
print('greater:arr2!=arr1:',np.not_equal(arr2,arr1))

 np.mod(arr2,arr1)= [0 1 6 0]

greater:arr2>arr1: [ True True False False]
greater:arr2>=arr1: [ True True False True]
greater:arr2<arr1: [False False True False]
greater:arr2<=arr1: [False False True True]
greater:arr2==arr1: [False False False True]
greater:arr2!=arr1: [ True True True False]

logical_and、logical_or、logical_xor：執行元素級別的布爾邏輯運算，至關於中綴運算符&、|、^

arr1=np.array([1,2,8,1])
arr2=np.array([4,5,6,0])
print(np.logical_or(arr1,arr2))
print(np.logical_and(arr1,arr2))
print(np.logical_xor(arr1,arr2))

 [ True True True True]

[ True True True False]
[False False False True]

power：至關於arr1**arr2

arr1=np.array([1,2,8,1])
arr2=np.array([4,5,6,0])
print(np.power(arr1,arr2))

 [     1     32 262144      1]

Numpy聚合函數

axis=0按列計算
axis=1按行計算
mean:去平均值  默認求全局的
min:最小值
max：最大值
sum：求和
std：標準差 np.sqrt(np.power(arr-arr.mean(),2)).sum()/arr.size

arr=np.array([
    [1,3,5,9],
    [2,4,6,8],
    [-5,-6,-8,-2]
])
print('arr.mean（axis=0）',arr.mean(axis=0))
print('arr.min（axis=1）',arr.min(axis=1))
print('arr.max',arr.max())
print('arr.sum（axis=1）',arr.sum(axis=1))
print('arr.std（axis=0）',arr.std(axis=0))

 arr.mean（axis=0） [-0.66666667 0.33333333 1. 5. ]

arr.min（axis=1） [ 1 2 -8]
arr.max 9
arr.sum（axis=1） [ 18 20 -21]
arr.std（axis=0） [ 3.09120617 4.49691252 6.37704216 4.96655481]

 np.where函數

xarr=np.array([-1.1,-1.2,-1.3,-1.4,-1.5])
yarr=np.array([-2.1,-2.2,-2.3,-2.4,-2.5])
condiion=xarr<yarr
result1=[x if c else y for (x,y,c) in zip(xarr,yarr,condiion)]
print(result1,type(result1))
result2=np.where(condiion,xarr,yarr)
print(result2,type(result2))

 [-2.1000000000000001, -2.2000000000000002, -2.2999999999999998, -2.3999999999999999, -2.5] <class 'list'>

[-2.1 -2.2 -2.3 -2.4 -2.5] <class 'numpy.ndarray'>

將數組中的全部異常數字替換爲0，好比將NaN替換爲0

arr=np.array([
    [1,2,np.NaN,4],
    [4,5,6,np.NaN],
    [7,8,9,np.NaN],
    [np.inf,np.e,np.pi,4]
])
condition=np.isnan(arr)|np.isinf(arr)
print('原始數據：')
print(arr)
print('修改後的數據：')
print(np.where(condition,0,arr))

 原始數據：

[[ 1. 2. nan 4. ]
[ 4. 5. 6. nan]
[ 7. 8. 9. nan]
[ inf 2.71828183 3.14159265 4. ]]
修改後的數據：
[[ 1. 2. 0. 4. ]
[ 4. 5. 6. 0. ]
[ 7. 8. 9. 0. ]
[ 0. 2.71828183 3.14159265 4. ]]

unique：去重操做

arr=np.array(['圖書','數碼','圖書','小吃','小吃'])
print('原始數據：')
for i in arr:
    print(i,end=' ')
print()
print('修改後的數據：')
arr1=np.unique(arr)
for i in arr1:
    print(i,end=' ')

 原始數據：

圖書 數碼 圖書 小吃 小吃 

修改後的數據：
圖書 小吃 數碼

 

 

 

adding：

Jupyter Notebook文件地址設置：

1.打開cmd,輸入 jupyter notebook --generate-config 

2.打開這個配置文件，找到「c.NotebookApp.notebook_dir=‘’ 」，去掉前面的#號， 把路徑改爲本身的工做目錄

3.配置文件修改完成後， 之後在jupyter notebook中寫的代碼等都會保存在 本身建立的目錄中。

按以上操做以後重啓Jupyter Notebook可能無效，解決方法以下：

jupyter notebook->右鍵->屬性->將目標中的%users%去掉

 

arr=np.array([u'數學',u'語文'])不能顯示字符能夠在前面加u

 

jupyter上方有的Cell,裏面的cell all能夠一次性執行全部步驟