版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
目录
什么是NumPy
NumPy(Numerical Python) 是科学计算基础库，提供大量科学计算相关功能，比如数据 统计，随机数生成等。其提供最核心类型为多维数组类型(ndarray)，支持大量的维度数组 与矩阵运算，Numpy 支持向量处理 ndarray 对象，提高程序运算速度。
Numpy_Ndarray对象
Numpy中定义的最终要的对象是称为ndarray的N维数组类型。它描述相同类型的元素集合。可以使用基于零的索引访问集合中的项目。
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
上面的构造器接受以下参数：
| 序号 | 参数 | 描述 |
|---|---|---|
| 1. | object | 任何暴露数组接口方法的对象都会返回一个数组或任何(嵌套)序列。 |
| 2. | dtype | 数组的所需数据类型，可选。 |
| 3. | copy | 可选，默认为true，对象是否被复制。 |
| 4. | order | C(按行)、F(按列)或A(任意，默认 |
| 5. | subok | 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类 |
| 6. | ndimin | 指定返回数组的最小维数 |
import numpy as np
#例子01
#a = np.array([1,2,3])
#print(a)
#print(type(a))
#多于一个维度
#a2 = np.array([[1,2],[3,4]])
#print(a2)
#最小维度
#a3 = np.array([1,2,3,4,5],ndmin = 2)
#print(a3)
NumPy数组创建
numpy.empty
创建指定形状和dtype的未初始化数组
numpy.empty(shape, dtype = float, order = ‘C’)
构造器接受下列参数：
| 序号 | 参数 | 描述 |
|---|---|---|
| 1. | Shape | 空数组的形状，整数或整数元组 |
| 2. | Dtype | 所需的输出数组类型，可选 |
| 3. | Order | C’为按行的 C 风格数组，'F’为按列的 Fortran 风格数组 |
#例: 数组元素为随机值
arr = np.empty((3,3),dtype = 'i1')
print(arr)
numpy.zeros
返回特定大小，以0填充
arr = np.zeros((3,3))
print(arr)
#自定义类型
arr = np.zeros((3,3), dtype = [('x', 'i4'), ('y', 'i4')])
print(arr)
numpy.ones
返回特定大小，以1填充
arr = np.ones((2,3,4))
print(arr)
arr = np.ones((3,3), dtype = [('x', 'i4'), ('y', 'i4')])
print(arr)
numpy.asarray
类似 numpy.array 可以将Python序列转换为ndarray
array和asarray的区别:array默认的是一个列表元素,
但是asArray是一个维度/矩阵
#来自列表
arr = [1,2,3,4]
arr2 = np.asarray(arr)
print(arr2)
print(type(arr))
print(type(arr2))
#来自元组
arr = (1,2,3,4)
arr2 = np.asarray(arr)
print(arr2)
print(type(arr))
print(type(arr2))
#来自元组列表
# arr = [(1,2,3,4),(5,6,7,8)]
# arr2 = np.asarray(arr)
# print(arr2)
# print(type(arr))
# print(type(arr2))
numpy.arange
这个函数返回ndarray对象，包含给定范围内的等间隔值
numpy.arange(start,stop,step,dtype)
arr = np.arange(5,dtype = float)
print(arr)
此结果减小了数学里面的误差思想,在数据挖掘,数据分析等里面使用此思想,降低数据误差
numpy.linspace
与arange函数类似 等差数列
numpy.linspace(start,stop,num,endpoint,retstep,dtype)
| 序号 | 参数 | 描述 |
|---|---|---|
| 1 | start | 起始值 |
| 2 | stop | 结束值 |
| 3 | num | 生成等间隔样例的数量，默认为50 |
| 4 | endpoin 序列中是否包含stop 值 默认为 True |
arr = np.linspace(10,20,9)
print(arr)
arr = np.linspace(10,20,5,endpoint=False)
print(arr)
arr = np.linspace(10,20,5,retstep=True)
print(arr) #返回步长
numpy.logspace
等比数列
numpy.logscale(start, stop, num, endpoint, base, dtype)
| 序号 | 参数 | 描述 |
|---|---|---|
| 1. | start | 起始值是base ** start |
| 2. | stop | 终止值是base ** stop |
| 3. | num | 范围内的数值数量，默认为50 |
| 4. | endpoint | 如果为true，终止值包含在输出数组当中 |
| 5. | base | 对数空间的底数，默认为10 |
| 6. | dtype | 输出数组的数据类型，如果没有提供，则取决于其它参数 |
arr = np.logspace(1,10,10,base = 2)
#以2为底的空间矩阵
print(arr)
random模块
| 序号 | 模块 | 描述 |
|---|---|---|
| 1 | rand | 返回 0 - 1 随机值 |
| 2 | randn | 返回一个样本具有标准正态分布 |
| 3 | randint | 返回随机的整数，位于半开区间[low,hight)size = 10 (3,3) |
| 4 | random_integers(low[, high, size]) | 返回随机的整数，位于闭区间 |
| 5 | random | 返回随机浮点数 |
arr = np.random.rand(9).reshape(3,3)
#9表示元素的个数 reshape(3,3)3行3列输出
print(arr)
#在人工资能里面利用正态分布函数操作:将机器学习的数据进行矩阵化图标分析
#人工智能/机器学习的核心:第一件事:获取'数据集'----其实抽象的就是将人类产生的数据集合,生成
arr = np.random.rand(3,2,3)
print(arr)
arr = np.random.randn(9).reshape(3,3)
print(arr)
arr = np.random.randn(3,2,3)
print(arr)
arr = np.random.randint(1,9,size = (2,4))
print(arr)
arr = np.random.random_integers(1,9,size =(2,4))
print(arr)
arr = np.random.random((3,2,3))
print(arr)
arr = np.random.randn(3,2,3)
print(arr)
NumPy数组属性
ndarray.shape
这个数组属性返回一个包含数组维度的元组，它也可以用于调整数组大小
a = np.array([[1,2,3],[4,5,6]])
print(a)
print(a.shape)
#调整数组大小
a = np.array([[1,2,3],[4,5,6]])
a.shape=(3,2)
print(a)
reshape
调整数组大小,新建一个矩阵
a = np.array([[1,2,3],[4,5,6]])
b = a.reshape(3,2)
print(b)
ndarray.ndim
返回数组的维数
a = np.arange(24)
print(a)
print(a.ndim)
b = a.reshape(2,4,3)
print(b)
print(b.ndim)
print(b.shape)
numpy.itemsize
返回数组中每个元素的字节单位长度
itemsize表示的是一个列表同统计单位
#数组的int8 一个字节
x = np.array([1,2,3,4,5], dtype = np.int8)
print(x.itemsize)
#数组的float32 4个字节
x = np.array([1,2,3,4,5], dtype = np.float32)
print(x.itemsize)
ndarray.size
返回数组的大小，即shape中的乘积
arr = np.arange(18).reshape(2,3,3)
print(type(str(arr)))
print(arr.shape)
print(arr.size)
NumPy数组类型
NumPy 数字类型是dtype(数据类型)对象的实例，
每个对象具有唯一的特征。 这些类型可以是np.bool_，np.float32等。
#使用数组标量类型
dt = np.dtype(np.int32)
print(dt)
#int8，int16，int32，int64 可替换为等价的字符串 'i1'，'i2'，'i4'，以及其他。
dt = np.dtype('i4')
print(dt)
NumPy基本数据类型:
| 数据类型 | 类型简写 | 说明 |
|---|---|---|
| int_ | 默认整形 | |
| intc | 等价于long的整形 | |
| int8 | i1 | 字节整形，1个字节，范围:[-128,127] |
| int16 | i2 | 整形,2个字节,范围:[-32768,32767] |
| int32 | i3 | 整形,4个字节,范围:[-2^31, 2^31-1] |
| int64 | i4 | 整形,8个字节,范围:[-2^63, 2^63-1] |
| uint8 | u1 | 无符号整形, 1个字节, 范围:[0,255] |
| uint16 | u2 | 无符号整形, 2个字节, 范围:[0,65535] |
| uint32 | u3 | 无符号整形, 1个字节, 范围:[0, 2^32-1] |
| uint64 | u4 | 无符号整形, 1个字节, 范围:[0,2^64-1] |
| bool_ | 以一个字节形成存储的布尔值(True或者False) | |
| float_ | float64简写形式 | |
| float16 | f2 | 半精度浮点型(2字节)：1符号位+5位指数+10位的小数部分 |
| float32 | f4或者f | 单精度浮点型(4字节)：1符号位+8位指数+23位的小数部分 |
| float64 | f8或者d | 双精度浮点型(8字节)：1符号位+11位指数+52位的小数部分 |
| complex_ | c16 | complex128的简写形式 |
| complex64 | c8 | 复数，由两个32位的浮点数来表示 |
| complex128 | c16 | 复数，由两个64位的浮点数来表示 |
| object | O | Python对象类型 |
| String_ | S | 固定长度的字符串类型(每个字符1个字节)，比如：要创建一个长度为8的字符串，应该使用S8Unicode_ |
结构化数据类型
dt = np.dtype([('age',np.int8)])
print(dt)
#将结构化数据应用于ndarray对象
# dt = np.dtype([('age',np.int8)])
# a = np.array([(10,),(20,),(30,)],dtype = dt)
# print(a)
#访问age列内容
# dt = np.dtype([('age','i1')])
# a = np.array([(10,),(20,),(30,)],dtype = dt)
#age已经被转化为结构化语言的age,而不是一个变量
# print(a['age'])
#结构化数据包含多个字段
student = np.dtype([('name','S20'),('age','i1'),('marks','f4')])
a = np.array([('joe',20,80),('susan',22,85),('tom',23,90),('fank',23,33)],dtype=student)
print(a)
print(a['name'])
每个内建类型都有一个唯一定义它的字符代码：
| 布尔值 | 整型 | 无符号整数 | 浮点 | 复数浮点 | 时间间隔 | 日期时间 | Python 对象 | 字节串 | Unicode | 原始数据(void) |
|---|---|---|---|---|---|---|---|---|---|---|
| b | I | u | f | c | m | M | o | S或a | U | V |
NumPy切片和索引
ndarray 对象的内容可以通过索引或者切片来访问和修改，就像python的内置容器对象一样
ndarray对象中的元素遵循基于零的索引。
- 有三种行可用的索引方法类型：
1. 字段访问
2. 基本切片
3. 高级索引
arr = np.arange(10)
arr2 = arr[2:7:2]
print(arr2)
arr=np.array([
[
[1,2,3,4],
[2,3,4,5],
[3,4,5,6]
],
[
[10,20,30,40],
[20,30,40,50],
[30,40,50,60]
]
])
print(arr[1])
print(arr[1][1])
print(arr[1][1][2])
#取40 50
print(arr[1][1][2:])
print(arr[1,1,2:])
#第一个[:]指的是空,而第二个:指的是无限大
print(arr[1][:][0:2]) #获取第二维所有的数据加第三维的第一第二个数据失败
print(arr[1,:,0:2]) #获取成功
#可以进行简单索引
NumPy - 高级索引 花式索引
如果一个ndarray是非元组序列，数据类型为整数或布尔值的ndarray，或者至少一个元素为序列对象的元组，
我们就能够用它来索引ndarray。高级索引始终返回数据的副本(数据是安全的) 与此相反，切片只提供了一个视图。
整数索引
这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。
当索引的元素个数就是目标ndarray的维度时，会变得相当直接。
#索引是通过列表的一个完整集合去采集数据的
a = np.arange(9).reshape(3,3)
print(a)
a[[0,1,2],[0,1,2]] = 9
num = a[[0,1,2],[0,1,2]]
#使用索引器 np.ix_()
num = a[np.ix_([0,1,2],[0,1])]
print(num)
print(a)
num2 = a[[[0,0],[2,2]],[[0,2],[0,2]]]
print(num2)
arr = np.arange(18).reshape(2,3,3)
print(arr)
arr[...,[0,1,2],[0,1,2]] = 9
num = arr[[0,1],[0,1,2],[0,1,2]]
num = arr[...,[0,1,2],[0,1,2]]
#使用索引器
#就是创建一个列表的副本,来保护数据的安全
num = arr[[0,1],[0,1,2],[0,1]]
num = arr[np.ix_([0,1],[0,1,2],[0,1])]
num[:,[0]] = 99
print(num)
print(arr)
- 布尔索引
当结果对象是布尔运算的结果是，将使用此类型的高级索引
# arr = np.arange(12).reshape(4,3)
# print(arr)
# print('大于五的元素是：')
# print(arr[arr>5])
names = np.array(['joe','susan','tom'])
scores = np.array([
[98,86,88,90],
[70,86,90,99],
[82,88,89,86]
])
classic = np.array(['语文','数学','英语','科学'])
print('susan的成绩是:')
# print(names=='susan')
print(scores[names=='susan'])
print('susan的数学成绩:')
# print(scores[names=='susan',classic=='数学'])
print(scores[names=='susan'].reshape(-1,)[classic=='数学'])
print('joe和susan的成绩是：')
print(scores[(names=='joe')|(names=='susan')])
print('非joe和susan的成绩')
print(scores[(names!='joe')&(names!='susan')])
'''
数组转置与轴对换
'''
arr = np.arange(24).reshape(2,3,4)
print(arr.shape)
# print(np.transpose(arr))
#print(arr.transpose())
print(arr.T)
NumPy数组运算与广播
- Numpy算数运算
用于执行算数运算的输入数组必须具有相同的行列或符合数组广播规则
a = np.arange(9).reshape(3,3)
b = np.array([2,3,4])
print(a)
print(b)
print('**************************************')
#两个数组相加
print(np.add(a,b))
print(a+b)
print('**************************************')
#两个数组相减
print(a-b)
print(np.subtract(a,b))
print('**************************************')
#两个数组相乘
print(a*b)
print(np.multiply(a,b))
print('**************************************')
print(a/b)
print(np.divide(a,b))
print('**************************************')
#两个数组取幂
print(a**b)
print(np.power(a,b))
print('**************************************')
print()
print()
print('****************两个数组取余**********************')
#mod 两个数组取余
a = np.array([10,20,30])
b = np.array([3,5,7])
print(np.mod(a,b))
print(np.remainder(a,b))
print('**************************************')
print()
- 数组的矩阵积
两个二位矩阵，满足第一个矩阵的列数与第二个矩阵的行数相同，那么就可以进行矩阵的乘法，即矩阵积
print()
arr1 = np.array([
[110,60,220],
[115,45,180],
[132,67,209]
])
arr2 = np.array([
[12.3,0.04],
[204,2.34],
[9.98,0.45]
])
print(arr2)
print(arr1.dot(arr2))
print('**************************************')
- Numpy广播
术语广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。
对数组的算术运算通常在相应的元素上进行，如果两个阵列具有完全相同的形状，则这些操作无缝执行
a = np.array([1,2,3,4])
b = np.array([[10,20,30,40],[1,2,3,4]])
c = a * b
print(c)
如果两个数组的维数不相同，则元素到元素的操作是不可能的。
然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。
较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。
- 如果满足以下规则，可以进行广播：
- 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
- 输出数组的shape是输入数组shape的各个轴上的最大值
- 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错
- 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值