Python
为了应试，被迫背单词。个人认为这种玩意，就该开卷考，然后丢你个实际点的题目让你做。
Numpy
代码 | 含义 |
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) | 取绝对值 |
Pandas
代码 | 含义 |
import pandas as pd | 导入pandas库 |
pd.Series(range(5)) | 把Python的range对象转换为一维数组 |
pd.Series(range(5),index=list(‘abcde’)) | 指定索引 |
pd.data_range(start=‘20180101’,end=‘20181231’,frq=‘H’) | 间隔为小时 |
pd.data_range(start=‘20180101’,end=‘20181231’,frq=‘D’) | 间隔为天 |
pd.data_range(start=‘20180101’,end=‘20181231’,frq=‘M’) | 间隔为月 |
pd.DataFrame(np.random.randn(12,4),index=dates,columns=list()‘ABCD’) | index索引，columns列名 |
df.head() | head默认前5行 |
df.head(3) | 显示前3行 |
df.tail(2) | 显示最后2行 |
df.index | 查看索引 |
df.columns | 查看列名 |
df.values | 查看值 |
df.describe() | 查看平均值，标准差，最小值，最大值等信息 |
df.sort_index(axis=0,ascending=False) | 对索引降序排序，原来的df不会变要重新赋值才变 |
df.sort_index(axis=1,ascending=Ture) | 对列进行升序排序 |
df.sort_values(by=‘A’) | 按A列对数据进行升序排序 |
df.sort_values(by=[‘E’,‘C’]) | 先按E列升序排序，再按C列升序 |
df[‘A’] | 选择某一列 |
60 in df[‘A’] | df[‘A’]是一个类似字典的结构;索引类似字典的键，默认访问字典的键而不是值 |
60 in df[‘A’].values | 测试60是否在A列的值当中 |
df[0:2] | 使用切片选多行，前闭后开,得到前2行 |
df.loc[:,[‘A’,‘C’]] | 选择多列 |
df.loc[[‘zhang’,‘li’],[‘A’,‘D’,‘E’]] | 同时指定多行和多列 |
df.loc[‘zhang’,[‘A’,‘D’,‘E’]] | 查看‘zhang’的三列数据 |
df.at[‘zhang’,‘A’] | 查看指定行列位置的值 |
df.iloc[3] | 查看二维数组第3行数据 |
df.iloc[0:3,0:4] | 查看二维数组前三行，前四列数据 |
df.iloc[[0,2,3],[0,4]] | 查询二维数组指定多行多列的数据 |
df.iloc[0,1] | 查询二位数组第0行第1列位置的数据值 |
df[df.A>50] | 查询A列大于50的所有行 |
df[df[‘E’]==‘test’] | 查询E列为‘test’的所有行 |
df[df[‘A’].isin([20,69])] | 查询A列值为0或69的所有行 |
df.nlargest(3,[‘C’]) | 返回C列值最大的前3行 |
df.iat[0,2]=3 | 修改指定行列位置的数据值 |
df.loc[: , ‘D’]=np.random.randint(50,60,4) | 修改某列的值 |
df[‘C’]=-df[‘C’] | 对指定列数据取反 |
dff=df[ : ] | 切片 |
dff[‘C’]=dff[‘C’]**2 | 替换列数据 |
dff.loc[dff[‘C’]==‘9.0’,‘D’]=100 | 把C列值为9的数据中的D列改为100 |
data=pd.DataFrame({‘k1’ : [‘one’]*3+[‘two’]*4,‘k2’:[1,1,2,3,3,4,4]}) | 要知道玩意弄出来是啥样的，二维数组的映射 |
data.replace(1,5) | 把所有1替换成5 |
data.replace({1:5,‘one’:‘ONE’}) | 使用字典指定替换关系 |
df1=df.reindex(columns=list(df.columns)+[‘G’]) | 增加一列，列名为G，NaN表示缺失值 |
df1.dropna() | 返回不包含缺失值的行 |
df1[‘G’].fillna(5,inplace=True) | 使用指定值原地填充缺失值（不会覆盖原来有的） |
data.drop_duplicates() | 返回新数组删除重复行 |
data.drop_duplicates([‘k1’]) | 删除k1列的重复数据 |
data.drop_duplicates([‘k1’],keep=‘last’) | 删除k1列的重复数据,保留最后一个数据 |
col2=data[2] | 获取第二列的数据,要列名就是2就和data[‘A’]一样 |
col2[col2>3.5] | 查询该列中>3.5的数值 |
data[np.abs(data)>2.5]=np.sign(data)*2.5 | 把所有数据都限定到[-2.5,2.5]之间 |
data[‘k1’]=data[‘k1’].map(str.upper) | 使用函数映射，k1列的值都变成大写的 |
data[‘k1’]=data[‘k1’].map({‘ONE’:‘one’,‘TWO’:‘two’}) | 使用字典表示映射关系 |
pd.cut(data2,[0,30,70,100]) | 数据切分，左开右闭，返回每个数据属于哪个区间(0,30],(30,70],(70,100] |
pd.cut(data2,[0,30,70,100],right=False) | 数据切分，左闭右开，返回每个数据属于哪个区间[0,30),[30,70),[70,100) |
pd.cut(data2,[0,30,70,100],right=False,labels=[‘low’,‘middle’,‘high’]) | 用标签代替了属于哪个区间，返回每个数据属于哪个标签 |
pd.cut(data,4) | 平分成4个区间，左右包含最小和最大（不一定等于最小最大） |
df1.shift(1) | 数据下移一行，空出来的NaN |
df1.shift(-1) | 数据上移一行，空出来的NaN |
df1[‘D’].value_counts() | 直方图统计,统计D列数据分布情况 |
df3=pd.concat([p1,p2,p3]) | 数据行合并,p1p2p3为切片选出来的多行数据 |
df4.groupby(‘A’).sum() | 分组计算，根据A的值分组，然后对每列求出该组数据的和 |
df4.groupby([‘A’,‘B’]).mean() | 按A和B分组 |
df4.groupby([‘A’,‘B’],as_index=False).mean() | as_index=False参数防止分组名变为索引 |
df.diff() | 纵向一阶差分，每行数据变为该行与上一行数据的差 |
df.diff(axis=1) | 横向一阶差分 |
df.diff(periods=2) | 纵向二阶差分 |
df.to_excel(‘d:\\test.xlsx’,sheet_name=‘dfg’) | 数据保存为excel |
df=pd.read_excel(‘d:\\test.xlsx’,‘dfg’,index_col=None,na_values=[‘NA’]) | 从excel读取数据 |
df.to_csv(‘d:\test.csv’) | 将数据保存为csv文件 |
df=pd.read_csv(‘d:\test.csv’) | 读取csv文件中的数据 |