【大數據技術能力提高_2】numpy學習

numpy學習

標籤（空格分隔）： numpy python

---

數據類型

5種類型：布爾值（bool），整數（int），無符號整數（uint）、浮點（float）、複數（complex）

支持的原始類型與 C 中的原始類型緊密相關：

Numpy 的類型	C 的類型	描述
np.bool	bool	存儲爲字節的布爾值（True或False）
np.byte	signed char	平臺定義
np.ubyte	unsigned char	平臺定義
np.short	short	平臺定義
np.ushort	unsigned short	平臺定義
np.intc	int	平臺定義
np.uintc	unsigned int	平臺定義
np.int_	long	平臺定義
np.uint	unsigned long	平臺定義
np.longlong	long long	平臺定義
np.ulonglong	unsigned long long	平臺定義
np.half / np.float16	-	半精度浮點數：符號位，5位指數，10位尾數
np.single	float	平臺定義的單精度浮點數：一般爲符號位，8位指數，23位尾數
np.double	double	平臺定義的雙精度浮點數：一般爲符號位，11位指數，52位尾數。
np.longdouble	long double
np.csingle	float complex	複數，由兩個單精度浮點數（實部和虛部）表示
np.cdouble	double complex	複數，由兩個雙精度浮點數（實部和虛部）表示。
np.clongdouble	long double complex	複數，由兩個擴展精度浮點數（實部和虛部）表示。

因爲其中許多都具備依賴於平臺的定義，所以提供了一組固定大小的別名：

注：類型代碼通常是頭一個字母+位數/8，如complex256位c32

|Numpy 的類型 |C 的類型 |類型代碼|描述|
| :----------- | :------: || :--- |
|np.int8 |int8_t |i1|字節（-128到127）|
|np.int16 |int16_t |i2|整數（-32768至32767）|
|np.int32 |int32_t |i4|整數（-2147483648至2147483647）|
|np.int64 |int64_t |i8|整數（-9223372036854775808至9223372036854775807）|
|np.uint8 |uint8_t |u1|無符號整數（0到255）|
|np.uint16 |uint16_t |u2|無符號整數（0到65535）|
|np.uint32 |uint32_t |u4|無符號整數（0到4294967295）|
|np.uint64 ||uint64_t |u8|無符號整數（0到18446744073709551615）||
|np.intp |intptr_t |無|用於索引的整數，一般與索引相同 ssize_t|
|np.uintp |uintptr_t |無|整數大到足以容納指針|
|np.float32 |float |f或f4|8位指數 |
|np.float64 / np.float_ |double |f8|請注意，這與內置python float的精度相匹配。|
|np.complex64 |float complex |c8|複數，由兩個32位浮點數（實數和虛數組件）表示|
|np.complex128 / np.complex_ |double complex |c16| 請注意，這與內置python 複合體的精度相匹配。|

建立、操做narray

import numpy as np

#新版本
x1 = np.int8([0,1,2,3,4,5,6,7,8,9]) 
x2 = np.arange(10, dtype=np.int8)
x1, x2

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int8),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int8))

#老版本
y1 = np.array(np.arange(9), dtype=np.int8)
y2 = np.array(np.arange(9), dtype='i1')
y1, y2
"""
新手最容易犯的一個錯誤就是把數組內容直接當作參數傳給array，如np.array(1,2,3)
"""

'\n\xe6\x96\xb0\xe6\x89\x8b\xe6\x9c\x80\xe5\xae\xb9\xe6\x98\x93\xe7\x8a\xaf\xe7\x9a\x84\xe4\xb8\x80\xe4\xb8\xaa\xe9\x94\x99\xe8\xaf\xaf\xe5\xb0\xb1\xe6\x98\xaf\xe6\x8a\x8a\xe6\x95\xb0\xe7\xbb\x84\xe5\x86\x85\xe5\xae\xb9\xe7\x9b\xb4\xe6\x8e\xa5\xe5\xbd\x93\xe5\x81\x9a\xe5\x8f\x82\xe6\x95\xb0\xe4\xbc\xa0\xe7\xbb\x99array\xef\xbc\x8c\xe5\xa6\x82np.array(1,2,3)\n'

#要轉換數組的類型，請使用 .astype() 方法（首選）或類型自己做爲函數
x1.astype('u1'), x2.astype(int),np.int16(y1), np.uint16(y2)

(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=uint8),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8], dtype=int16),
 array([0, 1, 2, 3, 4, 5, 6, 7, 8], dtype=uint16))

#dtype屬性，表明數組的類型；shape屬性，表明數組的形狀；ndim屬性，表明數組有幾個維度
#size屬性：表明數組中元素的個數， itemsize屬性：表明數組中單個元素以字節計的大小
#data屬性：數組中實際的數據
z = np.arange(15).reshape((3,5))
z.shape, z.dtype, z.ndim, z.size, z.itemsize, z.data, np.issubdtype(z.dtype, np.integer), np.issubdtype(z.dtype, np.floating)

