Duduk的python Numpy库学习笔记（基础入门）

        Python的Numpy库，通常需导入使用且给其一个别名np

import numpy as np

        克服列表的缺点（需同时存储数据类型，每一个元素可以是不同数据类型），在numpy中同一个数组仅容纳一种数据类型，减少了内存冗余 。

        类型为<class 'numpy.ndarray'>

        

一、数组基础

        1.1数据类型 

                1）整数形数组（int） and  浮点型数组（float）

 I.运用  .array()  方法创建

#创建整数型数组（int）
arr1=np.array([1,2,3])    #元素均为整数时，则为整数型数组（int）
print(arr1)

此时输出为[1 2 3]

#创建浮点型数组
arr2=np.array([1.0,2,3])    #当内含浮点数，无论占比多少，均为浮点型数组
arr3=np.array([1.0,2.0,3])
arr4=np.array([1.0,2.0,3.0])
print(arr2,arr3,arr4)

 输出均为为[1. 2. 3.]

II.运用  .arange()  方法创建

# 使用 .arange() 快速创立数组
arr1=np.arange(10)
print(arr1)            #输出为[0 1 2 3 4 5 6 7 8 9]
arr1=np.arange(5,10)
print(arr1)            #输出为[5 6 7 8 9]
arr1=np.arange(2,10,2)
print(arr1)            #输出为[2 4 6 8]
# 总结：.arange(起始，结束，间距)且左闭右开，取起始而不取结束

                2）同化定理

# 整数型数组
arr1=np.array([1,2,3])
arr1[0]=100.9            #若插入浮点数，浮点数会被截断仅留整数部分，数组仍为整数型
print(arr1)

输出为[100   2   3]

# 浮点型数组
arr2=np.array([1.0,2,3])
arr2[0]=10                # 若插入整数型元素，则元素升级为浮点型，数组仍未浮点型数组
print(arr2)

输出为[10.  2.  3.]

勿将浮点型元素直接加入整数型数组中，会被截断

                3）共同改变定理

I.运用  .satype()  方法同化

 使整数型数组（int）与浮点型（float）数组相互转化 

# 整数型数组
arr1=np.array([1,2,3])
print(arr1)            #结果为[1 2 3]
# 整数型数组（int） ——> 浮点数数组（float）
arr2=arr1.astype(float)
print(arr2)            #结果为[1. 2. 3.]
# 浮点数数组（float） ——> 整数型数组（int）
arr3=arr2.astype(int)
print(arr3)            #结果为[1 2 3]

II.运算中，整体改变

# 创建整数型数组（int）
arr=np.array([1,2,3])
print(arr)              #输出为[1 2 3]
# 整数型数组（int）与浮点数（float）做运算————！每一项！
#相加
print(arr+0.0)          #输出为[1. 2. 3.]
#相乘
print(arr*1.0)          #输出为[1. 2. 3.]
# 整数型数组（int）遇到除法（即使为整数相除）————！每一项！
print(arr/1)            #输出为[1. 2. 3.]

# 整数型数组（int）与浮点型数组（float）做运算,对应元素逐项运算
int_arr=np.array([1,2,3])
float_arr=np.array([1.0,2,3])
print(int_arr+float_arr)        #输出为[2. 4. 6.]

整数型数组（int）容易在运算中升级，但 浮点型数组（float）一般不会降级。

整数型数组（int）升级后，相应内存会增大，计算上无差错

        1.2数组维度

                        1）一维数组 and 二维数组 and 

I.维度数组特点

拼接时需要同维度数组

a.外形上的本质区别：

        一维数组使用1层中括号【】表示；

        二维数组使用2层中括号【】表示；

        n维数组使用n层中括号【】表示。

b.形状参数

        一维数组的形状参数形如：x 或 (x,)  ；

        二维数组的形状参数形如： (x,y)      ；

        n维数组的形状参数形如：  (x,y,z,...)；

II.运用  .ones()  方法创建

# 运用 .ones() 创建维度数组
#一维数组
arr1=np.ones(3)            #传入形状3
print(arr1)                #输出为[1. 1. 1.]，此时arr1为一维数组
#二维数组
arr2=np.ones((1,3))        #传入形状(1,3)
print(arr2)                #输出为[[1. 1. 1.]]，此时arr2为二维数组
#三维数组
arr3=np.ones((1,1,3))      #传入形状(1,1,3)
print(arr3)                #输出为[[[1. 1. 1.]]]，此时arr3为三维数组

III.运用   .shape  查看形状

# 创建维度数组
arr1=[1. 1. 1.]
arr2=[[1. 1. 1.]]
arr3=[[[1. 1. 1.]]]
print( arr1.shape )        #输出为(3,)
print( arr2.shape )        #输出为(1,3)
print( arr3.shape )        #输出为(1,1,3)

                2） 不同维度数组之间的转换

I.运用  .reshape()  重塑

