pandas基础

#python基础
#列表推导式与条件赋值
L=[]
def my_func(x):
    return 2*x
for i in range(5):
    L.append(my_func(i))
print(L)
print([my_func(i ) for x in range(5)])

print([m+'_'+n for m in ['a','b'] for n in ['c','d']])
value='cat' if 2>1 else "dog"
print(value)

L=[1,2,3,4,5,6,7]
print([i if i<=5 else 5 for i in L])

print("匿名函数与map方法")
#匿名函数与map方法
my_func=lambda x:2*x
print(my_func(3))
multi_para_func=lambda a,b:a+b
print(multi_para_func(1,2))

print([(lambda x:2*x)(i) for i in range(5)])
#map函数返回一个map对象，用list转为列表
print(list(map(lambda x:2*x,range(5))))
print(list(map(lambda x,y:str(x)+'_'+y,range(5),list("abcde"))))

print("----------------------------zip对象与enumerate方法------------------------------------")
#zip函数可以把多个迭代对象打包成一个元组构成的可迭代对象，返回一个zip对象，用tuple，list可得到相应的打包结果
L1,L2,L3=list("abc"),list("def"),list("hij")
print(list(zip(L1,L2,L3)))
print(tuple(zip(L1,L2,L3)))
print("-------------------在循环迭代中用到zip-------------")
for i,j,k in zip(L1,L2,L3):
    print(i,j,k)

print("-------------------enumerate可在迭代时绑定迭代元素的遍历序号-------------")
L=list("abcd")
for index,value in enumerate(L):
    print(index,value)

print("-------------------zip可在迭代时绑定迭代元素的遍历序号-------------")
for index,value in zip(range(len(L)),L):
    print(index,value)

print("-------------------当需要对两个列表建立字典映射时，可用zip-------------")
print(dict(zip(L1,L2)))

print("-----------------解压：* zip------------")
zipped=list(zip(L1,L2,L3))
print(zipped)
print(list(zip(*zipped)))

#numpy基础
print("-----------------二、numpy基础------------")
print("---------------1、np数组--------------")
print("--------------array构造------------")
import numpy as np
print(np.array([1,2,3]))
print("-----------------等差序列：np.linspace (起始，终点（包含），样本个数）np.arange（起始，终止（不包含），步长------------")
print(np.linspace(1,5,11))
print(np.arange(1,5,2))

print("------------特殊矩阵：zeros(各维度大小）,eye（n*n的单位矩阵）,full（元组传入大小------------")
print(np.zeros((2,3)))
print(np.eye(3))#3*3单位矩阵
print(np.eye(3,k=1))#偏移主对角线1个单位的伪单位矩阵
print(np.full((2,3),10))#元组传入大小，10表示填充数值
print(np.full((2,3),[1,2,3]))#每行填入相同列表

print("--------------随机矩阵：np.random------------")
print("------常见随机生成函数：rand(0-1均匀分布的随机数组）,randn（标准正态的随机数组）,"
      "randint（随机整数组）,choice（随机列表抽样）-------")
print("---生成服从0-1均匀分布的三个随机数---")
print(np.random.rand(3))#生成服从0-1均匀分布的三个随机数
print("------这里不是传入元组，每个维度大小分开输入--------")
print(np.random.rand(3,3))
print("------服从区间a到b上的均匀分布--------")
a,b=5,15
print((b-a)*np.random.rand(3)+a)
print("---选择已有的库函数---")
print(np.random.uniform(5,15,3))
print("---生成（0，1）标准正态分布---")
print(np.random.randn(3))
print(np.random.randn(2,2))
print("----服从方差为σ²，均值为mui的一元正态分布------")
sigma,mu=2.5,3
print(mu+np.random.randn(3)*sigma)
print("----一元正态分布也可从已知函数生成----------")
print(np.random.normal(3,2.5,3))

