numpy学习笔记1——基础知识

导入库

import numpy as np

创建数组

#创建数组
a = np.arange(5)
print(a)
#查看类型
print(a.dtype)
#查看维度
print(a.shape)

[0 1 2 3 4]
int32
(5,)

#多维数组
b = np.array([np.arange(2),np.arange(2)])
print(b)
print(b.dtype)
print(b.shape)

[[0 1]
 [0 1]]
int32
(2, 2)

#取数组的元素
c = np.array([[1,2],[3,4]])
print(c[0,0])
print(c[0][1])

1
2

数组类型

下图为numpy支持的数据类型。

(图片来源于Python数据分析基础教程：NumPy学习指南.第2版）

#指定数组类型
d = np.array([1,2],dtype='float32')

#查看数据类型对象(占几个字节)
print(d.dtype)
print(d.dtype.itemsize)

float32
4

#利用字符编码指令类型
e = np.array([1,2],dtype='f') #f表示单精度浮点数
print(e)
print(e.dtype)
f = np.array([1,2],dtype='f8') #8表示所占的字节数
print(f.dtype)

[1. 2.]
float32
float64

下图为字符编码：

(图片来源于Python数据分析基础教程：NumPy学习指南.第2版）

#dtype属性
g = np.dtype('float32')
print(g.char) #获取字符编码
print(g.type) #获取数据类型
print(g.str) #获取字符串表示

f
<class 'numpy.float32'>
<f4

print(g.str)给出数据类型的字符串表示，首个字符表示字节序，字节序是长为32或64的字存储顺序，包括大端序和小端序，大端序表示最高位字节存储在最低的内存地址处(>)，小端序表示最低位字节存储在最低位内存地址（<)。第一个字符后面表示字符编码，最后一个表示所占的字节数。

#自定义数据类型
#用长度40的字符窗存储名字，用32位整数存储库存数量，用单精度浮点数储存价格
f = np.dtype([('name','str_',40),('numitems','int32'),('price','float32')])
print(f)
print(f['name'])

#创建数组并指定数据类型
g = np.array([('Meaning of life DVD', 42, 3.14)], dtype=f)
print(g.dtype)

[('name', '<U40'), ('numitems', '<i4'), ('price', '<f4')]
<U40
[('name', '<U40'), ('numitems', '<i4'), ('price', '<f4')]

数组的索引与切片

#数组的索引与切片
l = np.arange(9)
print(l[0]) #取第一个元素
print(l[1:7]) 
print(l[1:7:2]) #步长为2
print(l[:7])
print(l[:7:2])
print(l[::-1]) #翻转数组

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

#多维数组的索引与切片
m = np.arange(24).reshape(2,3,4) #重塑为三维 三行、四列、二通道
print('m')
print(m)

print('m[0]')
print(m[0]) #第一通道

print('m[0,0,0]')
print(m[0,0,0]) #第一个元素

print('m[:,0,0]')
print(m[:,0,0])#每一通道的第一行第一列

print('m[0,::]')
print(m[0,::]) #第一通道所有 ==m[0]

print('m[0,...]')
print(m[0,...]) #第一通道所有 ==m[0]

print('m[0,1]')
print(m[0,1]) #第一通道 第二行

print('m[0,1,::2]')
print(m[0,1,::2])#第一通道 第二行 步长为2

print('m[...,1]')
print(m[...,1]) #所有通道第二列

print('m[:,1]')
print(m[:,1]) #所有通道第二行 

print('m[0,:,-1]')
print(m[0,:,-1])#第一通道最后一列

print('m[0,::-1,-1]')
print(m[0,::-1,-1]) #第一通道最后一列倒叙排列

print('m[0,::2,-1]')
print(m[0,::2,-1])#第一通道最后一列间隔

print('m[::-1]')
print(m[::-1]) #通道交换

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

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
m[0]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
m[0,0,0]
0
m[:,0,0]
[ 0 12]
m[0,::]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
m[0,...]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
m[0,1]
[4 5 6 7]
m[0,1,::2]
[4 6]
m[...,1]
[[ 1  5  9]
 [13 17 21]]
m[:,1]
[[ 4  5  6  7]
 [16 17 18 19]]
m[0,:,-1]
[ 3  7 11]
m[0,::-1,-1]
[11  7  3]
m[0,::2,-1]
[ 3 11]
m[::-1]
[[[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]

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

数组重塑

#数组的重塑
#ravel展平
n = np.array([[1,2,3,4],[5,6,7,8]])
print(n.ravel())
print(n)

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

#flatten展平
o = np.array([[1,2,3,4],[5,6,7,8]])
print(o.flatten())
print(o)

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

#元组重塑
o.shape=(4,2)
print(o)

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

#resize重塑
p = np.array([[1,2,3,4],[5,6,7,8]])
print('reshape')
print(p.reshape(4,2))
print(p)
print('resize')
p.resize((4,2))
print(p)

reshape
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
[[1 2 3 4]
 [5 6 7 8]]
resize
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

#转置
print('trainpose')
print(p.transpose())
print(p)

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

flatten和ravel的作用是一样的，不同的是flatten会请求分配内存来保存结果。reshape和resize的作用是一样的，不同的是reshape不会改变原数组，resize会改变原数组。同样的道理，转置操作也不会改变原数组。

数组的组合

#数组的组合
q = np.arange(9).reshape(3,3)
r = q *2
print(q)
print(r)

#水平组合
qr1 = np.hstack((q,r))
print('qr1')
print(qr1)
qr2 = np.concatenate((q,r),axis=1)
print('qr2')
print(qr2)

[[0 1 2]
 [3 4 5]
 [6 7 8]]
[[ 0  2  4]
 [ 6  8 10]
 [12 14 16]]
qr1
[[ 0  1  2  0  2  4]
 [ 3  4  5  6  8 10]
 [ 6  7  8 12 14 16]]
qr2
[[ 0  1  2  0  2  4]
 [ 3  4  5  6  8 10]
 [ 6  7  8 12 14 16]]

#垂直组合
qr3 = np.vstack((q,r))
print('qr3')
print(qr3)
qr4 = np.concatenate((q,r),axis=0)
print('qr4')
print(qr4)

qr3
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 0  2  4]
 [ 6  8 10]
 [12 14 16]]
qr4
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 0  2  4]
 [ 6  8 10]
 [12 14 16]]

