# -*- coding: utf-8 -*-
"""
Created on Fri Nov 8 10:17:18 2019
@author: lenovo
"""
import numpy as np
import pandas as pd
print(np.__version__)##打印输出numpy的版本和配置信息
np.show_config()
Z=np.zeros(10)##创建长度为10的零向量
print(Z)
Z=np.zeros((10,10))
print(Z.size * Z.itemsize)##获取数组所占内存大小
np.info(np.add)##用命令行获取numpy add函数的文档说明
Z=np.zeros(10)
Z[4]=1
print(Z)##创建一个长度为10的零向量，并把第五个值赋值为1
Z=np.arange(10,50)
print(Z)##获得一个值域为10到49的向量
Z=np.arange(50)
Z=Z[::-1]
print(Z)##讲一个向量进行翻转
Z=np.arange(9).reshape(3,3)
print(Z)##创建一个3*3的矩阵，值域为0到8
nz=np.nonzero([1,2,0,0,4.0])
print(nz)##找出非零位置的索引
z=np.eye(3)
print(z)##创建一个3*3的单位矩阵
z=np.random.random((3,3,3))
print(z)##创建一个3*3*3的随机矩阵
z=np.random.random((10,10))
zmax,zmin=z.max(),z.min()
print(z.max,z.min)##创建一个10*10的随机数组，并找出数组中最大值与最小值
z=np.random.random(30)
mean=z.mean()
print(mean)##创建一个长度为30的随机数组，并求出平均值
z=np.ones((10,10))
z[1:-1,1:-1]=0
print(z)##创建一个二维数组，边界值为1，内部值为0
z=np.ones((10,10))
z=np.pad(z,pad_width=1,mode='constant',constant_values=0)
print(z)##用0来填充一个数组的边界
z=np.diag([1,2,3,4],k=-1)#k=-1保证了偏移量
print(z)##创建一个5*5的矩阵，设置1,2，3,4在其对角线下面一行
z=np.zeros((8,8),dtype=int)
z[1::2,::2]=1
z[::2,1::2]=1
print(z)##创建一个8*8的国际象棋矩阵黑块为0，白块为1
print(np.unravel_index(100,(6,7,8)))##形状为（6，7,8）数组的形状，第100个元素的索引
z=np.tile(np.array([[1,0],[0,1]]),(4,4))
print(z)##创建一个8*8的棋盘矩阵
z=np.random.random((5,5))
zmax,zmin=z.max(),z.min()
z=(z-zmin)/(zmax-zmin)
print(z)##对5*5的矩阵归一化
color=np.dtype([("r",np.ubyte,1),
("g",np.ubyte,1),
("b",np.ubyte,1),
("a",np.ubyte,1)])
c=np.array((255,255,255,1),dtype=color)
print(c)##创建一个dtype来表示颜色（RGBA）
z=np.dot(np.zeros((5,3)),np.zeros((3,2)))
print(z)##一个5*3矩阵和一个3*2矩阵相乘
z=np.arange(11)
z[(3<=z)&(z<8)]*=-1
print(z)##给定一个一维数组把它从3到8的元素求相反数
print(sum(range(5),-1))##结果为9
z=np.random.uniform(-10,+10,10)
print(np.copysign(np.ceil(np.abs(z)),z))##从零位开始舍入浮点数组
z1=np.random.randint(0,10,10)
z2=np.random.randint(0,10,10)
print(np.intersect1d(z1,z2))##两个数组公共的元素
A=np.ones(3)*1
B=np.ones(3)*1
C=np.ones(3)*1
np.add(A,B,out=B)
np.divide(A,2,out=A)
np.negative(A,out=A)
np.multiply(A,B,out=A)##计算((A+B)*(-A/2))
##用五种方法提取随机数组中的整数部分
z=np.random.uniform(0,10,10)
print(z-z%1)
print(np.floor(z))
print(np.cell(z)-1)
print(z.astype(int))
print(np.trunc(z))
##创建一个5*5的矩阵且每一行的值范围为0~4
z=np.zeros((5,5))
z+=np.arange(5)
print(z)
##用一个生成10个整数的函数来构建数组
def generate():
for x in range(10):
yield x
z=np.fromiter(generate(),dtype=flaot,count=-1)
print(z)
##创建一个大小为10的向量，值域为0到1，不包括0和1
z=np.linspace(0,1,12,endpoint=True)[1:-1]
print(z)
#创建一个大小为10的随机向量，并把它排序
z=np.random.random(10)
z.sort()
print(z)
##对一个小数组求和
z=np.arange(10)
np.add.reduce(z)##np.add.reduce 是numpy.add模块中的一个ufunc（universal function）函数，c语言实现
##如何判断两随机数组相等
A=np.random.randint(0,2,5)
B=np.random.randint(0,2,5)
equal=np.allclose(A,B)
print(equal)
equal=np.array_equal(A,B)
print(equal)
##把数组变为只读
z=np.zeros(5)
z.flags.writeable=False
z[0]=1
##将一个10*2的笛卡尔坐标矩阵转换为极坐标
z=np.random.random((10,2))
x,y=z[:,2],z[:,1]
r=np.sqrt(x**2+y**2)
t=np.arctan2(y,x)
print(r)
print(t)
##创建一个大小为10的随机向量并且将该向量中最大的值替换为0
z=np.random.random(10)
z[z.argmax()]=0
print(z)
##创建一个结构化数组，其中x和y坐标覆盖[0,1]*[1,0]区域
z=np.zeros((5,5),[('x',float),('y').float])
z['x'],z['y']=np.meshgrid(np.linspace(0,1,5),np.linspace(0,1,5))
print(z)
##给定两个数组x和y，构造柯西矩阵
x=np.arange(8)
y=x+0.5
c=1.0/np.subtract.outer(x,y)
print(c)
print(np.linalg.det(c))##计算行列式
##打印每个numpy类型的最大和最小可表示值
for dtype in [np.int8,np.int32,np.int64]:
print(np.iinfo(dtype).min)
print(np.iinfo(dtype).max)
for dtype in [np.float32,np.float64]:
print(np.finfo(dtype).min)
print(np.finfo(dtype).max)
print(np.finfo(dtype).eps)
##打印数组中的所有的值
np.set_printoptions(threshold=np.nan)
z=np.zeros((16,16))
print(z)
##如何在数组中找到与给定标量接近的值
z=np.arange(100)
v=np.random.uniform(0,100)
index=(np.abs(z-v)).argmin()
print(z[index])
##创建表示位置（x,y）和颜色(r,g,b,a)的结构化数组
z=np.zeros(10,[('position',[('x',float,1),('y',float,1)]),('color',[('r',float,1),('g',float,1),('b',float,1)])])
print(z)
##思考形状为（100,2）的随机向量，求出点和点之间的距离
z=np.random.random((100,2))
x,y=np.atleast_2d(z[:0],z[:,1])
d=np.sqrt((x-x.T)**2+(y-y.T)**2)
print(d)
##将float（32）转换成integer（32）位
z=np.arange(10,dtype=np.int32)
z=z.astype(np.float32,copy=False)
print(z)
##读取TXT文件
z=np.genfromtxt("example.txt",delimiter=",")
print(z)
##枚举的等价操作
z=np.arange(9).reshape(3,3)
for index,value in np.ndenumerate(z):
print(index,value)
for index in np.ndindex(z.shape):
print(index,z[index])
##构造一个二维高斯矩阵
x,y=np.meshgrid(np.linspace(-1,1,10),np.linspace(-1,1,10))
d=sqrt(x**2+y**2)
sigma,mu=1.0,0.0
g=np.exp(-((d-mu)**2/(2.0*sigma**2)))
print(g)
##在二位数组的随机位置放置p个元素
n=10
p=3
z=np.zeros((n,n))
np.put(z,np.random.choice(range(n*n),p,replace=False),1)
print(z)
##减去矩阵每一行的平均值
x=np.random.rand(5,10)
y=x-x.mean(axis=1,keepdims=True)
print(y)
##对数组通过第n列进行排序
z=np.random.randint(0,10,(3,3))
print(z)
print(z[z[:,1].argsort()])
#判定一个给定的二维数组存在空列
z=np.random.nuiform(0,3,(3,10))
print((~z.any(axis=0)).any())
##从数组中找出与给定值最接近的值
Z=np.random.uniform(0,1,10)
z=0.5
m=z.flat[np.abs(Z-z).argmin()]
print(m)
##使用迭代器计算（1,3）和（3,1）的和
A=np.arange(3).reshape(3,1)
B=np.arange(3).reshape(1,3)
it=np.nditer([A,B,None])
for x,y,z in it:
z[...]=x+y
print(it.operands[2])
##创建一个具有name属性的数组类
class NameArray(np.ndarray):
def __new__(cls,array,name="no name"):
obj=np.asarray(array).view(cls)
obj.name=name
return obj
def __array_finalize__(self,obj):
if obj is None:
return
self.info=getattr(obj,'name',"no name")
z=NamedArray(np.arange(10),"rang_10")
print(z.name)
##给定一个向量，在第二个向量中每个元素加一
z=np.ones(10)
i=np.random.randint(0,len(z),20)
z+=np.bincount(i,minlength=len(z))
print(z)
np.add.at(z,i,1)
print(z)
##根据索引列表I将向量x的元素累加到数组F
x=[1,2,3,4,5,6]
i=[1,3,9,3,4,1]
f=np.bincount(i,x)
print(f)
##思考（dtype=ubyte）的（w,h,3）图像，计算唯一颜色的值
w,h=16,16
i=np.random.randint(0,2,(h,w,3)).astype(np.ubyte)
f=i[...,0]*256*256+i[...,1]*256+i[...,2]
n=len(np.unique(f))
print(np.unique(i))
##思考如何求一个四维数组最后两个轴的数据和
a=np.random.randint(0,10,(3,4,3,4))
sum=a.sum(axis=(-2,-1))
print(sum)
sum=a.reshape(a.shape[:-2]+(-1,)).sum(axis=-1)
print(sum)
##一维向量D，使用相同大小的向量S来计算D的子集的均值，描述子集索引
d=np.random.uniform(0,1,100)
s=np.random.randint(0,10,100)
d_sums=np.bincount(s,weights=d)
d_counts=np.bincount(s)
d_means=d_sums/d_counts
print(d_means)
print(pd.Series(d).groupby(s).mean())
##获得点积的对角线
a=np.random.uniform(0,1,(5,5))
b=np.random.uniform(0,1,(5,5))
np.diag(np.dot(a,b))
np.sum(a*b.T,axis=1)
np.einsum("ij,ji->i",a,b)
##考虑向量[1,2,3,4,5]，建立一个新的向量，在每个值之间交错有3个连续的零
z=np.array([1,2,3,4,5])
nz=3
z0=np.zeros(len(z)+(len(z)-1)*(nz))
z0[::nz+1]=z
print(z0)
##考虑一个维度（5,5,3）的数组，如何将其与一个（5,5）的数组相乘
a=np.ones((5,5,3))
b=2*np.ones((5,5))
print(a*b[:,:,None])
##对一个数组中任意两行做交换
a=np.arange(25).reshape(5,5)
a[[0,1]]=a[[1,0]]
print(a)
##给定一个二进制的数组c，如何生成一个数组A满足np.bincount(A)==c
c=np.buncount([1,1,2,3,4,4,6])
a=np.repeat(np.arange(len(c)),c)
print(a)
#通过滑动窗口计算一个数组的平均数
def moving_average(a,n=3):
ret=np.cumsum(a,dtype=float)
ret[n:]=ret[n:]-ret[:-n]
return ret[n-1:]/n
z=np.arange(20)
print(moving_average(z,n=3))
##对布尔值取反，改变浮点数的符号
z=np.random.randint(0,2,100)
np.logical_not(z,out=z)
z=np.random.uniform(-1.0,1.0,100)
np.negative(z,out=z)
##思考两组点集p0和p1去描述一组线和一个点p，如何计算点p到每一条线i的距离
def distance(p0,p1,p):
t=p1-p0
l=(t**2).sum(axis=1)
u=-((p0[::0]-p[...,0])*t[:,0]+(p0[:,1]-p[...,1])*t[:,1])/l
u=u.reshape(len(u),1)
d=p0+u*t-p
return np.sqrt((d**2).sum(axis=1))
p0=np.random.uniform(-10,10,(10,2))
p1=np.random.uniform(-10,10,(10,2))
p=np.random.uniform(-10,10,(1,2))
print(distance(p0,p1,p))
##考虑两组点集p0和p1去描述一组线（二维）和一组点集p，如何计算每一个点j(p[j])到每一条线i的距离
p0=np.random.uniform(-10,10,(10,2))
p1=np.random.uniform(-10,10,(10,2))
p=np.random.uniform(-10,10,(10,2))
print(np.array([distance(p0,p1,p_i) for p_i in p]))
##z=[1,2,3,4,5,6,7,8,9,10,11,12,13,14]，如何生成一个数组r=[[1,2,3,4],[2,3,4,5],[3,4,5,6]...[11,12,13,14]]
z=np.arange(1,15,dtype=np.uint32)
r=stride_tricks.as_strided(z,(11,4),(4,4))
print(r)
#计算矩阵的秩
z=np.random.uniform(0,1,(10,10))
u,s,v=np.linalg.svd(z)
rank=np.sum(s>1e-10)
print(rank)
##找出数组中出现频率最高的值
z=np.random.randint(0,10,50)
print(np.bincount(z).argmax())
##从一个10*10的矩阵中提取一个连续的3*3区块
z=np.random.randint(0,5,(10,10))
n=3
i=1+(z.shape[0]-3)
j=1+(z.shape[1]-3)
c=stride_tricks.as_strided(z,shape=(i,j,n,n),strides=z.strides+z.strides)
print(c)
##创建一个z[i,j]==z[j,i]的二维数组子类
class Symetric(np.ndarray):
def __setitem__(self,index,value):
i,j=index
super(Symetric,self).__setitem__((i,j),value)
super(Symetric,self).__setitem__((j,i),value)
def symetric(z):
return np.asarray(z+z.T-np.diag(z.diagonal())).view(Symetric)
s=symetric(np.random.randint(0,10,(5,5)))
s[2,3]=42
print(s)
##考虑p个n*n矩阵和一组形状为（n,1）的向量，计算p个矩阵的乘（n,1）
p,n=10,20
m=np.ones((p,n,n))
v=np.ones((p,n,1))
s=np.tensordot(m,v,axes=[[0,2],[0,1]])
print(s)
##对于一个16*16的数组，如何得到一个4*4区域的和
z=np.ones((16,16))
k=4
s=np.add.reduceat(np.add.reduceat(z,np.arange(0,z.shape[0],k),axis=0),np.arange(0,z.shape[1],k),axis=1)
print(s)
##找到数组的第n大值
z=np.arange(10000)
np.random.shuffle(z)
n=5
print(z[np.argsort(z)[-n:]])##slow
print(z[np.argpartition(-z,n)[:n]])
##给定任意向量，创建笛卡尔积
def cartesian(arrays):
arrays=[np.asarray(a) for a in arrays]
shape=(len(x) for x in arrays)
ix=np.indices(shape,dtype=int)
ix=ix.reshape(len(arrays),-1).T
for n,arr in enumerate(arrays):
ix[:,n]=arrays[n][ix[:,n]]
return ix
print(cartesian(([1,2,3],[4,5],[6,7])))
##从常规数组中创建记录数组
z=np.array([("hello",2.5,3),("world",3.6,2)])
r=np.core.records.fromarrays(z.T,names='col1,col2,col3',formats='s8,f8,i8')
print(r)
##思考一个大向量Z，用三种不同的方法计算它的立方
x=np.random.rand(5e7)
%timeit np.power(x,3)
%timeit x*x*x
%timeit np.einsum('i,i,i->i',x,x,x)
##考虑两个形状分别为（8,3）和(2,2)的数组A和B，如何在数组A中找到满足包含B中元素的行
a=np.random.randint(0,5,(8,3))
b=np.random.randint(0,5,(2,2))
c=(a[...,np.newaxis,np.newaxis]==b)
rows=np.where(c.any((3,1)).all(1))[0]
print(rows)
##思考一个10*3的矩阵，如何分解出有不全相同值的行
z=np.random.randint(0,5,(10,3))
print(z)
e=np.all(z[:,1:]==z[:,:-1],axis=1)
u=z[~e]
print(u)
u=z[z.max(axis=1)!=z.min(axis=1),:]
print(u)
##讲一个整数向量 转换成二进制矩阵
i=np.array([0,1,2,3,15,16,32,64,128])
b=((i.reshape(-1,1)&(2**np.arange(8)))!=0).astype(int)
print(b[:,::-1])
i=np.array([0,1,2,3,15,16,32,64,128],dtype=np.uint8)
print(np.unpackbits(i[:,np.newaxis],axis=1))
##给定一个二维数组，如何提出唯一的行
z=np.random.randint(0,2,(6,3))
t=np.ascontiguousarray(z).view(np.dtype((np.void,z.dtype.itemsize*z.shape[1])))
_,idx=np.unique(t,return_index=True)
uz=z[idx]
print(uz)
##考虑两个向量A和B，写出用einsum等式对应的inner，outer，sum，mul
a=np.random.uniform(0,1,10)
b=np.random.uniform(0,1,10)
np.einsum('i->',a)
np.einsum('i,i->i',a,b)
np.einsum('i,i',a,b)
np.einsum('i,j->ij',a,b)
##给定一个整数n和一个二维数组x，从x中选择可以被解释为从多n度的多项式分布式的行
x=np.asarray([[1.0,0.0,3.0,8.0],
[2.0,0.0,1.0,1.0],
[1.5,2.5,1.0.0.0]])
n=4
m=np.logical_and.reduce(np.mod(x,1)==0,axis=-1)
m &= (x.sum(axis=-1)==n)
print(x[m])
##对于一个一维数组x，计算它boostrapped之后95%置信区间的平均值
x=np.random.randn(100)
n=1000
idx=np.random.randint(0,x.size,(n,x.size))
means=x[idx].mean(axis=1)
confint=np.percentile(means,[2.5,97.5])
print(confint)
努力加油a啊，(o)/~
1052
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
