数据分析之Numpy

什么是数据分析

是把隐藏在一些看似杂乱无章的数据背后的信息提炼出来，总结出所研究对象的内在规律
    - 使得数据的价值最大化
         - 分析用户的消费行为
             - 制定促销活动的方案
             - 制定促销时间和粒度
             - 计算用户的活跃度
             - 分析产品的回购力度
    - 分析广告点击率
        - 决定投放时间,
        - 制定广告定向人群方案
        - 决定相关平台的投放

数据分析是用适当的方法对收集来的大量数据进行分析，帮助人们做出判断，以便采取适当的行动，例如：
    - 保险公司从大量赔付申请数据中判断哪些为骗保的可能
    - 支付宝通过从大量的用户消费记录和行为自动调整花呗的额度
    - 短视频平台通过用户的点击和观看行为数据针对性的给用户推送喜欢的视频

 

数据分析实现流程
    - 提出问题
    - 准备数据
    - 分析数据
    - 获得结论
    - 成果可视化

 

一、Numpy介绍

1、介绍

NumPy 是一个运行速度非常快的数学库，主要用于数组计算，包含：

  • 一个强大的N维数组对象 ndarray
  • 广播功能函数
  • 整合 C/C++/Fortran 代码的工具
  • 线性代数、傅里叶变换、随机数生成等功能

 

2、应用

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。

SciPy 是一个开源的 Python 算法库和数学工具包。

SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。

Matplotlib 是 Python 编程语言及其数值数学扩展包 NumPy 的可视化操作界面。它为利用通用的图形用户界面工具包，如 Tkinter, wxPython, Qt 或 GTK+ 向应用程序嵌入式绘图提供了应用程序接口（API）。

 

3、相关链接

 

 二、Numpy之ndarray的创建

1、使用np.array()创建数组

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

参数说明：

名称描述
object 数组或嵌套的数列
dtype 数组元素的数据类型，可选
copy 对象是否需要复制，可选
order 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认）
subok 默认返回一个与基类类型一致的数组
ndmin 指定生成数组的最小维度 
numpy中array叫数组，那么：数组和列表的区别是什么？

例如：
import numpy as np
arr = np.array([1,2,3])
# 结果：array([1, 2, 3])

arr = np.array([1, 2.2, "three"])
# 结果：array(['1', '2.2', 'three'], dtype='<U32')，可以看到数组里面的元素被统一转成了字符串

arr = np.array([1, 2.2])
# 结果：array([1. , 2.2])，可以看到数组里面的元素被统一转成了浮点数

结论：
    数组中存储的数据元素类型必须是统一类型
        优先级：
            字符串 > 浮点型 > 整数
1.一维数组创建
import numpy as np

np.array([1,2,3,4,5],dtype=int)  # dtype是指定数组元素的类型
# 结果：array([1, 2, 3, 4, 5])


2.二维数组创建
np.array([[1,2,3],[4,5,6],[7.7,8,9]])
# 结果
array([[1. , 2. , 3. ],
       [4. , 5. , 6. ],
       [7.7, 8. , 9. ]])

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


3.最小维度
np.array([1, 2, 3],ndmin=2)
# 结果
[[1,2,3]]

4.使用matplotlib.pyplot获取一个numpy数组，数据来源于一张图片
import matplotlib.pyplot as plt

img_arr = plt.imread('meinv.jpg')  # 把meinv.jpg这张图片读取成一个三维数组

plt.imshow(img_arr)  # 展示这张图片

操作该numpy数据，该操作会同步到图片中
new_arr = img_arr - 100  # 把图片的所有像素减去100
plt.imshow(new_arr)


img_arr.shape  # shape：形状（各维度的长度）
# 结果：(353, 626, 3)
 

 

2、ndarray 对象属性

属性说明
ndarray.ndim 秩，即轴的数量或维度的数量
ndarray.shape 数组的维度，对于矩阵，n 行 m 列
ndarray.size 数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype ndarray 对象的元素类型
ndarray.itemsize ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags ndarray 对象的内存信息
ndarray.real ndarray元素的实部
ndarray.imag ndarray 元素的虚部
ndarray.data 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。

1.numpy的常用属性

  • shape
  • ndim
  • size
  • dtype
