python——numpy

numpy库概述

• 提供了一个ndarry对象：ndarry是存储单一数据类型的多维数组。

ndarray数组操作

ndarray概述

• N维数组对象ndarray是用于存放同类型元素的多维数组。
• ndarray中的每一个元素在内存中都有相同存储大小的区域。
• ndarray中的每个元素是数据类型对象的对象（称为dtype）。
• 与python中的其他容器对象一样，可以通过对数组进行索引或切片。
• 可通过ndarray的方法和属性来访问和修改ndarray的内容。

ndarray创建数组

array函数。

• 他接受一切序列型的对象，然后产生一个含有传入数据的numpy数组。其中，嵌套序列（比如有一组的等长列表组成的列表）将会被转换为一个多维数组。

numpy.array(object,dtype = None,copy = True,order = None,subok = False,ndmin = 0)

import numpy as np
a = [1,2,3,4]
b = np.array(a)
print(b)
#输出：[1 2 3 4]

c = np.array([[1,2],[3,4]])
print(c)
#输出：
[[1 2]
 [3 4]]

zero和ones

• 分别可以创建指定长度或者形状的全0或全1的数组

ones = np.ones((3,3), dtype='int')
print(ones)
# 输出：
[[1 1 1]
 [1 1 1]
 [1 1 1]]
zeros = np.zeros(3, dtype='int')
print(zeros)
# 输出：[0 0 0]

empty

• 可以创建一个没有任何具体值得数组

import numpy as np
print(np.zeros(3))  #创建一个全0的一维数组
#输出：[0. 0. 0.]

print(np.ones(2))   #创建一个全1的一维数组
#输出：[1. 1.]

print(np.zeros((3,3)))  #创建一个全0的3*3的二维数组
#输出：
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]

print(np.ones((3,2)))   #创建一个全1的3*2的二维数组
#输出：
[[1. 1.]
 [1. 1.]
 [1. 1.]]

print(np.empty((2,3),dtype= int))	#创建一个全为随机数的2*3的二维数组
#输出：
[[6619222 7536754 7274601]
 [    110       0       0]]

单位矩阵identity（）

print(np.identity(3))	#单位矩阵，3*3的二维数组
#输出：
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

随机数组

均匀分布

• np.random.rand(10,10) 创建指定形状（10*10）的数组（范围在0到1之间）
• np.random.uniform(0,100) 创建指定范围内的一个数
• np.random.randint(0,100) 创建指定范围内的一个整数

正态分布

• np.random.normal(1.75,0.1,(2,3)) 给定均值/标准差/维度的正态分布

import numpy as np
print(np.random.randint(0,50,5))   #随机数组，5个0到50之间的数字
#输出：[24  7 48 49 12]

print(np.random.randint(0,50,(3,5)))    #随机数组，3*5的数组，都是0-50之间
#输出：
 [[ 5 46 10 49 13]
  [11 25 25 28  1]
  [ 0  7  3 35 11]]

print(np.random.rand(3,3))    #10个介于[0,1)的随机数
#输出：
[[0.58630376 0.8965535  0.33188688]
 [0.9478087  0.86305796 0.12916692]
 [0.79755139 0.76385636 0.61020787]]

print(np.random.standard_normal((5,3)) )    #从标准正态分布中随机采样5个数字
#输出：
[[ 0.72473252 -0.7599206   1.13919464]
 [ 0.92991417 -1.57710405 -0.03130133]
 [-1.78335371 -1.04393439  1.25677991]
 [-1.04369886 -0.9520803  -0.24479149]
 [ 1.48360519 -0.18533074  0.94197777]]

ndarray数组属性

数组和标量之间的运算

• 数组很重要，它可以使我们不用编写循环即可对数据执行批量运算，这通常叫做矢量化。大小相等的数组之间的任何算数运算都会将运算应用到元素级。同样，数组和标量之间的算术运算也会将那个标量值传播到各个元素。
• 多维数组和数字的四则运算会作用在数组中的每个元素上，这在 numpy 中被称为 广播（Broadcasting）.
• 用列表就必须用到循环，而numpy 中的矢量化操作把内部循环委托给高度优化的 C 和 Fortran 函数，从而实现更清晰，更快速的 Python 代码。

import numpy as np
arr = np.array([[1,2,3],[4,5,6]])
print(arr)
#输出：
[[1 2 3]
 [4 5 6]]

a = 1 / arr
print(a)
#输出：
[[1.         0.5        0.33333333]
 [0.25       0.2        0.16666667]]

b = arr - arr
print(b)
#输出：
[[0 0 0]
 [0 0 0]]

c = arr * arr
print(c)
#输出：
[[0 0 0]
 [0 0 0]]

d = arr ** 0.5
print(d)
#输出：
[[1.         1.41421356 1.73205081]
 [2.         2.23606798 2.44948974]]

