numpy模块（详解）

  • 重点

    • 索引和切片
    • 级联
    • 聚合操作
    • 统计操作
    • 矩阵

什么是数据分析

  • 是把隐藏在一些看似杂乱无章的数据背后的信息提炼出来，总结出所研究对象的内在规律
  • 数据分析是用适当的方法对收集来的大量数据进行分析，帮助人们做出判断，以便采取适当的行动
    • 商品采购量的多少
    • 总部向各个地区代理的发货量

为什么学习数据分析

  • 有岗位的需求
  • 是Python数据科学的基础
  • 是机器学习课程的基础

数据分析实现流程

  • 提出问题
  • 准备数据
  • 分析数据
  • 获得结论
  • 成果可视化

数据分析三剑客

  • numpy
  • pandas
  • matplotlib

numpy模块

  • NumPy(Numerical Python) 是 Python 语言中做科学计算的基础库。重在于数值计算，也是大部分Python科学计算库的基础，多用于在大型、多维数组上执行的数值运算。
  • numpy当成是一个一维或者多维的数组

numpy的创建

  • 使用np.array()创建
  • 使用plt创建
  • 使用np的routines函数创建
  • 使用array()创建一个一维数组
import numpy as np
arr = np.array([1,2,3,4,5])

# 结果：
array([1, 2, 3, 4, 5])
  • 使用array()创建一个多维数组
np.array([[1,2,3],[4,5,6]])

# 结果:
array([[1, 2, 3],
       [4, 5, 6]])
  • 数组和列表的区别是什么？

    • 列表中可以存储不同类型的数据
    • 数组中存储的数据元素类型必须一致

      str > float > int 数据类型的优先级

np.array([[1,2,3],[4,'five',6]])

# 如果在一个整数的数组中插入一个字符串，然后就会将全部的数据元素都转换成字符串
# 结果：
array([['1', '2', '3'],
       ['4', 'five', '6']], dtype='<U11')
  • 将外部的一张图片读取加载到numpy数组中，然后尝试改变数组元素的数值查看对原始图片的影响
import matplotlib.pyplot as plt
#图片数据的读取
img_arr = plt.imread('./1.jpg')
#将一个三维的numpy数组显示成一张图片
plt.imshow(img_arr-100)

# img_arr-100 会对每个这个照片中的每一个数值进行减100

? 可以看出在对这个照片的数值进行修改之后，照片的颜色发生了改变；

下边numpy模块对应的一些方法

  • zeros() -------- 生成一个自定义的元素都为0的数组
  • ones() -------- 生成一个自定义的元素都为1的数组
  • linespace() ---------- 生成多少个一维等差数列
  • arange() ---------- 生成以某个值为差的一维等差数列
  • random系列 ----------- 生成随机数组，
np.zeros(shape=(3,3))

# 结果：
array([[0., 0., 0.],
       [0., 0., 0.],
       [0., 0., 0.]])
np.ones(shape=(3,4)

# 结果
array([[1., 1., 1., 1.],
       [1., 1., 1., 1.],
       [1., 1., 1., 1.]])
np.linspace(0,100,num=20)   #  一维等差数列

# 结果：
array([  0.        ,   5.26315789,  10.52631579,  15.78947368,
        21.05263158,  26.31578947,  31.57894737,  36.84210526,
        42.10526316,  47.36842105,  52.63157895,  57.89473684,
        63.15789474,  68.42105263,  73.68421053,  78.94736842,
        84.21052632,  89.47368421,  94.73684211, 100.        ])
np.arange(0,100,2)   #  一维等差数列

# 结果：
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32,
       34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66,
       68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98])
np.random.randint(0,80,size=(5,8))

# 结果：
array([[29,  8, 73,  0, 40, 36, 16, 11],
       [54, 62, 33, 72, 78, 49, 51, 54],
       [77, 69, 13, 25, 13, 30, 30, 12],
       [65, 31, 57, 36, 27, 18, 77, 22],
       [23, 11, 28, 74,  9, 15, 18, 71]])

size里边的值是行和列，相当于二维，里边每增加一个数就会则增加一个维度

np.random.random(size=(3,4))

# 结果：
array([[0.0768555 , 0.85304299, 0.43998746, 0.12195415],
       [0.73173462, 0.13878247, 0.76688005, 0.83198977],
       [0.30977806, 0.59758229, 0.87239246, 0.98302087]])

下面的是一个三维数组：

np.random.random(size=(2,3,4))

