Numpy 数据类型和基本操作

Numpy 数据类型

bool 用一位存储的布尔类型（值为TRUE或FALSE）
inti 由所在平台决定其精度的整数（一般为int32或int64）
int8 整数，范围为128至127
int16 整数，范围为32 768至32 767
int32 整数，范围为231至231 1
int64 整数，范围为263至263 1
uint8 无符号整数，范围为0至255
uint16 无符号整数，范围为0至65 535
uint32 无符号整数，范围为0至2321
uint64 无符号整数，范围为0至2641
float16 半精度浮点数（16位）：其中用1位表示正负号，5位表示指数，10位表示尾数
float32 单精度浮点数（32位）：其中用1位表示正负号，8位表示指数，23位表示尾数
float64或float 双精度浮点数（64位）：其中用1位表示正负号，11位表示指数，52位表示尾数
complex64 复数，分别用两个32位浮点数表示实部和虚部
complex128或complex 复数，分别用两个64位浮点数表示实部和虚部

 一维数组的索引和切片

import numpy as np
d = np.arange(9)
print (d)
# [0 1 2 3 4 5 6 7 8]
print (d[2:4]) # 获取2~4 之间的元素
# [2 3]
print (d[::-1]) # 负数下标翻转数组
# [8 7 6 5 4 3 2 1 0]

# 改变数组的维度
# reshape 改变数组维度(重新调整矩阵的行数、列数、维数。)

import numpy as np
e = np.arange(9)
print (e)
# [0 1 2 3 4 5 6 7 8]
e1 = e.reshape(3,3) # 
print (e1)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

ravel函数完成展平

import numpy as np
f = np.arange(24).reshape(2,3,4)
print (f)
#[[[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15]
# [16 17 18 19]
# [20 21 22 23]]]
f1 = f.ravel()
print (f1)
#[ 0 1 2 ..., 21 22 23]

flatten 这个函数恰如其名，flatten就是展平的意思，与ravel函数的功能相同。不过，flatten函数会请求分配内存来保存结果，而ravel函数只是返回数组的一个视图（view）

f2 = f.flatten()
print (f2)
#[ 0 1 2 ..., 21 22 23]

shape,用元组设置维度

f.shape=(6,4)
print (f)
#[[ 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,resize和reshape函数的功能一样，但resize会直接修改所操作的数组：

f.resize((2,12))
print (f)
#[[ 0 1 2 ..., 9 10 11]
# [12 13 14 ..., 21 22 23]]

数组的组合

import numpy as np
a = np.arange(9).reshape(3,3)
print (a)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]
b = 2 * a
print (b)
#[[ 0 2 4]
# [ 6 8 10]
# [12 14 16]]

# 1. 水平组合hstack函数

h = np.hstack((a,b))
print (h)
#[[ 0 1 2 0 2 4]
# [ 3 4 5 6 8 10]
# [ 6 7 8 12 14 16]]

# 2. 垂直组合vstack函数

v = np.vstack((a,b))
print (v)
#[[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 0 2 4]
# [ 6 8 10]
# [12 14 16]]

# 3. 深度组合dstack函数(将一系列数组沿着纵轴（深度）方向进行层叠组合)

d = np.dstack((a,b))
print (d)
#[[[ 0 0]
# [ 1 2]
# [ 2 4]]
#
# [[ 3 6]
# [ 4 8]
# [ 5 10]]
#
# [[ 6 12]
# [ 7 14]
# [ 8 16]]]

# 4. 列组合,column_stack函数对于一维数组将按列方向进行组合,对于二维数组，column_stack与hstack的效果是相同

c = np.arange(5)
c1 = 2 * c
c2 = np.column_stack((c,c1))
print (c2)
#[[0 0]
# [1 2]
# [2 4]
# [3 6]
# [4 8]]

l = np.column_stack((a,b))
print (l)
#[[ 0 1 2 0 2 4]
# [ 3 4 5 6 8 10]
# [ 6 7 8 12 14 16]]

# 行组合row_stack函数（对于两个一维数组，将直接层叠起来组合成一个二维数组，对于二维数组，row_stack与vstack的效果是相同的）

c = np.arange(5)
c1 = 2 * c
c3 = np.row_stack((c,c1))
print (c3)
#[[0 1 2 3 4]
# [0 2 4 6 8]]

r = np.row_stack((a,b))
print (r)
#[[ 0 1 2]
# [ 3 4 5]
# [ 6 7 8]
# [ 0 2 4]
# [ 6 8 10]
# [12 14 16]]

# 分割数组

A = np.arange(9).reshape(3,3)
print (A)
#[[0 1 2]
# [3 4 5]
# [6 7 8]]

# 1. 水平分割 hsplit函数

H = np.hsplit(A,3)
print (H)
#[array([[0],
# [3],
# [6]]), array([[1],
# [4],
# [7]]), array([[2],
# [5],
# [8]])]

# 调用split函数并指定参数axis=1

H1 =np.split(A,3,axis=1)
print (H1)
#[array([[0],
# [3],
# [6]]), array([[1],
# [4],
# [7]]), array([[2],
# [5],
# [8]])]

# 2. 垂直分割,vsplit函数

V = np.vsplit(a,3)
print (V)
#[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

# 调用split函数并指定参数axis=0

V1 = np.split(A,3,axis=0)
print (V1)
#[array([[0, 1, 2]]), array([[3, 4, 5]]), array([[6, 7, 8]])]

# 3. 深度分割,dsplit函数

C = np.arange(27).reshape(3,3,3)
print (C)
#[[[ 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]]]
D = np.dsplit(C,3)
print (D)
#[array([[[ 0],
# [ 3],
# [ 6]],
#
# [[ 9],
# [12],
# [15]],
#
# [[18],
# [21],
# [24]]]), array([[[ 1],
# [ 4],
# [ 7]],
#
# [[10],
# [13],
# [16]],
#
# [[19],
# [22],
# [25]]]), array([[[ 2],
# [ 5],
# [ 8]],
#
# [[11],
# [14],
# [17]],
#
# [[20],
# [23],
# [26]]])]

# 数组的属性

num = np.arange(24).reshape(2,12)
print (num)
#[[ 0 1 2 ..., 9 10 11]
# [12 13 14 ..., 21 22 23]]

# 1. ndim属性，给出数组的维数，或数组轴的个数

print (num.ndim)
#2

# 2. size属性，给出数组元素的总个数

print (num.size)
#24

# 3. itemsize属性，给出数组中的元素在内存中所占的字节数

print (num.itemsize)
#4

# 4. nbytes属性,整个数组所占的存储空间(itemsize和size属性值的乘积)

print (num.nbytes)
#96

# 5. T属性,效果和transpose函数一样

# 数组的转换,tolist函数