python数据分析 —— numpy使用

NumPy - 简介

NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。

Numeric，即 NumPy 的前身，是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ，它拥有一些额外的功能。 2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。

Python的第三方扩展库，是其他数据分析模块的基础，主要用于数组、矩阵计算（比列表快得多）等方面。

NumPy 内容

Numpy提供的内容包括以下几部分：
1、一个强大的N维数组对象Array，也就是ndarray；
2、较为成熟的函数库；
3、用于整合C/C++和Fortran代码的工具包；
4、实用的线性代数、傅里叶变换和随机数生成函数。
NumPy是一个运行速度非常快的数学库，它的主要功能就是数组计算。NumPy配合SciPy（高级科学计算库）、Matplotlib（绘图工具库）一起使用可组成强大的科学计算环境，可用于代替MatLab的功能，并且有助于我们通过Python学习数据科学和机器学习。

NumPy – MatLab 的替代之一

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用。 这种组合广泛用于替代 MatLab，是一个流行的技术计算平台。 但是，Python 作为 MatLab 的替代方案，现在被视为一种更加现代和完整的编程语言。

NumPy 是开源的，这是它的一个额外的优势。

安装Numpy

pip install numpy

numpy的两种主要类型（array，numpy）

详解请看一下链接博客：
https://blog.csdn.net/weixin_43848614/article/details/107719347

注：python数据分析时常用 array

import numpy as np
a = np.arange(0, 12, 2).reshape(2,3)
b = np.arange(12, 24, 2).reshape(2,3)
print('a : \n', a)
print('b : \n', b)
print('a type: {} ; b type : {}'.format(type(a), type(b)))
print('a * b  :\n', a*b)
print('numpy multiply: \n', np.multiply(a,b))
print('array use numpy dot: ', np.dot(a,b))

结果为：

a : 
 [[ 0  2  4]
 [ 6  8 10]]
b : 
 [[12 14 16]
 [18 20 22]]
a type: <class 'numpy.ndarray'> ; b type : <class 'numpy.ndarray'>
a * b  :
 [[  0  28  64]
 [108 160 220]]
numpy multiply: 
 [[  0  28  64]
 [108 160 220]]
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-20-8f63481dfbf5> in <module>
      7 print('a * b  :\n', a*b)
      8 print('numpy multiply: \n', np.multiply(a,b))
----> 9 print('array use numpy dot: ', np.dot(a,b))

<__array_function__ internals> in dot(*args, **kwargs)
ValueError: shapes (2,3) and (2,3) not aligned: 3 (dim 1) != 2 (dim 0)

array类型使用 np.dot 进行矩阵乘法运算， 单独使用 * 或者 np.multiply 进行逐元素相乘（对应元素相乘）

np.dot(a, b.T)
b = np.mat(b)
print('b type: \n', type(b))
print('matrix 类型加后缀 .I 得到逆矩阵： \n', b.I)  #  matrix加 .I 得到逆矩阵
print('matrix 类型加后缀 .H 得到共轭矩阵: \n', b.H) #  matrix加 .H 得到共轭矩阵

结果为：

b type: 
 <class 'numpy.matrix'>
matrix 类型加后缀 .I 得到逆矩阵： 
 [[-0.88888889  0.63888889]
 [-0.05555556  0.05555556]
 [ 0.77777778 -0.52777778]]
matrix 类型加后缀 .H 得到共轭矩阵: 
 [[12 18]
 [14 20]
 [16 22]]

array与matrix 加后缀 .T 均可以得到转置矩阵， 但matrix 加 .I 得到逆矩阵，加 .H 得到共轭矩阵

NumPy基础数据结构

NumPy数组（即ndarray，以下统一用ndarray表示）是一种常见的特殊的数据结构——n维数组对象，它由两部分组成，包括：1、实际的数据。2、描述数据的元数据。

注：python中的列表、元组的缺点：
（1）浪费内存，每个元素是 Object型；即每个成员都需要存储引用对象值
（2）计算时间长，需要进行优化

ndarray中的每个元素在内存中使用相同大小的块。 ndarray中的每个元素是数据类型对象的对象（称为 dtype）。

从ndarray对象提取的任何元素（通过切片）由一个数组标量类型的 Python 对象表示。 下图显示了ndarray，数据类型对象（dtype）和数组标量类型之间的关系。

ndarray 对象属性