# 结果：
array([[[0.88291734, 0.1809206 , 0.35617448, 0.3049914 ],
        [0.72609875, 0.26811569, 0.34519581, 0.35372182],
        [0.26311417, 0.54276554, 0.2561482 , 0.30583742]],

       [[0.0986709 , 0.82136811, 0.41041769, 0.4089922 ],
        [0.5390292 , 0.60816895, 0.5686751 , 0.07936629],
        [0.98708008, 0.36585268, 0.30857405, 0.40176834]]])
  • 随机因子(系统时间)：无时无刻都在变化的值

    • 随机因子固定下来，随机性就固定
#固定随机性
np.random.seed(10)#固定时间种子
np.random.randint(0,100,size=(2,3))

# 结果：
array([[ 9, 15, 64],
       [28, 89, 93]])

numpy的常用属性

  • shape ------------------ 形状（重点）
  • ndim ------------------ 维度数
  • size ------------------- 数组的长度
  • dtype -------------------- 数组元素的类型（重点）
arr = np.random.randint(0,100,size=(5,6))

# 结果：
array([[88, 11, 17, 46,  7, 75],
       [28, 33, 84, 96, 88, 44],
       [ 5,  4, 71, 88, 88, 50],
       [54, 34, 15, 77, 88, 15],
       [ 6, 85, 22, 11, 12, 92]])

下边是这些属性的作用展示：

arr.shape
# 结果：
    (5, 6)

arr.ndim
# 结果：
    2

arr.size
# 结果：
    30

arr.dtype
# 结果：
    dtype('int32')

查看一下arr是什么类型

type(arr)

# 结果：
numpy.ndarray

numpy的数据类型(数组元素的类型)

  • array(dtype=?) 可以设定数据类型
  • arr.dtype = ‘?‘ 可以修改数据类型
#通过dtype修改数据的数据类型
arr.dtype = 'int16'

# 结果：
dtype('int16')

numpy的索引和切片操作（重点）

  • 意义：可以让我们取出numpy数组中任意指定的局部数据
  • 索引操作和列表同理
arr = np.random.randint(0,100,size=(3,4))

# 生成的数组
array([[ 1, 61, 28,  6],
       [85, 87, 91,  3],
       [ 6, 98, 91, 54]])

arr[1]          #取一行
# 结果：
array([85, 87, 91,  3])

arr[[1,2]]  #取多行
# 结果：
array([[ 1, 61, 28,  6],
       [85, 87, 91,  3]])
  • 切片操作

    • 切出前两列数据
    • 切出前两行数据
    • 切出前两行的前两列的数据
    • 数组数据翻转
    • 练习：将一张图片上下左右进行翻转操作
    • 练习：将图片进行指定区域的裁剪
#切出前两行数据
arr[0:2]

array([[ 1, 61, 28,  6],
       [85, 87, 91,  3]])
#切出前两列数据
#arr[hang,lie]

arr[:,:2]

array([[ 1, 61],
       [85, 87],
       [ 6, 98]])
#切出前两行的前两列的数据
arr[:2,:2]

array([[ 1, 61],
       [85, 87]])
#列反转
arr[:,::-1]

array([[ 6, 28, 61,  1],
       [ 3, 91, 87, 85],
       [54, 91, 98,  6]])
#行反转
arr[::-1]

array([[ 6, 98, 91, 54],
       [85, 87, 91,  3],
       [ 1, 61, 28,  6]])
#元素反转
arr[::-1,::-1]
array([[54, 91, 98,  6],
       [ 3, 91, 87, 85],
       [ 6, 28, 61,  1]])
img_arr.shape

(554, 554, 3)
#将一张图片反转
plt.imshow(img_arr[::-1,::-1,::-1])
<matplotlib.image.AxesImage at 0x224149be4e0>

变形reshape

arr = np.array([[1,2,3],[4,5,6]])
arr.shape

(2, 3)
#将多维变一维
arr_1 = arr.reshape((6,))

array([1, 2, 3, 4, 5, 6])
#一维变多维
arr_1.reshape((6,1))

array([[1],
       [2],
       [3],
       [4],
       [5],
       [6]])

arr_1.reshape((3,-1))   #-1表示自动计算行或者列数

array([[1, 2],
       [3, 4],
       [5, 6]])

级联操作：待级联的数组维度必须保持一致

  • 就是将多个numpy数组进行横向或者纵向的拼接
  • axis轴向的理解
arr = np.array([[1,2,3],[4,5,6]])
n_arr = arr
display(arr,n_arr)