arr = np.random.randint(0,100,size=(3,4,2))
array([[[83,  2],
        [84,  8],
        [93, 58],
        [68, 82]],

       [[96,  8],
        [51, 50],
        [63, 34],
        [53, 99]],

       [[31, 96],
        [47, 26],
        [12, 20],
        [75, 60]]]

arr.shape  # 返回的是数组的形状
(3, 4, 2)

arr.ndim  # 返回的是数组的维度
3

arr.size # 返回数组元素的个数 即 shape里面 n * m * ...
24

arr.dtype  # 返回的是数组元素的类型
dtype('int32')

type(arr)  # 数组的数据类型
numpy.ndarray

 

2.numpy的数据类型

  • array(dtype=?):可以设定数据类型
  • arr.dtype = '?':可以修改数据类

 

arr = np.array([1,2,3])
arr.dtype  # dtype('int64')

# 创建一个数组，指定数组元素类型为int32
arr = np.array([1,2,3],dtype='int32')
arr.dtype  # dtype('int32')

arr.dtype = 'uint8' #修改数组的元素类型
arr.dtype  # dtype('uint8')

 

3、使用np的routines函数创建

1. np.ones(shape, dtype=None, order='C')
# 创建元素都是1的4行5列的数组
np.ones(shape=(4,5),dtype=float)

# 结果
array([[1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.],
       [1., 1., 1., 1., 1.]])


2.  np.zeros(shape, dtype=None, order='C')
# 创建元素都是0的4行5列的数组
np.zeros(shape=(4,5),dtype=int)

结果
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0]])


3. np.full(shape, fill_value, dtype=None, order='C')
# 第一个参数shape是数组形状，第二个参数fill_value填充的常数
# 创建一个三维数组，有3个元素，每个元素是4行2列的二维数组
np.full(shape=(3,4,2),fill_value=88)

# 结果
array([[[88, 88],
        [88, 88],
        [88, 88],
        [88, 88]],

       [[88, 88],
        [88, 88],
        [88, 88],
        [88, 88]],

       [[88, 88],
        [88, 88],
        [88, 88],
        [88, 88]]])


4. np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) 等差数列
# 从0开始直到100，有20个数的等差数列
np.linspace(0,100,num=20,dtype=int)

# 结果
array([  0,   5,  10,  15,  21,  26,  31,  36,  42,  47,  52,  57,  63,
        68,  73,  78,  84,  89,  94, 100])


5. np.arange([start, ]stop, [step, ]dtype=None)
# 从0开始直到100(半开半闭区间，不含100)，公差为2的等差数列
np.arange(0,100,step=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])


6. np.random.randint(low, high=None, size=None, dtype='l')  随机生成
# 生成一个3行4列的二维数组，元素值在0到100内随机取
np.random.randint(0,100,size=(3,4))

# 每次结果都不一样的，因为元素是随机的
array([[69, 13, 25, 13],
       [92, 86, 30, 30],
       [89, 12, 65, 31]])

# 若想随机生成一次，后面每次都是这个数组，可以这么做
np.random.seed(10)  # 那时间固定一次，后面每次随机都只会生成一种结果
np.random.randint(0,100,size=(3,4))

# 无论多少次，结果都是这个
array([[ 9, 15, 64, 28],
       [89, 93, 29,  8],
       [73,  0, 40, 36]])


7. np.random.random(size=None)
生成0到1的随机数，左闭右开[0,1)
np.random.random(size=(3,4))

# 每次结果都是随机的，每次都不一样
array([[0.33549965, 0.41118255, 0.0768555 , 0.85304299],
       [0.43998746, 0.12195415, 0.73173462, 0.13878247],
       [0.76688005, 0.83198977, 0.30977806, 0.59758229]])

# 若想随机生成一次，后面每次都是这个数组，可以这么做
np.random.seed(10)
np.random.random(size=(3,4))

# 结果
array([[0.77132064, 0.02075195, 0.63364823, 0.74880388],
       [0.49850701, 0.22479665, 0.19806286, 0.76053071],
       [0.16911084, 0.08833981, 0.68535982, 0.95339335]])

 

三、ndarray的基本操作

1、索引