ndarray 对象属性有：

NumPy 数组的维数称为秩（rank），一维数组的秩为 1，二维数组的秩为 2，以此类推。

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

很多时候可以声明 axis。axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

(1) ndarray.ndim：ndarray的秩数（轴数），也就是数组的维度个数

(2) ndarray.shape：ndarray的形状，例如n行m列的ndarray，shape就是(n，m)

(3) ndarray.size：ndarray中所有元素的个数，例如n行m列的ndarray，size就是 n*m

a = np.array([[1,2,3],[4,5,6],[7,8,9]])
print('a数组的维度为：', a.ndim)
print('a数组的形状为：', a.shape)
print('a数组所有元素的个数为：', a.size)

结果为：

a数组的维度为： 2
a数组的形状为： (3, 3)
a数组所有元素的个数为： 9

(4) ndarray.dtype：ndarray的元素类型。

a1 = np.array([1, 2, 3, float(5)])
a2 = np.array(['str', 12, float(45)])
print(a1.dtype)
print(a2.dtype)

结果为：

float64
<U4

注意：
numpy默认ndarray的所有元素的类型是相同的
如果传进来的列表中包含不同的类型，则统一为同一类型，优先级：str>float>int

(5) ndarray.itemsize ： 这一数组属性返回数组中每个元素的字节单位长度

import numpy as np
a = np.array([1,2,3])  #默认是四个字节
b = np.array([1, 2, float(12)])
print(a.itemsize)
print(b.itemsize)   #  numpy默认ndarray的所有元素的类型是相同的

结果为：

4
8

numpy.flags

ndarray对象拥有以下属性。这个函数返回了它们的当前值。

序号	属性及描述
1.	C_CONTIGUOUS © 数组位于单一的、C 风格的连续区段内
2.	F_CONTIGUOUS (F) 数组位于单一的、Fortran 风格的连续区段内
3.	OWNDATA (O) 数组的内存从其它对象处借用
4.	WRITEABLE (W) 数据区域可写入。 将它设置为flase会锁定数据，使其只读
5.	ALIGNED (A) 数据和任何元素会为硬件适当对齐
6.	UPDATEIFCOPY (U) 这个数组是另一数组的副本。当这个数组释放时，源数组会由这个数组中的元素更新

import numpy as np 
x = np.array([1,2,3,4,5])  
print(x.flags)

结果为：

  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

ndarray数据类型转换

NumPy中支持的数据类型比Python内置的类型要更多，下表列举了常用的NumPy基本数据类型。

实部(.real)+ j虚部(.imag)

ndarray的元素类型
ndarray为什么要支持这么多种元素类型？
对比：Python语法仅支持整数、浮点数和复数3种类型
•科学计算涉及数据较多，对存储和性能都有较高要求
•对元素类型精细定义，有助于NumPy合理使用存储空间并优化性能
•对元素类型精细定义，有助于程序员对程序规模有合理评估

创建ndarray数组的常见方法

•从Python中的列表、元组等类型创建ndarray数组
•使用NumPy中函数创建ndarray数组，如：arange, ones, zeros等
•从字节流（raw bytes）中创建ndarray数组
•从文件中读取特定格式，创建ndarray数组

创建方法一： array() 函数创建

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

注：object 可以是 Python中的列表、元组等类型，来创建ndarray数组

举例：
创建一维数组：numpy.array([x,y,…])
创建二维数组：numpy.array([[x,y…],[x,y…],[x,y…]])

import numpy
a=numpy.array([1,2,3])                #一维
b=numpy.array([[1,2,3],[4,5,6],[7,8,9]])      #二维
c=numpy.array([1,2,3],dtype=complex)  #元素类型为复数
d=numpy.array([1,2,3],ndmin=2)        #二维
print(a,type(a))
print(b,type(b))
print(c,type(c))
print(d,type(d))

结果为：

[1 2 3] <class 'numpy.ndarray'>
[[1 2 3]
 [4 5 6]
 [7 8 9]] <class 'numpy.ndarray'>
[1.+0.j 2.+0.j 3.+0.j] <class 'numpy.ndarray'>
[[1 2 3]] <class 'numpy.ndarray'>

**ndarray ** 对象由计算机内存中的一维连续区域组成，带有将每个元素映射到内存块中某个位置的索引方案。 内存块以按行（C 风格）或按列（FORTRAN 或 MatLab 风格）的方式保存元素。