array([[1, 2, 3],
       [4, 5, 6]])

array([[1, 2, 3],
       [4, 5, 6]])
  • 匹配级联

    • 进行级联的多个数组的形状是完全一样
# axis=0 等于0表示列，等于1表示行
np.concatenate((arr,n_arr),axis=0)
# 按列匹配级联
array([[1, 2, 3],
       [4, 5, 6],
       [1, 2, 3],
       [4, 5, 6]])
  • 不匹配级联

    • 维度一致，但是行列个数不一致

      • 横向级联：保证行数一致
      • 纵向级联：保证列数一致
np.concatenate((a,arr),axis=1)

array([[1, 2, 1, 2, 3],
       [3, 4, 4, 5, 6]])

让照片按九宫格显示：

arr_3 = np.concatenate((img_arr,img_arr,img_arr),axis=1)
arr_9 = np.concatenate((arr_3,arr_3,arr_3),axis=0)
plt.imshow(arr_9)
<matplotlib.image.AxesImage at 0x224145d9978>

广播机制

  • 广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
x = np.array([[2,2,3],[1,2,3]])
y = np.array([[1,1,3],[2,2,4]])
display(x,y)

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

array([[1, 1, 3],
       [2, 2, 4]])
x+y

array([[3, 3, 6],
       [3, 4, 7]])
arr1 = np.array([[0, 0, 0],[1, 1, 1],[2, 2, 2], [3, 3, 3]])
# arr1.shape = (4,3)
arr2 = np.array([1, 2, 3])
display(arr1,arr2)

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

array([1, 2, 3])
arr1 + arr2

array([[1, 2, 3],
       [2, 3, 4],
       [3, 4, 5],
       [4, 5, 6]])
  • 广播的规则：

    • 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
    • 输出数组的形状是输入数组形状的各个维度上的最大值。
    • 如果输入数组的某个维度和待计算数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
    • 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

常用的聚合操作

  • sum,max,min,mean
arr = np.array([[8,20,5],[6,52,45]])

# 对每一行求和
arr.sum(axis=1)
array([ 33, 103])

# 求每一行的最大值
arr.max(axis=1)
array([20, 52])

# 求每一列的最小值
arr.min(axis=0)
array([ 6, 20,  5])

# 求每一列的平均值
arr.mean(axis=0)
array([ 7., 36., 25.])

常用的数学函数

  • NumPy 提供了标准的三角函数：sin()、cos()、tan()
  • numpy.around(a,decimals) 函数返回指定数字的四舍五入值。
    • 参数说明：

      • a: 数组
      • decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置
arr = np.array([[8,20,5],[6,52,45]])

np.sin(arr)

array([[ 0.98935825,  0.91294525, -0.95892427],
       [-0.2794155 ,  0.98662759,  0.85090352]])
arr = np.array([1.4,4.7,5.2])

array([1.4, 4.7, 5.2])
np.around(arr,decimals=0)    #对小数进行四舍五入

array([1., 5., 5.])
np.around(arr,decimals=-1)    # 最对小数点的前一位进行四舍五入

array([ 0.,  0., 10.])

常用的统计函数

  • numpy.amin() 和 numpy.amax()，用于计算数组中的元素沿指定轴的最小、最大值。
  • numpy.ptp():计算数组中元素最大值与最小值的差（最大值 - 最小值）。
  • numpy.median() 函数用于计算数组 a 中元素的中位数（中值）
  • 标准差std():标准差是一组数据平均值分散程度的一种度量。
    • 公式：std = sqrt(mean((x - x.mean())**2))
    • 如果数组是 [1，2，3，4]，则其平均值为 2.5。 因此，差的平方是 [2.25,0.25,0.25,2.25]，并且其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。
  • 方差var()：统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)。换句话说，标准差是方差的平方根。
arr = np.random.randint(60,100,size=(5,3))

array([[92, 75, 93],
       [85, 69, 97],
       [60, 78, 83],
       [63, 89, 76],
       [80, 78, 74]])
np.amin(arr,axis=1)

array([75, 69, 60, 63, 74])
np.ptp(arr,axis=0)

array([32, 20, 23])
np.median(arr,axis=0)

array([80., 78., 83.])
#标准差:std = sqrt(mean((x - x.mean())**2))
arr = np.array([1,2,3,4,5])
((arr - arr.mean())**2).mean()**0.5

1.4142135623730951
arr.std()

1.4142135623730951
#方差：mean((x - x.mean())**2)
arr.var()