基本索引和切片

一维数组索引和切片

• 选取数据子集或单个元素的方式很多
• 一维数组很简单，从表面上看，他们跟python列表的功能差不多
• 一维数组跟列表最重要的区别在于，数组切片是原始数组的视图。这意味着数据不会被复制，数组视图上的任何修改都会直接反映在原始数组上。
• 将一个标量值赋值给一个切片时，该值会自动传播到整个选区。

import numpy as np
arr= np.arange(10)
print(arr)
#输出：[0 1 2 3 4 5 6 7 8 9]

print(arr[5])
#输出：5

print(arr[5:8])
#输出：[5 6 7]

arr[5:8] = 12
print(arr)
#输出：[ 0  1  2  3  4 12 12 12  8  9]

arr_slice = arr[5:8]
arr_slice[1] = 12345
print(arr)
#输出：[    0     1     2     3     4    12 12345    12     8     9]

arr_slice[:] = 65
print(arr)
#输出：[ 0  1  2  3  4 65 65 65  8  9]

二维数组索引和切片

普通索引

• 在二维数组中，各索引位置的元素不再是标量而是一维数组
• 可以对各个元素进行递归访问，但是这样有点麻烦
• 还有一种方式是传入一个以逗号隔开的索引列表来选取单个元素
• 在多维数组中，如果省略了后面的索引，则返回对象会是一个维度低一点的ndarray

import numpy as np
arr3d = np.array([[[1,2,3],[4,5,6]],[[7,8,9],[10,11,12]]])
print(arr3d)
#输出：
[[[ 1  2  3]
  [ 4  5  6]]
 [[ 7  8  9]
  [10 11 12]]]

print(arr3d[0])
#输出：
[[1 2 3]
 [4 5 6]]

print(arr3d[0,1])
#输出：[4 5 6]

print(arr3d[0][1])
#输出：[4 5 6]

布尔索引

• 示例：
• 大于 3 的元素位置值为 True，小于等于 3 的元素位置值为 False。而这个布尔类型的数组就是布尔索引，通过它可以筛选出值为 True 位置的元素。

data = np.array([[1, 2], [3, 4], [5, 6]])
print(data > 3)
#输出：
[[False False]
 [False  True]
 [ True  True]]

• 当使用布尔索引获取子数组时，跟列表有点不同：
  区别：数组中and 改用 &，or 改用 |，not 改用 ~，并且每个条件要用括号括起来。

import numpy as np
data = np.array([[1, 2], [3, 4], [5, 6]])
print(data[(data > 3) & (data < 5)])
# 输出：[4]

# 大于 3 或者小于 2
print(data[(data > 3) | (data < 2)])
# 输出：[1 4 5 6]

# 大于 3 或者不小于 2（即大于等于 2）
print(data[(data > 3) | ~(data < 2)])
# 输出：[2 3 4 5 6]

数组统计方法

• 可以通过数组上的一组数学函数对蒸鹅数组或者某个轴向的数据进行统计计算
• 调用方法：data.sum() 或 np.sum(data)

#sum和cumsum的区别
import  numpy as np
a=np.random.randint(1,9,9).reshape((3,3))#随机生成3X3的矩阵
print(a)
#输出：
[[8 6 3]
 [7 6 3]
 [8 1 4]]

print(a.sum(axis=0))#对每一行求和
#输出：[23 13 10]

print(a.cumsum(axis=0))#对每一行求累加和
#输出：
[[ 8  6  3]
 [15 12  6]
 [23 13 10]]

二维数组的通用操作：axis

• axis：轴，轴和维度的概念是类似的，一维数组有 1 个轴，二维数组有 2 个轴，三维数组有 3 个轴等等。
• 在一维数组中，axis=0 就代表着它唯一的轴（一般是用不到的）；
• 二维数组中 axis=0 和 axis=1 代表其中的行轴和列轴；
• 在三维数组中，axis=0、axis=1 和 axis=2 分别代表对应的三条轴。

数组中的实用方法：

arange()方法

• numpy 中的 arange() 方法和 Python 中的 range() 用法类似，不同之处在于 arange() 方法生成的是数组，而 range() 方法生成的是 range 类型的序列。

随即方法

• np.random.rand() ===类似于===> random.random() ：生成 [0, 1) 之间的随机小数
• 参数为生成数组的形状。

# 不传参数时
print(np.random.rand())
# 输出：0.1392571183916036

# 传入一个参数时
print(np.random.rand(3))
# 输出：[0.7987698  0.52115291 0.70452156]

# 传入多个参数时
print(np.random.rand(2, 3))
# 输出：
# [[0.08539006 0.97878203 0.23976172]
#  [0.34301963 0.48388704 0.63304024]

• np.random.randint() ===类似于===>random.randint()
  • 注意：np.random.randint(m, n)是左闭又开
  • np.random.randint() 方法第三个参数支持传入生成的数组的形状

