本文主要针对Python处理Excel & CSV文件的应用。所有代码均实例化代入且逐条备注解释。
全文逐条手工输入整理，可能会产生错误之处，还请指正。
之后会陆续整理 “爬虫” 与 “金融量化分析” 两个文档
# --------------------------------------------------------------------------------------------
一、查询数据：
print(数据) # 查询完整数据值
print(数据.index) # 查索引名
print(数据['姓名']) # 查具体某列的值
print(数据[['姓名','性别']]) # 查具体多列的值
print(数据.values) # 查每列的值
print(数据.sort_index()) # 按索引列排序
print(数据.sort_values('日期')) # 按具体某列数据排序
print(数据['a'][0]) # 查具体列具体行的值，即a列、o行
print(数据.loc[0]['a']) # 查具体行具体列的值，即0行、a列 (按索引)
print(数据.iloc[0][0]) # 查具体行具体列的值，即0行、a列 （按行列数）
print(数据.dtypes) # 查数据类型
print(数据.columns) # 查全部列名
print(数据.loc[0:3]) # 查指定几行的值
print(数据.head()) # 查前5行的值（默认）
print(数据.head(3)) # 查前3行的值
print(数据.tail(5)) # 查最后5行的值（默认）
print(数据.tail(3)) # 查最后3行的值
print(数据.shape) # 查整个表共几行几列
print(数据.fillna(1)) # 将表格中的空白填充为数字1
print(数据.replace('Jack','Jason')) # 将表中的Jack全部替换成Jason
print(数据.reset_index(drop=True)) # 删除索引
print(数据.apply(np.square)) # 对数据各项求平方
print(数据.describe()) # 查每列数据的平均值/最大值/最小值/标准差
print(数据['姓名'].value_counts()) # 查姓名列相同的值出现的次数二、数据删除：
1.删除单行或多行
print(数据.drop(2)) # 删除第2行数据
print(数据.drop(labels=[1,3])) # 删除第1至第3行数据
2.删除单列或多列
print(数据.drop('语文',axis=1)) # 删除语文至一列数据
print(数据.drop(labels=['语文','英语'],axis=1)) # 删除语文和英语这两列数据
3.删除重复行
print(数据.drop_duplicates(数据['姓名'],keep='first')) # 删除重复行，并保留第一个重复值
print(数据.drop_duplicates(数据['姓名'],keep='last')) # 删除重复行，并保留最后一个重复值
print(数据.drop_duplicates(数据['姓名'],keep=False)) # 删除重复行，并保留无重复值
print(数据.drop_duplicates(数据['姓名','性别'],keep=False)) # 删除多列重复行，并保留无重复值三、处理缺失值/空白值：
1.显示空白值
print(数据.isnull()) # 判断表中是否有空值，有空值则为True
print(数据.notnull()) # 判断表中是否有空值，不是空值则为True
2.删除空白值
print(数据.dropna()) # 删除有空白值的行（有空值则整行数据删除）
print(数据.dropna(axis=1)) # 删除有空白值的列（有空值则整列数据删除）
print(数据.dropna(how='all')) # 若整行都为空值，则删除整行。否则不删
print(数据.dropna(subset=['语文','数学'])) # 删除指定多列中的空值
3.填充空白值
print(数据.fillna(100)) # 将整个数据中的空值都填为100
print(数据.fillna({'语文':2,'数学':3})) # 将语文列的空值填为2，数学列的空值填为3
print(数据.fillna(method='ffill')) # 将两个非空值之间的空值按上方的非空值，向下填充完整
print(数据.fillna(method='bfill')) # 将两个非空值之间的空值按下方的非空值，向上填充完整
print(数据.fillna(method='ffill',limit=2)) # 将两个非空值之间的空值按上方的非空值，向下填充2行四、Excel 文件的拆分与合并
import pandas as pd
import os # 如果功能涉及文件夹的操作，需要导入os模块
路径='c:/pandas' # 路径没有结尾.txt/.xlsx ，则表示文件夹
1.将一个文件夹中多个Excel合并
新数据=pd.ExcelWriter('c:/pandas/新数据.xlsx')
for i in os.listdir(路径):
数据=pd.read_excel('路径/文件名1.xlsx',header=1)
新数据=pd.concat([新数据,数据])
新数据.to_excel('路径/新数据.xlsx')
# 在'c:/pandas’文件夹下创建一个合并后的Excel文件
# 'os.listdir(路径)':读取路径这个文件夹下的所有文件的文件名
# concat:将数据合并入新数据中
2.将一个Excel中多个sheet合并成一个sheet
数据=pd.read_excel('路径/数据.xlsx',sheet_name=None)
SHEET名=list(数据.keys())
新数据=pd.DataFrame()
for i in SHEET名：
新数据1=数据[i]
新数据=pd.concat([新数据，新数据1])
新数据.to_excel('路径/新数据.xlsx')
# sheet_name=None：读取Excel中所有sheet
# list:获取数据中所有sheet名称
# pd.DataFrame:创建一个空的表格用来连接，并命名为新数据
# for:循环每个sheet名称
# concat:将新数据1合并入新数据中
3.将一个Excel中的一个sheet拆分成多个sheet （指定某列拆分成不同sheet）
数据=pd.read_excel('路径/数据.xlsx')
部门明细=list(数据['部门'].drop_duplicates())
新数据=pd.ExcelWriter('c:/pandas/新数据.xlsx')
for i in 部门明细：
数据1=数据[数据['部门']==i]
数据1.to_excel(新数据,sheet_name=i)
# drop_duplicates: 因为之后将按部门列中的部门明细拆分成不同sheet，所以先去除部门列的重复值
# 在'c:/pandas’文件夹下创建一个合并后的Excel文件
4.将一个Excel拆分成多个Excel
数据=pd.read_excel('路径/数据.xlsx')
部门明细=list(数据['部门'].drop_duplicates())
for i in 部门明细:
数据1=数据[数据['部门']==i]
数据1.to_excel('{0}.xlsx',format(i))
# 将format(i)的内容格式，填入{}中，并生成以i命名的Excel
五、字符串处理：
1. 字符的分割
print(数据['姓名'].str.cat(sep='*'))
# 例：王五*赵六*NaN*李逵
# 1.将姓名列的所有姓名串联，并用“*”隔开 2. cat为串联，sep为添加分隔符
print(数据['姓名'].str.cat(['变身']*len(数据),sep='^'))
# 例：王五^变身 赵六^变身 NaN^变身 李逵^变身
# 将姓名列的所有姓名后加变身两个字，并用“^”符号隔开
print(数据['姓名'].str.cat(['变身']*len(数据),sep='^'),na_rep='没有'))
# 例：王五^变身 赵六^变身 没有^变身 李逵^变身
# na_rep=‘没有’：将姓名列中的空值替代为“没有”这两个字
print(数据['小名'].str.split())
# 例： 王小明 李小马 王大军 赵小六
# 将小名列分离出来
print(数据['小名'].str.split('小'))
# 例：【王，明】 【李，马】 【王大军】 【赵，六】
# 将小名列分离出来，并用“小”字来分隔开，并删除小字，中间用逗号分隔
print(数据['小名'].str.split('小',expend=True))
# 例：【王 明】 【李 马】 【王大军】 【赵 六】
# 将小名列分离出来，并用“小”字来分隔开，并删除小字，中间用空格分隔
print('EeEeEe'.partition('e'))
# 例：'E','e','EeEe'
# 将从左至右遇到的第一个e字作为分隔符，并保留e字
2. 字符的获取
print(数据['小名'].str.get(2))
# 例： 明 马 军 六
# 获取小名列的第三个字符
print(数据['小名'].str.slice(0,2))
# 例： 王小 李小 王大 赵小
# 获取小名列位置1~2的字符
print(数据['小名'].str.slice_replace(1.3,'之'))
# 例： 王之 李之 王之 赵之
# 获取小名列的数据，并将2~3的数据替换成“之”字
print(数据['小名'].str.join('之'))
# 例： 王之小之明 李之小之马 王之大之军 赵之小之六
# 获取小名列的数据，并将各字符之间用之字链接
print(数据['日期'].astype('str').str.find('-'))
# 例： 2020-05-01 》》 位置：4
# 在日期列查找‘-’的具体位置，如果查不到则显示“-1”
3. 字符的验证
print(数据['小名'].str.contains('之',na='没有'))
# 查询小名列是否包含“之”字，有则显示“True”，没有则显示“没有”
print(数据['小名'].str.startswith('王'))
# 查询小名列是否以“王”字开头，是则显示“True”，否则显示“False”
print(数据['小名'].str.endswith('王'))
# 查询小名列是否以“王”字结尾，是则显示“True”，否则显示“False”
print(数据.str.isalpha())
# 判断字符串是否全部为字母，是显示True，否显示False
print(数据.str.isnumeric())
# 判断字符串是否全部为数字，是显示True，否显示False
print(数据.str.isalnum())
# 判断字符串是否全部为字母和数字组合，是显示True，否显示False
print(数据.str.isspace())
# 判断字符串是否全部为空格，是显示True，否显示False
print(数据.str.islower())
# 判断字符串是否全部为小写，是显示True，否显示False
print(数据.str.istitle())
# 判断字符串是否全部单词首字母都是大写，是显示True，否显示False
4. 字符的填充
print(数据['小名'].str.repeat(3))
# 例： 王小明王小明王小明 李小马李小马李小马
# 将小名列的数值重复显示3次
print(数据['小名'].str.pad(5,fillchar='&'))
# 例： &&&王明 &&李小马 &&王大军 &&赵小六
# 将姓名列的数据设置为5位字符，并将缺少值从左开始用“&”填充
print(数据['小名'].str.pad(5,fillchar='&',side='right'))
# 例： 王明&&& 李小马&& 王大军&& 赵小六&&
# 将姓名列的数据设置为5位字符，并将缺少值从右开始用“&”填充
print(数据['小名'].str.pad(5,fillchar='&'side='both'))
# 例： &&王明& &李小马& &王大军& &赵小六&
# 将姓名列的数据设置为5位字符，并将缺少值在两侧用“&”填充
print(数据['小名'].str.zfill(5)
# 例： 000王明 00李小马 00王大军 00赵小六
# 将姓名列的数据设置为5位字符，并将缺少值从左开始用“0”填充
5. 字符编码转换
print(数据['姓名'].str.encode('utf-8'))
# 编码转换
print(数据['姓名'].str.decode('utf-8'))
# 解码转换
6. 字符的替换
print(数据.str.lower())
# 所有字符转换成小写
print(数据.str.upper())
# 所有字符转换成大写
print(数据.str.title())
# 每一个单词的首字母大写
print(数据.str.capitalize())
# 第一个字母大写
print(数据.str.swapcase())
# 大小写交换
字典=str.maketrans({'前''qian','后':'hou'})
print(数据['方位'],str.translate(字典))
# 例： 前后左右 》》qianhou左右
# 指定替换字符
7. 删除空格/指定字符
print(数据['姓名'].str.strip('后'))
# 例： 前后左右 》》 前左右
# 删除姓名列字符串中的“后”字
print(数据['姓名'].str.strip())
# 删除姓名列字符串中的空格
六、离散化和分箱：
年份=[1992,1983,1922,1932,1973]
箱子=[1900,1950,2000]
结果=pd.cut(年份,箱子) # 箱子为分段的标准，即按1900，1950，2000来区分隔开
print(结果)
# 例：(1950,2000],(1950,2000],(1900,1950],(1900,1950],(1950,2000]
# 表示年份中的数据分别位于箱子中的哪个区间段
print(pd.value_counts(结果))
# 例：（1950,2000] >> 3 (1900,1950] >> 2
# 表示统计每段区间内年份的个数
结果=pd.cut(年份,箱子,labels=False)
print(pd.value_counts(结果))
# 例：1 >> 3 0 >> 2
# 表示将以上的区间段用0和1代替，统计每段区间内年份的个数
箱子名=['50年前','50年后']
结果=pd.cut(年份,箱子,labels=箱子名)
print(pd.value_counts(结果))
# 例： 50年后 >> 3 50年前 >> 2
# 表示用箱子名作为区间的名称
结果=pd.qcut(年份,q=4) # qcut 表示等分
print(pd.value_counts(结果))
# 将年份从小到大排序后4等分
七、多层索引与计算：
数据=pd.read_excel(路径,sheet_name='有序',index_col=['班级','学号'])
数据=数据.set_index('班级','学号')
数据=数据.loc[('1班',slice(None)),:] # slice(None)为显示1班内的所有行
数据=数据.loc[('1班','小明',slice(None)),:] # 查询1班中小明的相关数据
# sheet_name：将Excel的sheet重命名
# index_col：将班级和学号设置为索引
# -----------------------------------------------------------------
例：
番茄 红薯 合计
销量 毛利 销量 毛利 销量 毛利
20 2 30 5 50 7
40 3 60 4 100 7
数据=pd.read_excel(路径,header=[0,1]) # 将第一第二行设置为索引
总计=数据['番茄']+数据['红薯'] # 将番茄和红薯下的销量&毛利分别相加
总计.columns=pd.MultiIndex.from_product([['合计'],总计.columns])
print(总计)
结果=pd.concat([数据.总计].axis=1) # 将番茄和红薯和总计值横向连接
八、数据替换：
数据=数据.replace('第九','第八')
# 将所有的第九替换成第八
数据['数值'].replace('第九','第八',inplace=True)
# 将数值列的所有第九替换成第八
字典={'A':20,'B':30}
数据['数值'].replace(字典,inplace=True)
# 将数值列的所有A替换成20，B替换成30
数据['数值'].replace(['A','B'],30,inplace=True)
# 将数值列的所有A和B都替换成30
数据.replace([A-Z],88,regex=True,inplace=True)
# 使用正则表达式，将A至Z所有值都替换成88，regex=True 为正则表达式必写语句
九、列计算：
描述 >> 方法 >> 反转方法
加 >> add >> add
减 >> sub >> sub
乘 >> mul >> mul
除 >> div >> div
整除 >> floordiv >> floordiv
N次方 >> pow >> pow数据['销售金额']=数据['单价']*数据['销售数量']
数据['销售金额']=数据['单价']*2
def 涨价(X):
return x+3
数据['单价']=数据['单价'].apply(涨价) # 每行数据加3，方法一
数据['单价']=数据['单价'].apply(lambda x:x+3) # 每行数据加3，方法二
差异=数据['结束日期']-数据['起始日期'] # 两列日期求差
数据['间隔日期']=差异.apply(lambda x:x days) # 将差值转换为日期格式
数据=数据['门店1'].fillna(0)+数据['门店2'].fillna(0)
#门店1或门店2数据含空值时，将空值填充为0
import pandas as pd
import numpy as np
列表=[[1,2,3],[4,5,6],[7,8,9]]
数据.pd.DataFrame(列表,columns=list('xyz'),index=list('abc')) # 方法一
数据.pd.DataFrame(列表,columns=['x','y','z'],index=['a','b','c']) # 方法二
# 将“x”，“y”，“z”分别作为“列表”的各列列名
print(数据.apply(np.square))
# 对整个数据求平方
print(数据.apply(lambda m:np.square(m) if m.name=='x' else m))
# 将m作为变量，如果列名为’x‘,则对x列求平方，其余列保持不变
print(数据.apply(lambda m:np.square(m) if m.name=='x' else m,axis=1))
# 将m作为变量，如果列名为’x‘,则对x行求平方，其余行保持不变
print(数据.apply(lambda m:np.square(m) if m.name in list('yz') else m))
# 将m作为变量，如果列名为’y‘或’z‘,则对x列和y列求平方，其余列保持不变
print(数据.apply(lambda m:np.square(m) if m.name in list('yz') else m,axis=1))
# 将m作为变量，如果行名为‘y’或’、‘z’,则对x行和y行求平方，其余行保持不变
数据连接：
1. Concat
| 基础数据1 |
A |
B |
C |
D |
| 0 |
A0 |
B0 |
C0 |
D0 |
| 1 |
A1 |
B1 |
C1 |
D1 |
| 2 |
A2 |
B2 |
C2 |
D2 |
| 3 |
A3 |
B3 |
C3 |
D3 |
| 基础数据2 |
A |
B |
C |
D |
| 4 |
A4 |
B4 |
C4 |
D4 |
| 5 |
A5 |
B5 |
C5 |
D5 |
| 6 |
A6 |
B6 |
C6 |
D6 |
| 7 |
A7 |
B7 |
C7 |
D7 |
| 基础数据3 |
B |
D |
F |
| 2 |
B2 |
D2 |
F2 |
| 3 |
B3 |
D3 |
F3 |
| 6 |
B6 |
D6 |
F6 |
| 7 |
B7 |
D7 |
F7 |
数据1= pd.concat([基础数据1,基础数据2]) # 方法一
数据1= 基础数据1.append(基础数据2) # 方法二
| 数据1 |
A |
B |
C |
D |
| 0 |
A0 |
B0 |
C0 |
D0 |
| 1 |
A1 |
B1 |
C1 |
D1 |
| 2 |
A2 |
B2 |
C2 |
D2 |
| 3 |
A3 |
B3 |
C3 |
D3 |
| 4 |
A4 |
B4 |
C4 |
D4 |
| 5 |
A5 |
B5 |
C5 |
D5 |
| 6 |
A6 |
B6 |
C6 |
D6 |
| 7 |
A7 |
B7 |
C7 |
D7 |
数据2= pd.concat([基础数据1,基础数据3],axis=1) # 行对齐
| 数据2 |
A |
B |
C |
D |
B |
D |
F |
| 0 |
A0 |
B0 |
C0 |
D0 |
NaN |
NaN |
NaN |
| 1 |
A1 |
B1 |
C1 |
D1 |
NaN |
NaN |
NaN |
| 2 |
A2 |
B2 |
C2 |
D2 |
B2 |
D2 |
F2 |
| 3 |
A3 |
B3 |
C3 |
D3 |
B3 |
D3 |
F3 |
| 6 |
NaN |
NaN |
NaN |
NaN |
B6 |
D6 |
F6 |
| 7 |
NaN |
NaN |
NaN |
NaN |
B7 |
D7 |
F7 |
数据3= pd.concat([基础数据1,基础数据2],keys=['基础数据1','基础数据2']) #方法一
数据3= pd.concat({'基础数据1':基础数据1,'基础数据2':基础数据2}) # 方法二
| 数据3 |
A |
B |
C |
D |
|
| 基础数据1 |
0 |
A0 |
B0 |
C0 |
D0 |
| 基础数据1 |
1 |
A1 |
B1 |
C1 |
D1 |
| 基础数据1 |
2 |
A2 |
B2 |
C2 |
D2 |
| 基础数据1 |
3 |
A3 |
B3 |
C3 |
D3 |
| 基础数据2 |
4 |
A4 |
B4 |
C4 |
D4 |
| 基础数据2 |
5 |
A5 |
B5 |
C5 |
D5 |
| 基础数据2 |
6 |
A6 |
B6 |
C6 |
D6 |
| 基础数据2 |
7 |
A7 |
B7 |
C7 |
D7 |
数据4=pd.concat([基础数据1,基础数据3],axis=1,join='inner')
| 数据4 |
A |
B |
C |
D |
B |
D |
F |
| 2 |
A2 |
B2 |
C2 |
D2 |
B2 |
D2 |
F2 |
| 3 |
A3 |
B3 |
C3 |
D3 |
B3 |
D3 |
F3 |
数据5=pd.concat([基础数据1,基础数据3],axis=1,join_axis=[基础数据1.index])
| 数据5 |
A |
B |
C |
D |
B |
D |
F |
| 0 |
A0 |
B0 |
C0 |
D0 |
NaN |
NaN |
NaN |
| 1 |
A1 |
B1 |
C1 |
D1 |
NaN |
NaN |
NaN |
| 2 |
A2 |
B2 |
C2 |
D2 |
B2 |
D2 |
F2 |
| 3 |
A3 |
B3 |
C3 |
D3 |
B3 |
D3 |
F3 |
2. Join
| 基础数据1 |
A |
B |
key |
| 0 |
A0 |
B0 |
K0 |
| 1 |
A1 |
B1 |
K1 |
| 2 |
A2 |
B2 |
K0 |
| 3 |
A3 |
B3 |
K1 |
| 基础数据2 |
C |
D |
| K0 |
C0 |
D0 |
| K1 |
C1 |
D1 |
数据3=数据1.join(数据2,on='key')
| 数据1 |
A |
B |
key |
C |
D |
| 0 |
A0 |
B0 |
K0 |
C0 |
D0 |
| 1 |
A1 |
B1 |
K1 |
C1 |
D1 |
| 2 |
A2 |
B2 |
K0 |
C0 |
D0 |
| 3 |
A3 |
B3 |
K1 |
C1 |
D1 |
3. Merge
| 基础数据1 |
A |
B |
key1 |
key2 |
| 0 |
A0 |
B0 |
K0 |
K0 |
| 1 |
A1 |
B1 |
K0 |
K1 |
| 2 |
A2 |
B2 |
K1 |
K0 |
| 3 |
A3 |
B3 |
K2 |
K1 |
| 基础数据2 |
C |
D |
key1 |
key2 |
| 0 |
C0 |
D0 |
K0 |
K0 |
| 1 |
C1 |
D1 |
K1 |
K0 |
| 2 |
C2 |
D2 |
K1 |
K0 |
| 3 |
C3 |
D3 |
K2 |
K0 |
数据1=pd.merge(基础数据1,基础数据2,on=['key1','key2'])
| 数据1 |
A |
B |
key1 |
key2 |
C |
D |
| 0 |
A0 |
B0 |
K0 |
K0 |
C0 |
D0 |
| 1 |
A1 |
B1 |
K1 |
K0 |
C1 |
D1 |
| 2 |
A2 |
B2 |
K1 |
K0 |
C2 |
D2 |
数据2=pd.merge(基础数据1,基础数据2,on=['key1','key2'] ,how='outer') # outer：全外连接，根据基础数据1&2的’key1’&’key2’两列，连接基础数据1&2
| 数据2 |
A |
B |
key1 |
key2 |
C |
D |
| 0 |
A0 |
B0 |
K0 |
K0 |
C0 |
D0 |
| 1 |
A1 |
B1 |
K0 |
K1 |
NaN |
NaN |
| 2 |
A2 |
B2 |
K1 |
K0 |
C1 |
D1 |
| 3 |
A2 |
B2 |
K1 |
K0 |
C2 |
D2 |
| 4 |
A3 |
B3 |
K2 |
K1 |
NaN |
NaN |
| 5 |
NaN |
NaN |
K2 |
K0 |
C3 |
D3 |
数据3=pd.merge(基础数据1,基础数据2,on=['key1','key2'] ,how='left') # left：左连接，根据基础数据2的’key1’&’key2’两列，连接基础数据1&2
| 数据3 |
A |
B |
key1 |
key2 |
C |
D |
| 0 |
A0 |
B0 |
K0 |
K0 |
C0 |
D0 |
| 1 |
A1 |
B1 |
K0 |
K1 |
NaN |
NaN |
| 2 |
A2 |
B2 |
K1 |
K0 |
C1 |
D1 |
| 3 |
A2 |
B2 |
K1 |
K0 |
C2 |
D2 |
| 4 |
A3 |
B3 |
K2 |
K1 |
NaN |
NaN |
数据4=pd.merge(基础数据1,基础数据2,on=['key1','key2'] ,how='right') # right：右连接，根据基础数据1的’key1’&’key2’两列，连接基础数据1&2
| 数据4 |
A |
B |
key1 |
key2 |
C |
D |
| 0 |
A0 |
B0 |
K0 |
K0 |
C0 |
D0 |
| 1 |
A2 |
B2 |
K1 |
K0 |
C1 |
D1 |
| 2 |
A2 |
B2 |
K1 |
K0 |
C2 |
D2 |
| 3 |
NaN |
NaN |
K2 |
K0 |
C3 |
D3 |
数据5=pd.merge(基础数据1,基础数据2)
数据6=pd.merge(基础数据1,基础数据2,on='姓名',how='right') # 根据基础数据1的姓名列，连接基础数据1&2
数据7=pd.merge(基础数据1,基础数据2,on='姓名',how='left') # 根据基础数据2的姓名列，连接基础数据1&2
数据8=pd.merge(基础数据1,基础数据2,on='姓名',how='outer') # 根据基础数据1&2的全部姓名列，连接基础数据1&2
数据9=pd.merge(基础数据1,基础数据2,left_on='姓名',right_index=True) # 根据基础数据1的姓名列，连接基础数据2的index列
数据10=pd.merge(基础数据1,基础数据2,on='k',suffixes=['_l','_x']) # suffixes为后缀参数
# ---------------------------------------------------------------------------------
代码格式规范与排版：
# 代码下方出现波浪线表示代码输入的不规范，但依旧可正常执行代码。
# 如格式不清楚是否规范，可通过复制黏贴可运行的代码至空白处，系统会自动修正代码格式。
或Ctrl+Alt+L，直接将代码格式化
一、空行:
1. import语句上下保留两个空行
2. def函数声明上方保留两个空行
3. class类声明上方保留两个空行
4. def方法声明上方保留1个空行
5. 2个逻辑代码块之间保留1个空行
二、空格:
# 为方便阅读，以下用^代替空格
1. 赋值符号前后各保留一个空格 # 例： a^=^10
2. 所有二元运算符和数字之间用空格分开 # 例： a^+=^c^+^d
3. (),[],{} 括号内无空格 # 例： 合计=pd.concat([数据.总计])
4. 逗号、冒号、分号前面无空格，后面有一个空格 # 例： print(x,^y)
5. 参数列表、索引、切片的左括号前无空格 # 例： list[index]
三、缩进:
4个空格为一个缩进级别
四、断行：
1. 在逗号后面断开
2. 在运算符号前面断开
五、数字类型分类：
int 整数类型 # 例： 1
float 浮点类型 # 例： 1.0
complex 复数类型 # 例： 1+2j （1为实部，2为虚部）
bool 布尔类型 # 例：仅False/True两个值
六、运算符分类：
1.算数运算符：
+ 加 # 1+2=3 or 'Hello'+'World'='HelloWorld' 数字类型之间为求和，其他类型之间为连接符
- 减 # 2-1=1
* 乘 # 2*3=6 or 'Hello'*2='HelloHello' 数字类型之间为求积，其他类型之间为重复操作
/ 除 # 2/1=2
% 取余 # 3%2=1
// 取整 # 3//2=1 or -3//2=-2 求小于a/b的商的最大整数
** 幂(次方) # 10**2=100
2.关系运算符：
== 等于 # a等于b时，返回True，否则False
!= 不等于 # a不等于b时，返回True，否则False
> 大于
< 小于
>= 大于等于
<= 小于等于
3.逻辑运算符：
not 非 # a为True，返回False，a为False，返回True
and 与 # a，b全为True，返回True，否则False
or 或 # a,b一者及以上为True，返回True，否则False
4.赋值运算符：
+= a+=b >> a=a+b
-= a-=b >> a=a-b
*= a*=b >> a=a*b
/= a/=b >> a=a/b
%= a%=b >> a=a%b
**= a**=b >> a=a**b
//= a//=b >> a=a//b
&= a&=b >> a=a&b
》= a》=b >> a=a》b
《= a《=b >> a=a《b
5.位运算符：
~ 位反
& 位与
| 位或
^ 位异或
》 右移
《 左移
七、运算符优先级：
() 小括号
def() 函数调用
[],[] 切片
[] 下标
. 引用类成员
** 幂
~ 位反
+,- 正负号
*,/,% 乘，除，取余
+,- 加，减
《,》 位移
& 位与
^ 位异或
| 位或
in,not in,is,is not,<,<=,>,>=,<>,!=,== 比较
not 非
and 与
or 或
lambda() Lambda表达式
八、控制语句：
1.分支语句
1.1 if结构：
# 条件计算为True，则执行语句；否则执行if后面语句
if score >= 85:
print('优秀')
if score < 60:
print('加油')
if (score >= 60)and(score <= 85):
print('努力')
1.2 if-else结构：
# 先判断if条件，如果True，则执行语句1，然后跳过else语句及语句组2；如果False，则跳过语句1，执行语句2
if score >= 60:
print('及格')
if score >= 90:
print('优秀')
else:
print('不及格')
1.3 elif结构：
# 为if-else结构的多层嵌套，只执行if条件中的某一个语句
if score >= 90:
grade='A'
elif score >= 80:
grade='B'
elif score >= 70:
grade='C'
else:
grade='F'
print('Grade='+grade)
2.循环语句
2.1 while语句：
# 循环次数无限制，只要满足条件则循环
i=0
while i*i<100
i+=1
print('i={0}'.format(i))
print('i*i={0}'.format(i*i))
2.2 for语句：
# 用于序列循环，序列包括字符串，列表，元组
for item in 'Hello':
print(item) # 输出：H e l l o
for item in range(1,10,2) # 1代表开始值，10代表结束值 2代表步长
print('Count is:{0}'.format(item)) # 输出：Count is：1 Count is：3 Count is：5 Count is：7 Count is：9
3.跳转语句
3.1 break语句:
# 强行退出循环体，不再执行剩余语句
for item in range(5)
if item == 3
break
print('Count is:{0}'.format(item)) # 输出：Count is：0 Count is：1 Count is：2
3.2 continue语句：
# 跳过if目标语句，执行循环体
for item in range (5)
if item == 3
continue
print('Count is:{0}'.format(item)) # 输出：Count is：0 Count is：1 Count is：2 Count is：4
# ------------------------------------------------------------------------------------------
常见异常：
1. AttributeError异常： 访问一个类中不存在的元素（包括：成员变量、属性、成员方法）
2. OSError/IOError/FileNotFoundError异常： 操作系统相关异常（例：”未找到文件“或”磁盘已满“）
3. IndexError异常： 访问序列元素时，下标索引超出取值范围（例：序列*4个元素，要访问第5个元素时会弹出该异常）
4. KeyError异常： 访问字典里不存在的键
5. NameError异常： 使用一个不存在的变量
6. TypeError异常： 传入的变量类型与要求不符
7. ValueError异常： 传入一个无效的参数值
# ----------------------------------------------------------------------------------------------
日期的计算：
# datetime 表示时间和日期 ； date 表示日期 ； time 表示一天内的时间 ； timedelta 表示时间差
import datetime as 日期模块：
def 累加月(日期,传入的月份):
年=传入的月份//12
传入的月份=日期.month+传入的月份%12
if月!=12:
年=年+月//12
月=月%12
return 日期模块.date(日期.year+年,月,日期.day)
起始日期=日期模块.date(2020,05,26)
for i in 数据.index:
数据['日期'].at[i]=起始日期+日期模块.timedelta(days=i) # 例：2020.05.26 2020.05.27 2020.05.28
数据['日期'].at[i]=日期模块.date(起始日期.year+i,起始日期.month,起始日期.day) # 例：2020.05.26 2021.05.26 2022.05.26
数据['日期'].at[i] =累加月(起始日期,i) # 例：2020.05.26 2020.06.26 2020.07.26
Datetime 模块：
print(datetime.datetime.today()) # 输出： 2021-10-13 16:02:56.794003
# 返回当前本地日期和时间
print(datetime.datetime.now()) 输出： 2021-10-13 16:02:56.794003
# 返回当前本地日期和时间
print(datetime.datetime.utcnow()) 输出： 2021-10-13 08:02:56.794003
# 返回当前UTC日期和时间 （UTC时间与北京时间差8个小时）
print(datetime.datetime.fromtimestamp(999999999.999)) 输出： 2001-09-09 09:46:39.999000
# 返回与UNIX时间戳对应的本地日期和时间
print(datetime.datetime.utcfromtimestamp(999999999.999)) 输出： 2001-09-09 01:46:39.999000
# 返回与UNIX时间戳对应的UTC日期和时间
print(datetime.date(2021,10,13)) 输出：2021-10-13
# 表示日期信息
print(datetime.time(23,59,58,1999)) 输出：23:59:58.001999
# 表示一天中的具体时间信息
print(datetime.timedelta())
# 计算日期间的差异