Numpy功能介绍

Numpy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵；

Numpy内置了并行运算功能，当系统有多个核心时，做某种计算时，Numpy会自动做并行计算；

Numpy底层使用C语言编写，数组中直接存储对象，而不是存储对象指针，所以其运算效率远高于纯Python代码

Numpy基本属性

1）数组的基本属性
① 数组的维数称为秩（rank），一维数组的秩为1，二维数组的秩为2，以此类推
② 在NumPy中，每一个线性的数组称为是一个轴（axes），秩其实是描述轴的数量：
          比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组，所以一维数组就是NumPy中的轴（axes），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。
2）数组的属性对应的方法

import numpy as np

ar = np.array([1,2,3,4,5,6,7])
print(ar)          # 输出数组，注意数组的格式：中括号，元素之间没有逗号（和列表区分）
print(ar.ndim)     # 输出数组维度的个数（轴数），或者说“秩”，维度的数量也称rank
print(ar.shape)    # 数组的维度，对于n行m列的数组，shape为（n，m）
print(ar.size)     # 数组的元素总数，对于n行m列的数组，元素总数为n*m
print(ar.dtype)    # 数组中元素的类型，类似type()（注意了，type()是函数，.dtype是方法）
print(ar.itemsize) # 数组中每个元素的字节大小，int32类型字节为4，float64的字节为8
print(ar.data)     # 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性

–> 输出的结果为：

[1 2 3 4 5 6 7]
1
(7,)
7
int32
4
<memory at 0x0000000005927108>

数组的创建（1）

创建数组：array()函数，括号内可以是列表、元祖、数组、生成器等

ar1 = np.array(range(10))                    # 整型，生成器
ar2 = np.array([1,2,3.14,4,5])               # 浮点型
ar3 = np.array([[1,2,3],('a','b','c')])      # 二维数组：嵌套序列（列表，元祖均可）
ar4 = np.array([[1,2,3],('a','b','c','d')])  # 注意嵌套序列数量不一会怎么样
print(ar1,type(ar1),ar1.dtype)
print(ar2,type(ar2),ar2.dtype)
print(ar3,ar3.shape,ar3.ndim,ar3.size)       # 二维数组，共6个元素
print(ar4,ar4.shape,ar4.ndim,ar4.size)       # 一维数组，共2个元素

–> 输出的结果为：(注意第三个输出里面第一个是二维数组，占了两行)

[0 1 2 3 4 5 6 7 8 9] <class 'numpy.ndarray'> int32
[ 1.    2.    3.14  4.    5.  ] <class 'numpy.ndarray'> float64
[['1' '2' '3']
 ['a' 'b' 'c']] (2, 3) 2 6
[[1, 2, 3] ('a', 'b', 'c', 'd')] (2,) 1 2

数组的创建（2）

建数组：arange()，类似range()，在给定间隔内返回均匀间隔的值。

print(np.arange(10))        # 返回0-9，整型
print(np.arange(10.0))      # 返回0.0-9.0，浮点型
print(np.arange(5,12))      # 返回5-11
print(np.arange(5.0,12,2))  # 返回5.0-12.0，步长为2
print(np.arange(10000))     # 如果数组太大而无法打印，NumPy会自动跳过数组的中心部分，并只打印边角：

–> 输出的结果为：

[0 1 2 3 4 5 6 7 8 9]
[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9.]
[ 5  6  7  8  9 10 11]
[  5.   7.   9.  11.]
[   0    1    2 ..., 9997 9998 9999]

数组的创建（2）

创建数组：linspace():返回在间隔[开始，停止]上计算的num个均匀间隔的样本。
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
start：起始值，stop：结束值
num：生成样本数，默认为50
endpoint：如果为真，则停止是最后一个样本。否则，不包括在内。默认值为True。
retstep：如果为真，返回（样本，步骤），其中步长是样本之间的间距 → 输出为一个包含2个元素的元祖，第一个元素为array，第二个为步长实际值

ar1 = np.linspace(2.0, 3.0, num=5)
ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)
ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
print(ar1,type(ar1))
print(ar2)
print(ar3,type(ar3))

–> 输出的结果为：

[ 2.    2.25  2.5   2.75  3.  ] <class 'numpy.ndarray'>
[ 2.   2.2  2.4  2.6  2.8]
(array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25) <class 'tuple'>

数组的创建（3）

创建数组：zeros()/zeros_like()/ones()/ones_like()

1）numpy.zeros(shape, dtype=float, order='C'): 返回给定形状和类型的新数组，用零填充。
shape：数组纬度，二维以上需要用()，且输入参数为整数
dtype：数据类型，默认numpy.float64
order：是否在存储器中以C或Fortran连续（按行或列方式）存储多维数据。

2）np.zeros_like() 返回具有与给定数组相同的形状和类型的零数组

3）ones()/ones_like()和zeros()/zeros_like()一样，只是填充为1

ar1 = np.zeros(5)  
ar2 = np.zeros((2,2), dtype = np.int)
print(ar1,ar1.dtype)
print(ar2,ar2.dtype)
print('————————————')

ar3 = np.array([list(range(5)),list(range(5,10))])
ar4 = np.zeros_like(ar3)
print(ar3)
print(ar4)
print('————————————')

ar5 = np.ones(9)
ar6 = np.ones((2,3,4))
ar7 = np.ones_like(ar3)
print(ar5)
print(ar6)
print(ar7)

–> 输出的结果为：（注意倒数第二个是三维数组）

[0. 0. 0. 0. 0.] float64
[[0 0]
 [0 0]] int32
————————————
[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0 0 0 0 0]
 [0 0 0 0 0]]
————————————
[1. 1. 1. 1. 1. 1. 1. 1. 1.]
[[[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]

 [[1. 1. 1. 1.]
  [1. 1. 1. 1.]
  [1. 1. 1. 1.]]]
[[1 1 1 1 1]
 [1 1 1 1 1]]

创建数组（4）

创建单位矩阵（数组）：np.eye()
创建一个正方的N*N的单位矩阵，对角线值为1，其余为0

print(np.eye(5))

–> 输出的结果为：（注意结果是二维的）

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

Numpy里面的数据类型

bool 用一个字节存储的布尔类型（True或False）

inti 由所在平台决定其大小的整数（一般为int32或int64）

int8 一个字节大小，-128 至 127

int16 整数，-32768 至 32767

int32 整数，-2 ** 31 至 2 ** 32 -1

int64 整数，-2 ** 63 至 2 ** 63 - 1

uint8 无符号整数，0 至 255

uint16 无符号整数，0 至 65535

uint32 无符号整数，0 至 2 ** 32 - 1

uint64 无符号整数，0 至 2 ** 64 - 1

float16 半精度浮点数：16位，正负号1位，指数5位，精度10位

float32 单精度浮点数：32位，正负号1位，指数8位，精度23位

float64或float 双精度浮点数：64位，正负号1位，指数11位，精度52位

complex64 复数，分别用两个32位浮点数表示实部和虚部

complex128或complex 复数，分别用两个64位浮点数表示实部和虚部