#创建一维数组
arr1=np.arange(10)
#创建二维数组
arr2=arr1.reshape(2,5)  #可以填入-1令其自动计算，但若另一位非总元素的因数会报错
print(arr2)

输出为  [[0 1 2 3 4]
               [5 6 7 8 9]] 

        小结1.一维数组称为向量

        小结2.二维数组成为矩阵

二、数组的创建

        2.1创建指定数组 np.array()

                当知道数组的每一个元素基体数值事使用 np.array()

        2.2创建递增数组 np.arange()

                arange 全称是 array_range

        2.3创建同值数组 np.zeros()

                np.zeros() 为全0数组，但生成的为浮点型数组（float）

                np.ones()为全1数组，同样的也为浮点型数组（float）

                可能为避免插入的浮点型元素被截断，若想要别的数字就运算得便可（如+-*/）。

        2.4创建随机数组 np.random

                1）np.random.random()   

浮点型随机数组

# 此函数固定生成的为0~1之间的随机浮点型数组，括号内传入数组的形状参数
arr1=np.random.random(5)
print(arr1)        #输出为[0.34357583 0.04100289 0.9269526  0.44781917 0.52650029]
# 若想随机生成其他范围之间的数，可对其整体进行运算。
# 以60~100为例
arr1=(100-60)*np.random.random(5)+60
print(arr1)        #输出为[78.26476411 95.8051686  88.6098689  70.28521861 75.77184491]
# 以37~66为例
arr1=(66-37)*np.random.random(5)+37
print(arr1)        #输出为[50.34588316 49.12841428 50.97130994 44.1973814  42.94570724]
# 不同次数的尝试输出结果可能并不相同，因为随机生成。但并非完全随机

                2）np.random.randint() 

整数型随机数组

# 此函数可定义随机区间以及形状参数
# 举例生成 10~100 之间的形状参数为（1，15）的整数型数组
arr2=np.random.randint(10,100,(1,15))
print(arr2)            #输出为[[78 63 69 37 22 32 89 19 16 35 70 76 77 60 83]]

但同样也可以用random实现整数型随机数组的生成 ，运用 .astype() 转化为整数型即可

                3）np.random.normal()

传入三个参数，即（均值，标准差，形状）

# 需要手动输入均值与标准差
arr3=np.random.normal(0,1,(1,4))
print(arr3)        #输出为[[-1.41694951 -0.92354107 -1.22427377  0.01356136]]

若仅想生成01标准正态分布可以使用 np.random.randn 仅需传入形状

# 直接在括号中输入形状参数即可，不用多加一层括号
arr3=np.random.randn(1,5)
print(arr3)        #输出为[[-1.27080664  0.00831389 -0.7056034   0.38036363 -0.90665569]]

三、数组的索引 

        3.1 元素的访问与修改

下标与Python列表一致，访问元素时使用中括号，索引由0开始

正序时第一个元素为[0]，倒序时最后一个元素为[-1]

修改与Python列表同理，索引后直等于即可（例如arr1[0]=12）

        3.2花式索引

花式索引时使用两层中括号，内层中括号表示同时索引内的俩个下标对应的元素

注意，若不是一维数组，则对于的中括号下标结合为坐标表示元素

花式索引即以向量代替普通索引的行列元素，且输出仍是一个向量

        3.3数组切片

                1）向量切片

与Python列表切片完全相同

                2）矩阵切片

仅含一层中括号（两层为花式索引）

每个逗号为间隔，以：切分每个x/y/z/...的起始值：结束值：间隔值

                3）切片为原数组的视图

并不会如Python列表产生新变量

备份切片为新变量， .copy()

！！不知道是否存在深浅拷贝！！

                3）数组的赋值仅为绑定，不产生新变量

解决方法也是使用 .copy()

四、数组的变形

        4.1数组的转制  .T

仅对矩阵有效，向量需先行转化为矩阵才可使用（向量使用后无明显变化）

                1）  .T  使行矩阵与列矩阵相互转化

arr1=np.arange(1,10).reshape(3,3)
arr1
##array([[1, 2, 3],                 首先生成一个三行三列的矩阵
##       [4, 5, 6],
##       [7, 8, 9]])
a1=arr1.T
a1
##array([[1, 4, 7],                 抽出每一列作为行，转制
##       [2, 5, 8],
##       [3, 6, 9]])
a2=a1.T
a2
##array([[1, 2, 3],                 相反则仍未其本身
##       [4, 5, 6],
##       [7, 8, 9]])

        4.2数组上下翻转  np.flipud()

表示up-down

                1）向量可使用此函数

在数学中，向量并非横向排列，而是纵向排列。

arr1=np.arange(10)
print(arr1)        #输出为[0 1 2 3 4 5 6 7 8 9]
arr_ud=np.flipud(arr1)        #上下翻转
print(arr_ud)      #输出为[9 8 7 6 5 4 3 2 1 0]
#效果是数组上下位置颠倒

        4.3数组左右翻转  np.fliplr()

表示left-right

                1）向量不能使用此函数

