Python 深度学习之numpy

个人手记

注意：在pycharm中不能将文件名命名为已有模块名

一、导入numpy作为np，并查看版本和安装位置

import numpy as np
print(np.__version__,'/n',np.__file__)

二、在NumPy中，数组这一类又被称为ndarray。

1、ndarray.ndim
指数组的维度，即数组轴（axes）的个数，其数量等于秩（rank）。
通俗地讲，我们平时印象中的数组就是一维数组，维度为1、轴的个数为1、秩也等于1；
最常见的矩阵就是二维数组，维度为2、轴的个数为2（可以理解为由x轴、y轴组成）、秩等于2；我们所知的空间就相当于三维数组，
维度为3、轴的个数为3（x、y、z轴）、秩等于3；以此类推。

2、ndarray.shape
按教程的话翻译过来是数组的维度，这样就很容易和ndim的概念混淆。
所以可以这样理解，shape的返回值是一个元组，元组的长度就是数组的维数，即ndim。
而元组中每个整数分别代表数组在其相应维度（/轴）上的大小。
以最常见的矩阵为例，print shape后返回（2,3），说明这是一个2行3列的矩阵。
 
3、原型：np.arange([start,] stop[, step,], dtype=None)  要省略都省略,不然就写全
参数一：数组开始的数字start
参数二：数组结束的数字stop
参数三：数组累加的步长step
参数四：数组内元素的数据类型dtype
        “The type of the output array.  If `dtype` is not given, infer the data
        type from the other input arguments.”
返回值：生成一个 N维数组对象ndarray(快速而灵活的大数据集容器)
该对象由两部分组成：1、实际的数据；2、描述这些数据的元数据；
用法一：只有一个参数，表示个数，从0开始。
用法二：齐全参数，表示生成一个一定范围内数组。


4、原型：numpy.full(shape, fill_value, dtype=None, order='C') 生成给定形状和数据类型的数组；
参数一：shape规定数组类型（2,3）表示二行三列的二维数组； 
参数二：fill_value填充的数据值； 
参数三：dtype规定类型； 
参数四：order在内存中以行主（C风格）或列主（Fortran风格）顺序存储多维数据。

5、原型：numpy.ones(shape, dtype = None, order = 'C') 
生成指定形状的数组 默认数组元素以浮点数 1. 来填充

6、原型：np.where(condition[, x, y])
共有三种用法：
用法一>
     传入三个参数的时候，满足条件输出x，不满足条件输出y 
用法二>
     传入一个数组参数的时候，输出非0元素 
用法三>
     传入一个判断条件参数的时候，输出满足条件的元素

7、原型：numpy.reshape(a, newshape, order='C')不改变数组数据的前提下，改变数组的形状
参数一a：被修改的数组名 
参数二：新的数组的形状，通常是整数或者整型数组 
参数三：通常是CFA三个值 返回值是一个新的视图，不然就复制一份 


注意：
     （1）如果新的数组和原来的数组大小不一致，那么不能原数组承接新形状数组。
     （2）如果原数组元素不能大于新数组的元素个数。 
      以上两条均会爆出ValueError: cannot reshape array of size 21 into shape (2,15)错误 
补充：
      C-style order是以行为主，存储格式为a[0][0],a[0][1],a[1][0],a[1][1]，矩阵运算比较友好 
      F-style order是以列为主，存储格式为a[0][0],a[1][0],a[0][1],a[1][1]，科学计算友好。
      A 按照他存的顺序读取，存C-style就按照C读，存F-style就按F读取 新形状中如果设置为-1：
      缺省值-1代表不知道要给行（或者列）设置为几，reshape函数会根据原矩阵的形状自动调整。 

8、原型：np.concatenate((a1, a2, …), axis=0) 数组拼接
参数(a1, a2, …)：表示要拼接的数组
参数axis：默认是0表示纵向拼接垂直堆叠；1表示横向拼接水平堆叠

9、原型：np.repeat(a,repeats,axis=None) 
参数一：传入一个数组 
参数二：数组每个元素重复的次数 
参数三：axis=None时候就会flatten当前矩阵，实际上就是变成了一个行向量； axis=0,沿着y轴复制，实际上增加了行数； axis=1,沿着x轴复制，实际上增加列数； 

10、原型：numpy.tile(A,reps) 整个函数用于重复数组A来构建新的数组 
参数一：传入一个数组A 
参数二：reps则决定A重复的次数，新数组的维度为max（reps.ndim，A.ndim） 

注意： numpy的数组没有tile属性，该属性是属于上级numpy的。 
报错信息：'numpy.ndarray' object has no attribute 'tile' 

11、原型：np.r_ 列不变行累加（纵向扩展） 按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等，类似于pandas中的concat()。 

12、原型：np.c_ 行不变列累加（横向扩展） 按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等，类似于pandas中的merge()。

