1.理解Numpy

Numpy是一個功能強(qiáng)大的Python第三方庫，允許更高級的數(shù)據(jù)操作和數(shù)學(xué)計算

2.什么是Numpy？

Numpy是一個功能強(qiáng)大的Python庫，主要用于對多維數(shù)組執(zhí)行計算。
Numpy來源于兩個詞---Numerical和Python。

3.引入Numpy模塊

#引入 模塊的名字
import numpy as np

4.Numpy創(chuàng)建數(shù)組的幾種方式

（1）np.array創(chuàng)建數(shù)組

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

運(yùn)行結(jié)果：
[1 2 3 4]

（2）np.arange(起點，終點，步長)創(chuàng)建數(shù)組

b = np.arange(0, 10, 2)
print(b)

運(yùn)行結(jié)果：
[0 2 4 6 8]

（3）np.random.random((行，列))創(chuàng)建0-1之間隨機(jī)數(shù)組

創(chuàng)建一個N行N列的數(shù)組，其中里面的值是0-1之間的隨機(jī)數(shù)

c = np.random.random((3,3))
print(c)

運(yùn)行結(jié)果：
[[0.09045976 0.31720375 0.75277534]
[0.00118458 0.39388824 0.70546639]
[0.24588278 0.35719804 0.76919751]]

（4）np.random.randiant(起點，終點，size=(行，列))創(chuàng)建數(shù)組

創(chuàng)建一個N行N列的數(shù)組，其中值的范圍可以通過前面2個參數(shù)來指定

d = np.random.randint(0,10,size=(6,4))
print(d)

運(yùn)行結(jié)果：
[[2 6 5 8]
[9 0 4 5]
[5 6 4 7]
[3 6 3 9]
[4 6 7 5]
[4 4 2 8]]

5.數(shù)組和列表的區(qū)別

（1）數(shù)組（ndarray）與列表（list）類似，是具有相同類型的多個元素構(gòu)成的整體。
（2）數(shù)組局限：
數(shù)組元素要求是相同類型，而列表的元素可以是不同類型。
如果傳進(jìn)來的列表中包含不同的類型，則統(tǒng)一為統(tǒng)一類型，優(yōu)先級：str>float>int
（3）數(shù)組優(yōu)勢：
數(shù)組可以與標(biāo)量進(jìn)行運(yùn)算，數(shù)組之間也可以進(jìn)行矢量化運(yùn)算。
數(shù)組在運(yùn)算時，具有廣播能力。
數(shù)組底層使用C程序編寫，運(yùn)算速度快。
數(shù)組底層使用C中數(shù)組的存儲方式（緊湊存儲），節(jié)省內(nèi)存空間。
（4）數(shù)組與列表的區(qū)別
<1>是不同的對象

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

運(yùn)行結(jié)果：
[1, 2, 3] <class 'list'>
[1 2 3] <class 'numpy.ndarray'>
<2>數(shù)組元素要求是相同類型，而列表的元素可以是不同類型

a = [1, "柚子", True]
b = np.array([1, 2, '3'])
print(a)
print(b)

運(yùn)行結(jié)果：
[1, '柚子', True]
['1' '2' '3']
<3>數(shù)組可以對位相加，列表不行

a = [1, 2, 3]
b = [2, 4, 6]
print(a + b)
c = np.array([1, 2, 3])
d = np.array([2, 4, 6])
print(c + d)

運(yùn)行結(jié)果：
[1, 2, 3, 2, 4, 6]
[3 6 9]

6.特殊函數(shù)

（1）np.zeros((行，列)):N行N列的全零數(shù)組

a = np.zeros((4,6))
print(a)

運(yùn)行結(jié)果：
[[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0. 0.]]
（2）np.ones((行，列)):N行N列的全1數(shù)組

b = np.ones((2,3))
print(b)

運(yùn)行結(jié)果：
[[1. 1. 1.]
[1. 1. 1.]]
（3）np.full((行，列)，指定值):全部為指定值的N行N列數(shù)組

c = np.full((5, 7), 7)
print(c)

運(yùn)行結(jié)果：
[[7 7 7 7 7 7 7]
[7 7 7 7 7 7 7]
[7 7 7 7 7 7 7]
[7 7 7 7 7 7 7]
[7 7 7 7 7 7 7]]
（4）np.eye(N):生成一個在斜方形上元素為1，其他元素都為0的N行N列矩陣

d = np.eye(5)
print(d)

運(yùn)行結(jié)果：
[[1. 0. 0. 0. 0.]
[0. 1. 0. 0. 0.]
[0. 0. 1. 0. 0.]
[0. 0. 0. 1. 0.]
[0. 0. 0. 0. 1.]]
注意：
數(shù)組中的數(shù)據(jù)類型必須一致，要么全部為整型，要么全部為為浮點類型，要么全部為字符串類型
不能同時出現(xiàn)多種數(shù)據(jù)類型
(4)empty()函數(shù)
原型：np.empty(shape,dtype = float, order = 'c')
作用：創(chuàng)建一個指定形狀（shape）、數(shù)據(jù)類型（dtype）且未初始化的數(shù)組
參數(shù)說明：
shape:數(shù)組形狀
dtype:數(shù)據(jù)類型，可選
order:有“C”和“F”兩個選項，分別代表行優(yōu)先和列優(yōu)先，在計算機(jī)內(nèi)存中的存儲元素的順序

7.數(shù)據(jù)類型

續(xù)圖片：Unicode類型，使用'U10'

np.dtype() #定義數(shù)據(jù)類型

dt = np.dtype(np.bool_)
print(dt)

運(yùn)行結(jié)果:
bool
（1）
a.展示結(jié)構(gòu)化數(shù)據(jù)類型的使用，類型字段和對應(yīng)的實際類型將被創(chuàng)建
b.將數(shù)據(jù)類型應(yīng)用于ndarray對象

dt = np.dtype([('score',np.int16)])
print(dt)
a = np.array([10,20,30], dtype = dt)
print(a)