在数学中，向量并非横向排列，而是纵向排列。

        4.4数组的重塑  .reshape()

传入形状参数即可

        4.5数组的拼接  .concatenate()

默认参数axis=0，即为默认行拼接。       可更改为1，列拼接

向量与矩阵不可拼接，会报错

        4.6数组的分裂  .split()

                1）向量的分裂

需要两个参数，第一个为准备分割的向量，后一个为切分阶段点（以中括号）

                2）矩阵的分裂

默认参数axis=0，即为默认行切分。       可更改为1，列切分

五、数组的运算

        5.1数组与系数运算

常用运算符相同

若没有特定索引，直接输入数组名，运算时是对数组中每个元素运算

        5.2数组与数组运算（同形状）

也为逐项计算 

        5.3广播

                1）向量与矩阵计算时，自动且只升级为行矩阵

                2）某矩阵为行或列矩阵时，会被广播适配另一个矩阵

I.向量（行矩阵）被广播时，广播意为沿各个延伸方向复制本省（存疑）

II. 列矩阵被广播时，同上

III.行矩阵、列矩阵同时被广播（不适配时），先各自广播而后适配 

六、数组的函数

        6.1矩阵乘积  np.dot()

混有向量时，输出结果必为向量。

例如，（1，5）x（5，1）必为（1，1）而非（5，5）

1、当矩阵A的列数（column）等于矩阵B的行数（row）时，A与B可以相乘。

2、矩阵C的行数等于矩阵A的行数，C的列数等于B的列数。

3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。

                1）向量与向量乘积

arr1=np.arange(5)        #生成向量
arr2=np.arange(5)        #生成向量
print(np.dot(arr1,arr2))        #输出为30（意为 1*1 + 2*2 + 3*4 + 4*4 ）

                2）向量与矩阵乘积 

（1，5） x （5，3）=（1，3）

arr1=np.arange(5)
arr2=np.arange(15).reshape(5,3)
print(np.dot(arr1,arr2))            #输出为[ 90 100 110] (矩阵乘法)

                3）矩阵与向量乘积

（3，5） x (5，1）=（3，1）

                4）矩阵与矩阵乘积

（5，2） x （2，8）=（5，8）

                （顺序不同，亦有所不同），小心报错。。

        6.2数学函数

                1）绝对值函数  np.abs()

                2）三角函数  .sin()  .cos()  .tan()

                3）指数函数  .exp()   

意为e的__次方

                4）对数函数  .log() 

意为以e为底的对数

若想以其他数字为底，则使用换底公式即可

        6.3聚合函数 

向量的用法与矩阵相同，仅仅没有 axis 参数。。 

                1）最大/小值  np.max()

输入两个参数，对象以及axis（维度）

输出为比较对象维度中最大的元素

不输入axis的话则求出整体的最大值

                2）求和/积  np.sum() / np.prod() 

输入两个参数，对象以及axis（维度）

输出为对象维度中元素逐项运算

不输入axis的话则求出整体和/积 

                3）均值/标准差  np.mean() / np.std() 

 

输入两个参数，对象以及axis（维度）

输出为对象维度的均值/标准差（大概率为浮点型数组）

不输入axis的话则求出整体均值/标准差 

                 4）缺失值

前缀加上nan，计算时会忽略跳过而不报错

七、布尔型数组 （掩码）

布尔型数组的产生基于（大于、小于、等于）几类基础比较 

arr1=np.arange(1,7).reshape(2,3)
print(arr1)
#[[1 2 3]
# [4 5 6]]
print(arr1>=4)                    #布尔类型的产生
#[[False False False]
# [ True  True  True]]

同时，同纬度数组作比较也会产生布尔型数组。（可同时检索多个条件） 

        7.1numpy中的条件 

numpy中不使用与（and），或（or），非（not）

使用的为  &  ,  |  ,  非还没找到 

        7.2 布尔型数组中True的数量

使用求和的函数计算即可  np.sum

                1)  np.any()

只要布尔类型中含一个及以上个True，则返回True

                2） np.all()

只有布尔类型中全为True时,才返回True

        7.3布尔类型数组作为掩码

如筛选条件符合的，可以用掩码。

举例（寻找数组中大于4的数）

arr1=np.arange(1,13).reshape(3,4)
print(arr1)
#[[ 1  2  3  4]
# [ 5  6  7  8]
# [ 9 10 11 12]]
print(arr1 > 4)                #生成的为布尔型数组
#[[False False False False]
# [ True  True  True  True]
# [ True  True  True  True]]
print(arr1[arr1 > 4])            #将布尔型数组作为索引（掩码）放入中括号内
#[ 5  6  7  8  9 10 11 12]        #符合条件的位置上的元素排列为向量

矩阵进行掩码操作后，退化为了向量。 

        7.4满足条件元素所在位  np.where() 

       返回的为一元组，元组中第一个为元素所在位置，第二个为数据类型（dtype=int64等，int64为64位整数类型）