arr = np.random.randint(0,100,size=(5,5)) 
# arr的值
array([[55, 56, 91, 30, 93],
       [37, 39, 50, 11, 12],
       [ 2, 86, 17, 42, 50],
       [21, 59, 69, 65, 59],
       [92, 38, 98, 38, 84]])

arr[1]  #取出了numpy数组中的下标为1的行数据
array([37, 39, 50, 11, 12])

arr[[1,3,4]] #取出多行(取第1、3、4行数据)
array([[37, 39, 50, 11, 12],
       [21, 59, 69, 65, 59],
       [92, 38, 98, 38, 84]])
       

根据索引修改数据
# 索引从0开始
arr[1][2] = 55555  # 把索引为1的那行的索引为2的那个数改成55555

# 结果
array([[   55,    56,    91,    30,    93],
       [   37,    39, 55555,    11,    12],
       [    2,    86,    17,    42,    50],
       [   21,    59,    69,    65,    59],
       [   92,    38,    98,    38,    84]])

 

2、切片

arr = np.random.randint(0,100,size=(5,5))
# 数组arr
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])

# 1.获取二维数组前两行
arr[0:2]
# 结果
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1]])


# 2.获取二维数组前两列
arr[:,0:2]  # 逗号前面切的是行，后面切的是列，不写代表不切
# 结果
array([[37, 12],
       [ 5, 79],
       [76, 71],
       [20, 18],
       [29, 14]])


# 3.获取二维数组前两行和前两列数据
arr[0:2,0:2]
# 结果
array([[37, 12],
       [ 5, 79]])

 

3、切片倒序

将数据反转使用    ::

# arr数组
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])


# 1.将数组的所有行倒序
arr[::-1]
# 结果
array([[   29,    14,    50,    68,    87],
       [   20,    18,    84,    11,    28],
       [   76,    71,     6,    25,    50],
       [    5,    79,    15,    16,     1],
       [   37,    12,    72,     9,    75]])


# 2.将数组索引为2的行开始倒序
arr[2::-1]
# 结果
array([[   76,    71,     6,    25,    50],
       [    5,    79,    15,    16,     1],
       [   37,    12,    72,     9,    75]])


# 3.将数组的所有列倒序
arr[:,::-1]
# 结果
array([[   75,     9,    72,    12,    37],
       [    1,    16,    15,    79,     5],
       [   50,    25,     6,    71,    76],
       [   28,    11,    84,    18,    20],
       [   87,    68,    50,    14,    29]])


# 4.将数组索引为2的列开始倒序
arr[:,2::-1]
# 结果
array([[   72,    12,    37],
       [   15,    79,     5],
       [    6,    71,    76],
       [   84,    18,    20],
       [   50,    14,    29]])


# 5.全部倒序
arr[::-1,::-1]
# 结果
array([[   87,    68,    50,    14,    29],
       [   28,    11,    84,    18,    20],
       [   50,    25,     6,    71,    76],
       [    1,    16,    15,    79,     5],
       [   75,     9,    72,    12,    37]])

 

3.2、图片切片倒序

img_arr = plt.imread('E:\meinv.png')
plt.imshow(img_arr)

 

img_arr.shape
# (260, 401, 4)


# 图片左右翻转
plt.imshow(img_arr[:,::-1,:]) # img_arr[行，列，颜色]

 

# 图片上下翻转
plt.imshow(img_arr[::-1,:,:])

 

# 图片裁剪的功能
plt.imshow(img_arr[77:200,88:300,:])

 

 

4、变形

使用arr.reshape()函数，注意参数是一个tuple！

新数组的shape属性应该要与原来数组的一致，即新数组元素数量与原数组元素数量要相等。一个参数为-1时，
那么reshape函数会根据另一个参数的维度计算出数组的另外一个shape属性值。

# arr
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])
       
# 查看arr的维度和大小
arr.shape  # (5, 5) 代表是5行5列的二维数组
arr.size  # 25 即5*5=25 共25个元素

       
# 将二维的数组变形成1维
arr_1 = arr.reshape((25,))  # 这里的25 = arr.size 即原数组的元素个数
array([37, 12, 72,  9, 75,  5, 79, 15, 16,  1, 76, 71,  6, 25, 50, 20, 18,
       84, 11, 28, 29, 14, 50, 68, 87])
       