運(yùn)行結(jié)果：
[('score', '<i2')]
[(10,) (20,) (30,)]
（2）
a.定義一個結(jié)構(gòu)化數(shù)據(jù)類型
球星類型：
字符串字段：名字
整數(shù)字段：年齡
浮點數(shù)字段：收入
b.將這個dtype應(yīng)用到ndarray對象

球星字段 = np.dtype([('名字','S20'),('年齡',np.int8),('收入',np.float16)])
超級球星 = np.array([('meixi',37,9),('cluo',36,8)],dtype=球星字段)
print(超級球星)

運(yùn)行結(jié)果：
[(b'meixi', 37, 9.) (b'cluo', 36, 8.)]

（3）設(shè)置以及查詢數(shù)據(jù)類型(.dtype)

encode() 編碼
decode() 解碼
ascii 編碼
gb2312 gbk 這2種編碼是中國創(chuàng)造的編碼、用來顯示中文的
unicode utf-8 這2種編碼幾乎能運(yùn)用于世界上每一個國家
python中字符串的兩種類型：bytes,str
str存儲unicode類型
bytesd存儲byte類型

a = np.array([1,2,3,4],dtype = 'S20')
print(a)  # bytes 數(shù)據(jù)類型 字符串
print(a[1].decode('utf-8'), type(a[1].decode('utf-8')))  #解碼
print(a.dtype)  #查詢數(shù)據(jù)類型

運(yùn)行結(jié)果：
[b'1' b'2' b'3' b'4']
2 <class 'str'>
|S20
數(shù)組 一種數(shù)據(jù)類型

#默認(rèn)數(shù)據(jù)類型
b = np.array([1, 2, 3, 4])
print(b.dtype)
c = np.array([1,2,3.5,4])
print(c.dtype)

運(yùn)行結(jié)果：
int32
float64

（4）修改數(shù)據(jù)類型 (.astype())

<1>Numpy是基于C語言編寫，引用了C語言的數(shù)據(jù)類型，所以Numpy的數(shù)組中數(shù)據(jù)類型多樣。
<2>不同的數(shù)據(jù)類型有利于處理海量數(shù)據(jù)，針對不同數(shù)據(jù)賦予不同數(shù)據(jù)類型，從而節(jié)省內(nèi)存空間。

a = np.array([1, 2, 3, 4], dtype = np.int8)
print(a.dtype)
f = a.astype(np.float16)
print(f.dtype)

運(yùn)行結(jié)果：
int8
float16、

8.數(shù)組維度與檢測

（1）一維數(shù)組
np.array([1,2,3,4])
二維數(shù)組
np.array([[1,2],[3,4]])
三維數(shù)組
np.array([[[1,2],[3,4]],[[5,6],[7,8]]])

#一維數(shù)組
a_1 = np.array([1,2,3,4])
print(a_1)
#二維數(shù)組
a_2 = np.array([[1,2],[3,4]])
print(a_2)
#三維數(shù)組
a_3 = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
print(a_3)

運(yùn)行結(jié)果：
[1 2 3 4]
[[1 2]
[3 4]]
[[[1 2]
[3 4]]

[[5 6]
[7 8]]]
（2）檢測(.ndim)

print(a_3.ndim)

運(yùn)行結(jié)果：3

9.數(shù)字形狀查詢

數(shù)組的形狀查詢：shape屬性
它是一個元組，返回每個維中元素的數(shù)量。有時候我們可能需要知道某一維的特定數(shù)量。

#一維數(shù)組
a_1 = np.array([1,2,3,4])
#二維數(shù)組
a_2 = np.array([[1,2],[3,4],[5,6]])
#三維數(shù)組
a_3 = np.array([[[1,2,3],[3,4,3]],[[5,6,3],[7,8,3]]])
print(a_1.shape)
print(a_2.shape)
print(a_3.shape)

運(yùn)行結(jié)果：
(4,)
(3, 2)
(2, 2, 3)

10.修改數(shù)組形狀

（1）reshape：不改變數(shù)據(jù)條件下修改形狀
修改數(shù)組形狀：
數(shù)組.reshape((2,6))
np.reshape(arr,(2,6))

三維度數(shù)組 轉(zhuǎn)化為二維度數(shù)組  一維度數(shù)組
a1 = np.array([[[1,2],[2,3]],[[3,4],[4,5]]])
print(a1.ndim)
a2 = a1.reshape((8,))
print(a2,a2.ndim)

運(yùn)行結(jié)果：
3
[1 2 2 3 3 4 4 5] 1

一維度數(shù)組  升 二維度數(shù)組
a_1 = np.array([1,2,3,4,5,6])
print(a_1.ndim)
a_2 = a_1.reshape((2,3))
print(a_2,a_2.ndim)

運(yùn)行結(jié)果：
1
[[1 2 3]
[4 5 6]] 2
（2）flat:數(shù)組元素迭代器
數(shù)組.flat

a = np.arange(9)
a2 = a.reshape(3,3)
print(a2)
#想要提取每一行的數(shù)組
for row in a2:
    print(row)
#每一個元素
for e in a2.flat:
    print(e)

運(yùn)行結(jié)果：
[[0 1 2]
[3 4 5]
[6 7 8]]
[0 1 2]
[3 4 5]
[6 7 8]
0
1
2
3
4
5
6
7
8

（3）數(shù)組扁平化（多維數(shù)組轉(zhuǎn)化為一維數(shù)組）

數(shù)組.reshape(-1)
數(shù)組.flatten()：返回一組數(shù)據(jù)拷貝，對拷貝所做的修改不會影響原始數(shù)組
數(shù)組.ravel()：返回展開數(shù)組

a = np.array([[[1,2],[3,4]],[[5,6],[7,8]]])
print(a.ndim)
a1 = a.reshape(-1)
print(a1)
a2 = a.flatten()  #拷貝數(shù)組
a2[1] = 100
print(a)
a3 = a.ravel()
a3[1] = 100
print(a)