2.0

矩阵相关

  • 必须要掌握：

    • 矩阵是什么
    • 单位矩阵
    • 转置矩阵
    • 矩阵的乘法运算
  • NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。一个 的矩阵是一个由行（row）列（column）元素排列成的矩形阵列。
  • matlib.empty() 函数返回一个新的矩阵，语法格式为：numpy.matlib.empty(shape, dtype)，填充为随机数据
    • 参数介绍：

      • shape: 定义新矩阵形状的整数或整数元组
      • Dtype: 可选，数据类型
import numpy.matlib as matlib
matlib.empty(shape=(5,6))

matrix([[1.16302223e-311, 1.16302228e-311, 1.16302223e-311,
         1.16302226e-311, 1.16302223e-311, 1.16302226e-311],
        [1.16302356e-311, 1.16302355e-311, 1.16302226e-311,
         1.16302222e-311, 1.16302222e-311, 1.16302226e-311],
        [1.16302223e-311, 1.16302223e-311, 1.16302747e-311,
         1.16302356e-311, 1.16302747e-311, 1.16302228e-311],
        [1.16302223e-311, 1.16302223e-311, 1.16302356e-311,
         1.16302449e-311, 1.16302228e-311, 1.16302228e-311],
        [1.16302364e-311, 1.16302364e-311, 1.16302226e-311,
         1.16302278e-311, 1.16302228e-311, 1.16302228e-311]])
  • numpy.matlib.zeros()，numpy.matlib.ones()返回填充为0或者1的矩阵
matlib.ones(shape=(3,4))

matrix([[1., 1., 1., 1.],
        [1., 1., 1., 1.],
        [1., 1., 1., 1.]])
  • numpy.matlib.eye() 函数返回一个矩阵，对角线元素为 1，其他位置为零。

    • numpy.matlib.eye(n, M,k, dtype)

      • n: 返回矩阵的行数
      • M: 返回矩阵的列数，默认为 n
      • k: 对角线的索引
      • dtype: 数据类型
  • 单位矩阵：
    • 行列数一致且对角线值为1其他值为0的矩阵
matlib.eye(n=5,M=4,k=0)

matrix([[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.],
        [0., 0., 0., 0.]])

matlib.eye(n=5,M=5,k=2)
matrix([[0., 0., 1., 0., 0.],
        [0., 0., 0., 1., 0.],
        [0., 0., 0., 0., 1.],
        [0., 0., 0., 0., 0.],
        [0., 0., 0., 0., 0.]])
# 当k的值变化时，矩阵的对角线在移动
  • numpy.matlib.identity() 函数返回给定大小的单位矩阵。单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。
matlib.identity(5)

matrix([[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.]])
  • 转置矩阵:行 -> 列，列 -> 行

    • .T
arr = np.random.randint(0,100,size=(5,5))

array([[51, 79, 17, 50, 53],
       [25, 48, 17, 32, 81],
       [80, 41, 90, 12, 30],
       [81, 17, 16,  0, 31],
       [73, 64, 38, 22, 96]]
arr.T

array([[51, 25, 80, 81, 73],
       [79, 48, 41, 17, 64],
       [17, 17, 90, 16, 38],
       [50, 32, 12,  0, 22],
       [53, 81, 30, 31, 96]])
  • 矩阵相乘

    • numpy.dot(a, b, out=None)

      • a : ndarray 数组
      • b : ndarray 数组

    • 第一个矩阵第一行的每个数字（2和1），各自乘以第二个矩阵第一列对应位置的数字（1和1），然后将乘积相加（ 2 x 1 + 1 x 1），得到结果矩阵左上角的那个值3。也就是说，结果矩阵第m行与第n列交叉位置的那个值，等于第一个矩阵第m行与第二个矩阵第n列，对应位置的每个值的乘积之和。
    • 线性代数基于矩阵的推导： 
a = np.array([[2,1],[4,3]])
b = np.array([[1,2],[1,0]])
display(a,b)

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

array([[1, 2],
       [1, 0]])
np.dot(a,b)

array([[3, 4],
       [7, 8]])

原文地址：https://www.cnblogs.com/zhufanyu/p/12024951.html

时间： 2024-10-28 05:23:32

numpy模块（详解）的相关文章

Python中time模块详解

在Python中,与时间处理有关的模块就包括:time,datetime以及calendar.这篇文章,主要讲解time模块. 在开始之前,首先要说明这几点: 在Python中,通常有这几种方式来表示时间:1)时间戳 2)格式化的时间字符串 3)元组(struct_time)共九个元素.由于Python的time模块实现主要调用C库,所以各个平台可能有所不同. UTC(Coordinated Universal Time,世界协调时)亦即格林威治天文时间,世界标准时间.在中国为UTC+8.DST