print("----randint可指定随机整数的最小值和最大值（不包含）和维度大小-----")
print("生成5到14的随机整数")
low,high,size=5,15,(2,2)
print(np.random.randint(low,high,size))
print("---------choice可从给定的列表中，以一定概率和方式抽取结果---------")
print('-----当不指定概率时为均匀采样，默认抽取方式为有放回抽样----')
my_list=['a','b','c','d']
print(np.random.choice(my_list,2,replace=False,p=[0.3,0.4,0.2,0.1]))
print(np.random.choice(my_list,(3,3)))

print("----当返回的元素个数与原列表相同时，不放回抽样等价于使用permutation函数，即打散原列表-----")
print(np.random.permutation(my_list))
print("-----随机种子，能固定随机数的输出结果----")
print(np.random.seed(0))
print(np.random.rand())


print("----------------------2、np数组的变形与合并------------------------")
print("-------转置:T-----")
print(np.zeros((2,3)).T)
print("-------合并：r_,c_-----")
print("-------对二维数组，r_,c_表示上下合并，左右合并--------")
print(np.r_[np.zeros((2,3)),np.zeros((2,3))])
print(np.r_[np.zeros((2,3)),np.zeros((2,3))])
print("--------一维数组和二维数组合并：视为列向量，长度匹配：只能使用c_--------")
try:
    np.r_[np.array([0,0]),np.zeros((2,1))]
except Exception as e:
    Err_Msg=e
print(Err_Msg)
print(np.r_[np.array([0,0,]),np.zeros(2)])
print(np.c_[np.array([0,0]),np.zeros((2,3))])

print("--------维度变化reshape(c:逐行填充读取)（F：逐列填充读取）---------")
target=np.arange(8).reshape(2,4)
print(target)
print("-----------按行读取填充--------------")
target2=target.reshape((4,2),order="C")
print(target2)

print("-----------按列读取填充--------------")
target3=target.reshape((4,2),order="F")
print(target3)

print("-----特别地，由于被调数组大小是确定的，reshape允许有一个维度存在空缺，此时只需填充-1即可------")
target4=target.reshape((4,-1))
print(target4)

print("-------经常：将n*1大小数组转为1维数组--------")
target5=np.ones((3,1))
print(target5)
target6=target5.reshape(-1)
print(target6)

print("---------------3、np数组切片与索引-------------------")
target7=np.arange(9).reshape(3,3)
print(target7)
print(target7[:-1,[0,2]])

print("---------------np.ix_在对应维度上使用布尔索引，但此时不能使用slice切片-----------------")
print(target7[np.ix_([True,False,True],[True,False,True])])
print(target7[np.ix_([1,2],[True,False,True])])

print("-----------------当维度为1：直接布尔索引，无需np.ix_-------------")
new=target7.reshape(-1)
print(new[new%2==0])

print("-------------------4、常见函数-----------------------")

print("---------------where-----------------")
a=np.array([-1,1,-1,0])
print("-------------TRUE：填充a，否则填充5-------------------")
print(np.where(a>0,a,5))

print("---------------nonzero,argmax,argmin(返回的都是索引）-----------------")
print("---------nonzero（返回非零数索引），argmax(返回最大值索引）,argmin(返回最小值索引-----------")
a=np.array([-2,-5,0,1,3,-1])
print(np.nonzero(a))
print(a.argmax())
print(a.argmin())

print("---------------any,all-----------------")
print("-----------any:至少存在一个True或非零元素：返回True,否则：返回False---------")
print("-----------all:全为True或非零元素：返回True,否则：返回False---------")
a=np.array([0,1])
print(a.any())
print(a.all())

print("--------------cumprod,cumsum,diff-----------------")
print("---------------cumprod：累乘返回相同长度的数组-----------------")
print("---------------cumsum：累加返回相同长度的数组-----------------")
print("-----Diff：和前一个元素做差，由于第一个元素为缺失值，故在默认参数情况下，返回长度是（原数组-1）-------")
a=np.array([1,2,3])
print(a.cumprod())
print(a.cumsum())
print(np.diff(a))