運(yùn)行結(jié)果：
3
[1 2 3 4 5 6 7 8]
[[[1 2]
[3 4]]

[[5 6]
[7 8]]]
[[[ 1 100]
[ 3 4]]

[[ 5 6]
[ 7 8]]]

11.數(shù)組元素個數(shù)與所占內(nèi)存

（1）np.size:Numpy數(shù)組中元素個數(shù)

（2）np.itemsize:Numpy數(shù)組中每個元素所占字節(jié)數(shù)

（3）np.size*np.itemsize:Numpy數(shù)組中所占總內(nèi)存空間字節(jié)數(shù)

a = np.array([1,2,3,4,5,6,7,8,9])
print(a.size)  #數(shù)組中元素個數(shù)  9
print(a.itemsize)  #數(shù)組中每個元素所占字節(jié)數(shù)  4
#數(shù)組當(dāng)中所有元素占有內(nèi)存中的總字節(jié)數(shù)
print(a.size*a.itemsize)  #總字節(jié)數(shù) 9*4 = 36

運(yùn)行結(jié)果：
9
4
36

（4）數(shù)組所占有的實際空間

nbytes屬性是數(shù)組中的所有數(shù)據(jù)消耗掉的字節(jié)數(shù)
sys.getsizeof():這個方法以字節(jié)為單位返回對象的大小
整個數(shù)組 = 數(shù)組元素 + 空數(shù)組

a = np.array([1,2,3,4,5,6,7,8,9])
print(a.nbytes)  #數(shù)組中總字節(jié)數(shù)
b = np.array([])
print(sys.getsizeof(b))
print(sys.getsizeof(a))  #整個數(shù)組

運(yùn)行結(jié)果：
36
112
148

12.數(shù)組的索引和切片

#######（1）一維數(shù)組的索引和切片
正索引&負(fù)索引

a = np.array([1,2,3,4,5,6,7,8,9])
print(a[1])  #正索引
print(a[-1])  #負(fù)索引

運(yùn)行結(jié)果：
2
9
正向切片&反向切片[開始：結(jié)尾：步長]

a = np.array([1,2,3,4,5,6,7,8,9])
print(a[0:4])  #[0,4)左閉右開  正向切片 步長默認(rèn)為1
print(a[0:4:2])  #步長為2
print(a[-4:-1])  #負(fù)向切片
print(a[-4:-1:2])
print(a[:])

運(yùn)行結(jié)果：
[1 2 3 4]
[1 3]
[6 7 8]
[6 8]
[1 2 3 4 5 6 7 8 9]

（2）二維數(shù)組

<1>二維數(shù)組的索引

a2 = np.array([
    [1,2],
    [3,4],
    [5,6],
    [7,8]
])
#獲取某一行數(shù)據(jù)：數(shù)組[索引]
print(a2[1])
#獲取某行某列的數(shù)據(jù)：數(shù)組[行，列]
print(a2[2,1])
#獲取多個某行某列的數(shù)據(jù)：數(shù)組[[行索引，行索引],[列索引，列索引]]
print(a2[[1,2,3],[0,1,1]])
#獲取某幾行數(shù)據(jù):數(shù)組[[索引，索引，索引]]
print(a2[[1,2,3]])

運(yùn)行結(jié)果：
[3 4]
6
[3 6 8]
[[3 4]
[5 6]
[7 8]]
<2>二維數(shù)組的切片及倒索引
二維數(shù)組的切片：
對行切片：可以有start:stop:step
對列切片：可以有start:stop:step
切幾行數(shù)據(jù)：數(shù)組[索引：索引]
獲取某一列全部數(shù)據(jù)：數(shù)組[:1]
獲取多列數(shù)據(jù)：數(shù)組[:,[0:1]]

所有行所有列：數(shù)組[:,:]
所有行部分列，所有行第二列：數(shù)組[:,1]
所有行的第一列和第二列：數(shù)組[:,0:2]

部分列所有行
獲取第二行所有列：數(shù)組[1,:]
獲取第一和二行所有列：[0:2,:]
獲取奇數(shù)所有列：數(shù)組[::2,:]

負(fù)索引的使用
數(shù)組[-1]#最后一行
數(shù)組[::-1]#行倒序
數(shù)組[::-1,::-1]#行倒序，列倒敘

a1 = np.array([
    [1,2,3],
    [4,5,6],
    [7,8,9]
])
#切片某一行 某幾行數(shù)據(jù) 數(shù)組[行索引：行索引]
print(a1[0:3])
#所有行部分列，所有行第二列：數(shù)組[:1]
print(a1[:,1])  #獲得一維數(shù)組
print(a1[:,[1]])  #獲得二維數(shù)組
#獲取多列數(shù)據(jù):數(shù)組[:,[0,2]]
print(a1[:,[0,2]])
#數(shù)組[::-1]#行倒序
print(a1[::-1])
#數(shù)組[::-1,::-1]#行倒序，列倒敘
print(a1[::-1,::-1])

運(yùn)行結(jié)果：
[[1 2 3]
[4 5 6]
[7 8 9]]
[2 5 8]
[[2]
[5]
[8]]
[[1 3]
[4 6]
[7 9]]
[[7 8 9]
[4 5 6]
[1 2 3]]
[[9 8 7]
[6 5 4]
[3 2 1]]

13.布爾索引

我們可以通過一個布爾數(shù)組來索引目標(biāo)數(shù)組，以此找出與布爾數(shù)組中值為True的對應(yīng)的目標(biāo)數(shù)組中的數(shù)據(jù)

（1）一維數(shù)組

arr = np.arange(7)
print(arr)  #[0 1 2 3 4 5 6] 7個元素
#新建布爾數(shù)組 True 真 False 假
bool1 = np.array([True,False,False,False,True,True,False])
print(arr[bool1])'

運(yùn)行結(jié)果：
[0 1 2 3 4 5 6]
[0 4 5]

（2）二維數(shù)組

arr = np.arange(28).reshape((7,4))
bool2 = np.array([True,False,False,False,True,True,False])  #對應(yīng)的是行
print(arr[bool2])