# 将一维变形成多维
arr_1.reshape((5,5,1))  
# 等同于 
arr.reshape((5,5,1))
array([[[37],
        [12],
        [72],
        [ 9],
        [75]],

       [[ 5],
        [79],
        [15],
        [16],
        [ 1]],

       [[76],
        [71],
        [ 6],
        [25],
        [50]],

       [[20],
        [18],
        [84],
        [11],
        [28]],

       [[29],
        [14],
        [50],
        [68],
        [87]]])

# 图片倒置
# 使用上面那个meinv.jpg
# 查看图片原本的形状
img_arr.shape  # (353, 626, 3)

# 查看图片的大小
img_arr.size  # 662934

# 将原数据三维数组变形成一维数组
arr_1 = img_arr.reshape((662934,))

# 将arr_1元素倒置
arr_1 = arr_1[::-1]

# 再将arr_1重新变形成三维数组
a_img = arr_1.reshape((353, 626, 3))

# 查看结果
plt.imshow(a_img)




 


5、级联


将多个numpy数组进行横向或者纵向拼接


axis轴向的理解：


    

  • 0:代表进行纵向(列)拼接
    • 

  • 1:代表进行横向(行)拼接
    • 

  • 2:三维数组才有
    • 



注意点：


    

  • 级联只能是同一维度的数组进行级联，比如二维数组和二维数组，三维数组和三维数组；二维数组跟三维数组不能进行级联
    • 

  • 维度相同的情况下，列拼接需要列数相同的情况下才可以，行拼接需要行数相同的情况下才可以；
    • 

  • 例如：两个二维数组，arr=5行5列；arr1=5行4列，那么arr跟arr1只能进行行拼接，即axis=1
    • 

  • 例如：两个二维数组，arr=4行3列；arr1=3行3列，那么arr跟arr1只能进行列拼接，即axis=0
    • 





按轴axis连接array组成一个新的array，0代表纵轴，1代表横轴

# arr数组
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])

# arr数组
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])

# 1.安照横轴把两个arr拼接成新的数组
np.concatenate((arr,arr),axis=1)
# 结果
array([[   37,    12,    72,     9,    75,    37,    12,    72,     9,
           75],
       [    5,    79,    15,    16,     1,     5,    79,    15,    16,
            1],
       [   76,    71,     6,    25,    50,    76,    71,     6,    25,
           50],
       [   20,    18,    84,    11,    28,    20,    18,    84,    11,
           28],
       [   29,    14,    50,    68,    87,    29,    14,    50,    68,
           87]])


# 2.安照横轴把arr和arr1拼接成新的数组
arr1 = np.random.randint(0,100,size=(5,4))
# arr1如下
array([[87, 94, 96, 86],
       [13,  9,  7, 63],
       [61, 22, 57,  1],
       [ 0, 60, 81,  8],
       [88, 13, 47, 72]])

# 拼接arr(5行5列)和arr1(5行4列)
np.concatenate((arr,arr1),axis=1)
# 结果
array([[   37,    12,    72,     9,    75,    87,    94,    96,    86],
       [    5,    79,    15,    16,     1,    13,     9,     7,    63],
       [   76,    71,     6,    25,    50,    61,    22,    57,     1],
       [   20,    18,    84,    11,    28,     0,    60,    81,     8],
       [   29,    14,    50,    68,    87,    88,    13,    47,    72]])


# 3.按照纵轴拼接两个arr
np.concatenate((arr,arr),axis=0)
# 结果
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87],
       [   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])


# 4.合并两张照片
img_3 = np.concatenate((img_arr,img_arr,img_arr),axis=1)  # 先横轴把照片拼接3次
img_9 = np.concatenate((img_3,img_3,img_3),axis=0)  # 再把上面合并后的照片再纵轴合并三次
plt.imshow(img_9)



# 5.np.hstack与np.vstack
np.hstack与np.vstack只能拼接数组，不能拼接图片
np.hstack横轴拼接
np.vstack纵轴拼接

np.hstack((arr,arr))
# 结果
array([[   37,    12,    72,     9,    75,    37,    12,    72,     9,
           75],
       [    5,    79,    15,    16,     1,     5,    79,    15,    16,
            1],
       [   76,    71,     6,    25,    50,    76,    71,     6,    25,
           50],
       [   20,    18,    84,    11,    28,    20,    18,    84,    11,
           28],
       [   29,    14,    50,    68,    87,    29,    14,    50,    68,
           87]])

