| import numpy as np | 导入numpy库 |
| a1=np.array([1,2,3,4,5,6]) | 参数为列表的array函数实现方式 |
| a2=np.array([1,2,3,4,5,6]) | 参数为元组的array函数实现方式 |
| b1=np.array([[100,98,99],[88,78,95]]) | 参数为列表的array函数实现方式 二维数组 |
| dem1=np.array([(0,0,0),(1,1,1),(2,2,2)]) | 参数为列表嵌套元组的array函数实现二维数组 |
| c1=np.array([ [[100,98,99],[88,79,95]], [[98,97,99],[89,91,68]] ]) | 参数为列表的array函数实现三维数组 |
| r1=np.array([‘b’,‘中国’,‘136’]) | 字符串数组的建立 |
| d1=np.array([True,False,0,1]) | 布尔数组建立 |
| np.alltrue(d1) | 测试数组d1是否全为True，返回True或者False |
| e1=np.array([10.5,6.22,7.28]) | 浮点数组建立 |
| e1.dtype | 显示数组类型 |
| f1=np.array([100+2j,8J,2.1+3j]) | 复数数组的建立，j和J都可以 |
| g1=np.array([‘OK?’,10,'岁‘，0.3,False]) | numpy数组要求统一类型，否则自动转字符串型 |
| arrange(start,stop,step,dtype=Node) | 以指定步长累加生成指定范围有序元素的数组 |
| h1=np.arange(5) | 默认start=0,默认步长=1,生成[0 1 2 3 4]，不包含最后一个 |
| h2=np.arange(0,5) | [0 1 2 3 4] |
| h3=np.arange(0,5,0.5) | [0. 0.5 1. 1.5 2. 2.5 3. 3.5 4. 4.5] |
| h4=np.arange(5,0,-1) | [5 4 3 2 1] |
| linespace(start,stop,num=num_points,endpoint=True,retstep=False,dtype=None,axis=0) | 在指定的范围内返回均匀步长的样本数组 |
| i0=np.linespace(0,1,2) | [0. 1.],2个等分点每个差1/1 |
| i1=np.linespace(0,4,4) | PPT看效果，每个差4/3 |
| i2=np.linespace(0,4,10) | PPT看效果，每个差4/9 |
| a=np.linespace(0.02,2,10,endpoint=False) | endpoint=False不包含最后一点，每个差1.98/10 |
| a=np.linespace(0.02,2,10,retstep=True) | 每个差1.98/9,返回步长以及序列数组，作为元组输出，看PPT |
| r=np.linespace(p,q,3,axis=0) | p=np.array[[1,2],[3,4]],q=np.array([[5,6],[7,8]]),想一下结果 |
| s=np.linespace(p,q,3,axis=1) | 想一下结果 |
| zeros(shape,dtype=float,order=‘C’) | 产生值为0的数组，默认浮点型 |
| z1=np.zeros(5) | [0. 0. 0. 0. 0.] |
| ones(shape,dtype=None,order=‘C’) | 产生值为1的数组，dtype=None,但还是浮点 |
| o1=np.ones((2,3)) | 2行3列全1数组，浮点 |
| empty(shape,dtype=float,order=‘C’) | 产生不确定值的数组 |
| e10=np.empty(5) | 建立5个值不确定的一维数组 |
| logspace(start,stop,num=,endpoint=True,base=10.0,dtype=None,axis=0) | 返回对数刻度上均匀间隔的数字,默认base=10.0 |
| np.logspace(2.0,3.0,num=4) | 4个值分别为lgX=2,lgX=2.3333……,lgX=2.666……,lgX=3 |
| full(shape.fill_value,dtype=None,order=‘C’) | 返回指定值的数组 |
| f10=np.full(5,10) | 建立5个填充值为10的一维数组 |
| f11=np.full((3,3),8) | 建立3x3,填充值为8的二维数组 |
| eye(N,M=None,k=0,dtype=<clase’float’>) | 返回对角线为1,其他都为0的二维度数组 |
| np.eye(4) | 建立4x4的主对角线为1的数组 |
| repeat(a,repeats,axis=None) | 建立每个元素重复N次的数组，注意是元素不是整个数组 |
| np.repeat([0,1,0],5) | [0,0,0,0,0,1,1,1,1,1,0,0,0,0,0] |
| ar.ndim | 数组的维数，前面不用加np.也不用() |
| ar.shape | 数组的形状大小 |
| ar.size | 数组元素的个数 |
| ar.dtype | 数组元素类型 |
| ar.itemsize | 返回数组元素字节大小 |
| t2=t1.reshape(3,3) | .reshape()方法改变数组形状，t1改成3x3二维数组 |
| m1=np.ones(9).all() | .all()方法判断是否全为非0,是则返回True,否则返回False |
| np.array([[1,0,2],[1,2,3]]).all(axis=1) | 从行方向判断每行的值是否都非0,这个例子返回array([False,True]) |
| t1.any(axis=0) | .any()方法判断数组是否有非0值，有就返回True,否则返回False,这个例子是列方向判断 |
| t1.any(axis=1) | 行方向判断是否有非零值 |
| ar2=ar1,id(ar1),id(ar2) | 直接复制，ar1和ar2的id一样，如果改ar2,ar1也会变 |
| ar0=ar1.copy() | ar0内容和ar1一样，id不一样 |
| a1.astype(float) | .astype()方法改变数组元素类型，把a1改成浮点型数组 |
| np.vstack((c1,c2)) | 垂直对接c1,c2两数组,c1c2要用()或者[]包起来，是作为一个参数！ |
| np.hstack((c1,c2)) | 水平对接c1,c2两数组 |
| r6=np.hsplit(r5,2) | 把数组r5按第一维度等分，垂直切割为2个数组，注意split拼写末尾没有e |
| r6=np.vsplit(r5,2) | 把数组r5按第一维度等分，水平切割为2个数组 |
| n1[9] | 一维数组，读取下标为9的元素 |
| n1[-1] | 一维数组，读取从右往左第一个元素 |
| n1[0]=10 | 一维数组，指定下标修改值 |
| n2=n1.reshape(2,5) | 把一维数组n1改成2x5的二维数组 |
| n2[1,0] | 读取第二行第一列数据 |
| n2[1,1]=-1 | 第二行第二列数据修改为-1 |
| n3=np.arange(12).reshape(2,2,3) | 2层x2行x3列的三维数组 |
| n3[1,0,2]=-1 | 第三维的第二2层，二维的第1行，一维的第3列的值改为-1 |
| n3[1,…]等同于n3[1,]，n3[1], | 当确定不了维度时可以通过下标右边…(:)省略号或者直接省略下标数来读取数组,例子把第2层的都给读取了 |
| n3[1,…,2] | 不能用n3[1,2]会报错，读取第2层，第3列所有数据 |
| n4[1][1] | 等价n4[1,1]但是效率很低 |
| s1[1:4] | 取一维数组下标1到3的元素 |
| s1[:5] | 取一维数组下标0到4的元素 |
| s1[5:] | 取一维数组下标5到末尾的元素 |
| s1[:-1] | 去一维数组下标0到倒数第二个元素，s1[-1]是倒数第一个，切片左闭右开 |
| s1[::2] | 步长为2 |
| s2[1:3] | 二维数组切片，取第2，3行子数组值 |
| s2[:2] | 取1,2行子数组 |
| s2[: , 2] | 取所有行，第三列子数组 |
| s2[: , :2] | 取所有行，第1，2列子数组 |
| s2[1,2:] | 取第2行，第三列到最后列子数组 |
| s3[1,1,:] | 三维数组，取第2层，第2行所有列子数组 |
| s3[0,:,:2] | 三维数组，取第1层，所有行，第1、2列子数组 |
| fi1[[1,2,4,5]] | 一维数组，整数数组索引，利用整数数组的所有元素下标作为下标值进行索引 |
| fi2[[1,2,3]] | 二维数组，一维整数数组索引，指定第2,3,4行。如果索引数组也是二维的那就直接对应到下标，看PPT |
| s4[b1] | b1为布尔数组，可以用布尔数组做索引，看PPT |
| for g1 in d2: print(g1) | 数组g1=[0,1,2]作为元素集合，迭代输出d2元素 |
| one+two | 数组和数组运算，基本都是每个元素和元素对应，也可以直接和标量做运算，PPT看一下即可 |
| np.exp([1,2,3]) | 底数为e,列表为指数 |
| np.exp(1) | 标量作为指数 |
| np.exp(n) | n=np.arange(3),数组作为指数 |
| np.log(np.e) | 求以e为底，e为真数的指数 |
| np.log(c11) | 列表作为真数 |
| np.log10(10) | 10为底，10为真数 |
| np.log2(4) | 2为底，4为真数 |
| np.sin(x)，np.cos(x)，np.tan(x),np.arcsin(y1),np.sinh(xx),np.cosh(xx),np.tanh(xx) | 各种三角函数 |
| np.degrees(radian) | 弧度转角度,等效np.rad2deg(radian) |
| np.radians(degrees)/np.pi | 角度转弧度，等效deg2rad() |
| np.hypot(3,4) | 直角三角形求斜边 |
| np.random.rand() | 产生[0,1)范围浮点数 |
| np.random.rand(2,6) | 二维数组参数下，产生二维数组的随机数[0,1) |
| rn=np.random.randn(10) | 产生10个标准正态分布的随机数 |
| random.randin(low,high=None,size=None,dtype=‘1’) | 产生指定范围的整形随机数，注意可以不用的参数 |
| np.random.randint(4,size=8) | 产生[0,3]的8个随机整数 |
| rn=np.random.randint(0,4,size=(2,2)) | 产生[0,3]的4个随机整数构成2x2的二维数组 |
| np.random.normal(loc= , scale= , size= ) | normal在这里是指正态分布，该方法通过loc和scale指定正态分布的均值和方差，返回一个数组，内容是从这个分布中随机取得的值，而size就是指定这个数组的大小 |
| np.random.uniform(low=0.0,high=1.0,size=None) | 在[low,high)范围内产生均匀分布的随机数 |
| np.random.poisson(lam=1.0,size=None) | lam期望间隔，lam>=0.一列期望，间隔必须可以在请求的大小上播放（不懂什么玩意） |
| np.random.permutation(10) | 产生[0,9]的随机排序 |
| np.random.permutation(x3) | 指定列表对象随机排序 |
| x1=np.random.shuffle(x) | 直接对x数组乱序处理 |
| np.random.choice(a,3) | 从a里随机取3个数，可以重复 |
| np.random.choice(a,3,replace=False) | 从a里随机抽取3个数，不可以重复 |
| np.random.choice(a,3,replace=False,p=[0.5,0.3,0.1,0.1,0]) | p对每个元素设置权重，总权重为1 |
| np.unique(cx) | cx去重 |
| np.intersect1d(x1,y1) | 求两个数组的交集，注意是1d不是ld |
| np.union1d(x1,y1) | 求两个数组的并集 |
| np.setdiff1d(x1,y1) | 求两个数组的差集 |
| np.setxor1d(x1,y1) | 求两个数组异或集，去掉两个数组都有的元素 |
| np.in1d(x1,y1) | 判断x1的元素是否在y1当中，返回长度和x1相同的布尔数组 |
| np.sum(a1) | 求a1所有元素的和，可以用a1.sum()代替 |
| np.nansum(a2) | 求和的时候忽略a2当中的NaN |
| np.prod(a1) | 求a1所有元素的积 |
| np.prod(a1,axis=0) | 以列为单位求积 |
| a1.max(axis=1) | 以行为单位求max |
| np.min(a1,axis=1) | 以行为单位求a1的min |
| np.cumsum(a1,axis=1) | 以行为单位，求累积和 |
| np.mean(a1,axis=1) | 以行为单位，求元素的平均值 |
| np.medina(a3) | 求a3的平均值 |
| v1=np.var([3,2,1]) | 求3,2,1的方差，可以用a1.var()代替 |
| np.std([3,2,1]) | 求3,2,1的标准差，可以用a1.std()代替 |
| np.ptp(a1,axis=0) | 以列为单位，统计列轴最大和最小差 |
| np.percentile(a1,50,axis=0) | 每个列方向取在50%位置的数 |
| np.diff(a1) | diff(a,n=1,axis=-1),默认n=1,求a1一阶差分 |
| np.ediff1d(d1) | 数组连续元素之间的差异 |
| np.ediff1d(d1,to_begin=[0,0],to_end=10) | to_begin返回差异前面追加to_begin,末尾追加to_end，看PPT |
| np.gradient(g1) | 对一维数组元素进行梯度计算 |
| np.gradient(g1) | 对二维数组的顺序元素进行梯度计算 |
| np.trapz([1,2,3],[4,5,6],axis=1) | 以行为单位进行积分 |
| np.sort(a1,axis=1) | 按行为单位进行排序（升序） |
| a1.sort(axis=0) | 用数组方法sort()排序，改变原有数组的排序 |
| np.place(p1,p1>10,[0,1]) | 对于数组里元素>10的元素一次用0,1代替 |
| np.put(p2,[3,4,5],[0,0]) | 替换顺序下标3,4,5的依次为[0,0] |
| np.put_along_axis(p3,np.array([[1],[1],[1]],0,axis=1)) | 通过指定axis和花式索引将值放入目标数组 |
| np.fiil_diagonal(z1,5) | 二维数组z1主对角线填充5 |
| np.delete(d,np.s_[0:2],axis=1) | 在行方向上，删除d数组的1,2列，如果axis=None,删除后的数组组成一维数组 |
| np.delete(d,np.s_[0:2],axis=0) | 在列方向上，删除d数组的1,2行 |
| np.insert(b1,3,[2,2,2],axis=1) | 在行方向上，第4列处插入新列值 |
| np.insert(b1,3,[2,2,2],axis=0) | 在行方向上，第4行处插入新行值 |
| np.append(z1,[[1,1,1],[2,2,2],[3,3,3]],axis=1) | 在行方向末尾加新值 |
| np.append(z1,[[1,1,1],[2,2,2],[3,3,3]],axis=0) | 在列方向末尾加新值，要求维数保持一直 |
| np.trim_zeros([0,0,0,1,2,3,0,0]) | 去除前导0和尾随0,返回[1,2,3] |
| np.around(f1) | around(a,decimals=0)四舍五入函数，decimals为要保留的小数位数 |
| np.rint(f1) | 简单取最接近的整数,四舍六入，五取偶 |
| np.fix(f1) | 向0方向舍入到最接近的整数 |
| np.floor(f1) | 取浮点数的整数部分舍去小数 |
| np.ceil(f1) | 返回输入元素的上限整数 |
| np.where(a1<=5,a1,10) | where(condition,[x,y])如果conditon条件为True则迭代返回符合条件的x数组内的元素，否则y数组。a1数组元素小于等于5的标量，大于5的都设置为10 |
| np.abs(a1) | 取绝对值 |
404
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