運(yùn)行結(jié)果：
[[ 0 1 2 3]
[16 17 18 19]
[20 21 22 23]]
拓展：數(shù)據(jù)清洗

#拓展
arr = np.arange(28).reshape((7,4))
names = np.array(['Ben','Tom','Ben','Lucy','jackson','Mike','Ben'])
print(names=='Ben')
print(arr[names=='Ben'])    

運(yùn)行結(jié)果：
[[ 0 1 2 3]
[ 8 9 10 11]
[24 25 26 27]]

14.連接數(shù)組

（1）concatenate()

原型：numpy.concatenate((a1,a2,...),axis)
作用：用于沿指定軸連接相同形狀的兩個或者多個數(shù)組
參數(shù)說明：
a1,a2,...:相同類型的數(shù)組
axis:沿著它連接數(shù)組的軸，默認(rèn)為0

x = np.arange(4).reshape((2,2))
print(x)
print("\n")
y = np.arange(4,8).reshape((2,2))
print(y)
print("\n")
print(np.concatenate((x,y)))
print("\n")
print(np.concatenate((x,y),axis = 1))

運(yùn)行結(jié)果：
[[0 1]
[2 3]]

[[4 5]
[6 7]]

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

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

（2）stack() 維數(shù)變成了三維

原型：numpy.stack(arrays,axis)
作用：用于沿新軸連接數(shù)組序列
參數(shù)說明：
arrays:相同形狀的數(shù)組序列
axis:數(shù)組中的軸，輸入數(shù)組沿著它來堆疊

x = np.arange(4).reshape((2,2))
print(x)
print("\n")
y = np.arange(4,8).reshape((2,2))
print(y)
print("\n")
a = np.stack((x,y))
print(a)
print(a.shape,a.ndim)
print("\n")
b = np.stack((x,y),axis = 1)
print(b)
print(b.shape,a.ndim)

運(yùn)行結(jié)果：
[[0 1]
[2 3]]

[[4 5]
[6 7]]

[[[0 1]
[2 3]]

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

[[[0 1]
[4 5]]

[[2 3]
[6 7]]]
(2, 2, 2) 3

（3）hstack()

是numpy.stack函數(shù)的變體，它通過水平堆疊來生成數(shù)組

（4）vstack()

是numpy.stack函數(shù)的變體，它通過垂直堆疊來生成數(shù)組

x = np.arange(4).reshape((2,2))
print(x)
print("\n")
y = np.arange(4,8).reshape((2,2))
print(y)
print("\n")
a = np.hstack((x,y))
print(a)
print(a.shape,a.ndim)
print("\n")
b = np.vstack((x,y))
print(b)
print(b.shape,a.ndim)

運(yùn)行結(jié)果：
[[0 1]
[2 3]]

[[4 5]
[6 7]]

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

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

15、分割數(shù)組

（1）split()

原型：numpy.split(ary,indices_or_sections,axis = 0)
作用：函數(shù)沿特定的軸將數(shù)組分割為子數(shù)組
參數(shù)說明：
ary:被分割的數(shù)組
indices_or_sections：是一個整數(shù)，就用該數(shù)平均切分，如果是一個數(shù)組，為沿軸切分的位置（左開右閉）
axis:沿著哪個維度進(jìn)行切分，默認(rèn)為0，橫向切分。為1時，縱向切分。

x = np.arange(12)
print(x)
a = np.split(x,3)
print(a)
b = np.split(x,[2,7])
print(b)

運(yùn)行結(jié)果：
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[array([0, 1, 2, 3]), array([4, 5, 6, 7]), array([ 8, 9, 10, 11])]
[array([0, 1]), array([2, 3, 4, 5, 6]), array([ 7, 8, 9, 10, 11])]

x = np.arange(12).reshape(3,4)
print(x)
print("\n")
a = np.split(x,3)
print(a)
print("\n")
b = np.split(x,2,axis=1)
print(b)

運(yùn)行結(jié)果：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]

[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]])]

（2）hsplit()

用于水平分割數(shù)組，通過指定要返回的相同形狀的數(shù)組數(shù)量來拆分原數(shù)組

（3）vsplit()

用于水平分割數(shù)組，通過指定要返回的相同形狀的數(shù)組數(shù)量來拆分原數(shù)組

x = np.arange(12).reshape(2,6)
print(x)
print("\n")
a = np.hsplit(x,3)
print(a)
print("\n")
b = np.vsplit(x,2)
print(b)

運(yùn)行結(jié)果：
[[ 0 1 2 3 4 5]
[ 6 7 8 9 10 11]]

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

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

16.數(shù)組元素的添加與刪除

(1)resize()

原型：numpy.resize(arr,shape)
作用：返回指定大小的新數(shù)組
參數(shù)說明：
arr:要修改大小的數(shù)組
shape:返回數(shù)組的新形狀

x = np.arange(6).reshape(2,3)
print(x)
print("\n")

y = np.resize(x,(3,2))
print(y)
print("\n")

z = np.resize(x,(3,4))
print(z)

運(yùn)行結(jié)果：
[[0 1 2]
[3 4 5]]

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

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

（2）append()

原型：numpy.append(arr,values,axis = None)
作用：
在數(shù)組的末尾添加值
追加操作會分配整個數(shù)組，并把原來的數(shù)組復(fù)制到新數(shù)組中
輸入數(shù)組的維度必須匹配否則將生成ValueError
參數(shù)說明：
arr:輸入數(shù)組
Values:要向arr添加的值，需要和arr形狀相同（除了要添加的軸）
axis:默認(rèn)為None。當(dāng)axis無定義時，是橫向加成，返回總是為一維數(shù)組！當(dāng)axis有定義時，分別是0和1的時候。為0的時候（列數(shù)要相同）。當(dāng)axis為1的時候，數(shù)組是加在右邊（行數(shù)要相同）。

x = np.arange(6).reshape(2,3)
print(x)

a = np.append(x, [7,8,9])
print(a)
print(a.shape)

b = np.append(x, [[7,8,9]], axis = 0)  #axis = 0 添加行，列數(shù)要相同
print(b)
print(b.shape)

