numpy.random.randint
Return random integers from low (inclusive) to high (exclusive).
Return random integers from the “discrete uniform” distribution of the specified dtype in the “half-open” interval [low, high). If high is None (the default), then results are from [0, low).
numpy.ndarray.astype #Copy of the array, cast to a specified type.
np.ravel() #Return a contiguous flattened array. A 1-D array, containing the elements of the input, is returned. A copy is made only if needed.
numpy的ravel() 和 flatten()函数
首先声明两者所要实现的功能是一致的（将多维数组降位一维）。这点从两个单词的意也可以看出来，ravel(散开，解开)，flatten（变平）。两者的区别在于返回拷贝（copy）还是返回视图（view），numpy.flatten()返回一份拷贝，对拷贝所做的修改不会影响（reflects）原始矩阵，而numpy.ravel()返回的是视图（view，也颇有几分C/C++引用reference的意味），会影响（reflects）原始矩阵。
numpy模块之axis https://blog.csdn.net/fangjian1204/article/details/53055219
numpy是针对矩阵或者多维数组进行运算的，而在多维数组中，对数据的操作有太多的可能
通过不同的axis，numpy会沿着不同的方向进行操作：如果不设置，那么对所有的元素操作；如果axis=0，则沿着纵轴进行操作；axis=1，则沿着横轴进行操作。但这只是简单的二位数组，如果是多维的呢？可以总结为一句话：设axis=i，则numpy沿着第i个下标变化的方向进行操作。
numpy array aixs的理解 http://www.knowsky.com/1042890.html
>>> import numpy as np
>>> a = np.array([[1,2],[10,20]])
>>> a
array([[1, 2], [10, 20]])
试试看当axis=0的时候平均值的输出：
>>> a.mean(axis=0)
array([ 5.5, 11. ])
当aixs=1的时候平均值的输出：
>>> a.mean(axis=1)
array([ 1.5, 15. ])
看似规律就是axis=0时是按照列来求平均而当axis=1时是按照行来求平均值的。 但是这种方法很难应用到高维的array中去：
>>> b = np.array([[[1,2,3],[4,5,6],[7,8,9]]])
>>> b #array([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])
>>> b.shape (1, 3, 3)
>>> b.mean(axis=0) #array([[ 1., 2., 3.], [ 4., 5., 6.], [ 7., 8., 9.]])
>>> b.mean(axis=1) #array([[ 4., 5., 6.]])
可以看出当数组的形状为（1，3，3） axis=1时并不是按照行来求平均值的， 而且axis=0时的结果就是形状为（3，3） 数值就是它本身的数组。 以上我们就可以总结出：
axis的数值是和数组的形状有关的。 如果axis=0， 则就按照最外面的那层array计算平均值； 如果axis=1， 则就按倒数第二层的array计算平均值， 以此类推。 那么我们就可以推导：既然上面的b数组是三维的形状（1，3，3） 那么就有axis=2，而且结果就是最里面那3行每行的平均值：
>>> b.mean(axis=2) #array([[ 2., 5., 8.]])
但是由于b只有三维（python从0开始index形状）， 当我们用axis=3时，就会有错误：
IndexError: tuple index out of range
numpy.r_用法
Translates slice objects to concatenation along the first axis.
This is a simple way to build up arrays quickly. There are two use cases.
If the index expression contains comma separated arrays, then stack them along their first axis.
If the index expression contains slice notation or scalars then create a 1-D array with a range indicated by the slice notation.
numpy.c_用法
Translates slice objects to concatenation along the second axis.
Python Numpy模块函数np.c_和np.r_学习使用
https://blog.csdn.net/together_cz/article/details/79548217
np.r_是按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等，类似于pandas中的concat()
np.c_是按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等，类似于pandas中的merge()
原文：Numpy将数组保存至txt文档中
1.如何将array保存到txt文件中？2.如何将存到txt文件中的数据读出为ndarray类型？
1:numpy.savetxt(fname,X):第一个参数为文件名，第二个参数为需要存的数组（一维或者二维）。
2.numpy.loadtxt(fname)：将数据读出为array类型。
若想将多个数组保存到一个文件中，可用方法numpy.savez()
原文：Python读取txt文件并保存为数组
numpy.loadtxt
numpy.genfromtxt
原文：Python将数组（矩阵）存成csv文件，将csv文件读取为数组或矩阵
Python处理csv文件时经常会用到讲csv文件整体读取为一个数组或者矩阵的情况，借助numpy包，可以使用如下代码简洁高效低实现：
import numpy as np
my_matrix = np.loadtxt(open("c:\\1.csv","rb"),delimiter=",",skiprows=0)
将数组或者矩阵存储为csv文件可以使用如下代码实现：
np.savetxt('new.csv', my_matrix, delimiter =',')
Python 基础——range() 与 np.arange()
https://blog.csdn.net/lanchunhui/article/details/49493633
range()返回的是range object，而np.nrange()返回的是numpy.ndarray()
range仅可用于迭代，而np.nrange作用远不止于此，它是一个序列，可被当做向量使用。
range()不支持步长为小数，np.arange()支持步长为小数
两者都有三个参数，以第一个参数为起点，第三个参数为步长，截止到第二个参数之前的不包括第二个参数的数据序列
某种意义上，和STL中由迭代器组成的区间是一样的，即左闭右开的区间。[first, last)或者不加严谨地写作[first:step:last)
numpy.reshape用法
newshape : int or tuple of ints
The new shape should be compatible with the original shape. If an integer, then the result will be a 1-D array of that length. One shape dimension can be -1. In this case, the value is inferred from the length of the array and remaining dimensions.
Python Numpy中reshape函数参数-1的含义
https://blog.csdn.net/weixin_39449570/article/details/78619196
新数组的shape属性应该要与原来数组的一致，即新数组元素数量与原数组元素数量要相等。一个参数为-1时，那么reshape函数会根据另一个参数的维度计算出数组的另外一个shape属性值。例如：
>>> z = np.array([[1, 2, 3, 4],[5, 6, 7, 8],[9, 10, 11, 12],[13, 14, 15, 16]])
>>> print(z.reshape(2,-1))
[[1 2 3 4 5 6 7 8]
[ 9 10 11 12 13 14 15 16]]
inplace:bool,default False
if True,do operation inplace and return None
numpy.where(condition[, x, y])
Return elements, either from x or y, depending on condition.
If only condition is given, return condition.nonzero().
np.where 函数是三元表达式 x if condition else y的矢量化版本，当符合条件时是x，不符合是y，常用于根据一个数组产生另一个新的数组。假设有一个随机数生成的矩阵，希望将所有正值替换为2，负值替换为-2
arr = np.random.randn(4,4)
arr
np.where(arr>0,2,-2)
numpy.random.permutation
Parameters: x : int or array_like If x is an integer, randomly permute np.arange(x). If x is an array, make a copy and shuffle the elements randomly.
Returns: out : ndarray Permuted sequence or array range.
Randomly permute a sequence, or return a permuted range.
If x is a multi-dimensional array, it is only shuffled along its first index.
>>> np.random.permutation(10)
array([1, 7, 4, 3, 0, 9, 2, 5, 8, 6])
>>> np.random.permutation([1,4,9,12,15])
array([15, 1, 9, 4, 12])
shuffle与permutation的区别
函数shuffle与permutation都是对原来的数组进行重新洗牌（即随机打乱原来的元素顺序）；区别在于shuffle直接在原来的数组上进行操作，改变原来数组的顺序，无返回值。而permutation不直接在原来的数组上进行操作，而是返回一个新的打乱顺序的数组，并不改变原来的数组。
seed() 方法改变随机数生成器的种子
以下是seed() 方法的语法:
import random
random.seed ( [x] )
Python生成随机数
给定范围内整数：
np.random.randint(0,10) Return random integers from low (inclusive) to high (exclusive)
生成一个0到1的随机浮点数：0<=n<1.0
random.random #random模块
生成指定范围内随机实数
np.random.uniform(9,10)
随机选一个数：
np.random.randrange(9,100,10)
np.random.choice([5,6,7,8,9])
从一个字符串里面，随机选取一个字符：
np.random.choice("从一个字符串里面，随机选取一个字符！")
numpy.random.randn #Return a sample (or samples) from the “standard normal” distribution.从标准正态分布中返回一个或多个样本值
zip( ) 函数 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。
zip 语法：
zip([iterable, ...])
参数说明：
iterabl -- 一个或多个迭代器
以下实例展示了 zip 的使用方法：
>>>a =[1,2,3]
>>> b =[4,5,6]
>>> c =[4,5,6,7,8]
>>> zipped =zip(a,b) # 打包为元组的列表 [(1, 4), (2, 5), (3, 6)]
>>> zip(a,c) # 元素个数与最短的列表一致 [(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped) # 与 zip 相反，可理解为解压，返回二维矩阵式 [(1, 2, 3), (4, 5, 6)]
numpy.linspace（）函数
numpy.linspace(start, stop, num=50, endpoint=True,retstep=False, dtype=None)
该函数返回一组具有相同间隔的数据/采样值，数据的间隔通过计算获得
参数：
- tart：序列的起始值
- stop：序列的终止值，除非endpoint被设置为False。当endpoint为True时，数据的间隔：(stop-start)/num。当endpoint为False时，数据的间隔：(stop-start)/(num+1)。
- num：采样的数目，默认值为50
- endpoint：为真则stop为最后一个采样值，默认为真。
- retstep：为真则返回(samples,step)，step为不同采样值的间距
- dtype：输出序列的类型。
返回：
- samples：n维的数组
- step：采样值的间距
例子：
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
在指定的间隔内返回均匀间隔的数字。
返回num均匀分布的样本，在[start, stop]。这个区间的端点可以任意的被排除在外。
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
Return evenly spaced numbers over a specified interval.
Returnsnumevenly spaced samples,calculated over the interval [start,stop].
The endpoint of the interval can optionally be excluded.
# 线性代数
# numpy.linalg
模块包含线性代数的函数。使用这个模块，可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等。
import numpy as np
# 1. 计算逆矩阵
#创建矩阵
A = np.mat("0 1 2;1 0 3;4 -3 8")
print (A)
#[[ 0 1 2]
# [ 1 0 3]
# [ 4 -3 8]]
# 使用inv函数计算逆矩阵
inv = np.linalg.inv(A)
print (inv)
#[[-4.5 7. -1.5]
# [-2. 4. -1. ]
# [ 1.5 -2. 0.5]]
# 检查原矩阵和求得的逆矩阵相乘的结果为单位矩阵
print (A * inv)
#[[ 1. 0. 0.]
# [ 0. 1. 0.]
# [ 0. 0. 1.]]
# 注：矩阵必须是方阵且可逆，否则会抛出LinAlgError异常。
# 2.求解线性方程组
# numpy.linalg
中的函数solve可以求解形如 Ax = b 的线性方程组，其中 A 为矩阵，b 为一维或二维的数组，x 是未知变量
import numpy as np
#创建矩阵和数组
B = np.mat("1 -2 1;0 2 -8;-4 5 9")
b = np.array([0,8,-9])
# 调用solve函数求解线性方程
x = np.linalg.solve(B,b)
print (x)
#[ 29. 16. 3.]
# 使用dot函数检查求得的解是否正确
print (np.dot(B , x))
# [[ 0. 8. -9.]]
# 3.特征值和特征向量
# 特征值（eigenvalue）即方程 Ax = ax 的根，是一个标量。其中，A 是一个二维矩阵，x 是一个一维向量。特征向量（eigenvector）是关于特征值的向量
# numpy.linalg
模块中，eigvals函数可以计算矩阵的特征值，而eig函数可以返回一个包含特征值和对应的特征向量的元组
import numpy as np
# 创建一个矩阵
C = np.mat("3 -2;1 0")
# 调用eigvals函数求解特征值
c0 = np.linalg.eigvals(C)
print (c0)
# [ 2. 1.]
# 使用eig函数求解特征值和特征向量 (该函数将返回一个元组，按列排放着特征值和对应的特征向量，其中第一列为特征值，第二列为特征向量)
c1,c2 = np.linalg.eig(C)
print (c1)
# [ 2. 1.]
print (c2)
#[[ 0.89442719 0.70710678]
# [ 0.4472136 0.70710678]]
# 使用dot函数验证求得的解是否正确
for i in range(len(c1)):
print ("left:",np.dot(C,c2[:,i]))
print ("right:",c1[i] * c2[:,i])
#left: [[ 1.78885438]
# [ 0.89442719]]
#right: [[ 1.78885438]
# [ 0.89442719]]
#left: [[ 0.70710678]
# [ 0.70710678]]
#right: [[ 0.70710678]
# [ 0.70710678]]
# 4.奇异值分解
# SVD（Singular Value Decomposition，奇异值分解）是一种因子分解运算，将一个矩阵分解为3个矩阵的乘积
# numpy.linalg 模块中的svd函数可以对矩阵进行奇异值分解。该函数返回3个矩阵——U、Sigma和V，其中U和V是正交矩阵，Sigma包含输入矩阵的奇异值。
import numpy as np
# 分解矩阵
D = np.mat("4 11 14;8 7 -2")
# 使用svd函数分解矩阵
U,Sigma,V = np.linalg.svd(D,full_matrices=False)
print ("U:",U)
#U: [[-0.9486833 -0.31622777]
# [-0.31622777 0.9486833 ]]
print ("Sigma:",Sigma)
#Sigma: [ 18.97366596 9.48683298]
print ("V",V)
#V [[-0.33333333 -0.66666667 -0.66666667]
# [ 0.66666667 0.33333333 -0.66666667]]
# 结果包含等式中左右两端的两个正交矩阵U和V，以及中间的奇异值矩阵Sigma
# 使用diag函数生成完整的奇异值矩阵。将分解出的3个矩阵相乘
print (U * np.diag(Sigma) * V)
#[[ 4. 11. 14.]
# [ 8. 7. -2.]]
# 5. 广义逆矩阵
# 使用numpy.linalg模块中的pinv函数进行求解,
# 注：inv函数只接受方阵作为输入矩阵，而pinv函数则没有这个限制
import numpy as np
# 创建一个矩阵
E = np.mat("4 11 14;8 7 -2")
# 使用pinv函数计算广义逆矩阵
pseudoinv = np.linalg.pinv(E)
print (pseudoinv)
#[[-0.00555556 0.07222222]
# [ 0.02222222 0.04444444]
# [ 0.05555556 -0.05555556]]
# 将原矩阵和得到的广义逆矩阵相乘
print (E * pseudoinv)
#[[ 1.00000000e+00 -5.55111512e-16]
# [ 0.00000000e+00 1.00000000e+00]]
# 6. 行列式
# numpy.linalg
模块中的det函数可以计算矩阵的行列式
import numpy as np
# 计算矩阵的行列式
F = np.mat("3 4;5 6")
# 使用det函数计算行列式
print (np.linalg.det(F))
# -2.0
python里x=randn mat=x.T.dot 是求什么
x=randn这个写法是不对的。
randn是numpy里的一个生成随机array的函数。
比如说要生成一个三行两列的随机array，可以这样写：
import numpy
x= numpy.random.randn(3,2)
像这样：
后面这个mat=x.T.dot(...)是先求这个3*3矩阵的转置（.T），再求与点积(.dot)
点积就是矩阵各个对应元素相乘, 这个时候要求两个矩阵必须同样大小。
其实可以分步来的，就知道做了什么运算了。
像这样：
dot(2)是点乘常数就不说了，
那个x.T.dot([1,2,3])就是x.T的
1*1+2*2+3*3=14
2*1+3*2+4*3=20
懂了木有 =。=
ndimage.convolve() 卷积
scipy模块的ndimage是一个处理多维图像的函数库，其中包括图像滤波器、傅里叶变换、图像的旋转拉伸以及测量和形态学处理等。
Python bytearray() 函数
描述
bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
语法
bytearray()方法语法：
参数
- 如果 source 为整数，则返回一个长度为 source 的初始化数组；
- 如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
- 如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
- 如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
- 如果没有输入任何参数，默认就是初始化数组为0个元素。
返回值
返回新字节数组。
实例
以下实例展示了 bytearray() 的使用方法：
>>>bytearray() bytearray(b'') >>> bytearray([1,2,3]) bytearray(b'\x01\x02\x03') >>> bytearray('runoob', 'utf-8') bytearray(b'runoob') >>>
\x对应的是UTF-8编码的数据，通过转化规则可以转换为Unicode编码，就能得到对应的汉字，转换规则很简单，先将\x去掉，转换为数字，然后进行对应的位移操作即可，需要注意的是先要判断utf-8的位数
cv2.waitKey(0)：
The function waitKey waits for a key event infinitely (when delay≤0 ) or for delay
milliseconds, when it is positive. Since the OS has a minimum time between
switching threads, the function will not wait exactly delay ms, it will wait at
least delay ms, depending on what else is running on your computer at that
time. It returns the code of the pressed key or -1 if no key was pressed before
the specified time had elapsed.
numpy.random.uniform介绍：
1.函数原型： numpy.random.uniform(low,high,size)功能：从一个均匀分布[low,high)中随机采样，注意定义域是左闭右开，即包含low，不包含high.参数介绍:
low: 采样下界，float类型，默认值为0；
high: 采样上界，float类型，默认值为1；
size: 输出样本数目，为int或元组(tuple)类型，例如，size=(m,n,k), 则输出m*n*k个样本，缺省时输出1个值。返回值：ndarray类型，其形状和参数size中描述一致。
eval()是程序语言中的函数，功能是获取返回值，不同语言大同小异，函数原型是返回值 = eval( codeString )，如果eval函数在执行时遇到错误，则抛出异常给调用者。
Python List list()方法
描述
list() 方法用于将元组转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
x_vals = np.random.normal(1, 0.1, 100) 生成100个服从均值为1，方差为0.1的正态分布的元素也就是从均值为1，方差为0.1的正态分布中输出100个元素。
np.array 生成一个数组
np.random.choice Generates
a random sample from a given 1-D array 抽样
a1 = np.random.choice(a=5, size=3, replace=False, p=None)
从a 中以概率P，随机选择3个, p没有指定的时候相当于是一致的分布replacement 代表的意思是抽样之后还放不放回去
np.concatenate #Join a sequence of arrays along an existingaxis. The arrays must have same shape
numpy.linspace
linspace的功能最初是从MATLAB中学来的，用此来创建等差数列。近期用Python的时候发现也有这个功能，提供相应功能的是numpy。在指定的间隔内返回均匀间隔的数字。
numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
Return evenly spaced numbers over a specified interval.
Returnsnumevenly spaced samples,calculated over the interval [start,stop].
The endpoint of the interval can optionally be excluded.
numpy.matrix(data,dtype,copy):返回一个矩阵，其中data为ndarray对象或者字符形式；dtype:为data的type；copy:为bool类型。
矩阵对象的属性：
matrix.T transpose：返回矩阵的转置矩阵
matrix.H hermitian (conjugate) transpose：返回复数矩阵的共轭元素矩阵
matrix.I inverse：返回矩阵的逆矩阵
matrix.A base array：返回矩阵基于的数组
numpy.mat
Interpret the input as a matrix.
Unlike matrix, asmatrix does not make a copy if the input is already a matrix
or an ndarray. Equivalent to matrix(data, copy=False).
numpy.matrix
Returns a matrix from an array-like object, orfrom a string of data. A matrix is a specialized 2-D array that retains its 2-Dnature through operations. It has certain special operators, such as * (matrixmultiplication) and ** (matrix power).
numpy.ndarray
An array object represents a multidimensional,homogeneous array of fixed-size items. An associated data-type object describesthe format of each element in the array (its byte-order, how many bytes itoccupies in memory, whether it is an integer, a floating point number, orsomething else, etc.)
numpy中的ndarray与array的区别、不同
翻译自stackoverflow上的回答 https://stackoverflow.com/questions/15879315/what-is-the-difference-between-ndarray-and-array-in-numpy
问：What is the difference between ndarray and array in Numpy? Andwhere can I find the implementations in the numpy source code?
（Numpy中ndarray和array的区别是什么？我在哪儿能够找到numpy中相应的实现？）
答：Well, np.array is just a convenience function to create anndarray, it is not a class itself.
（嗯，np.array只是一个便捷的函数，用来创建一个ndarray，它本身不是一个类）
Youcan also create an array using np.ndarray, but it is not the recommended way.From the docstring of np.ndarray:
（你也能够用np.ndarray来创建，但这不是推荐的方式。来自np.ndarray的文档：）
Arrays should be constructed using array, zeros or empty … Theparameters given here refer to a low-level method (ndarray(…)) forinstantiating an array.
（Arrays 应该能用array,zeros或empty来构造…这里的参数和一个实例化array的低层方法与有关）
Mostof the meat of the implementation is in C code, here in multiarray, but you canstart looking at the ndarray interfaces here:
https://github.com/numpy/numpy/blob/master/numpy/core/numeric.py
下面让我们来看看ndarray数组对象是如何在内存中储存的。
dtype对象则知道如何将元素的二进制数据转换为可用的值。如上图每32位表示一个有用数据
dim count表示数组维数，上图为2维数组
dimmension 3×3给出数组的shape
strides中保存的是当每个轴的下标增加1时，数据存储区中的指针所增加的字节数。例如图中的strides为12,4，即第0轴的下标增加1时，数据的地址增加12个字节：即a[1,0]的地址比a[0,0]的地址要高12个字节，正好是3个单精度浮点数的总字节数；第1轴下标增加1时，数据的地址增加4个字节，正好是单精度浮点数的字节数。
注意numpy里有两种数据类型，ndarray和matrix，一般用ndarray，要用到矩阵的乘除法时再用matrix。
numpy.nan_to_num
Replace nan with zero and inf with large finite numbers.
If x is inexact, NaN is replaced by zero,and infinity and -infinity replaced by the respectively largest and most negative finite floating point values representable by x.dtype.
For complex dtypes, the above is applied to each of the real and imaginary components of x separately.
If x is not inexact, then no replacements are made.
np.mean()函数功能：求取均值
经常操作的参数为axis，以m *n矩阵举例：
axis 不设置值，对 m*n个数求均值，返回一个实数
axis = 0：压缩行，对各列求均值，返回1* n 矩阵
axis =1 ：压缩列，对各行求均值，返回m *1 矩阵
Pythonsplit()通过指定分隔符对字符串进行切片，如果参数 num 有指定值，则仅分隔 num 个子字符串
split() 方法语法：str.split(str="", num=string.count(str)).
参数
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。
返回值
返回分割后的字符串列表。
实例
以下实例展示了split()函数的使用方法：
#!/usr/bin/python
str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );
print str.split(' ', 1 );
以上实例输出结果如下：
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']
np.nan_to_num(x, copy=True)
replace nan with 0 and inf with large finite numbers
使用0代替数组x中的nan元素，使用有限的数字代替inf元素
>>> x = np.array([np.inf, -np.inf, np.nan, -128, 128])
>>> np.nan_to_num(x)
array([ 1.79769313e+308, -1.79769313e+308, 0.00000000e+000,
-1.28000000e+002, 1.28000000e+002])
>>> y = np.array([complex(np.inf, np.nan), np.nan, complex(np.nan, np.inf)])
>>> np.nan_to_num(y)
array([ 1.79769313e+308 +0.00000000e+000j,
0.00000000e+000 +0.00000000e+000j,
0.00000000e+000 +1.79769313e+308j])