13、原型：numpy.intersect1d(ar1,ar2,assume_unique=False, return_indices=False)
参数一二：需要求的数组名 
参数三：bool，默认为False，True假定数组唯一
参数四：bool，默认为False，True返回两数组交集的索引，如有多个值，第一个优先
return：一个数组。1、公共元素组成的数组 2、arr1第一次出现公共值的索引 3、arr2第一次出现公共值的索引

14、原型：numpy.setdiff1d(ar1, ar2, assume_unique=False) 从集合ar1中找到与ar2不同的元素组成新的数组返回。

15、原型：numpy.where(condition[, x, y]) 返回x或y中符合condition的元素。
    如果condition为true返回x 
    用法一：只有condition一个参数的时候，功能是简写的 np.asarray(condition).nonzero()； 总之就是在调用nonzero函数。 

16、原型：numpy.nonzero(a) 返回非零元素的索引。
 
17、原型：class numpy.vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None) 向量化函数。 
参数一：pyfunc函数和方法 
参数二：输出数据类型。必指为一个typecode字符串或数据类型说明符列表。每个输出应该有一个数据类型说明符。 
参数三：如果为None，则docstring将是 pyfunc.__doc__。 
参数四：表示函数不会向量化的位置或关键字参数的字符串或整数集。这些将直接传递给未经修改的pyfunc 
参数五：如果为True，则缓存第一个函数调用，该函数调用确定未提供otype的输出数。 
参数六：广义通用函数签名，例如，(m,n),(n)->(m)用于矢量化矩阵 - 向量乘法。如果提供的话，pyfunc将调用（并期望返回）具有由相应核心维度的大小给出的形状的数组。默认情况下，pyfunc假定将标量作为输入和输出。 vectorized :向量化的数组

三、numpy训练

问题1：创建从0到9的一维数字数组

arr = np.arange(0,9,1,dtype=float)
print(arr)

问题2：创建一个numpy2*2数组元素值全为True（真）的数组

numArrF = np.full((2,2),True,dtype = bool,order = 'C')
print(numArrF)
numArrOB = np.ones((3,3), dtype=bool)
print(numArrOB)
numArrOI = np.ones((3,2),dtype = int)
print('输出ones建立的数组：',numArrOI)

问题3：创建一个0-30的数组，从 arr 中提取所有的奇数

numArr = np.arange(6,30,1,dtype = int)
print('输出数组：',numArr)
print('查找数组所有的奇数：',numArr[numArr % 2 == 1])  #使用数组名来获取下标'''
print('numpy的where函数查找数组值所匹配的下标：',np.where(numArr == 8))

问题4：将上一问题的numArr中所有奇数替换为-1。

取出直接赋值替换
numArr[numArr % 2 == 1] = -1
print('原数组替换数组值：',numArr)

问题5：将arr中的所有奇数替换为-1，而不改变arr。

numArr = np.arange(1,20,1,dtype= float)
print(numArr)
print(np.where(numArr % 2 == 1, -1, numArr))

问题6：将一维数组转换为2行的2维数组

arrShape = np.arange(2,24,1,dtype = int )
print('arrShape未修改元素：\n',arrShape)
#下面两种用法均可
arrShapenew1 = arrShape.reshape((2 ,-1), order = 'C')
print('new arrShape first:\n',arrShapenew1)
arrShapenew2 = np.reshape(arrShape,(2,-1),order = 'C')
print('new arrShape second:\n',arrShapenew2)

问题7：何为水平堆叠？何为垂直堆叠？

水平堆叠：纵向拼接，axis=1，表示以横轴为基准，将数组横向拼接
垂直堆叠：与上相反

问题8：垂直堆叠和水平堆叠数组a和数组b

arr1 = np.arange(10).reshape(2,-1)
arr2 = np.repeat(1,10).reshape(2,-1)
print('纵向拼接（垂直堆叠）：\n',np.concatenate((arr1,arr2), axis = 0))
print('横向拼接（水平堆叠）：\n',np.concatenate((arr1,arr2), axis = 1))
print('append拼接：\n',np.append(arr1,arr2))   #一维追加，行不变，列总和
print('stack拼接：\n',np.stack([arr1,arr2]))  #分两个数组进行堆叠
print('hstack拼接（水平堆叠）：\n',np.hstack([arr1,arr2]))   #行和行相拼接
print('vstack拼接（垂直堆叠）：\n',np.vstack([arr1,arr2]))   #列和列相拼接
print('dstack拼接（垂直堆叠）：\n',np.dstack([arr1,arr2]))   #两数组的每个元素相组合形成一个新的数组，作为新数组的元素。
#使用np.r_[a,b]整合多个数组为一个数组，行相等，列累加
print('np.r_[a,b]列不变行累加：\n',np.r_[arr1,arr2])
print('np.c_[a,b]行不变列累加：\n',np.c_[arr1,arr2])

问题9：何为硬编码？何为软编码？

硬编码>将可变变量用一个固定数值表示，不可修改；（写死了，不能改了）
软编码>通过一个标记取代变量名称，而这个标记的值是可以不断变化的。（跟随）



