這里是首先需要安裝好Anaconda
Anaconda的安裝參考Python之路-初識python及環境搭建並測試
配置好環境之后開始使用Jupyter Notebook
1.打開cmd,輸入 jupyter notebook --generate-config
2.打開這個配置文件，找到“c.NotebookApp.notebook_dir=‘’ ”， 把路徑改成自己的工作目錄
使用notepad++打開這個文件，大概在124行添加自己的工作目錄
c.NotebookApp.notebook_dir = 'D:\Python' 注意：去掉注釋符合，前面不能有空格
3.配置文件修改完成后， 以后在jupyter notebook中寫的代碼等都會保存在自己創建的目錄中。
Scipy庫簡介
Scipy庫是基於Python生態的一款開源數值計算、科學與工程應用的開源軟件，主要包括NumPy、Scipy、pandas、matplotlib等等。
官方文檔：https://scipy.org/
numPy、Scipy、pandas、matplotlib簡介
numpy——基礎，以矩陣為基礎的數學計算模塊，純數學存儲和處理大型矩陣。 這個是很基礎的擴展，其余的擴展都是以此為基礎。
scipy——數值計算庫,在numPy庫的基礎上增加了眾多的數學、科學以及工程計算中常用的庫函數。 方便、易於使用、專為科學和工程設計的Python工具包.它包括統計,優化,整合,線性代數模塊,傅里葉變換,信號和圖像處理,常微分方程求解器等等。
pandas——數據分析,基於numPy 的一種工具，為了解決數據分析任務而創建的.Pandas 納入了大量庫和一些標准的數據模型，提供了高效地操作大型數據集所需的工具。
matplotlib——繪圖,對於圖像美化方面比較完善，可以自定義線條的顏色和式樣，可以在一張繪圖紙上繪制多張小圖，也可在一張圖上繪制多條線，可以很方便的對數據進行可視化分析。
NumPy歷史
1995年Jim HugUNin開發了Numeric
隨后Numarray包誕生
Travis Oliphants整合Numeric和Numarray，開發NumPy，2006 年第一個版本誕生
使用Anaconda發行版的Python，已經安裝好NumPy模塊，所以可以不用再安裝NumPy模塊了。
依照標准的NumPy標准，習慣使用import numpy as np的方式導入該模塊。
NumPy模塊
numPy：Numerical Python，即數值Python包，是Python進行科學計算的一個基礎包，所以是一個掌握其他Scipy庫中模塊的基礎模塊，一定需要先掌握該包的主要使用方式。
官方文檔：https://docs.scipy.org/doc/numpy/user/index.html
NumPy模塊是Python的一種開源的數值計算擴展，是一個用python實現的科學計算包，主要包括：
一個具有矢量算術運算和復雜廣播能力的快速且節省空間的多維數組，稱為ndarray(N-dimensional array object)
用於對整組數據進行快速運算的標准數學函數：ufunc(universal function object)
實用的線性代數、傅里葉變換和隨機數生成函數。
NumPy和稀疏矩陣的運算包Scipy配合使用更加方便。
NumPy核心數據結構：ndarray
NumPy的數組類被稱作ndarray。通常被稱作數組。注意numpy.array和標准Python庫類array.array並不相同，后者只處理一維數組和提供少量功能。
一種由相同類型的元素組成的多維數組，元素數量是實現給定好的
元素的數據類型由dtype(data-type)對象來指定，每個ndarray只有一種dtype類型
ndarray的大小固定，創建好數組后數組大小是不會再發生改變的
ndarray創建
可以通過numpy模塊中的常用的幾個函數進行創建ndarray多維數組對象，主要函數如下：
array函數：接收一個普通的python序列，並將其轉換為ndarray
zeros函數：創建指定長度或者形狀的全零數組。
ones函數：創建指定長度或者形狀的全1數組。
empty函數：創建一個沒有任何具體值的數組(准備地說是創建一些未初始化的ndarray多維數組)
練習
In [1]:
import numpy as np
創建數組
In [2]:
help(np.array)
Help on built-in function array in module numpy.core.multiarray:
array(...)
array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
Create an array.
Parameters
----------
object : array_like
An array, any object exposing the array interface, an
object whose __array__ method returns an array, or any
(nested) sequence.
dtype : data-type, optional
The desired data-type for the array. If not given, then
the type will be determined as the minimum type required
to hold the objects in the sequence. This argument can only
be used to 'upcast' the array. For downcasting, use the
.astype(t) method.
copy : bool, optional
If true (default), then the object is copied. Otherwise, a copy
will only be made if __array__ returns a copy, if obj is a
nested sequence, or if a copy is needed to satisfy any of the other
requirements (`dtype`, `order`, etc.).
order : {'C', 'F', 'A'}, optional
Specify the order of the array. If order is 'C', then the array
will be in C-contiguous order (last-index varies the fastest).
If order is 'F', then the returned array will be in
Fortran-contiguous order (first-index varies the fastest).
If order is 'A' (default), then the returned array may be
in any order (either C-, Fortran-contiguous, or even discontiguous),
unless a copy is required, in which case it will be C-contiguous.
subok : bool, optional
If True, then sub-classes will be passed-through, otherwise
the returned array will be forced to be a base-class array (default).
ndmin : int, optional
Specifies the minimum number of dimensions that the resulting
array should have. Ones will be pre-pended to the shape as
needed to meet this requirement.
Returns
-------
out : ndarray
An array object satisfying the specified requirements.
See Also
--------
empty, empty_like, zeros, zeros_like, ones, ones_like, fill
Examples
--------
>>> np.array([1, 2, 3])
array([1, 2, 3])
Upcasting:
>>> np.array([1, 2, 3.0])
array([ 1., 2., 3.])
More than one dimension:
>>> np.array([[1, 2], [3, 4]])
array([[1, 2],
[3, 4]])
Minimum dimensions 2:
>>> np.array([1, 2, 3], ndmin=2)
array([[1, 2, 3]])
Type provided:
>>> np.array([1, 2, 3], dtype=complex)
array([ 1.+0.j, 2.+0.j, 3.+0.j])
Data-type consisting of more than one element:
>>> x = np.array([(1,2),(3,4)],dtype=[('a','<i4'),('b','<i4')])
>>> x['a']
array([1, 3])
Creating an array from sub-classes:
>>> np.array(np.mat('1 2; 3 4'))
array([[1, 2],
[3, 4]])
>>> np.array(np.mat('1 2; 3 4'), subok=True)
matrix([[1, 2],
[3, 4]])
In [3]:
#用一維列表創建
np.array([1,2,3])
Out[3]:
array([1, 2, 3])
In [4]:
#用元祖創建
np.array((1,2,3))
Out[4]:
array([1, 2, 3])
In [6]:
#duo維數組
np.array([[1,2,3,4],[5,6,7,8]])
Out[6]:
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
In [8]:
#三維數組
np.array([[1,2,3],[2,3,4],
[[4,5,6],[6,7,8]]])
Out[8]:
array([[1, 2, 3], [2, 3, 4], [[4, 5, 6], [6, 7, 8]]], dtype=object)
In [15]:
#通過zeros創建數組,創建一個元素為0d的數組
# np.zeros((3,3))
np.zeros((2,3,4))
Out[15]:
array([[[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]],
[[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 0.]]])
In [16]:
#ones生成元素為1的數組
np.ones((2,3))
Out[16]:
array([[ 1., 1., 1.],
[ 1., 1., 1.]])
In [17]:
np.empty((3,3))
Out[17]:
array([[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])
ndarray其它創建方式
arange函數: 類似python的range函數，通過指定開始值、終值和步長來創建一個一維數組，注意：最終創建的數組不包含終值
linspace函數：通過指定開始值、終值和元素個數來創建一個一維數組，數組的數據元素符合等差數列，可以通過endpoint關鍵字指定是否包含終值，默認包含終值
logspace函數：和linspace函數類似，不過創建的是等比數列數組
使用隨機數填充數組，即使用numpy.random中的random()函數來創建0-1之間的隨機元素，數組包含的元素數量由參數決定
練習
其他創建方式
In [22]:
#arange
# np.arange(9)
# np.arange(1,9,2)
np.arange(9,0,-2)
Out[22]:
array([9, 7, 5, 3, 1])
In [23]:
#linspace生成等差shulie
np.linspace(1,10,5)
Out[23]:
array([ 1. , 3.25, 5.5 , 7.75, 10. ])
In [25]:
#logspace等比數列
# np.logspace(0,2,5)#默認
np.logspace(0,2,5,base = 2)
Out[25]:
array([ 1. , 1.41421356, 2. , 2.82842712, 4. ])
In [27]:
#使用random創建隨機數
np.random.random((3,3))
Out[27]:
array([[ 0.78764356, 0.39990922, 0.65267886],
[ 0.85181922, 0.47399746, 0.3324923 ],
[ 0.90719725, 0.16047382, 0.25940587]])
In [30]:
np.random.randint(10,30,size = (3,3))
Out[30]:
array([[13, 12, 11],
[22, 18, 19],
[26, 10, 25]])
In [31]:
np.random.randn(3,3)#標准正態分布
Out[31]:
array([[ 0.89698445, 0.76038415, 0.96602525],
[ 1.03257187, -2.18487826, 0.30305221],
[ 0.33735975, 0.25791743, -0.23504451]])
In [32]:
np.random.rand(9)#(0,1)之間的隨機數
Out[32]:
array([ 0.81492509, 0.16966199, 0.38262906, 0.08861263, 0.75228657,
0.9020329 , 0.91608186, 0.16995603, 0.95110964])
ndarray對象屬性
ndim 數組軸(維度)的個數，軸的個數被稱作秩
shape 數組的維度, 例如一個2排3列的矩陣，它的shape屬性將是(2,3),這個元組的長度顯然是秩，即維度或者ndim屬性
size 數組元素的總個數，等於shape屬性中元組元素的乘積。
dtype 一個用來描述數組中元素類型的對象，可以通過創造或指定dtype使用標准Python類型。不過NumPy提供它自己的數據類型。
itemsize 數組中每個元素的字節大小。例如，一個元素類型為float64的數組itemsiz屬性值為8(=64/8),又如，一個元素類型為complex32的數組item屬性為4(=32/8).
NumPy基本數據類型
ndarray中元素數據類型
創建numpy數組的時候可以通過屬性dtype顯示指定數據類型，如果不指定的情況下，numpy會自動推斷出適合的數據類型，所以一般不需要顯示給定數據類型。
如果需要更改一個已經存在的數組的數據類型，可以通過astype方法進行修改從而得到一個新數組。
NumPy基本數據類型
數值型dtype的命名方式為：一個類型名稱(eg:int、float等)，后接一個表示各個元素位長的數字
比如Python的float數據類型(雙精度浮點值)，需要占用8個字節(64位)，因此在NumPy中記為float64
每個數據類型都有一個類型代碼，即簡寫方式
練習
In [1]:
import numpy as np
基本屬性
In [12]:
#ndimdim數組軸（維度）的個數，軸的個數稱為秩
arr = np.random.randint(1,9,size = (3,3))
# arr
arr.ndim
Out[12]:
array([[2, 4, 4],
[7, 1, 8],
[7, 7, 5]])
In [14]:
#shape數組的維度 形狀
arr = np.random.randint(1,9,size = (3,3))
arr.shape
Out[14]:
(3, 3)
In [18]:
#dtype 描述元祖中元素類型
arr = np.random.randint(1,9,size = (2,3))
arr.dtype
arr.itemsize#元素字節大小
arr.size#元素個數
Out[18]:
6
In [24]:
# arr2 = np.array([1,2,3,4])
# arr2.dtype
# arr3 = arr2.astype('f4')
# arr3.dtype
arr2 = np.array([1,2,3,4],dtype = float)
arr2.dtype
Out[24]:
dtype('float64')
In [27]:
np.array(['Python','java','C'],dtype = 'S9')
Out[27]:
array([b'Python', b'java', b'C'],
dtype='|S9')
ndarray修改形狀
對於一個已經存在的ndarray數組對象而言，可以通過修改形狀相關的參數/方法從而改變數組的形狀。
直接修改數組ndarray的shape值, 要求修改后乘積不變。
直接使用reshape函數創建一個改變尺寸的新數組，原數組的shape保持不變，但是新數組和原數組共享一個內存空間，也就是修改任何一個數組中的值都會對另外一個產生影響，另外要求新數組的元素個數和原數組一致。
當指定某一個軸為-1的時候，表示將根據數組元素的數量自動計算該軸的長度值。
練習
修改數組形狀
In [37]:
#shape修改
arr = np.random.randint(1,9,size = (2,5))
arr.shape
# arr.shape = (5,2)
# arr
arr.shape = (-1,5)
arr
Out[37]:
array([[6, 6, 4, 6, 6],
[3, 1, 1, 8, 7]])
In [45]:
#reshape修改
arr = np.arange(9)
arr
Out[45]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8])
In [47]:
arr2 = arr.reshape(3,3)
arr2
arr2[0][1] = 100
arr2
Out[47]:
array([[ 0, 100, 2],
[ 3, 4, 5],
[ 6, 7, 8]])
In [48]:
arr
Out[48]:
array([ 0, 100, 2, 3, 4, 5, 6, 7, 8])
In [49]:
arr = np.arange(9).reshape(3,3)
arr
Out[49]:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
In [51]:
arr = np.arange(12).reshape(-1,3)
arr
Out[51]:
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
NumPy基本操作
數組與標量、數組之間的運算
數組的矩陣積(matrix product)
數組的索引與切片
數組的轉置與軸對換
通用函數：快速的元素級數組成函數
聚合函數
np.where函數
np.unique函數
ndarray-數組與標量、數組之間的運算
數組不用循環即可對每個元素執行批量的算術運算操作，這個過程叫做矢量化，即用數組表達式代替循環的做法。
矢量化數組運算性能比純Python方式快上一兩個數據級。
大小相等的兩個數組之間的任何算術運算都會將其運算應用到元素級上的操作。
元素級操作：在NumPy中，大小相等的數組之間的運算，為元素級運算，即只用於位置相同的元素之間，所得的運算結果組成一個新的數組，運算結果的位置跟操作數位置相同。
ndarray-數組的矩陣積
矩陣：多維數組即矩陣
矩陣積(matrix product)：兩個二維矩陣(行和列的矩陣)滿足第一個矩陣的列數與第二個矩陣的行數相同，那么可以進行矩陣的乘法，即矩陣積，矩陣積不是元素級的運算。也稱為點積、數量積。
ndarray-多維數組的索引
In [1]:
import numpy as np
數組與標量的運算
In [7]:
arr = np.arange(0,9).reshape(3,3)
arr
arr+2
arr*3
arr/2
arr-3
Out[7]:
array([[-3, -2, -1],
[ 0, 1, 2],
[ 3, 4, 5]])
In [19]:
arr1 = np.array([[10,20,30],
[40,50,60]])
arr2 = np.array([[1,2,3],
[4,5,6]])
print(arr1)
print(arr2)
[[10 20 30]
[40 50 60]]
[[1 2 3]
[4 5 6]]
In [10]:
arr1+arr2
Out[10]:
array([[11, 22, 33],
[44, 55, 66]])
In [11]:
arr1*arr2
Out[11]:
array([[ 10, 40, 90],
[160, 250, 360]])
In [12]:
print(arr2-arr1)
[[ -9 -18 -27]
[-36 -45 -54]]
In [20]:
print(arr2 / arr1)
[[ 0.1 0.1 0.1]
[ 0.1 0.1 0.1]]
In [24]:
arr1 = np.array([[100,101,102],
[50,60,70],
[10,20,30]])
arr2 = np.array([[2,3],
[3,4],
[5,6]])
print(arr1)
print(arr2)
[[100 101 102]
[ 50 60 70]
[ 10 20 30]]
[[2 3]
[3 4]
[5 6]]
In [26]:
np.dot(arr1,arr2)#矩陣相乘（點積）
Out[26]:
array([[1013, 1316],
[ 630, 810],
[ 230, 290]])
ndarray-數組的切片
ndarray-布爾類型索引
利用布爾類型的數組進行數據索引，最終返回的結果是對應索引數組中數據為True位置的值。
練習
索引和切片
In [27]:
arr = np.random.randint(1,9,size = (2,3,3))
arr
Out[27]:
array([[[4, 3, 8],
[4, 3, 6],
[1, 8, 4]],
[[4, 3, 2],
[4, 5, 2],
[5, 2, 8]]])
In [28]:
print(arr[0,0,1])
3
In [29]:
print(arr[0,0,1])
3
In [30]:
print(arr[1,0,1])
3
In [31]:
print(arr[:,:,1])#切片
[[3 3 8]
[3 5 2]]
In [32]:
arr = np.random.randint(1,9,size = (2,3,4))
arr
Out[32]:
array([[[3, 5, 8, 7],
[5, 8, 6, 1],
[6, 8, 5, 2]],
[[3, 2, 3, 6],
[5, 4, 8, 6],
[8, 2, 4, 5]]])
In [33]:
print(arr[:,:,1:3])
[[[5 8]
[8 6]
[8 5]]
[[2 3]
[4 8]
[2 4]]]
In [34]:
print(arr[0,:,1:3])
[[5 8]
[8 6]
[8 5]]
In [35]:
print(arr[0,1:3,1:3])
[[8 6]
[8 5]]
In [37]:
print(arr[0,0:3:2,1:3])
[[5 8]
[8 5]]
ndarray-花式索引
花式索引(Fancy indexing)指的是利用整數數組進行索引的方式。
練習
花式索引
In [39]:
arr = np.random.randint(1,9,size = (8,4))
arr
Out[39]:
array([[1, 3, 7, 3],
[5, 5, 6, 3],
[3, 7, 2, 7],
[1, 8, 4, 2],
[2, 7, 6, 2],
[4, 7, 8, 5],
[3, 6, 4, 2],
[5, 3, 2, 1]])
In [40]:
#獲取0,3,5 行
print(arr[[0,3,5]])
[[1 3 7 3]
[1 8 4 2]
[4 7 8 5]]
In [42]:
#獲取0,0 3,3 5,2數據
print(arr[[0,3,5],[0,3,2]])
[1 2 8]
In [43]:
#索引器
print(arr[np.ix_([0,3,5],[0,3,2])])
[[1 3 7]
[1 2 4]
[4 5 8]]
ndarray-數組轉置與軸對換
數組轉置是指將shape進行重置操作，並將其值重置為原始shape元組的倒置，比如原始的shape值為:(2,3,4)，那么轉置后的新元組的shape的值為: (4,3,2)f
對於二維數組而言(矩陣)數組的轉置其實就是矩陣的轉置
可以通過調用數組的transpose函數或者T屬性進行數組轉置操作
練習
布爾索引
In [46]:
A = np.random.random((4,4))
print(A.shape)
A
(4, 4)
Out[46]:
array([[ 0.10672869, 0.852003 , 0.53935853, 0.07336634],
[ 0.38104429, 0.13577986, 0.41589372, 0.39334269],
[ 0.38895639, 0.41326197, 0.05121095, 0.76327218],
[ 0.5542428 , 0.62085344, 0.06846954, 0.13081136]])
In [47]:
arr2 = A < 0.5
arr2
Out[47]:
array([[ True, False, False, True],
[ True, True, True, True],
[ True, True, True, False],
[False, False, True, True]], dtype=bool)
In [80]:
name = np.array(['joe','susan','Tom'])
score = np.array([
[70,80,90],
[77,88,99],
[66,78,89],
])
classes = np.array(['語文','數學','英語'])
print(score)
[[70 80 90]
[77 88 99]
[66 78 89]]
In [82]:
name2 = name == 'joe'
name2
Out[82]:
array([ True, False, False], dtype=bool)
In [86]:
score[name == 'joe'].reshape(-1)
Out[86]:
array([70, 80, 90])
In [88]:
score[name == 'joe',classes == '數學']
Out[88]:
array([80])
In [89]:
score[name == 'Tom',classes == '語文']
Out[89]:
array([66])
In [90]:
score[(name == 'joe')|(name == 'susan')]
Out[90]:
array([[70, 80, 90],
[77, 88, 99]])
In [91]:
score[(name != 'joe')&(name != 'susan')]
Out[91]:
array([[66, 78, 89]])
In [92]:
score[(name != 'joe')&(name != 'susan'),classes == '數學']
Out[92]:
array([78])
ndarray-通用函數/常用函數
ufunc：numpy模塊中對ndarray中數據進行快速元素級運算的函數，也可以看做是簡單的函數(接受一個或多個標量值，並產生一個或多個標量值)的矢量化包裝器。
主要包括一元函數和二元函數
ndarray-通用函數/常用函數(一元函數)
練習
In [1]:
import numpy as np
常用一元函數
In [2]:
arr = np.array([-1,-2,-4])
np.abs(arr)
Out[2]:
array([1, 2, 4])
In [6]:
#平方根
arr = np.random.randint(1,9,size = (3,3))
print(arr)
print(np.sqrt(arr))
[[5 2 2]
[1 7 3]
[1 4 1]]
[[ 2.23606798 1.41421356 1.41421356]
[ 1. 2.64575131 1.73205081]
[ 1. 2. 1. ]]
In [8]:
arr = np.random.randint(1,9,size = (3,3))
print(arr)
print(np.exp(arr))
print(np.sign(arr))
[[6 4 1]
[1 4 8]
[2 3 3]]
[[ 4.03428793e+02 5.45981500e+01 2.71828183e+00]
[ 2.71828183e+00 5.45981500e+01 2.98095799e+03]
[ 7.38905610e+00 2.00855369e+01 2.00855369e+01]]
[[1 1 1]
[1 1 1]
[1 1 1]]
In [11]:
arr = np.random.randint(1,9,size = (3,3))
print(arr)
print(np.isnan(arr))
print(np.isfinite(arr))#有窮
print(np.isinf(arr))#無窮
[[1 2 5]
[1 8 7]
[3 6 7]]
[[False False False]
[False False False]
[False False False]]
[[ True True True]
[ True True True]
[ True True True]]
[[False False False]
[False False False]
[False False False]]
ndarray-通用函數/常用函數(二元函數)
練習
二元函數
In [12]:
arr = np.random.randint(1,9,size = (3,3))
arr2 = np.random.randint(1,9,size = (3,3))
print(arr)
print(arr2)
[[2 7 2]
[1 5 7]
[8 6 2]]
[[2 8 1]
[4 2 5]
[5 5 4]]
In [13]:
np.greater(arr,arr2)#比大小
Out[13]:
array([[False, False, True],
[False, True, True],
[ True, True, False]], dtype=bool)
In [14]:
np.power(arr,2)#次方
Out[14]:
array([[ 4, 49, 4],
[ 1, 25, 49],
[64, 36, 4]], dtype=int32)
ndarray-聚合函數
聚合函數是對一組值(eg一個數組)進行操作，返回一個單一值作為結果的函數。當然聚合函數也可以指定對某個具體的軸進行數據聚合操作；
常將的聚合操作有：平均值、最大值、最小值、方差等等
練習
聚合函數
In [15]:
arr = np.random.randint(1,9,size = (3,3))
arr
Out[15]:
array([[6, 3, 5],
[4, 5, 8],
[3, 3, 6]])
In [22]:
# print(arr.min(axis = 0))#列
# print(arr.max(axis = 0))
# print(arr.mean(axis = 0))
# print(arr.min(axis = 1))#行
# print(arr.max(axis = 1))
# print(arr.mean(axis = 1))
print(arr.std())
print(arr.std(axis = 1))
1.61780219762
[ 1.24721913 1.69967317 1.41421356]
np.where函數
np.where函數是三元表達式x if condition else y的矢量化版本
練習
案例：將數組中的所有異常數字替換為0，比如將NaN替換為0
where函數
In [23]:
help(np.where)
Help on built-in function where in module numpy.core.multiarray:
where(...)
where(condition, [x, y])
Return elements, either from `x` or `y`, depending on `condition`.
If only `condition` is given, return ``condition.nonzero()``.
Parameters
----------
condition : array_like, bool
When True, yield `x`, otherwise yield `y`.
x, y : array_like, optional
Values from which to choose. `x` and `y` need to have the same
shape as `condition`.
Returns
-------
out : ndarray or tuple of ndarrays
If both `x` and `y` are specified, the output array contains
elements of `x` where `condition` is True, and elements from
`y` elsewhere.
If only `condition` is given, return the tuple
``condition.nonzero()``, the indices where `condition` is True.
See Also
--------
nonzero, choose
Notes
-----
If `x` and `y` are given and input arrays are 1-D, `where` is
equivalent to::
[xv if c else yv for (c,xv,yv) in zip(condition,x,y)]
Examples
--------
>>> np.where([[True, False], [True, True]],
... [[1, 2], [3, 4]],
... [[9, 8], [7, 6]])
array([[1, 8],
[3, 4]])
>>> np.where([[0, 1], [1, 0]])
(array([0, 1]), array([1, 0]))
>>> x = np.arange(9.).reshape(3, 3)
>>> np.where( x > 5 )
(array([2, 2, 2]), array([0, 1, 2]))
>>> x[np.where( x > 3.0 )] # Note: result is 1D.
array([ 4., 5., 6., 7., 8.])
>>> np.where(x < 5, x, -1) # Note: broadcasting.
array([[ 0., 1., 2.],
[ 3., 4., -1.],
[-1., -1., -1.]])
Find the indices of elements of `x` that are in `goodvalues`.
>>> goodvalues = [3, 4, 7]
>>> ix = np.in1d(x.ravel(), goodvalues).reshape(x.shape)
>>> ix
array([[False, False, False],
[ True, True, False],
[False, True, False]], dtype=bool)
>>> np.where(ix)
(array([1, 1, 2]), array([0, 1, 1]))
In [24]:
np.where([[True, False], [True, True]],[[1, 2], [3, 4]],[[9, 8], [7, 6]])
Out[24]:
array([[1, 8],
[3, 4]])
In [25]:
np.where([[0, 1], [1, 0]])
Out[25]:
(array([0, 1], dtype=int64), array([1, 0], dtype=int64))
In [27]:
x = np.arange(9.).reshape(3, 3)
print(x)
np.where( x > 5 )
[[ 0. 1. 2.]
[ 3. 4. 5.]
[ 6. 7. 8.]]
Out[27]:
(array([2, 2, 2], dtype=int64), array([0, 1, 2], dtype=int64))
In [28]:
arr1 = np.random.randint(1,9,size = (1,5)).reshape(-1)
arr2 = np.random.randint(1,9,size = (1,5)).reshape(-1)
print(arr1)
print(arr2)
[5 7 7 8 2]
[6 4 8 5 4]
In [29]:
condition = arr1 < arr2
print(condition)
[ True False True False True]
In [30]:
arr4 = np.where(condition,arr1,arr2)
arr4
Out[30]:
array([5, 4, 7, 5, 2])
In [34]:
arr = np.array([
[1,2,3,np.NaN],
[1,2,3,np.pi],
[1,2,3,np.e]
])
arr
condition = np.isnan(arr)|np.isinf(arr)
arr2 = np.where(condition,0,arr)
arr2
Out[34]:
array([[ 1. , 2. , 3. , 0. ],
[ 1. , 2. , 3. , 3.14159265],
[ 1. , 2. , 3. , 2.71828183]])
np.unique函數
np.unique函數的主要作用是將數組中的元素進行去重操作(也就是只保存不重復的數據)
練習
unique去重操作
In [37]:
arr = np.array(['a','b','c','d','a','b','c','d'])
arr
print(np.unique(arr))
['a' 'b' 'c' 'd']