((3L, 5L),
 dtype('int32'),
 2,
 15,
 4,
 <read-write buffer for 0x0000000007485580, size 60, offset 0 at 0x000000000745BC38>,
 True,
 False)

溢出錯誤

當值須要比數據類型中的可用內存更多的內存時，例如，numpy.power對於64位整數正確計算 100 * 10 * 8，但對於32位整數給出1874919424（不正確）。

np.power(100, 8, dtype=np.int64), np.power(100, 8, dtype=np.int32)

(10000000000000000, 1874919424)

# NumPy分別提供numpy.iinfo 並numpy.finfo 驗證NumPy整數和浮點值的最小值或最大值：
np.iinfo(np.int), np.iinfo(np.int32), np.iinfo(np.int64)

(iinfo(min=-2147483648, max=2147483647, dtype=int32),
 iinfo(min=-2147483648, max=2147483647, dtype=int32),
 iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64))

建立數組有5種常規機制：

一、從其餘Python結構（例如，列表，元組）轉換
二、numpy原生數組的建立（例如，arange、ones、zeros等）
三、從磁盤讀取數組，不管是標準格式仍是自定義格式
四、經過使用字符串或緩衝區從原始字節建立數組
五、使用特殊庫函數（例如，random）

Ones 和 zeros 填充方式

注：[,]裏面是可選參數，如：empty(shape[, dtype, order]) ，shape是必選參數，dtype, order是可選參數

方法	描述
empty(shape[, dtype, order])	返回給定形狀和類型的新數組，而無需初始化條目。
empty_like(prototype[, dtype, order, subok, …])	返回形狀和類型與給定數組相同的新數組。
eye(N[, M, k, dtype, order])	返回一個二維數組，對角線上有一個，其餘地方爲零。
identity(n[, dtype])	返回標識數組。
ones(shape[, dtype, order])	返回給定形狀和類型的新數組，並填充爲1。
ones_like(a[, dtype, order, subok, shape])	返回形狀與類型與給定數組相同的數組。
zeros(shape[, dtype, order])	返回給定形狀和類型的新數組，並用零填充。
zeros_like(a[, dtype, order, subok, shape])	返回形狀與類型與給定數組相同的零數組。
full(shape, fill_value[, dtype, order])	返回給定形狀和類型的新數組，並用fill_value填充。
full_like(a, fill_value[, dtype, order, …])	返回形狀和類型與給定數組相同的完整數組。

從現有的數據建立

方法	描述
array(object[, dtype, copy, order, subok, ndmin])	建立一個數組。
asarray(a[, dtype, order])	將輸入轉換爲數組。
asanyarray(a[, dtype, order])	將輸入轉換爲ndarray，但經過ndarray子類。
ascontiguousarray(a[, dtype])	返回內存中的連續數組（ndim > = 1）（C順序）。
asmatrix(data[, dtype])	將輸入解釋爲矩陣。
copy(a[, order])	返回給定對象的數組副本。
frombuffer(buffer[, dtype, count, offset])	將緩衝區解釋爲一維數組。
fromfile(file[, dtype, count, sep, offset])	根據文本或二進制文件中的數據構造一個數組。
fromfunction(function, shape, **kwargs)	經過在每一個座標上執行一個函數來構造一個數組。
	fromiter(iterable, dtype[, count])
fromstring(string[, dtype, count, sep])	從字符串中的文本數據初始化的新一維數組。
loadtxt(fname[, dtype, comments, delimiter, …])	從文本文件加載數據。

注：可經過np.array?來查看相關函數的說明

#zero和ones代碼實現
"""
zero：建立全部元素爲0的數組
ones：建立全部元素爲1的數組
empty：建立全部元素爲隨機的數組 *****
"""
np.empty([2, 2], dtype=int), np.empty((3, 3)),np.empty_like(([1,2,3], [4,5,6])),np.eye(4)

(array([[43998544,        0],
        [62099504,        0]]), array([[0.22222222, 0.44444444, 0.66666667],
        [0.88888889, 1.11111111, 1.33333333],
        [1.55555556, 1.77777778, 2.        ]]), array([[         0, 1073741824,          0],
        [1074790400,          0, 1075314688]]), array([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]]))

#由於浮點數的有限精度問題，array返回的數組可能沒法預知，所以出現浮點數時，最好用linspace
np.arange(10,100,10),np.linspace(0,2,10)

(array([10, 20, 30, 40, 50, 60, 70, 80, 90]),
 array([0.        , 0.22222222, 0.44444444, 0.66666667, 0.88888889,
        1.11111111, 1.33333333, 1.55555556, 1.77777778, 2.        ]))

打印數組

打印出來很是相似嵌套列表
若是數組太長，則會自動忽略部數據，只打印首位

print np.arange(24).reshape(2,3,4),np.arange(1000000)

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

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]] [     0      1      2 ... 999997 999998 999999]

基本操做

在數組上進行算術操做都是元素級別的(elementwise)。

注：在線性代數中，乘號*表明的矩陣乘法,但在numpy中表明元素級別乘法，矩陣乘法用np.dot(a,b)或a.dot(b)