如何在无硬编码的情况下生成numpy中的自定义序列？
问题10：创建以下模式而不使用硬编码。只使用numpy函数和下面的输入数组a
给定： a = np.array([1,2,3])
期望的输出：
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])

aa = np.array(([1,2,3],[4,5,6]))
a = np.array([1,2,3])
print('a的ndim = ',a.ndim)
print('aa的ndim = ',aa.ndim)
print('默认none复制:\n',a.repeat(3))   #按元素复制，生成一维数组
print('按行复制:\n',aa.repeat(3,axis=0))   #按行复制  “需要弄明白：axis为0表示的y轴是哪个？”
print('按列复制:\n',aa.repeat(3,axis=1))   #按列复制  “疑问：为什么一维数组不能进行按列复制，增加列”
print('每行对应的复制的次数，要和数组的行对应:\n',aa.repeat([4,3],axis=0))  #每行对应的复制的次数，要和数组的行对应
print('每列对应的复制次数，要和数组的列数对应:\n',aa.repeat([2,3,4],axis=1))  #每列对应的复制次数，要和数组的列数对应
print('重复数组\n',np.tile(a,3))
print('实现生成自定义数组R：\n',np.r_[a.repeat(3),np.tile(a,3)])
print('实现生成自定义数组C：\n',np.c_[a.repeat(3),np.tile(a,3)])

问题11：获取数组a和数组b之间的公共项。
给定：a = np.array([1,2,3,2,3,4,3,4,5,6])
     b = np.array([7,2,10,2,7,4,9,4,9,8])
期望的输出：array([2, 4])

a = np.array([1,2,3,2,3,4,3,4,5,6])
b = np.array([7,2,10,2,7,4,9,4,9,8])
print('使用交集，按位取公共元素项：\n', np.intersect1d(a,b,return_indices = True))   #注意intersect1d中倒数第二个字母为数字1不是字母L

问题12：从数组a中删除数组b中的所有项。
给定：a = np.array([1,2,3,4,5])
     b = np.array([5,6,7,8,9])
期望的输出：array([1,2,3,4])

a = np.array([1,2,3,4,5])
b = np.array([5,6,7,8,9])
print('setdiff1d实现删除其他存在项：\n',np.setdiff1d(a,b,assume_unique= True ))

问题13：获取a和b元素匹配（相等）的位置（索引）。
给定：a = np.array([1,2,3,2,3,4,3,4,5,6])
     b = np.array([7,2,10,2,7,4,9,4,9,8])
期望的输出：(array([1, 3, 5, 7]),)

a = np.array([1,2,3,2,3,4,3,4,5,6])
b = np.array([7,2,10,2,7,4,9,4,9,8])
print('使用where筛选符合条件元素的索引：\n',np.where(a == b))
print('返回匹配的元素\n',a==b)
print('使用 nonzero筛选符合条件的元素索引：\n',np.nonzero( a==b ))

问题14：获取5到10之间的所有项目。
给定：a = np.array([2, 6, 1, 9, 10, 3, 27])
期望的输出：(array([6, 9, 10]),)

print('\n获取5到10之间的所有项目:')
a = np.array([2, 6, 1, 9, 10, 3, 27])
print('a[np.where((a>=5) & (a<=10))] = ',a[np.where((a>=5) & (a<=10))])   #条件要取优先级括号
print('a[np.where(np.logical_and(a>=5,a<=10))] = ',a[np.where(np.logical_and(a>=5,a<=10))])
print('a[(a>=5)&(a<=10)] = ',a[(a>=5)&(a<=10)])

scalar标量数据，python只有一种特定数据类型(整形和浮点型)
在研究科学数据计算领域远远不够，numpy中用拥有24种数据类型描述标量scalar；
numpy默认数据类型是float，int_不是继承python3的。


问题15：适用于转换两个标量的函数maxx，以求两个数组的最大值。
给定：
def maxx(x, y): #求两个最大值
    if x >= y:
        return x
    else:
        return y
maxx(1, 5)
# > 5
期望的输出：
a = np.array([5, 7, 9, 8, 6, 4, 5])
b = np.array([6, 3, 4, 8, 9, 7, 1])
pair_max(a, b)
# > array([ 6.,  7.,  9.,  8.,  9.,  7.,  5.])

print('定义函数按位求解两个数组的最大值：\n',)
def maxArr(x,y):
    if x>y:
        return x
    else:
        return y

a = np.array([2,4,5,2,15,53,3,9])
b = np.array([5,3,2,6,25,26,7,1])
maxA = np.vectorize(maxArr,otypes=[int])    #自定义函数返回的值是什么？为何无法输出? 参数传入的值
print(maxA(a,b))

问题16：建立一个三行三列数组，交换第一列和第二列

a = np.arange(0,18,2,dtype = int ).reshape(3,3)
print('原数组：\n',a)
aa = a[:,[1,0,2]]
print('交换0 1两列后：\n',aa)   #普通的建立temp交换是没有用