np.vstack((arr,arr))
# 结果
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87],
       [   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])


# 6.级联需要注意的点：
级联的参数是列表：一定要加中括号或小括号
维度必须相同
形状相符:在维度保持一致的前提下，如果进行横向（axis=1）级联，必须保证进行级联的数组行数保持一致。如果进行纵向（axis=0）级联，必须保证进行级联的数组列数保持一致。
可通过axis参数改变级联的方向




 


6、切分




# 与级联类似，三个函数完成切分工作：
np.split(arr,行／列号，轴):参数2是一个列表类型
np.vsplit
np.hsplit

# 参数
split(arr, indices_or_sections, axis=0) # 把一个数组从左到右按顺序切分 
arr:要切分的数组 
indices_or_sections:如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置
axis：沿着哪个维度进行切向，默认为0，横向切分


# 1. 按整数切分
A = np.arange(16).reshape(4,4)
# A的值
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])

# 切横轴，即切成纵向的两个数组
np.split(A,2,axis = 1)
# 结果
[array([[ 0,  1],
        [ 4,  5],
        [ 8,  9],
        [12, 13]]), array([[ 2,  3],
        [ 6,  7],
        [10, 11],
        [14, 15]])]

# 切纵轴，即切成横向的两个数组
np.split(A,2,axis = 0)
# 结果
[array([[0, 1, 2, 3],
        [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],
        [12, 13, 14, 15]])]

# 2.按元组位置切割
# arr的值
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])

# 按照第2行第三列切
np.split(arr,(2,3),axis=1)
# 结果
[array([[37, 12],
        [ 5, 79],
        [76, 71],
        [20, 18],
        [29, 14]]), array([[   72],
        [15],
        [    6],
        [   84],
        [   50]]), array([[ 9, 75],
        [16,  1],
        [25, 50],
        [11, 28],
        [68, 87]])]


# 3.切分照片
plt.imshow(img_arr)



# 按照第300行，切纵轴，切成横向的两部分
plt.imshow(np.split(img_arr,(300,),axis=0)[0])




plt.imshow(np.split(img_arr,(300,),axis=0)[1])



 






 


7、副本




可使用copy()函数创建副本
修改操作对副本进行，原数据不会变化

c_arr = arr.copy()
c_arr[1][4] = 10010
# arr
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])




 


8、ndarray的聚合操作




# 1.求和sum
# arr
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])

# 按照横轴相加
arr.sum(axis=1)
# 结果
array([  205, 116,   228,   161,   248])

# 按照纵轴相加
arr.sum(axis=0)
# 结果
array([  167,   194, 227,   129,   241])

# 求所有元素的和
arr.sum()  # 958

# 2. 最大最小值: max/ min
# 每行中取最大的值
arr.max(axis=1)
# 结果
array([ 75, 79, 76, 84, 87])

# 每列中取最小的值
arr.min(axis=0)
# 结果
array([ 5, 12,  6,  9,  1])

# 求所有元素中最小的值
arr.min()  # 1

# 3.平均值：mean()
# 每行的平均值
arr.mean(axis=1)
# 结果
array([   41. , 23.2,    45.6,    32.2,    49.6])

# 求所有元素的平均值
arr.mean()  # 38.32

# 4.其他聚合函数
Function Name    NaN-safe Version    Description
np.sum    np.nansum    Compute sum of elements
np.prod    np.nanprod    Compute product of elements
np.mean    np.nanmean    Compute mean of elements
np.std    np.nanstd    Compute standard deviation
np.var    np.nanvar    Compute variance
np.min    np.nanmin    Find minimum value
np.max    np.nanmax    Find maximum value
np.argmin    np.nanargmin    Find index of minimum value
np.argmax    np.nanargmax    Find index of maximum value
np.median    np.nanmedian    Compute median of elements
np.percentile    np.nanpercentile    Compute rank-based statistics of elements
np.any    N/A    Evaluate whether any elements are true
np.all    N/A    Evaluate whether all elements are true
np.power 幂运算