若a+=b，a是int，b是float，則會報錯，由於b比a更精錯，但b+=a則不會報錯

a = np.array([1,2,3,4])
b = np.arange(4)
a-b, a+b, a*b, a*2, a/3,a.dot(b) #所有新增的一個數組

(array([1, 1, 1, 1]),
 array([1, 3, 5, 7]),
 array([ 0,  2,  6, 12]),
 array([2, 4, 6, 8]),
 array([0, 0, 1, 1]),
 20)

ndarray內置函數：sum,min,max,comsum，而且能夠經過制定axis=0或1來指定對行或者列操做

通用函數

一元ufunc

函數	說明
abs、fabs	計算整數、浮點數或複數的絕對值。對於非複數，fabs更快
sqrt	計算各元素的平方根
square	計算各元素的平方
exp	計算各元素的指數$e^X$
log、log十、log二、log1P	分別對天然對數（$e^X$），底數分別爲e、十、二、1+x
sign	計算各元素的正負號：1（正數）、-1（負數）
floor	計算各元素小於等於該值的最大整數
ceil	計算各元素大於等於該值的最小整數
rint	將各元素四捨五入到最接近的整數，保留dtype
modf	將數組的小數與整數部分分別以兩個獨立的數組形式返回
isnan	返回哪些值是nan的布爾型數組
isfinite、isinf	返回哪些數組是有窮或無窮的布爾型數組
cos、cosh、sin、sinh、tan、tanh	普通和雙曲三角函數
arccos、arccosh、arcsin、arcsinh、arctan、arctanh	反三角函數
logical_not	計算各元素not x的真值。至關於-arr

二元ufunc

函數	說明
add	將數組中對應的元素相加
subtract	從第一個數組中減去第二個數組中的元素
multiply	數組元素相乘
divide、floor_divide	除法或除不要餘數
power	第一個元素A，根據第二個相應的元素計算$A^B$
maximum、fmax、minimum、fmin	元素最大值和最小值計算。fmax和fmin將忽略NaN
mod	除法求餘數
copysign	將第二個數組中的符號複製給第一個數組中的值
greater、greater_equal、less、less_equal、equal、not_equal	比較運算，產生布爾型數組。依次> >= < <= == !=
logical_and、logical_or、logical_xor	真值邏輯運算。與或非

索引、切片以及遍歷

一維數組很是相似與python的list和tuple，它們能夠被index、slice、iterate
copy方法能夠複製數組和標量值

c = np.arange(10)
c,c[0],c[1:3],c[:5],c[5:],c[:-1],c[:]

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

跟列表最重要的區別在於，數組的切片的數據不會複製，任何修改都會反饋到元數據上

c1 = c[4:6]
c1[:] = 111
c

array([  0,   1,   2,   3, 111, 111,   6,   7,   8,   9])

#二維數組的索引和切片
d = np.arange(16).reshape((4,4))
d[1][0],d[0,1]

(4, 1)

#布爾型索引
#布爾型索引在多維數組裏面常常會跟上面的數字索引方法混用
e = np.array(['a','b','c','e','f','g','h','i','j','k'])
e == 'e',c[e == 'f'],c[e != 'e'],c[(e == 'f')|(e != 'f')]

(array([False, False, False,  True, False, False, False, False, False,
        False]),
 array([111]),
 array([  0,   1,   2, 111, 111,   6,   7,   8,   9]),
 array([  0,   1,   2,   3, 111, 111,   6,   7,   8,   9]))

元素的形狀

能夠經過reshape（建立新數組）、resize（改變原數組）、ravel（使數組變扁平）

將不一樣的數組堆疊（stacking）起來

多個數組能夠沿着不一樣的額軸堆疊起來，用vstack（豎向）、hstack（橫向）

將一個數組切分紅多個

使用hsplit或vsplit將一個數組沿制定方向切分split(array,(x,y))切分爲x列和y列，split(array,n)切分爲n個數組

拷貝與視圖

一、簡單的賦值不發生拷貝；函數調用也不會產生拷貝
二、不一樣數據對象能夠共享相同的數據，view方法新建一個數組，可是仍使用相同的數據
三、深拷貝：copy

廣播

在NumPy中若是遇到大小不一致的數組運算，就會觸發廣播機制。知足必定的條件才能觸發廣播，否則也會報錯。

形狀相同

形狀相同的數組之間的運算就是在對應位作運算。

形狀不一樣

當數組大小不一致時，就會觸發廣播機制。廣播機制的規則：

1.讓全部輸入數組都向其中shape最長的數組看齊，shape中不足的部分都經過在前面加1補齊；

2.輸出數組的shape是輸入數組shape的各個軸上的最大值；

3.若是輸入數組的某個軸和輸出數組的對應軸的長度相同或者其長度爲1時，這個數組可以用來計算，不然出錯；

4.當輸入數組的某個軸的長度爲1時，沿着此軸運算時都用此軸上的第一組值。