#深度组合
qr5 = np.dstack((q,r))
print('深度组合qr5')
print(qr5)

深度组合qr5
[[[ 0  0]
  [ 1  2]
  [ 2  4]]

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

 [[ 6 12]
  [ 7 14]
  [ 8 16]]]

#列组合
s = np.arange(3)
t = np.array([3,4,5])
print('st1')
st1 = np.column_stack((s,t))
print(st1)

qr6 = np.column_stack((q,r))
print('qr6')
print(qr6) #==qr1\qr2水平组合

st1
[[0 3]
 [1 4]
 [2 5]]
qr6
[[ 0  1  2  0  2  4]
 [ 3  4  5  6  8 10]
 [ 6  7  8 12 14 16]]

#行组合
print('st3')
st2 = np.row_stack((s,t))
print(st2)

qr7 = np.row_stack((q,r))
print('qr7')
print(qr7) #==qr3\qr4垂直组合
print(qr7==qr3)

st3
[[0 1 2]
 [3 4 5]]
qr7
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 0  2  4]
 [ 6  8 10]
 [12 14 16]]
[[ True  True  True]
 [ True  True  True]
 [ True  True  True]
 [ True  True  True]
 [ True  True  True]
 [ True  True  True]]

数组的分割

#数组的分割

#水平分割
u = np.array([[0,1,2],[3,4,5],[6,7,8]])
print(np.hsplit(u,3)) #==np.split(u,3,axis=1)

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

#垂直分割
print(np.vsplit(u,3)) #==np.split(u,3,axis=0)

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

#深度分隔
v = np.arange(27).reshape(3,3,3)
print(np.dsplit(v,3))

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

数组的属性

#数组的属性
#维度
w = np.arange(9).reshape(3,3)
print(w)
print(w.ndim)

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

#总个数
print(w.size)

9

#元素所占字节数
print(w.itemsize)

4

#整个数组所占字节=元素个数*每个元素所占字节数
print(w.nbytes)

36

#转置
print(w.T)
s = np.arange(9) #一维数组的装置为本身
print(s.T)
print(s.transpose())
print(s.reshape(s.shape[0],1))#一维数组的装置

[[0 3 6]
 [1 4 7]
 [2 5 8]]
[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]]

#取实部
y = np.array([1.j+1,2.j+3])
print(y.real)
#取虚部
print(y.imag)
print(y.dtype)
print(y.dtype.str)

[1. 3.]
[1. 2.]
complex128
<c16

#flat属性
fls = np.arange(4).reshape(2,2)
print(fls.flat)
#1遍历
for fl in fls.flat :
    print(fl)
#2获取元素
print(fls.flat[2])
print(fls.flat[[1, 3]]) #获取多个
#3赋值
fls.flat = 7
print(fls)
fls.flat[[1, 3]] = 1
print(fls)

<numpy.flatiter object at 0x000001E979311DF0>
0
1
2
3
2
[1 3]
[[7 7]
 [7 7]]
[[7 1]
 [7 1]]

flat属性会返回一个np.flatiter对象，是获取flatiter的唯一方式。flat属性可以使得像遍历以一维数组的方法来遍历多维数组。

数组转换

#数组转换
#转为列表
z1 = np.array([[1,2,3,4],[5,6,7,8]])
print(z1)
print(z1.tolist())
z2 = np.array([1.j +2, 2.j+3])
print(z2)
print(z2.tolist())

[[1 2 3 4]
 [5 6 7 8]]
[[1, 2, 3, 4], [5, 6, 7, 8]]
[2.+1.j 3.+2.j]
[(2+1j), (3+2j)]

#类型转换
z3 = z1.astype('float32')
print(z3)
print(z3.dtype)
z4 = z2.astype('complex')
print(z4)
print(z4.dtype)

[[1. 2. 3. 4.]
 [5. 6. 7. 8.]]
float32
[2.+1.j 3.+2.j]
complex128