c = np.append(x, [[7,8],[8,9]], axis = 1)  #axis = 1 添加列，行數(shù)要相同
print(c)
print(c.shape)

運(yùn)行結(jié)果：
[[0 1 2]
[3 4 5]]
[0 1 2 3 4 5 7 8 9]
(9,)
[[0 1 2]
[3 4 5]
[7 8 9]]
(3, 3)
[[0 1 2 7 8]
[3 4 5 8 9]]
(2, 5)

（3）inser()

原型：np.insert(arr, obj, values, axis)
作用：在給定索引之前，沿給定軸在輸入數(shù)組中插入值
注意：如果值的類型轉(zhuǎn)換為要插入，則它與輸入數(shù)組不同。插入沒有原地的，函數(shù)會返
回一個新數(shù)組。此外，如果未提供軸，則輸入數(shù)組會被展開。
參數(shù)說明
arr：輸入數(shù)組
obj：在其之前插入值的索引
values：要插入的值
values：沿著它插入的軸，如果未提供，則輸入數(shù)組會被展開

x = np.arange(6).reshape(3, 2)
print(x)

a = np.insert(x, 3, [11, 12])
print(a)

b = np.insert(x, 3, [11, 12], axis=0)
print(b)

c = np.insert(x, 3, [11], axis=0)  #廣播
print(c)

d = np.insert(x, 1, 11, axis=1)
print(d)

運(yùn)行結(jié)果：
[[0 1]
[2 3]
[4 5]]
[ 0 1 2 11 12 3 4 5]
[[ 0 1]
[ 2 3]
[ 4 5]
[11 12]]
[[ 0 1]
[ 2 3]
[ 4 5]
[11 11]]
[[ 0 11 1]
[ 2 11 3]
[ 4 11 5]]

（14）delete()

原型：numpy.delete(arr, obj, axis)
作用：返回從輸入數(shù)組中刪除指定子數(shù)組的新數(shù)組。
與insert()函數(shù)的情況一樣，如果未提供軸參數(shù)，則輸入數(shù)組將展開
參數(shù)說明
arr:輸入數(shù)組
obj:可以被切片，整數(shù)或者整數(shù)數(shù)組， 表明要從輸入數(shù)組刪除的子數(shù)組
axis:沿著它刪除給定子數(shù)組的軸，如果未提供，則輸入數(shù)組會被展開

x = np.arange(2, 14).reshape(3, 4)
print(x)

a = np.delete(x, 4)  #6的下標(biāo)為4，刪除6
print(a)

print(x)  #原數(shù)組不變

b = np.delete(x, 1, axis=1) #刪除下標(biāo)為1的那一列
print(b)