numpy.asarray

此函数类似于numpy.array，除了它有较少的参数。 这个例程对于将 Python 序列转换为ndarray非常有用。

numpy.asarray(a, dtype = None, order = None)

构造器接受下列参数：

序号	参数及描述
1.	a 任意形式的输入参数，比如列表、列表的元组、元组、元组的元组、元组的列表
2.	dtype 通常，输入数据的类型会应用到返回的ndarray
3.	order 'C’为按行的 C 风格数组，'F’为按列的 Fortran 风格数组

# 将列表转换为 ndarray 
# 设置了 dtype  
# 来自元组列表的 ndarray

import numpy as np 
x1 =  [1,2,3] 
x2 =  (1,2,3) 
x3 =  [(1,2,3),(4,5)] 

a1 = np.asarray(x1)  
a2 = np.asarray(x2, dtype =  float)  
a3 = np.asarray(x3)
print(a1,'\n',a2,'\n',a3, '\n')

结果为：

[1 2 3] 
 [1. 2. 3.] 
 [(1, 2, 3) (4, 5)] 

numpy.fromiter

此函数从任何可迭代对象构建一个ndarray对象，返回一个新的一维数组。

numpy.fromiter(iterable, dtype, count = -1)

构造器接受下列参数：

序号	参数及描述
1.	iterable 任何可迭代对象
2.	dtype 返回数组的数据类型
3.	count 需要读取的数据数量，默认为-1，读取所有数据

以下示例展示了如何使用内置的range()函数返回列表对象。 此列表的迭代器用于形成ndarray对象。

import numpy as np 
list = range(5)  
it = iter(list)   # 从列表中获得迭代器
x = np.fromiter(it, dtype =  float)   # 使用迭代器创建 ndarray
print(it)
print(x)
print(type(x))

结果为：

<range_iterator object at 0x000002B370DEFBF0>
[0. 1. 2. 3. 4.]
<class 'numpy.ndarray'>

创建方法二： 使用NumPy中函数创建

arange()、ones(shape)、zeros(shape)、full(shape,val)、eye(n)

numpy.arange(start, stop, step, dtype)

这个函数返回ndarray对象，包含给定范围内的等间隔值。

numpy.arange(start, stop, step, dtype)

构造器接受下列参数：

序号	参数及描述
1.	start 范围的起始值，默认为0
2.	stop 范围的终止值（不包含）
3.	step 两个值的间隔，默认为1
4.	dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

# arange() 函数创建
a = np.arange(1, 20, 2)  # 类似于 range(1, 20, 2) 
print(a)
print(type(a))

结果为：

[ 1  3  5  7  9 11 13 15 17 19]
<class 'numpy.ndarray'>

range()函数与arange()函数的区别：

（1）range()函数，返回range对象
（2）arange()函数， 返回 array

从打印结果可以看出，Python的列表和元组数据间用逗号隔开，而ndarray的数据之间用空格隔开。

a1 = [1, 2, 3]
a2 = (1, 2, 3)
b1 = np.array(a1)
b2 = np.array(a2)
print(a1)
print(b1)
print(a2)
print(b2)

[1, 2, 3]
[1 2 3]
(1, 2, 3)
[1 2 3]

np.ones(shape, dtype=None, order=‘C’)
np.zeros(shape, dtype=None, order=‘C’)
np.full(shape, fill_value, dtype=None, order=‘C’)
np.eye(N, M=None, k=0, dtype=float) 对角线为 1 其他的位置为 0

a = np.ones((1,2,3), dtype = int)
b = np.zeros((1,2,3), dtype = int)
c = np.full((1,4),fill_value=8.88)
d = np.eye(3)
print(a)
print(b)
print(c)
print(d)
print(type(a))

结果为：

[[[1 1 1]
  [1 1 1]]]

[[[0 0 0]
  [0 0 0]]]

[[8.88 8.88 8.88 8.88]]