"""常用的数学函数"""
NumPy 提供了标准的三角函数：sin()、cos()、tan()

numpy.around(a,decimals) 函数返回指定数字的四舍五入值。
参数说明：
  a: 数组
  decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

np.sin(2.5)  # 0.5984721441039565

np.sin(arr)
array([[-0.64353813, -0.53657292,  0.25382336,  0.41211849, -0.38778164],
       [-0.95892427, -0.44411267,  0.65028784, -0.28790332,  0.84147098],
       [ 0.56610764,  0.95105465, -0.2794155 , -0.13235175, -0.26237485],
       [ 0.91294525, -0.75098725,  0.73319032, -0.99999021,  0.27090579],
       [-0.66363388,  0.99060736, -0.26237485, -0.89792768, -0.82181784]])

np.around(3.14)  # 3.0

np.around(3.1415926,2)  # 3.14




方差：是衡量源数据和期望值相差的度量值。


方差是各个数据与平均数之差的平方的和的平均数，即




其中，x表示样本的平均数，n表示样本的数量，xi表示个体，而s2就表示方差。




方差是和中心偏离的程度，用来衡量一批数据的波动大小（即这批数据偏离平均数的大小）并把它叫做这组数据的方差，记作S2。 在样本容量相同的情况下，方差越大，说明数据的波动越大，越不稳定。


 


标准差：是离均差平方的算术平均数(即：方差)的算术平均根。


标准差是方差的算术平方根。标准差能反映一个数据集的离散程度。平均数相同的两组数据，标准差未必相同。


与方差的关系：方差=标准差的平方。






"""常用的统计函数"""
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[1].std()  # 标准差：28.484381685407882

arr[1].var()  # 方差：811.3599999999999




 


四、广播机制


【重要】ndarray广播机制的三条规则:缺失维度的数组将维度补充成进行运算的数组的维度。缺失的数组元素使用已有元素进行补充。


    

  • 规则一：为缺失的维度补1(进行运算的两个数组之间的维度只能相差一个维度)
    • 

  • 规则二：缺失元素用已有值填充
    • 

  • 规则三：缺失维度的数组只能有一行或者一列
    • 





# 例1： m = np.ones((2, 3)) a = np.arange(3) 求m+a
m = np.ones((2, 3))
a = np.arange(3)
display(m,a)
# m和a
array([[1., 1., 1.],
       [1., 1., 1.]])

array([0, 1, 2])

m+a
# 等于这样的相加
array([[1., 1., 1.],
       [1., 1., 1.]])

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

# 结果
array([[1., 2., 3.],
       [1., 2., 3.]])


# 例2： a = np.arange(3).reshape((3, 1)) b = np.arange(3) 求a+b
a = np.arange(3).reshape(3,1)
b = np.arange(3)
display(a,b)
# a和b的值
array([[0],
       [1],
       [2]])
array([0, 1, 2])

a+b
# 等于这样相加
array([[0, 0, 0],
       [1, 1, 1],
       [2, 2, 2]])

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

# 结果
array([[0, 1, 2],
       [1, 2, 3],
       [2, 3, 4]])





 


五、ndarray的排序


np.sort()与ndarray.sort()都可以，但有区别：


    

  • np.sort()不改变输入
    • 

  • ndarray.sort()本地处理，不占用空间，但改变输入
    • 





# arr
array([[   37,    12,    72,     9,    75],
       [    5,    79,    15,    16,     1],
       [   76,    71,     6,    25,    50],
       [   20,    18,    84,    11,    28],
       [   29,    14,    50,    68,    87]])

# 按纵轴排序，且原本的arr数组已经改变了
arr.sort(axis=0)
arr
# 结果
array([[    5,    12,     6,     9,     1],
       [   20,    14,    50,    11,    28],
       [   29,    18,    72,    16,    50],
       [   37,    71,    84,    25,    75],
       [   76,    79,    15,    68,    87]])

# 按横轴排序，原本的arr数组不变
np.sort(arr,axis=1)
# 结果
array([[    1,     5,     6,     9,    12],
       [   11,    14,    20,    28,    50],
       [   16,    18,    29,    50,    72],
       [   25,    37,    71,    75,    84],
       [   68,    76,    79,    87,    15]])