運(yùn)行結(jié)果：
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
[ 2 3 4 5 7 8 9 10 11 12 13]
[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
[[ 2 4 5]
[ 6 8 9]
[10 12 13]]

(5)unique()

原型：numpy.unique(arr,return _index, return_inverse,return counts)
作用：去除數(shù)組中的重復(fù)元素
參數(shù)說明
arr:輸入數(shù)組，如果不是一維數(shù)組則會展開
return_index:如果為true，返回新列表元素在舊列表中的位置（下標(biāo)），并以列表形式儲
return_inverse:如果為true,返回舊列表元素在新列表中的位置（下標(biāo)），并以列表形式儲
return_counts:如果為true，返回去重數(shù)組中的元素在原數(shù)組中的出現(xiàn)次數(shù)

x = np.array([1, 2, 3, 4, 5, 6, 1, 1, 2, 5, 6, 5, 8])
print(x)
print(x.size)
a = np.unique(x, return_index=True)
print(a)

運(yùn)行結(jié)果：
[1 2 3 4 5 6 1 1 2 5 6 5 8]
13
(array([1, 2, 3, 4, 5, 6, 8]), array([ 0, 1, 2, 3, 4, 5, 12], dtype=int64), array([3, 2, 1, 1, 3, 2, 1], dtype=int64))

17.字符串函數(shù)

字符串函數(shù)是用于對 dtype 為 numpy.string_ 或numpy.unicode_ 的數(shù)組執(zhí)行向量化字符串操作基于 python 內(nèi)置庫中的標(biāo)準(zhǔn)字符串函數(shù)在宇符數(shù)組類 (numpy.char） 中定義

(1)add()

對兩個數(shù)組的元素進(jìn)行字符串連接

print(np.char.add(["youzi"],["piaoliang"]))
print(np.char.add(["yozui","kaige"],["piaoliang","shuaiqi"]))

運(yùn)行結(jié)果：
['youzipiaoliang']
['yozuipiaoliang' 'kaigeshuaiqi']

(2)multiply()

返回按元素多重連接后的字符串

print(np.char.multiply("good",3))

運(yùn)行結(jié)果：
goodgoodgood

(3)center()

將字符串居中，并使用指定字符在左側(cè)和右側(cè)進(jìn)行填充

print(np.char.center(["nice","handsome"],20,fillchar="*"))

運(yùn)行結(jié)果：
['********nice********' '******handsome******']

(4)capitalize()

將字符串第一個字母轉(zhuǎn)換為大寫

print(np.char.capitalize(["youzi is a kind girl","kaiGe is a good man"]))

運(yùn)行結(jié)果：
['Youzi is a kind girl' 'Kaige is a good man']

(5)title()

將字符串的每個單詞的第一個字母轉(zhuǎn)換為大寫

print(np.char.title(["youzi is a kind girl","kaiGe is a good man"]))

運(yùn)行結(jié)果：
['Youzi Is A Kind Girl' 'Kaige Is A Good Man']

(6)lower()

數(shù)組元素轉(zhuǎn)換為小寫

print(np.char.lower(["youzi is a kind girl","kaiGe is a good man"]))

運(yùn)行結(jié)果：
['youzi is a kind girl' 'kaige is a good man']

(7)upper()

數(shù)組元素轉(zhuǎn)換為大寫

print(np.char.upper(["youzi is a kind girl","kaiGe is a good man"]))

運(yùn)行結(jié)果：
['YOUZI IS A KIND GIRL' 'KAIGE IS A GOOD MAN']

(8)split()

指定分離符對字符串進(jìn)行分割，并返回數(shù)組列表

print(np.char.split(["youzi is a kind girl","kaiGe is a good man"]))

運(yùn)行結(jié)果：
[list(['youzi', 'is', 'a', 'kind', 'girl'])
list(['kaiGe', 'is', 'a', 'good', 'man'])]

(9)splitlines()

返回元素中的行列表，以換行符分割

print(np.char.splitlines(["you\nzi is a kind girl","kaiGe is a good man"]))

運(yùn)行結(jié)果：
[list(['you', 'zi is a kind girl']) list(['kaiGe is a good man'])]

(10)strip()

移除元素開頭或者結(jié)尾處的特定字符

print(np.char.strip(["********youzi is a kind girl****","**kaiG******e is a good man"],"*"))

運(yùn)行結(jié)果：
['youzi is a kind girl' 'kaiG******e is a good man']

(11)join()

通過指定分隔符來連接數(shù)組中的元素

print(np.char.join("-",["nice","good"]))
print(np.char.join(["-","*"],["nice","good"]))

運(yùn)行結(jié)果：
['n-i-c-e' 'g-o-o-d']
['n-i-c-e' 'goo*d']

(12)replace()

使用新字符串替換字符串中的所有字符串

print(np.char.replace(["youzi is a kind girl","kaiGe is a good man"],"good","handsome"))

運(yùn)行結(jié)果：
['youzi is a kind girl' 'kaiGe is a handsome man']

(13)encode()

編碼，數(shù)組元素依此調(diào)用str.encode

print(np.char.encode(["good","nice"],"utf-8"))

運(yùn)行結(jié)果：
[b'good' b'nice']

(14)decode()

解碼，數(shù)組元素依此調(diào)用str.decode

a = np.char.encode(["good","nice"],"utf-8")
print(np.char.decode(a,"utf-8"))

運(yùn)行結(jié)果：
['good' 'nice']

18.數(shù)學(xué)函數(shù)

（1）標(biāo)準(zhǔn)三角函數(shù)sin()、cos()、tan(）

a = np.array([0,30,45,60,90])
print("不同角度的正弦值：")
print(np.sin(a*np.pi/180))

運(yùn)行結(jié)果：
不同角度的正弦值：
[0. 0.5 0.70710678 0.8660254 1. ]

（2）反三角函數(shù)arcsin()、arccos()、arctan()

（3）around()

原型：numpy.around(a,decimals=0)
作用：返回指定數(shù)字的四舍五入值
參數(shù)說明：
a:數(shù)組
decimals:舍入的小數(shù)位數(shù)。默認(rèn)值為0。如果為負(fù)，整數(shù)將四舍五入到小數(shù)點左
側(cè)的位置。

x = np.array([1.0, 3.145, 4.635, 5.213])
print(np.around(x))

運(yùn)行結(jié)果：
[1. 3. 5. 5.]

（4）floor()

作用：問下取整，返回不大于輸入?yún)?shù)的最大整數(shù)。即標(biāo)量x 的下限是最大的整數(shù)i，使得i<=x。注意在Python中，向下取整總是從0舍入。

（5） ceil()

作用：向上取整，返回輸入值的上限，即，標(biāo)量x的上限是最小的整數(shù)i，使得i>=x。

x = np.array([1.0, 3.145, 4.635, 5.213])
print(np.floor(x))
print(np.ceil(x))

運(yùn)行結(jié)果:
[1. 3. 4. 5.]
[1. 4. 5. 6.]

19.算術(shù)函數(shù)

（1）add() 加，subtract() 減，multiply() 乘，divide () 除

x = np.arange(9,dtype = "f").reshape(3,3)
print("x數(shù)組：")
print(x)
print("\n")
y = np.array([10,10,10])
print("y數(shù)組：")
print(y)
print("\n")

print(np.add(x,y))
print("\n")
print(np.subtract(x,y))
print(np.multiply(x,y))
print(np.divide(x,y))

運(yùn)行結(jié)果：
x數(shù)組：
[[0. 1. 2.]
[3. 4. 5.]
[6. 7. 8.]]

y數(shù)組：
[10 10 10]

[[10. 11. 12.]
[13. 14. 15.]
[16. 17. 18.]]

[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
[[ 0. 10. 20.]
[30. 40. 50.]
[60. 70. 80.]]
[[0. 0.1 0.2]
[0.3 0.4 0.5]
[0.6 0.7 0.8]]

（2）reciprocal()

作用：返回參數(shù)逐個元素 的倒數(shù)

x = np.array([0.25, 0.5, 1, 100])
print(np.reciprocal(x))

運(yùn)行結(jié)果：
[4. 2. 1. 0.01]

（3）power()

作用：將第一個輸入數(shù)組中的元素作為底數(shù)，計算它與第二個輸入數(shù)組中相應(yīng)元素的冪

x = np.array([2,3,4])
y = np.array([1,2,3])
print(np.power(x,y))

運(yùn)行結(jié)果：
[ 2 9 64]

（4）mod()、remainder()

作用：計算輸入數(shù)組中相應(yīng)元素的相除后的余數(shù)

x = np.array([10,10,10])
y = np.array([2,3,4])
print(np.remainder(x,y))

運(yùn)行結(jié)果：
[0 1 2]

20、統(tǒng)計函數(shù)

（1）amax()、amin()

作用：計算數(shù)組中的元素沿指定軸的最大值、最小值

x = np.random.randint(1,11,9).reshape((3,3))
print(x)
print(np.amin(x,0))  #按列
print(np.amax(x,1))  #按行

運(yùn)行結(jié)果：
[[8 4 1]
[6 2 4]
[1 4 9]]
[1 2 1]
[8 6 9]

（2）ptp()

作用：計算數(shù)組中元素最大值與最小值的差（最大值-最小值）

x = np.random.randint(1,11,9).reshape((3,3))
print(x)
print(np.ptp(x))
print(np.ptp(x,0))
print(np.ptp(x,1))

運(yùn)行結(jié)果：
[[8 4 1]
[6 2 4]
[1 4 9]]
8
[7 2 8]
[7 4 8]

（3）percentile()

原型：numpy .percentile(a, p, axis)
作用：百分位數(shù)是統(tǒng)計中使用的度量，表示小于這個值的觀察值的百分比
參數(shù)說明
a:輸入數(shù)組
p:要計算的百分位數(shù)，在0- 100之間
axis:沿著它計算百分位數(shù)的軸
說明：
<1>第p個百分位數(shù)是這樣一個值，它使得至少有 p% 的數(shù)據(jù)項小于或等于這個值，且至少有(100-p)% 的數(shù)據(jù)項大于或等于這個值
<2>高等院校的入學(xué)考試成績經(jīng)常以百分位數(shù)的形式報告。比如，假設(shè)某個考生在入學(xué)考試中的語文部分的原始分?jǐn)?shù)為 54 分。相對于參加同一考試的其他學(xué)生來說，他的成績?nèi)绾尾⒉蝗菀字?。但是如果原始分?jǐn)?shù)54分怡好對應(yīng)的是第70百分位數(shù)，我們就能知道大約70%的學(xué)生的考分比他低，而約30%的學(xué)生考分比他高。這里的p=70。