[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
<class 'numpy.ndarray'>

numpy.empty

它创建指定形状和dtype的未初始化数组。 它使用以下构造函数：

numpy.empty(shape, dtype = float, order = 'C')

构造器接受下列参数：

序号	参数及描述
1.	Shape 空数组的形状，整数或整数元组
2.	Dtype 所需的输出数组类型，可选
3.	Order 'C’为按行的 C 风格数组，'F’为按列的 Fortran 风格数组

ones_like()、zeros_like()、full_like(a,val)

linspace()、logspace()、conctatenate()

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

np.linspace(start = 0,stop = 150,num = 50,endpoint=False,retstep=True,dtype=np.int8)

(array([   0,    3,    6,    9,   12,   15,   18,   21,   24,   27,   30,
          33,   36,   39,   42,   45,   48,   51,   54,   57,   60,   63,
          66,   69,   72,   75,   78,   81,   84,   87,   90,   93,   96,
          99,  102,  105,  108,  111,  114,  117,  120,  123,  126, -127,
        -124, -121, -118, -115, -112, -109], dtype=int8), 3.0)

numpy.logspace

此函数返回一个ndarray对象，其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂，通常为 10。

numpy.logscale(start, stop, num, endpoint, base, dtype)

序号	参数及描述
1.	num 范围内的数值数量，默认为50
2.	endpoint 如果为true，终止值包含在输出数组当中
3.	base 对数空间的底数，默认为10

import numpy as np
a = np.logspace(1,10,num =  10,  base  =  2)  
print(a, type(a))

结果为：

[   2.    4.    8.   16.   32.   64.  128.  256.  512. 1024.] <class 'numpy.ndarray'>

ndarray数组的变换

对于创建后的ndarray数组，可以对其进行维度变换和元素类型变换

ndarray数组的维度变换

ndarray数组的类型变换

astype()、tolist()

NumPy中设置ndarray数据类型使用astype()函数，基本用法如下。

astype()方法一定会创建新的数组（原始数据的一个拷贝），即使两个类型一致

ndarray数组向列表的转换

ndarray数组的操作

数组的索引和切片

索引：获取数组中特定位置元素的过程
切片：获取数组元素子集的过程

一维数组的索引和切片：与Python的列表类似

ndarray数组的运算

数组与标量之间的运算

数组与标量之间的运算作用于数组的每一个元素

NumPy一元函数

对ndarray中的数据执行元素级运算的函数

NumPy二元函数

NumPy库入门
数据的维度：一维、多维、高维 ndarray类型属性、创建和变换
.ndim .shape .size .dtype .itemsize
.reshape(shape) .resize(shape) .swapaxes(ax1,ax2) .flatten()
np.arange(n) np.ones(shape) np.zeros(shape) np.full(shape,val) np.eye(n) np.ones_like(a) np.zeros_like(a) np.full_like(a,val)
数组的索引 和切片
数组的运算 一元函数 二元函数

数据的CSV文件存取

CSV

CSV (Comma‐Separated Value,逗号分隔值)
CSV是一种常见的文件格式，用来存储批量数据

np.savetxt(frame, array, fmt=’%.18e’, delimiter=None)
•frame : 文件、字符串或产生器，可以是.gz或.bz2的压缩文件
•array : 存入文件的数组
•fmt: 写入文件的格式，例如：%d %.2f %.18e
•delimiter : 分割字符串，默认是任何空格

np.loadtxt(frame, dtype=np.float, delimiter=None，unpack=False)
•frame : 文件、字符串或产生器，可以是.gz或.bz2的压缩文件
•dtype: 数据类型，可选
•delimiter : 分割字符串，默认是任何空格 •unpack : 如果True，读入属性将分别写入不同变量

CSV文件的局限性
CSV只能有效存储一维和二维数组 np.savetxt() np.loadtxt()只能有效存取一维和二维数组

任意维度的数据的存取

a.tofile(frame, sep=’’, format=’%s’)
•frame : 文件、字符串
•sep: 数据分割字符串，如果是空串，写入文件为二进制
•format : 写入数据的格式

np.fromfile(frame, dtype=float, count=‐1, sep=’’)
•frame : 文件、字符串
•dtype: 读取的数据类型
•count : 读入元素个数，‐1表示读入整个文件
•sep: 数据分割字符串，如果是空串，写入文件为二进制

Numpy的便捷文件存取

np.save(fname, array) 或np.savez(fname, array)
•fname: 文件名，以.npy为扩展名，压缩扩展名为.npz
•array : 数组变量
np.load(fname)
•fname: 文件名，以.npy为扩展名，压缩扩展名为.npz

该方法需要读取时知道存入文件时数组的维度和元素类型 a.tofile()和np.fromfile()需要配合使用 可以通过元数据文件来存储额外信息

NumPy的随机数函数子库

NumPy的random子库 np.random.*

np.random.rand()
np.random.randn()
np.random.randint()

# random.rand()  创建随机数数组，浮点数，[0,1)，均匀分布 
import numpy as np
a = np.random.rand(2,3,4)
print(a)
# random.randn() 创建随机数数组，标准正态分布 
import numpy as np
sn = np.random.randn(2,3,3)
print(sn)
# randint(low[,high,shape]) 根据shape创建随机整数或整数数组，范围是[low, high) 
b = np.random.randint(100, 200, (3,4))
print(b)

结果为：

[[[0.77370416 0.98004405 0.71921366 0.7021638 ]
  [0.04528677 0.3841447  0.76890114 0.43853833]
  [0.6942368  0.33256993 0.97824932 0.97823238]]

 [[0.07550738 0.320338   0.75497812 0.90577501]
  [0.25334138 0.43705909 0.55602009 0.07789836]
  [0.15239915 0.10905574 0.66632375 0.33536652]]]


[[[ 0.39603121 -0.71415742  1.30171626]
  [-1.40338408  0.01807574  0.52046266]
  [ 1.00825969  0.11692623  0.45832172]]

 [[ 0.196081    0.3349378  -1.6255099 ]
  [ 0.30915698  1.07331915  0.78043277]
  [-1.50378625 -1.38103722 -0.84332737]]]


[[149 172 133 108]
 [166 115 149 147]
 [133 121 100 183]]

# 设置随机数种子
np.random.seed(10)
np.random.randint(100, 200, (3,4))

array([[109, 115, 164, 128],
       [189, 193, 129, 108],
       [173, 100, 140, 136]])

shuffle()、permutation()、choice()

uniform()、normal()、poisson()

Numpy的统计函数

numpy轴（axis）的理解：

https://blog.csdn.net/weixin_43848614/article/details/104871156

axis=0代表往跨行（down)，而axis=1代表跨列（across)