print("---------------统计函数-----------------")
print("-------常见统计函数：max,min,mean,median,std,var,sum,quantile--------")
print("------------分位数计算：全局方法，因此不能通过array.quantile方法调用--------------------")
target9=np.arange(5)
print(target9)
print(target9.max())
print(np.quantile(target9,0.5))#0.5分位数
print("------------对于含有缺失值的数组，返回的结果也是缺失值，如要略过缺失值，必须使用nan*类型函数---------")
target10=np.array([1,2,np.nan])
print(target10)
print(target10.max())
print(np.nanmax(target10))
print(np.nanquantile(target10,0.5))

print("--------------对于协方差、相关系数：cov,corrcoef--------------")
target11=np.array([1,3,5,9])
target12=np.array([1,5,3,-9])
print("-------cov---------")
print(np.cov(target11,target12))
print("-------corrcoef---------")
print(np.corrcoef(target11,target12))

print("-----二维Numpu数组中统计函数axis参数：能够进行某一个维度下的统计特征计算------")
print("--------axis=0:结果为列的统计指标-------------")
print("--------axis=1:结果为行的统计指标-------------")

target12=np.arange(1,10).reshape(3,-1)
print(target12)
print(target12.sum(0))
print(target12.sum(1))

print("------------------5、广播机制--------------")
print("-----------------标量和数组的操作-------------------")
print("--------当一个标量和数组运算：标量会自动把大小扩充为数组大小，之后进行逐元素操作---------")
res=3*np.ones((2,2))+1
print(res)
res=1/res
print(res)


print("--------------------二维数组之间的操作----------------------")
print("----当两个数组维度完全一致：使用对应元素操作------")
res=np.ones((3,2))
print(res)
print("-------------第二个数组扩充第一维度为3------------")
print(res*np.array([[2,3]]))
print("-----------第二个数组扩充第二个维度为2---------------")
print(res*np.array([[2],[3],[4]]))
print("---------------等价于两次扩充，第二个数组两个维度分别扩充为3和2-----------------")
print(res*np.array([[2]]))

print("-------------------[c]一维数组与二维数组的操作---------------------")
print("-------------自动扩展到相同维度，再运算，低维度向高维度扩展--------------")
print("--------如果两个数组的后缘维度(从末尾开始算起的维度)的轴长度相符或其中一方的长度为1，则认为它们是广播兼容的。广播会在缺失维度和(或)轴长度为1的维度上进行。---------------")
print("--------第一个示例---------")
print(np.ones(3))
print(np.ones((2,3)))
print(np.ones(3)+np.ones((2,3)))
print("--------第二个示例---------")
print(np.ones(3))
print(np.ones((2,1)))
print(np.ones(3)+np.ones((2,1)))
print("--------第三个示例---------")
print(np.ones(1))
print(np.ones((2,3)))
print(np.ones(1)+np.ones((2,3)))

print("---------------6、向量与矩阵的计算-----------------")
print("-------------[a]向量内积：dot--------------------")
a=np.array([1,2,3])
b=np.array([1,3,5])
print(a.dot(b))

print("-------------[b]向量范数和矩阵范数:np.linalg.norm--------------------")
print("-------------------在矩阵范数计算：ord（最重要参数）-----------------")
matrix_target=np.arange(4).reshape(-1,2)
print(matrix_target)
print(np.linalg.norm(matrix_target,'fro'))
print(np.linalg.norm(matrix_target,np.inf))
print(np.linalg.norm(matrix_target,2))

vector_target=np.arange(4)
print(vector_target)
print("----------np.inf 表示+∞，没有确切数值,类型为浮点型---------")
print("--------------np.linalg.norm()用于求范数，linalg本意为linear(线性) + algebra(代数)，norm则表示范数-----")
print(np.linalg.norm(vector_target,np.inf))
print(np.linalg.norm(vector_target,2))
print(np.linalg.norm(vector_target,3))


print("-------------[c]矩阵乘法--------------------")
a=np.arange(4).reshape(-1,2)
print(a)
b=np.arange(-4,0).reshape(-1,2)
print(b)
print(a@b)