# 再查看arr
array([[    5,    12,     6,     9,     1],
       [   20,    14,    50,    11,    28],
       [   29,    18,    72,    16,    50],
       [   37,    71,    84,    25,    75],
       [   76,    79,    15,    68,    87]])




 


六、矩阵


在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。


由 m × n 个数aij排成的m行n列的数表称为m行n列的矩阵，简称m × n矩阵。记作：




这m×n 个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数 aij为(i,j)元的矩阵可记为(aij)或(aij)m × n，m×n矩阵A也记作Amn。




元素是实数的矩阵称为实矩阵，元素是复数的矩阵称为复矩阵。而行数与列数都等于n的矩阵称为n阶矩阵或n阶方阵。


 


矩阵加法




矩阵的加法满足下列运算律(A，B，C都是同型矩阵)：


A + B = B + A


(A + B) + C = A + (B + C)


应该注意的是只有同型矩阵之间才可以进行加法。


 


矩阵减法




 


矩阵数乘




矩阵的数乘满足以下运算律：


a(bX) = b(aX)
a(bX) = (ab)X
(a+b)X = aX + bX
a(X + Y) = aX + aY


 


矩阵与矩阵相乘


设A为 m * p 的矩阵，B为 p * n 的矩阵，那么称 m * n 的矩阵C为矩阵A与B的乘积，记作 C = AB

矩阵相乘的注意事项：
1、当矩阵A的列数（column）等于矩阵B的行数（row）时，A与B可以相乘。
2、矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。
3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。




 


转置


把矩阵A的行和列互相交换所产生的矩阵称为A的转置矩阵（AT）  ，这一过程称为矩阵的转置。




矩阵的转置满足以下运算律：


ATT = A


(a.A)T = a.AT


(AB)T = BTAT




"""矩阵相关函数介绍
NumPy 中包含了一个矩阵库 numpy.mat 、numpy.matrix 、 numpy.matrixlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。

numpy.identity()函数返回给定大小的单位矩阵。单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为0

numpy.eye()可以创建跟identity一样的单位矩阵，也可以创建 n * m 阶矩阵。

矩阵的创建可以调用numpy.mat、numpy.matrix来进行创建，调用mat函数和调用matrix(data, copy=False)等价。
mat与matrix不同在于：mat不会创建副本。
"""

# 创建矩阵的几种方式
mat1 = np.mat("1,2,3;4,5,6;7,8,9")  # 使用分号隔开数据
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
        
mat2 = np.mat([[1,2,3],[4,5,6],[7,8,9]])  # 也可以使用数组形式
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
        

mat3 = np.matrix("1,2,3;4,5,6;7,8,9")  # matrix使用分号隔开数据
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
        
mat4 = np.matrix([[1,2,3],[4,5,6],[7,8,9]])  # matrix使用数组形式
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
        

narr = np.array([[1,2,3],[4,5,6],[7,8,9]])
mat5 = np.matrix(narr)  # 将ndarray转化为矩阵类型
type(mat5)  # <class 'numpy.matrix'>
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])


# numpy.identity()返回一个标准的 n阶单位矩阵
np.identity(3, dtype=int)
array([[1, 0, 0],
       [0, 1, 0],
       [0, 0, 1]])

# numpy.eye()可以创建n阶单位矩阵和n*m阶段矩阵
np.eye(3,dtype=int)
array([[1, 0, 0],
       [0, 1, 0],
       [0, 0, 1]])

np.eye(3,4,dtype=int)
array([[1, 0, 0, 0],
       [0, 1, 0, 0],
       [0, 0, 1, 0]])

# 矩阵的转置
mat1.T
matrix([[1, 4, 7],
        [2, 5, 8],
        [3, 6, 9]])


矩阵相乘：numpy.dot(a, b, out=None)

# 数乘
2 * mat1
matrix([[ 2,  4,  6],
        [ 8, 10, 12],
        [14, 16, 18]])
        
# 矩阵与矩阵相乘
mat1 * mat2
或者
np.dot(mat1, mat2)
matrix([[ 30,  36,  42],
        [ 66,  81,  96],
        [102, 126, 150]])




 






            

            
posted @ 
2019-02-15 16:43 
我用python写Bug 
阅读(622) 
评论(0) 
编辑 
收藏 
举报