x = np.array([[10,7,4],[3,2,1]])
print(x)
print(np.percentile(x,50))
print(np.percentile(x,50,axis=0))
print(np.percentile(x,50,axis=1))

運(yùn)行結(jié)果：
[[10 7 4]
[ 3 2 1]]
3.5
[6.5 4.5 2.5]
[7. 2.]

（4）median()

作用：算數(shù)組中元素的中位數(shù)（中值）

x = np.array([[30,65,70],[80,95,10],[50,90,60]])
print(x)
print(np.median(x))
print(np.median(x,axis=0))  #按列
print(np.median(x,axis=1))  #按行

運(yùn)行結(jié)果：
[[30 65 70]
[80 95 10]
[50 90 60]]
65.0
[50. 90. 60.]
[65. 80. 60.]

（5）mean()

作用：返回數(shù)組中元素的算數(shù)平均值。如果提供了軸，則沿其計算。

x = np.arange(1, 10).reshape((3, 3))
print(x)
print(np.mean(x))
print(np.mean(x, axis=0))  #按列
print(np.mean(x, axis=1))  #按行

運(yùn)行結(jié)果：
[[1 2 3]
[4 5 6]
[7 8 9]]
5.0
[4. 5. 6.]
[2. 5. 8.]

（6）average()

作用：根據(jù)在另一個數(shù)組中給出的各自的權(quán)重計算數(shù)組中元素的加權(quán)平均數(shù)，可以接受一個軸參數(shù)。如果沒有指定軸，則數(shù)組會被展開。
加權(quán)平均值*
將各數(shù)值乘以相應(yīng)的權(quán)數(shù)，然后加總求和得到總體值，再除以總的單位數(shù)
考慮數(shù)組[1,2,3,4]和相應(yīng)的權(quán)重[4,3,2,1]，通過將相應(yīng)元素的乘積相加，井牾和除
以權(quán)重的和，來計算加權(quán)平均值
注意：如果return參數(shù)設(shè)置為True，則返回權(quán)重的和
加權(quán)平均值=(1*4+2*3+3*2+4*1)/（4+3+2+1)

x = np.array([1,2,3,4])
wts = np.array([4,3,2,1])
print(x)
print(np.average(x))
print(np.average(x,weights=wts))

運(yùn)行結(jié)果：
[1 2 3 4]
2.5
2.0

print("權(quán)重的和：")
print(np.average([1,2,3,4],weights=[4,3,2,1],returned=True))

運(yùn)行結(jié)果：
權(quán)重的和：
(2.0, 10.0)
（1）多維數(shù)組中

x = np.arange(6).reshape((3,2))
print(x)
wts = np.array([3,5])
print(np.average(x,axis=1,weights=wts))

運(yùn)行結(jié)果：
[[0 1]
[2 3]
[4 5]]
[0.625 2.625 4.625]

（7）標(biāo)準(zhǔn)差