# 不传入形状时
print(np.random.randint(0, 5))
# 输出：3

# 形状为一维数组时
print(np.random.randint(0, 5, 3))
# 输出：[4 0 1]

# 形状为二维数组时
print(np.random.randint(0, 5, (2, 3)))
# 输出：
# [[0 2 1]
#  [4 2 0]]

genfromtxt()方法：文件读取

• genfromtxt() 方法的返回值是一个多维数组

#用 numpy 读取一个以逗号分隔的 CSV 文件
data = np.genfromtxt('data.csv', delimiter=',', dtype=None, encoding='utf8')

• delimiter参数：分隔符
• dtype 参数：因为 genfromtxt() 方法默认会将数组元素的类型转为浮点数，因为我们 csv 里面有字符串还有浮点数，如果转成浮点数，城市名等字符串元素会出错。所以将 dtype 设为 None，NumPy 会自行选择合适的类型，作为数组元素的类型（这里是字符串类型）；
• encoding 参数：它是为了指定编码的方式，因为 csv 里有中文字符，所以一般都将编码设为 utf8。

其他

numpy矩阵操作

numpy矩阵库（Matrix）

• numpy中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是ndarray对象。
• 一个m*n的矩阵是一个由m行（row）n列（column）元素排列成的矩阵阵列。
• 矩阵里的元素可以是数字、符号或数学式。
• Numpy和Matlib不一样，对于多维数组的运算，缺省情况下并不使用矩阵运算，如果你希望对数组进行矩阵运算的话，可以调用ndarray对象相应的函数。

numpy矩阵生成

常规方式生成matrix（）

矩阵中的x[0,0]和x[0][0]代表的含义不一样

import numpy as np
x = np.matrix([[1,2,3],[4,5,6]])
y = np.matrix([1,2,3,4,5,6])

#x[0,0]返回行下标和列下标都为0的元素
#注意，对于矩阵x来说，x[0][0]和x[0,0]的含义不一样
print(x,y,x[0,0],x[0][0],sep = '\n\n')

#结果：
[[1 2 3]
 [4 5 6]]

[[1 2 3 4 5 6]]

1

[[1 2 3]]

matlib.empty()

语法：
numpy.matlib.enpty(shape,dtype,order)

• shape：定义新矩阵性状的整数或整数元组
• dtype:可选，数据类型
• order：C（行序优先）或者F（列序优先）

import numpy.matlib
import numpy as np
print(np.matlib.empty((2,2),dtype = int))	#填充为随机数据
#输出：
[[6881356 7471202]
 [7471201 5243001]]

numpy.matlib.zeros()：元素全为0

numpy.matlib.ones()：元素全为1

numpy.matlib.eye()

• 该函数返回一个矩阵，对角线元素为1，其他位置为零。

语法：
numpy.matlib.eye(n,M,k,dtype)

• n：返回矩阵的行数
• M：返回矩阵的列数，默认为n
• k：对角线的索引

import numpy.matlib
import numpy as np
print(np.matlib.eye(n = 3,M = 4,k = 1,dtype = int))
#输出：
[[0 1 0 0]
 [0 0 1 0]
 [0 0 0 1]]

numpy.matlib.identity()

• 返回给定大小的单位矩阵
• 单位矩阵是一个方阵，主对角线上的元素全为1，其余都为零

import numpy.matlib
import numpy as np
print(np.matlib.identity(3,dtype = int))
#输出：
[[1 0 0]
 [0 1 0]
 [0 0 1]]

numpy.matlib.rand()

• 该函数创建一个给定大小的矩阵，数据是随机填充的

import numpy.matlib
import numpy as np
print(np.matlib.rand(3,4))	#值为[0,1)之间的随机数
#输出：
[[0.98469167 0.60934979 0.74185134 0.54811488]
 [0.93386949 0.70868984 0.38646533 0.05972873]
 [0.16865481 0.24159916 0.65534165 0.1395666 ]]

矩阵常用操作

矩阵和二维数组的相互转换

• 矩阵总是二维的，而ndarray是一个n维数组。当两个对象的维度一样时，可以互换。

import numpy as np
import numpy.matlib
i = np.matrix('1,2;3,4')
print(i)
#输出：
[[1 2]
 [3 4]]
j = np.asarray(i)

print (j)
#输出：
[[1 2]
 [3 4]]
k = np.asmatrix(j)

print(k)
#输出：
[[1 2]
 [3 4]]

numpy.linalg

• numpy.linalg中有一组标准的矩阵分解运算以及诸如求逆和行列式之类的东西

import numpy as np

a = np.array([[1,1,1],[0,2,5],[2,5,-1]])
b = np.array([6,-4,27])
x = np.linalg.solve(a,b)
print(x)