Numpy知识点总结

Numpy简介

官方参考文档链接: (https://docs.scipy.org/doc/numpy-dev/user/index.html)
Numpy：Numerical Python ，即数值Python包，是Python进行科学计算一个基础包。包括：

• 一个具有矢量运算和复杂广播能力的快速且节省空间的多维数组，称为ndarray（N-dimensional array object）;
• 用于对数组数据进行快速运算的标准科学函数，ufunc（unviersal function object）；
• 用于整合c/c++和fortran代码的工具包；
• 实用的线性代数，博里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便。

Numpy的数据结构：ndarray

ndarray介绍

1. ndarry：N维数组
2. 一种相同类型元素组成的多维数组，元素数量是事先指定好的。
3. 元素的数据类型由dtype（data-type）对象来指定，每个ndarry只有一种dtype。
4. 大小固定，创建好数组时一旦指定好大小，就不会再发生改变。

Numpy的基本操作

1. array函数接收一个普通的python序列，转成ndarry

#导入numpy包
import numpy as np
#创建一个二维数组
narr = np.array([[1,2,3,4],[5,6,7,8]])
#查看数组的维度(打印结果2)
narr.ndim
#查看数组深度和维度打印结果（2L,4L）
narr.shape
#查看数组的数据类型，返回结果（dtype('int32')）
narr.dtype

#|代表分割，4代表保留4位。打印结果array(['aaaa','java','pyth'])
np.array(['aaaaa','java','python'],dtype='|s4')
#数组中的数据类型转换,指定为int类型，即使数组中元素为字符串也会自动转换为int。打印结果array([1,2,3])
np.array(['1','2','3'],dtype='int')
#查看数组中的元素个数,返回结果8.
narr.size

2. 利用shape查看复杂维度的数组。

np.array([
    [
        [1,2,3,4],
        [5,6,7,8]
    ],
    [
        [3,4,5,6],
        [2,2,2,2]
    ]
])
print(arr.shape)  #打印结果（2，2，4） shape 打印结果对应每个维度的深度值，有三个维度，分别对应2，2，4的深度值
print(arr[1,0,1]) #打印结果4 

3. ndarry的常见创建方式

zeros函数创建指定长度或形状的全0函数

np.zeros((3,4),np.int)
打印结果：
array([[0, 0, 0, 0],
[0, 0, 0, 0],
[0, 0, 0, 0]])

ones函数创建指定长度或形状的全1数组,同上，填充值为1的数组

empty函数创建一个没有任何具体值的数组（准确的说是一些未初始化的随机值）

4. range() 和py.arange

• range()返回的是range object，而np.nrange()返回的是numpy.adarray()
  • 两者都是均匀地（evenly）等分区间；
  • range尽可用于迭代，而np.arange作用远不止于此，它是一个序列，可被当做向量使用。
• range()不支持步长为小数，np.arange()支持步长为小数
• 两者都可用于迭代
• 两者都有三个参数，以第一个参数为起点，第三个参数为步长，截止到第二个参数之前的不包括第二个参数的数据序列
  某种意义上，和STL中由迭代器组成的区间是一样的，即左闭右开的区间。[first, last)或者不加严谨地写作[first:step:last)

5. np.linspace() 生成等差数列

• 第一个参数值代表起始位置，第二个参数值代表结束位置，第三个参数值代表元素个数

np.linspace(2,19,3)
运行结果：array([ 2. , 10.5, 19. ])

6. np.logspace() 生成10的幂形式的等比例数列

• 第一个参数代表10的开始次方，第二个参数代表10的结束次方，第三个参数代表生成的元素个数。

np.logspace(2,10,3)
输出结果：array([1.e+02, 1.e+06, 1.e+10]) #1.e是科学计数法，代表10的次方

7. np.reshape()维度转化

np.arange(1,9).reshape((2,4)) #将[1,2,3,4,5,6,7,8]转为一个二个维度的数组
输出array([[1, 2, 3, 4],[5, 6, 7, 8]])
np.arange(1,9).reshape((2,2,2)) #转化成一个三个维度的数组

8. 生成随机数组

np.random.random((2,3,4)) #生成0-1之间的随机数组

9. ==arr.astype()==对数组数据类型进行转换

arr = np.array([1,2,3,4])
arr.astype(‘float’) #转换数组里的数据为float类型
arr.dtype #查看数组数据类型

• 常见的数据类型

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_ complex128	类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

• 一些类型的缩写

名称	描述
b	布尔型
i	(有符号) 整型
u	无符号整型 integer
f	浮点型
c	复数浮点型
m	timedelta（时间间隔）
M	datetime（日期时间）
O	(Python) 对象
S, a	(byte-)字符串
U	Unicode
V	原始数据 (void)

10. 矩阵相乘和矩阵积

在numpy中矩阵可以直接做加减乘除运算
arr1 = np.array([1,2,3,4])
arr2 = np.array([2,3,4,5])
arr1*arr2则为对位相乘

矩阵积np.dot(a, b)
a = np.array([[1,2],[3,4],[11,12]])
b = np.array([[5,6,13],[7,8,14]])
np.dot(a,b)
输出结果：array([[ 19, 22, 41],
[ 43, 50, 95],
[139, 162, 311]])
解释：例如
[
[a1,b1,c1],
[d1,e1,f1]
]
对
[
[a2,b2],
[d2,e2],
[f2,g2]
]
做点积运算则：
[
[a1a2+b1 * d2+c1 f2,a1b2+b1e2+c1f2],
[d1a2+e1d2+f1f2 , d1b2+e1e2+f1*g2]
]

Numpy的数组切片

1. 数组的选取规则 数组对象[起始位置:终止位置:位置步长]

项目	含义
a[1:10:1]	代表选取一维数组从1开始的下一位数，选到第10位，步长为1（注意：左开右闭，选不到1能选到10）
a[::3]	代表起始和结束位不指定，步长为3
a[2:5]	一个：代表从第二位选到第五位
a[::-1]	代表逆序输出
a[0]	等价于 a[0,:,:]同时等价于a[0,...]如果大于三个维度不想写太多：后面的可以直接用...代替
a[::3,::3,::3]	代表第一个维度步长为3，第二个第三个维度步长为3

注：多个维度选择每个维度同上面的选择规则

   arr = np.arange(1,10).reshape(3,3)
   array([[1, 2, 3],
      [4, 5, 6],
      [7, 8, 9]])
   
   1.arr[::1,::2]  # ::1代表第一个维度的选择规则，::2代表第二个维度的选择规则即步长为2开始结束任意
   输出：
   array([[1, 3],
      [4, 6],
      [7, 9]])

Numpy改变维度

numpy改变维度通常有三种方式：

1. 视图变维–>返回一个具有新维度的新数组对象–>数据共享 （reshape/ravel arr.transpose()：行列转换）

arr.reshape(2,2,2) #转换成2 x 2 x 2的数组
arr.ravel()转化为1维数组

2. 复制变维–>返回一个具有新维度的新数组对象–>数据独立 (arr.flatten())

arr.flatten()转化为一维数组，但是数据会被复制一份

3. 就地变维–>在原数组之上，改变维度，不返回新数组 arr.shape()/arr.resize()

arr.shape(2,2,2) #直接改变原数据结构

数组的组合与拆分

1. 垂直组合
   np.vstack((上，下))–>组合数组
   np.concatenate((上，下)，axis=0) #axis后面的值就是维度意思在哪个维度组合，0代表在0维上组合，1代表在维度为1的数组上进行组合

  #np.vstack(上，下)-->组合数组
  a= np.arange(11,23).reshape(3,4)
  输出：
  array([[11, 12, 13, 14],
     [15, 16, 17, 18],
     [19, 20, 21, 22]])
     
  b=arr+10
  输出：
  array([[21, 22, 23, 24],
     [25, 26, 27, 28],
     [29, 30, 31, 32]])
  
  c=np.vstack((arr,arrb))
  输出：
  array([[11, 12, 13, 14],
     [15, 16, 17, 18],
     [19, 20, 21, 22],
     [21, 22, 23, 24],
     [25, 26, 27, 28],
     [29, 30, 31, 32]])
     
    np.concatenate((a,b),axis=0)  #axis后面的值就是维度意思在哪个维度组合，0代表在0维上组合，1代表在维度为1的数组上进行组合
    输出：array([[11, 12, 13, 14],            axis为1的输出：array([[11, 12, 13, 14, 21, 22, 23, 24]，
     [15, 16, 17, 18],											   [15, 16, 17, 18, 25, 26, 27, 28],
     [19, 20, 21, 22],                                             [19, 20, 21, 22, 29, 30, 31, 32]])
     [21, 22, 23, 24],
     [25, 26, 27, 28],
     [29, 30, 31, 32]])

2. 水平组合
   np.hstack((左，右))–>数组组合
   np.concatenate((左，右)，axis=1) -->如果二维数组axis=1代表水平方向组合
3. 水平拆分
   np.hsplit(数组，份数) //按照从左到右的顺序进行水平拆分
   np.split(数组，份数，axis=1) //如果是二维数组，从左到右进行拆分
4. 垂直拆分
   np.vsplit(数组，份数) //按份数拆成相等大小
   np.split(数组，份数，axis=0) //同上concatenate的axis。都是基于shape的深度属性。
5. 深度组合
   np.dstack((前，后))–>做深度组合
   例如：下图的两个二维数组，做深度组合后11跟21进行组合成一个数组，12和22组合，13和23组合
   这样就在原来的维度基础上增加了一个维度，会变成一个三维数组
   

输出结果： array([[[11, 21],
[12, 22],
[13, 23]],
[[14, 24],
[15, 25],
[16, 26]],
[[17, 27],
[18, 28],
[19, 29]]])

6. 深度拆分
   np.dsplit(数组，份数)–>前，…，后

7.行列组合（针对一维度数组）
np.row_stack((上，下))-->组合数组
np.column_stack((左，右))-->组合数组

Numpy的常用属性

字段	属性
shape	维度
dtype	元素类型
size	元素数量
ndim	维度，len(shape)
itemsize	元素的字节
nbytes	总字节数=size * itemsize
real	复数数组的实部数组
image	复数数组的虚部数组
T	数组对象的转置视图
flat	扁平迭代器

numpy数组对象转python列表对象

数组对象.tolist()->转化为python列表