bx = np.arange(15,0,-1).reshape(3,5)
np.max(bx)
np.max(bx,axis=0)
np.argmax(bx,axis=1)
np.unravel_index(np.argmax(bx), bx.shape)
np.ptp(bx)
np.median(bx)
print(bx)
print('每一列最大值：', np.max(bx,axis=0))
print('每一行最大值的下标：', np.argmax(bx,axis=1))
print('根据shape将一维下标index转换成多维下标：', np.unravel_index(np.argmax(bx), bx.shape))
print('最大值与最小值的差值：', np.ptp(bx))
print('每一行平均数的值：', np.median(bx, axis=1))

结果为：

[[15 14 13 12 11]
 [10  9  8  7  6]
 [ 5  4  3  2  1]]
每一列最大值： [15 14 13 12 11]
每一行最大值的下标： [0 0 0]
根据shape将一维下标index转换成多维下标： (0, 0)
最大值与最小值的差值： 14
每一行平均数的值： [13.  8.  3.]

注：

argmin(a) 计算数组a中元素最小值、最大值的降一维后下标，想知道在数组中的位置需使用 unravel_index(index, shape) [参数不能少]

numpy的梯度函数

函数	说明
np.gradient(f)	计算数组f中元素的梯度，当f为多维时，返回每个维度梯度

梯度：连续值之间的变化率，即斜率
XY坐标轴连续三个X坐标对应的Y轴值：a, b, c，其中，b的梯度是：(c‐a)/2

实例：图像的手绘效果

图像的数组表示

图像一般使用RGB色彩模式，即每个像素点的颜色由红®、绿(G)、蓝(B)组成

RGB三个颜色通道的变化和叠加得到各种颜色，其中
•R 红色，取值范围，0‐255
•G 绿色，取值范围，0‐255
•B 蓝色，取值范围，0‐255
RGB形成的颜色包括了人类视力所能感知的所有颜色。

PIL，Python Image Library

PIL库是一个具有强大图像处理能力的第三方库 在命令行下的安装方法：
pip install pillow

from PILimport Image

Image是PIL库中代表一个图像的类（对象）

图像是一个由像素组成的二维矩阵，每个元素是一个RGB值

参考博客：
https://blog.csdn.net/qq_36119192/article/details/83748951

https://blog.csdn.net/u011915116/article/details/88776052

https://blog.csdn.net/a373595475/article/details/79580734
import