python中threading模块详解（一）

python中threading模块详解(一) 来源 http://blog.chinaunix.net/uid-27571599-id-3484048.html threading提供了一个比thread模块更高层的API来提供线程的并发性.这些线程并发运行并共享内存. 下面来看threading模块的具体用法: 一.Thread的使用 目标函数可以实例化一个Thread对象,每个Thread对象代表着一个线程,可以通过start()方法,开始运行. 这里对使用多线程并发,和不适用多线程并发做

ansible常用模块详解

ansible常用模块详解: ansible <host-pattern> [-m module_name] [-a args] [options] #ansible命令格式  指定主机组或ip地址  指定调用模块   传递给模块的参数   ansible-doc -l #列出可用模块 ansible-doc -s model_name #查看指定模块详细用法 command:ansible默认模块,对指定主机执行命令,不能理解特殊字符 例:ansible web -a 'date' #对we

nginx的配置及模块详解

nginx: nginx是俄罗斯软件工程师Igor Sysoev开发的免费开源web服务器软件,nginx采用了模块化.事件驱动.异步.单线程及非阻塞的架构,并大量采用了多路复用及事件通知机制来实现高并发和高性能,解决C10K的问题,主要功能就是提供http和反向代理服务,以及邮件服务及反向代理等,并且具有多种web服务器功能特性:负载均衡,缓存,访问控制,带宽控制,以及高效整合各种应用的能力. 在nginx中,连接请求由为数不多的几个仅包含一个线程的进程worker以高效的回环(run-loo

python的logging模块详解

日志级别 >>>import logging >>>logging.NOTSET 0 >>>logging.DEBUG 10 >>>logging.INFO 20 >>>logging.WARN 30 >>>logging.ERROR 40 >>>logging.CRITICAL 50 >>>logging._levelNames {0:'NOTSET', 10:

Ceph Monitor基础架构与模块详解

转自:https://www.ustack.com/blog/ceph-monitor/ Ceph rados cluster离不开Monitor,如果没有Monitor,则Ceph将无法执行一条简单的命令.Monitor由于其特殊性,了解它,对于我们深入理解Ceph,保证Ceph的稳定性,有很大帮助. Monitor 基本架构介绍 Monitor的基本架构图: Monitor的主要任务就是维护集群视图的一致性,在维护一致性的时候使用了Paxos协议,并将其实例化到数据库中,方便后续的访问.所以

nodejs QueryString模块 详解

QueryString模块 "QueryString" 模块用于实现URL参数字符串与参数对象的互相转换 此类一共包括4个方法: querystring.stringify(obj, [sep], [eq]) querystring.parse(str, [sep], [eq], [options]) querystring.escape querystring.unescape 一:querystring.stringify(obj,[sep],[eq]) 对象格式化成参数字符串 ,

(转)python time模块和datetime模块详解

python time模块和datetime模块详解 原文:http://www.cnblogs.com/tkqasn/p/6001134.html 一.time模块 time模块中时间表现的格式主要有三种: a.timestamp时间戳,时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量 b.struct_time时间元组,共有九个元素组. c.format time 格式化时间,已格式化的结构使时间更具可读性.包括自定义格式和固定格式. 1.时间格式转换图: 2.主要ti

Ansible安装部署及常用模块详解

Ansible命令使用 Ansible语法使用ansible <pattern_goes_here> -m <module_name> -a <arguments> -m NAME,–module-name=NAME:指定执行使用的模块 -u USERNAME,–user=USERNAME:指定远程主机以USERNAME运行命令 -s,–sudo:相当于Linux系统下的sudo命令 -USUDO_USERNAME,–sudo-user=SUDO_USERNAME:使用

Python中time模块详解(转)

Python中time模块详解(转) 在平常的代码中,我们常常需要与时间打交道.在Python中,与时间处理有关的模块就包括:time,datetime以及calendar.这篇文章,主要讲解time模块. 在开始之前,首先要说明这几点: 在Python中,通常有这几种方式来表示时间:1)时间戳 2)格式化的时间字符串 3)元组(struct_time)共九个元素.由于Python的time模块实现主要调用C库,所以各个平台可能有所不同. UTC(Coordinated Universal Ti