標(biāo)準(zhǔn)差是一組數(shù)據(jù)平均值分散程度的一種度量
標(biāo)準(zhǔn)差是方差的算術(shù)平方根
公式：std = sqrt (mean( (x - x.mean()）**2)）
說明：如果數(shù)組是[1，2，3，4]，則其平均值為 2.5。因此，差的平方是
[2.25,0.25,0.25,2.25]，并且其平均值的平方根除以 4，即 sqrt(5/4)，結(jié)果為
1.1180339887498949

print(np.std([1,2,3,4]))

運(yùn)行結(jié)果：
1.118033988749895

（8）方差

統(tǒng)計中的方差（樣本方差）是每個樣本值與全體樣本值的平均數(shù)之差的平方值的平
均數(shù)，即mean((x- x.mean())** 2)。換句話說，標(biāo)準(zhǔn)差是方差的平方根。

print(np.var([1,2,3,4]))

運(yùn)行結(jié)果：1.25

21.排序函數(shù)

（1）sort()

原型：sort(a, axis, kind, order)
功能：返回輸入數(shù)組的排序副本

x = np.random.randint(1,11,12).reshape(3,4)
print("x數(shù)組：")
print(x)
a = np.sort(x)
print(a)
b = np.sort(x, axis=0)
print(b)

運(yùn)行結(jié)果：
x數(shù)組：
[[ 4 2 8 7]
[10 1 3 5]
[ 3 4 4 10]]
[[ 2 4 7 8]
[ 1 3 5 10]
[ 3 4 4 10]]
[[ 3 1 3 5]
[ 4 2 4 7]
[10 4 8 10]]

dt = np.dtype([("name", "S10"), ("age", int)])
y = np.array([("liudh", 34), ("zhangxy", 23), ("rendehua", 40),("xiaogang", 30)], dtype=dt)
print(y)
c = np.sort(y,order="age")
print(c)

運(yùn)行結(jié)果：
[(b'liudh', 34) (b'zhangxy', 23) (b'rendehua', 40) (b'xiaogang', 30)]
[(b'zhangxy', 23) (b'xiaogang', 30) (b'liudh', 34) (b'rendehua', 40)]

（2）argsort(）

作用：對輸入數(shù)組沿給定軸執(zhí)行間接排序，并使用指定排序類型返回數(shù)據(jù)的索引數(shù)組。
這個索引數(shù)組用于構(gòu)造排序后的數(shù)組。

x = np.array([3,1,2])
print("x數(shù)組:")
print(x)
print("\n")
a = np.argsort(x)
print(a)
b = x[a]
print(b)
print(x)
for index in a:
    print(x[index])

運(yùn)行結(jié)果：
x數(shù)組:
[3 1 2]

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

（3）lexsort()

作用：使用鍵序列執(zhí)行間接排序。鍵可以看作是電子表格中的一列。該函數(shù)返回一個索引數(shù)組，使用它可以獲得排序數(shù)據(jù)。
注意：最后一個鍵恰好是 sort 的主鍵。
舉例：小升初考試，重點班錄取學(xué)生按照總成績錄取。在總成績相同時，數(shù)學(xué)成績高的
優(yōu)先錄取，在總成績和數(shù)學(xué)成績都相同時，按照英語成績錄取……這里，總成績排在電
子表格的最后一列，數(shù)學(xué)成績在倒數(shù)第二列，英語成績在倒數(shù)第三列
說明：排序時首先排 nm，順序為：amar、anil、raju、ravi。綜上排序結(jié)果為[3 1 0 2]

nm = ('raju', 'anil', 'ravi', 'amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')

print("調(diào)用lexsort()函數(shù)：")
ind = np.lexsort((dv,nm))
print(ind)

print("使用這個索引來獲取排序后的數(shù)據(jù)：")
print([nm[i] + "," + dv[i] for i in ind])

運(yùn)行結(jié)果：
調(diào)用lexsort()函數(shù)：
[3 1 0 2]
使用這個索引來獲取排序后的數(shù)據(jù)：
['amar,f.y.', 'anil,s.y.', 'raju,f.y.', 'ravi,s.y.']

（4）msort(a)

作用：數(shù)組按第一個軸排序，返回排序后的數(shù)組副本
說明：np.msort(a)相等于 np.sort(a, axis=0)

（5）sort_complex(a)

作用：對復(fù)數(shù)按照先實部后虛部的順序進(jìn)行排序

（6）partition(a,kth[,axis,kind,order])

作用：指定一個數(shù)，對數(shù)組進(jìn)行區(qū)分

x = np.array([3,4,1,2])
print("x數(shù)組:")
print(x)
print("\n")

運(yùn)行結(jié)果：
x數(shù)組:
[3 4 1 2]

print(np.partition(x,3))  #比3小的放在前面

運(yùn)行結(jié)果：
[1 2 3 4]

print(np.partition(x,(1,3)))  #小于1的在1的前面，大于3的在3的后面 

運(yùn)行結(jié)果：
[1 2 3 4]

（7）argpartition(a,kth[,axis,kind,order])

作用：可以通過關(guān)鍵字kind指定算法沿著指定軸對數(shù)組進(jìn)行區(qū)分。

x = np.array([10,21,1,4,3,5,8,6,1,1,2])
print(x)
print(np.argpartition(x,5)) #比5小的放左邊，比5大的放右邊，用下標(biāo)表示
print(x[np.argpartition(x,5))

運(yùn)行結(jié)果：
[10 21 1 4 3 5 8 6 1 1 2]
[ 2 8 9 10 4 3 5 7 6 1 0]
[ 1 1 1 2 3 4 5 6 8 21 10]

22、搜索函數(shù)

（1）max()、min()

作用：沿給定軸返回最大值和最小值

x = np.array([[30,40,70],[80,20,10],[50,90,60]])
print("x數(shù)組：")
print(x)
print(x.flatten())  #展開數(shù)組變成一維數(shù)組
print(np.max(x))
print(np.max(x, axis=0))
print(np.max(x, axis=1))

運(yùn)行結(jié)果：
x數(shù)組：
[[30 40 70]
[80 20 10]
[50 90 60]]
[30 40 70 80 20 10 50 90 60]
90
[80 90 70]
[70 80 90]

（2）argmax()、argmin()

作用：沿給定軸返回最大值和最小值的索引

（3）nonzero()

作用：返回輸入數(shù)組中非零元素的索引

x = np.array([[30,40,70],[80,20,10],[50,90,60]])
print(np.nonzero(x))

運(yùn)行結(jié)果：
(array([0, 0, 0, 1, 1, 1, 2, 2, 2], dtype=int64), array([0, 1, 2, 0, 1, 2, 0, 1, 2], dtype=int64))

（4）where()

作用：返回輸入數(shù)組中滿足給定條件的元素的索引

x = np.array([[30,40,70],[80,20,10],[50,90,60]])
y = np.where(x>30)
print(y)
print(x[y])

運(yùn)行結(jié)果：
(array([0, 0, 1, 2, 2, 2], dtype=int64), array([1, 2, 0, 0, 1, 2], dtype=int64))
[40 70 80 50 90 60]

（5）extract()

作用：根據(jù)某個條件從數(shù)組中抽取元素，返回滿條件的元素

x = np.array([[31, 40, 4], [2, 23, 10], [50, 3, 60]])
print("x數(shù)組：")
print(x)
con = np.mod(x, 2) == 0
print(con)
print(np.extract(con, x))

運(yùn)行結(jié)果：
x數(shù)組：
[[31 40 4]
[ 2 23 10]
[50 3 60]]
[[False True True]
[ True False True]
[ True False True]]
[40 4 2 10 50 60]

（6）

（7）

（8）

（9）

（3）