Pandas模块

前言：

最近公司有数据分析的任务，若是使用Python作数据分析，那么对Pandas模块的学习是必不可少的；

本篇文章基于Pandas 0.20.0版本

话很少说社会你根哥！开干！

pip install -i https://pypi.tuna.tsinghua.edu.cn/simple pandas==0.20.0

 

1、数据分析须要的基本数据结构

数据统计、分析创建在二维表为基础数据结构之上，每一行称为1个Case，每1列成为1个variable ；

按列分析：分析每 1个变量的变化、趋势、统计信息；

按行分析：对case进行分组、归类；

 

2、Pandas读取源数据

没有数据 怎么作分析呢？数据可能须要您本身建立，也多是其余数据源，因此Pandas能够从各类数据源中导入数据， EXCEL/ CSV/ 统计软件/数据库.....

 

1.手工创建数据框

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行

#新建数据库框
df1=pd.DataFrame({ 'var1':1.0, 'var2':[5,2,0,1,3,1,4], 'var3':'张根' #常数
}) ''' var1 var2 var3 0 1.0 5 张根 1 1.0 2 张根 2 1.0 0 张根 3 1.0 1 张根 4 1.0 3 张根 5 1.0 1 张根 6 1.0 4 张根 '''

以列为单位构造数据框

df1=pd.DataFrame(data=[[1,"test"],[2,"train"],[3,'test'],[4,'train']],columns=['var2','va3']) #columns 列
''' var2 va3 0 1 test 1 2 train 2 3 test 3 4 train '''
print(df1)

一行为单位建立数据库框

 

2.Pandas文件读取

Pandas提供了2个读取文件方法，其中read_csv()能够用于读取文本文件，read_excel()用于读取Excel格式文件；

filepath_or_buffe： 打开文件路径 sep: 设置列分隔符 ',' head: 设置从第几行开始 usecols: 设置使用的列 na_values: 设置为 NaN 缺失值

2.1 read_csv()

可读取csv格式文件，默认以' ,' 分割为 1列，注意read_csv()方法不只能够读取CSV格式的文件，它通用于文本文件的读取；

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
 df1=pd.read_csv('univ.csv',encoding='gbk')  #注意文件名称 1定要是英文
print(df1) ''' 名次 学校名称 总分 类型 所在省份 所在城市 办学方向 主管部门 0 1 北京大学 100.00 综合 北京 北京市 中国研究型 教育部 1 2 清华大学 98.50 理工 北京 北京市 中国研究型 教育部 2 3 复旦大学 82.79 综合 上海 上海市 中国研究型 教育部 3 4 武汉大学 82.43 综合 湖北 武汉市 中国研究型 教育部 4 5 浙江大学 82.38 综合 浙江 杭州市 中国研究型 教育部 .. ... ... ... .. ... ... ... ... 95 96 浙江师范大学 63.37 师范 浙江 金华市 区域特点研究型 浙江省 96 97 安徽大学 63.34 综合 安徽 合肥市 区域研究型 安徽省 97 98 首都医科大学 63.32 医药 北京 北京市 区域特点研究型 北京市 98 99 江南大学 63.31 综合 江苏 无锡市 区域特点研究型 教育部 99 100 山西大学 63.29 综合 山西 太原市 区域研究型 山西省 '''

pd.read_csv()

有时候个人csv数据并不是来自*.csv文件而是来自API，莫慌；

import requests import pandas as pd from io import StringIO from micro_crm.update_name_script import obtain_token sa = { 'url': 'http://39.107.6.24:8107',  # 'https://vipcloud2.cloud.sensorsdata.cn',
    'project': 'production',  # 'zhupj',
    'username': 'admin', 'password': 'UF0d6O' } class ExcelHandler(object): def __init__(self,file='D:\数据埋点方案标准模板1.xlsx'): self.file_name=file self.excel= pd.ExcelFile(self.file_name) def parser_excel(self,sheet,ignore=1,*args,**kwargs): ''' :param sheet: #sheet名称 :param args: #按照该列drop_nan :param kwargs: #{'excel列关包含的键字':'datafreme列的别名' } :return: df = obj.parser_excel('物品属性值校验表', 2, *['property_cn'], **{"property_cn": '名称', "property_enum": '枚举值'}) df = obj.parser_excel('item', 3, *['property_en'],**{"property_en": '属性英文名', "property_cn": '属性中文名', 'enumeration_value': "枚举值","enumeration_flag": '须要进行枚举值校验的字段'}) ''' df = self.excel.parse(sheet,header=None) index_col = [] rows, cols = df.shape for col in range(cols): if sum(df[col].isin(list(kwargs.values()))) > 0: index_col.append(col) if not index_col: return pd.DataFrame() df = df[index_col] df.columns = list(kwargs.keys()) df = df.dropna(subset=args)[ignore:] return df class GoodsCheckHandler(ExcelHandler):#物品表
    def __init__(self,file='D:\数据埋点方案标准模板1.xlsx'): super().__init__(file='D:\数据埋点方案标准模板1.xlsx') def get_search_columns(self): item_df = obj.parser_excel('item', 3, *['property_en'], **{"property_en": '属性英文名', "property_cn": '属性中文名', 'enumeration_value': "枚举值", "enumeration_flag": '须要进行枚举值校验的字段'}) filed_info=list(item_df.loc[item_df.enumeration_flag =="T"].property_en.values) filed_info.extend(['item_type','category'])#'item_id','item_type'为固定的item表搜素列
        return filed_info def item_search_aip(self,**kwargs): params = { 'project': kwargs.get('project'), 'q':self.sql, 'format':'csv' #'csv',
 } headers = { 'sensorsdata-token':self.token, } site_url = kwargs.get('url') + '/api/sql/query' data = requests.get(url=site_url, params=params, headers=headers).text data=data.replace('\t',',') try: df=pd.read_csv(filepath_or_buffer=StringIO(data),usecols=self.get_search_columns(), encoding='utf-8') except Exception: print('解析API数据失败，请检查列名') df=pd.DataFrame() return df def get_search_column_values(self): fileds=','.join(self.get_search_columns()) sql = 'select {0} from items;'.format(fileds)#.format(fileds)
            self.sql=sql self.token=obtain_token(sa)['token'] df=self.item_search_aip(**sa) return df obj=GoodsCheckHandler() print(obj.get_search_column_values())

df=pd.read_csv(filepath_or_buffer=StringIO(data),usecols=self.get_search_columns(), encoding='utf-8')

 

 

 

2.2 read_excel()

读取excle，以 ' tab' 分割为1列

sheet_name:指定sheet名称

df1=pd.read_excel('aa.xlsx',sheet_name=0,header=0)

read_excel()

循环遍历excel对象

df = pd.read_excel(io="pandas.xlsx", header=None) for index, item in df.iterrows():#index：索引，每一行
    print(index,item)

 

class ExcelHandler(object): def __init__(self,file='D:\数据埋点方案标准模板1.xlsx'): self.file_name=file self.excel= pd.ExcelFile(self.file_name) def parser_excel(self,sheet,ignore=1,*args,**kwargs): ''' :param sheet: #sheet名称 :param args: #按照该列drop_nan :param kwargs: #{'excel列关包含的键字':'datafreme列的别名' } :return: df = obj.parser_excel('物品属性值校验表', 2, *['property_cn'], **{"property_cn": '名称', "property_enum": '枚举值'}) df = obj.parser_excel('item', 3, *['property_en'],**{"property_en": '属性英文名', "property_cn": '属性中文名', 'enumeration_value': "枚举值","enumeration_flag": '须要进行枚举值校验的字段'}) ''' df = self.excel.parse(sheet,header=None) index_col = [] rows, cols = df.shape for col in range(cols): if sum(df[col].isin(list(kwargs.values()))) > 0: index_col.append(col) if not index_col: return pd.DataFrame() df = df[index_col] df.columns = list(kwargs.keys()) df = df.dropna(subset=args)[ignore:] return df

打开Excel

 

 

 

 

 

2.3 read_sql()

读取数据库数据

sql:须要执行的sql / 要读取的表名 con:sqlalchemy 建立的 数据库链接名称 index_col:做为索引列 的列名 columns:显示的列

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['id','initiator','alarm_time',]) ''' sql:须要执行的sql / 要读取的表名 con:sqlalchemy 建立的 数据库链接名称 index_col:做为索引列 的列名 ,columns:显示的列 '''
print(data)

read_sql()

 

 3、Pandas 输出数据

有输入就得有输出，如何把pandas读取到的数据   输出保存到外部文件？

 

1.输出到.csv格式文件

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data_frame=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['id','initiator','alarm_time',]) data_frame.to_csv(path_or_buf='zhanggen.csv',sep='|',columns=['id','initiator','alarm_time'],header=['ID','发起人','发起时间'],index=True,mode='w',encoding='utf-8') ''' path_or_buf: 写入文件的路径 columns: 写入的列们,使用列表指定 header: 指定列名 index: 是否导出索引列（默认为True） mode: Python 写文件的模式 encoding: 指定编码 '''

to_csv()

 

2.输出到Excel文件

原来 把数据库里的数据  导出到Excel，还能够这么简单！

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data_frame=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['id','initiator','alarm_time',]) data_frame.to_excel(excel_writer='zhanggen.xlsx',sheet_name='工单数据' ,columns=['id','initiator','alarm_time'],header=['ID','发起人','发起时间'],index=True,encoding='utf-8') ''' excel_writer: Excel路径 sheet_name: 指定Excel中sheet名称 columns: 写入的列们,使用列表指定 header: 指定列名 index: 是否导出索引列（默认为True） encoding: 指定编码 '''

to_excel()

 

追加写

startrow=指定从第几行开始写

s_df.to_excel(excel_writer=writer, sheet_name='事件表&物品表match校验', index=False,encoding='utf-8',columns=['os','app_version','event','probability'],header=['应用操做系统','应用版本号','事件名称','拼表成功率'])#,startrow=10
us_df.to_excel(excel_writer=writer, sheet_name='事件表&物品表match校验', index=False,encoding='utf-8',startrow=len(s_df)+10,columns=['os','app_version','event','item_type','e_item_id'], header=['应用操做系统','应用版本号','事件名称','事件表中item_type名称','事件表中item_id'])#,startrow=10
writer.save() writer.close()

 

 

3.输出到数据库

原来pandas还能够作数据库备份！原来把Excel数据导入数据里面也如此简单！

确保数据 主键不重复！

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') backup_mysql_con=create_engine('mysql+pymysql://webproject:web@192.168.1.18:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data_frame=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['id','initiator','alarm_time',]) data_frame.to_sql(name='cmdb_worker_order',con=backup_mysql_con,if_exists='replace',index=True,) ''' name: 表名 con: 数据库链接对象 if_exists: fail 若是表已经存在：fail 不作任何处理 replace 删除原表重建新表 append 在原表以后插入新数据 index :是否导出索引 True '''

to_sql()

 

4.输出为HTML文件 

如何把一个个Excel文件，经过 前端网页显示出来呢？

import pandas as pd bj08=pd.read_csv(filepath_or_buffer='PM25\Beijing_2008_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj09=pd.read_csv(filepath_or_buffer='PM25\Beijing_2009_HourlyPM25_created20140709.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj10=pd.read_csv(filepath_or_buffer='PM25\Beijing_2010_HourlyPM25_created20140709.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj11=pd.read_csv(filepath_or_buffer='PM25\Beijing_2011_HourlyPM25_created20140709.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj12=pd.read_csv(filepath_or_buffer='PM25\Beijing_2012_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj13=pd.read_csv(filepath_or_buffer='PM25\Beijing_2013_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj14=pd.read_csv(filepath_or_buffer='PM25\Beijing_2014_HourlyPM25_created20150203.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj15=pd.read_csv(filepath_or_buffer='PM25\Beijing_2015_HourlyPM25_created20160201.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj16=pd.read_csv(filepath_or_buffer='PM25\Beijing_2016_HourlyPM25_created20170201.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj=bj08.append(other=[bj09,bj10,bj11,bj12,bj13,bj14,bj15,bj16],ignore_index=True,verify_integrity=True) print(bj.to_html())

to_html()

 

5.输出为json数据

居然还能够把dataframe转成josn数据

xls = pd.ExcelFile('pandas.xlsx') df = xls.parse( header=None) df.columns=['name','age','gender'] # df=df.to_json(orient="records")
print(df.to_json())

to_json()

 

 

4、DataFrame普通列操做

数据清洗是什么？就是修改一下列名、修改一下列的数据类型。。。。。。。。。

1.查看datafreme数据

Pandas读取到的数据以后 会把数据转换成DataFrame数据类型；

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') backup_mysql_con=create_engine('mysql+pymysql://webproject:web@192.168.1.18:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data_frame=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['id','initiator','alarm_time',]) print(data_frame.info()) ''' <class 'pandas.core.frame.DataFrame'> Index: 2434 entries, 201803280808 to 201901290053203724928934 Data columns (total 3 columns): id 2434 non-null int64 initiator 2434 non-null object alarm_time 2434 non-null object dtypes: int64(1), object(2) memory usage: 76.1+ KB None '''

data_frame.info()查看pandas dataframe的基本信息

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') backup_mysql_con=create_engine('mysql+pymysql://webproject:web@192.168.1.18:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data_frame=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['id','initiator','alarm_time',]) print(data_frame.head(8))# 浏览前8条

data_frame.head(8)查看前8行

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') backup_mysql_con=create_engine('mysql+pymysql://webproject:web@192.168.1.18:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data_frame=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['id','initiator','alarm_time',]) print(data_frame[6:18])  #dataframe 还支持切片

data_frame[6:18]切片获取指定行

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') backup_mysql_con=create_engine('mysql+pymysql://webproject:web@192.168.1.18:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data_frame=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['id','initiator','alarm_time',]) print(data_frame.tail(8))# 浏览后8条

data_frame.tail(8)浏览后8条

 

2.修改列名称

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
data_frame=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') print(data_frame.columns) #查看datafreme的列属性
data_frame.columns=['名次1', '学校名称1', '总分1', '类型1', '所在省份1','所在城市1', '办学方向1','主管部门1']#修改修属性。
data_frame.rename(columns={'总分1':'总分6'},inplace=True) # 利用字典修改指定的列，inplace=True 直接修改元数据
print(data_frame.columns) data_frame.columns=['名次', '学校名称', '总分', '类型', '所在省份','所在城市', '办学方向','主管部门'] print(data_frame.columns)

重命名列

 

3.筛选列

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
data_frame=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') # print(data_frame.名次)
print(data_frame[['所在省份','名次','学校名称']])

列筛选

 

4.删除列

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
data_frame=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') d3=data_frame.drop(columns=['名次','主管部门'],inplace=False) #inplace=False 不修改源数据
del d3['名次','主管部门'] #直接删除元数据列，尽可能少这么干
print(d3)

删除列

 

5.列数据类型转换

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
data_frame=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') print(data_frame.dtypes) #查看列的 数据类型 object 字符串变量
print(data_frame.astype(dtype='str',copy=True,errors='raise').dtypes) print(data_frame.名次.astype(dtype='int',copy=True,errors='raise').dtypes)#修改指定列（名次列）
''' dtype: 指定转成的数据类型 copy=True 是否生成新的副本，而不是替换原数据 errors="raise"/"ignore" 转换时出错误是否抛出 raise，忽视ignore '''

列数据类型转换

 

 

5、DataFrame索引列操做

只要数据量大了 就会 出现查询慢的问题，所以Pandas的DataFrame数据也支持 经过索引加速；

 

1.建立索引

全部的 data frame在创建的时候，自然拥有流水号（0、一、二、3.......）索引，所以这里的 建立索引指定是 自定义索引列；

注意：即便是自定义的索引也 应当避免重复，虽然索引重复程序不会报错，可是会影响数据分析过程；

建立DataDrame时手工建立索引列

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行 # data_frame=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk')
 df1=pd.DataFrame({'年龄':18,'战斗力':[90,89,98,100,],'昵称':['老狗','猴儿','大占','豆儿'],'辈分':'小弟'}) print(df1) ''' 年龄 战斗力 昵称 辈分 18 1 老狗 小弟 18 2 猴儿 小弟 18 3 大占 小弟 18 4 豆儿 小弟 '''
#全部的 data frame在创建的时候，自然拥有流水号索引，所以这里的 建立索引指定是 自定义索引,注意即便是自定义的索引也不能重复
df2=pd.DataFrame({'年龄':18,'战斗力':[90,89,98,100,],'昵称':['老狗','猴儿','大占','豆儿'],'辈分':'小弟'},index=[5,6,8,9]) print(df2) ''' 年龄 战斗力 昵称 辈分 18 90 老狗 小弟 18 89 猴儿 小弟 18 98 大占 小弟 18 100 豆儿 小弟 ''' 建立dataframe时创建索引

pd.DataFrame({'年龄':18,'战斗力':[90,89,98,100,],'昵称':['老狗','猴儿','大占','豆儿'],'辈分':'小弟'},index=[5,6,8,9])

数据读取时建立索引列

 

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col=['类型','学校名称'])  #index_col=[指定索引列]
print(df1)

pd.read_csv('univ.csv',encoding='gbk',index_col=['类型','学校名称'])

2.设置某列为索引 

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') df2=df1.set_index(keys=['名次','学校名称','总分'],drop=True,append=False,inplace=False) #设置['名次','学校名称','总分']联合索引，修改源文件
print(df2) ''' keys: 设置索引的列 drop=True: 创建索引以后是否删除该列？ append=False: 是否在原流水索引的基础上添加索引，False默认是直接替换； inplace=False:是否直接替换原数据 '''

df.set_index

3.还原索引为普通列

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') df2=df1.set_index(keys=['名次','学校名称','总分'],drop=True,append=False,inplace=False) #设置['名次','学校名称','总分']联合索引，修改源文件
print(df2) df2.reset_index(level=['学校名称','总分','名次'],drop=False,inplace=True) #还原['名次','学校名称','总分']联合索引，源文件生效
print(df2) ''' drop=True: True将该索引直接删除？False还原为普通列！ inplace=False:是否直接修改原数据 level=[] :指定还原的索引列 '''

df.reset_index()

4.修改索引

修改索引名称

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') df2=df1.set_index(keys=['名次','学校名称','总分'],drop=True,append=False,inplace=False) print(df2.index.names) df2.index.names=[None,None,None]  #修改索引名称
print(df2.index.names)

df2.index.names=[None,None,None]

修改索引值

索引值能够所有替换，但不能修改。

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') df2=df1.set_index(keys=['名次','学校名称','总分'],drop=True,append=False,inplace=False) df2.index=['a','b','c','d'] #修改索引值（必须一次性所有替换）

df2.index=['a','b','c','d']

5.强行更新索引 

经过df1.reindex() ，不加任何参数的方式还原全部索引列，没法清除 index_col=[ ]设置的索引；

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk')  #index_col=[指定索引列]
print(df1.set_index(['名次'])) print(df1.reindex()) #还原全部索引列（还原不了读取 数据设置的 cl）

df1.reindex()

 

经过df1.reindex()填充缺失值

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk')  #index_col=[指定索引列]
df2=df1.reindex([6,8,66,88,99,999999],fill_value='不知道') # 重置索引 [6,8,66,88,99,999999]，取得原来索引对应的数据填入新表，999999号索引在原数据中没有对应的数据，因此须要作填充操做；
print(df2) ''' 名次 学校名称 总分 类型 所在省份 所在城市 办学方向 主管部门 6 7.0 上海交通大学 81.76 综合 上海 上海市 中国研究型 教育部 8 9.0 国防科学技术大学 80.31 理工 湖南 长沙市 中国研究型 中央军委 66 67.0 合肥工业大学 64.88 理工 安徽 合肥市 行业特点研究型 教育部 88 89.0 中央民族大学 63.78 民族 北京 北京市 行业特点研究型 国家民委 99 100.0 山西大学 63.29 综合 山西 太原市 区域研究型 山西省 999999 NaN NaN NaN NaN NaN NaN NaN NaN '''
#显然 999999

'''' lables:[ ](列表结构的数值) copy=True:创建新对象而不是直接修改原数据 method:针对已经排序过的的索引 进行缺失值填充 method=pad / ffill: 用前面的有效数值填充 method=backfill /bfill: 用后面的有效数值填充 method=nearest: 使用最近的数值进行填充 fill_value='不知道' limit=None 设置向前、向后最大步长 '''

df1.reindex([6,8,66,88,99,999999],fill_value='不知道')

 

 

6、DataFrame行排序和筛选

一、排序

1.0. 根据索引排序：为何要设置索引就是 便于快速排序、查询！

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk')  #index_col=[指定索引列]
df1.set_index(['类型','学校名称'],inplace=True) #创建二重索引
df1.sort_index(level=['类型','学校名称'],ascending=[True,False],na_position='last',inplace=True) ''' level:多重索引时，用于排序的级别号，和名称 ascending=[True,False] 指定升序？降序？多列时以列表形式提供 na_position='last/first' 缺失值放在最前仍是最后 inplace=True 修改原数据框 '''
print(df1)

df1.sort_index(level=['类型','学校名称'],ascending=[True,False],na_position='last',inplace=True)

1.1.根据变量值（列名称）进行排序：若是没有设置索引，也须要对数据进行排序，那么只能使用变量值进行排序了，虽然相比索引排序会较慢；

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk')  #index_col=[指定索引列]
df1.sort_values(by=['类型','学校名称'],axis=0,ascending=[True,False],na_position='last',inplace=True) ''' by: 多重索引时，用于排序的变量名称 ascending=[True,False] 是否为升序排序？ na_position='last/first' 设置缺失值 排列的顺序 最前 仍是最后 inplace=True 是否对原数据框进行修改？ '''
print(df1)

df1.sort_values(by=['类型','学校名称'],axis=0,ascending=[True,False],na_position='last',inplace=True)

 

2.筛选

Pandas全部筛选都是基于 对行、列 设置 True/ False 值，True的是命中的、False的是为未命中的不显示的；

 

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') setlist=[True,False,True,True,False,True] print(df1.iloc[setlist]) ''' 名次 学校名称 总分 类型 所在省份 所在城市 办学方向 主管部门 0 1 北京大学 100.00 综合 北京 北京市 中国研究型 教育部 True 2 3 复旦大学 82.79 综合 上海 上海市 中国研究型 教育部 True 3 4 武汉大学 82.43 综合 湖北 武汉市 中国研究型 教育部 True 5 6 中国人民大学 81.98 综合 北京 北京市 中国研究型 教育部 True '''

全部筛选的本质都基于 设置（行、列的）True/False 值进行的筛选的；

 

2.0. 绝对位置筛选：按照行、列的绝对位置进行筛选

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') #iloc 即integer location 按照行、列序号进行检索，支持同时指定行列，指定列时须要先用","表名列序号
print(df1.iloc[0:3])               #筛选前3行
print(df1.iloc[[0,3]])             #筛选第 0行 和第3行
print(df1.iloc[:,0:3])             #筛选全部行(:)的的 第0 - 3列
print(df1.iloc[[1,4],0:3])         #筛选第 一、4行 的 第0 - 3列
print(df1.iloc[ [1,4],[0,3] ])     #筛选第 一、4行 的 第0、3列
print(df1.iloc[ 1:4,[0,3] ])         #筛选第 1到4行 的 第0、3列

df1.iloc[0:3]

 

2.1.按照索引值进行筛选

df.loc

根据索引位置进行切片操做

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') print(df1.loc[2:4]) # 设置名次列为索引列，获取索引为2 -- 索引为4 的行

df1.loc[2:4]

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') df1.set_index(keys=['学校名称'],inplace=True) print(df1.loc['北京大学':'复旦大学'])  #以 学校名称列为索引，获取 从北京大学-----复旦大学的行

df1.loc['北京大学':'复旦大学']

 

根据索引筛选指定行

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') df1.set_index(keys=['学校名称'],inplace=True) print(df1.loc[['北京大学','清华大学',]])  #以 学校名称列为索引，仅获取 [北京大学、清华大学] 行

df1.loc[['北京大学','清华大学',]]

根据索引筛选指定的行 和 列

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') df1.set_index(keys=['学校名称'],inplace=True) print(df1.loc[['北京大学','清华大学',],['名次','所在省份']])  #以 学校名称列为索引，仅获取 [北京大学、清华大学]行，仅获取【名次','所在省份】列

df1.loc[['北京大学','清华大学',],['名次','所在省份']]

 

2.2 多重索引检索

For example 现有中国大学名单，设置 “所在省份“,“学校名称”2列为多重索引；

利用多重索引进行检索，场景有3： 

场景1:  仅使用1级索引

pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col=['所在省份','学校名称']) # 设置多重索引 index_col=【所在省份、学校名称】
print(df1.loc[['河南','河北']])  #获取在河北、河南省的大学

df1.loc[['河南','河北']]

场景2:  使用 下级（2...）级索引

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col=['所在省份','学校名称']) # 设置多重索引 index_col=【所在省份、学校名称】
print(df1.xs(key='郑州大学',level=1,drop_level=False)) #利用二级索引学校名称 筛选出郑州大学
''' 名次 总分 类型 所在城市 办学方向 主管部门 所在省份 学校名称 （多重索引） 河南 郑州大学 62 65.01 综合 郑州市 区域研究型 河南省 '''

df1.xs(key='郑州大学',level=1,drop_level=False)

场景3. 多重索引所有TM给我利用上

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col=['所在省份','学校名称']) # 设置多重索引 index_col=【所在省份、学校名称】 # print(df1.loc[['河南','河北']]) #获取在河北、河南省的大学
print(df1.loc[[('河南','解放军信息工程大学'),('河北','燕山大学')]]) #利用多重索引完整检索('所在省份','学校名称)筛选出 河南的解放军信息工程大学 河北的 燕山大学

df1.loc[[('河南','解放军信息工程大学'),('河北','燕山大学')]]

 

2.3 条件筛选

筛选出 中国排名前10的大小

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') # 设置多重索引 index_col=【所在省份、学校名称】
print( df1[df1.名次 < 11])  #筛选出 中国排名前10的大小

df1[df1.名次 < 11]

 

2.4 列表筛选

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') # 设置多重索引 index_col=【所在省份、学校名称】
print(df1[df1.名次.isin([1,5,6,8])]) #筛选 名次为 1,5,6,8 的行
print(df1[df1.所在省份.isin(['河北','河南'])]) #筛选 所在省份为 '河北','河南' 的行

df1[df1.名次.isin([1,5,6,8])]

 索引列列表筛选

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col='学校名称') # 设置 学校名称 为索引列

print(df1[df1.index.isin(['郑州大学'])])  #根据索引筛选 郑州大学

df1[df1.index.isin(['郑州大学'])]

 

2.5 多重条件联合筛选

若是单一的条件筛选没法知足筛选需求，能够把多重条件联合在一块儿进行筛选，相似Django ORM里面的 Q 查询。

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col='学校名称') # 设置 学校名称 为索引列
df2=df1[df1.名次 > 80 ] print(df2[df2.所在省份.isin(['河北','河南'])]) print('\033[1;35m ----------------------------花式一些------------------------------------\033[0m') df3=df1[df1.名次 > 80 ] [df1[df1.名次 > 80 ].所在省份.isin(['河北','河南'])] print(df3)

多条件联合筛选

 

2.6 Python条件表达式筛选 

联合条件筛选，要么一步步得引用变量，要么级联使用又容易致使语法错误；

Pandas有1中更加简单、容易的筛选方式 经过Python的条件表达式筛选；

import pandas as pd pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col='学校名称') # 设置 学校名称 为索引列
capital='北京' city='上海' df2=df1.query('名次 > 10 and 名次 < 90 and 所在省份 not in [@capital,@city ]',inplace=False) print(df2)

df1.query()

 

 

7、DataFrame列操做

 

1.新增列

1.0.生成新列

import pandas as pd import numpy,math pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col='学校名称') # 设置 学校名称 为索引列
 df1['new_row']=df1.总分+df1.名次+1     #对列进行操做 新增1列
df1.new_row=numpy.sqrt(df1.new_row)     #求新增列的平方根
df1.new_row=numpy.sqrt(df1.new_row)     #求新增列的平方根
df1.new_row=df1.总分.apply(math.sqrt)+10 #使用math模块计算平方根+10 apply

df1['new_row']=df1.总分+df1.名次+1

 

1.1.对单列进行函数运算 apply(函数)

#apply( 函数表达式)：对单列进行函数运行
def m_head(tmpstr): return tmpstr[:1] df1.new_row=df1.所在省份.apply(m_head)

df1.new_row=df1.所在省份.apply(m_hea

 

from sqlalchemy import create_engine import matplotlib.pyplot as plt import matplotlib as mpl import datetime,time import pandas as pd mpl.use('Agg') mpl.rcParams['font.sans-serif'] = ['simhei'] mpl.rcParams['font.serif'] = ['simhei'] import seaborn as sns sns.set_style("darkgrid",{"font.sans-serif":['simhei','Droid Sans Fallback']}) # pd.options.display.max_rows = 10 # 配置最多输出多少行


def later_work_pie(): mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') data=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,columns=['alarm_time','initiator','fault_category','is_late','agent']).query('fault_category in [1,2,3,4] and is_late == True',inplace=False) def Unified_time_format(time_str): time_str_list=time_str.split(' ') if len(time_str_list) != 2:  #2018.04.08 13.29.39 统一格式 2018.04.08_14:17:00
            n=time_str.replace('_', ' ').replace(':', '.') return n else: return time_str data['alarm_time']=data['alarm_time'].apply(Unified_time_format) df1 = data.set_index(pd.to_datetime(data['alarm_time'], format='%Y.%m.%d %H.%M.%S')) last_monday=(datetime.datetime.now() +datetime.timedelta(days=-7)).strftime("%Y-%m-%d %H:%M:%S") this_monday=datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S") df1=df1[last_monday:this_monday] df=pd.value_counts(df1.agent) fig = plt.figure()                              #在任何绘图以前，咱们须要一个Figure对象，能够理解成咱们须要一张画板才能开始绘图。
    ax = fig.add_subplot(111)                       #添加每个 Axes能够理解成为真正能够做画的纸。
    ax.set_title('本周超时工单信息') # print(dict(zip(df.index,df)))
    lables=[ i+' 数量：'+str(v)  for i,v in dict(zip(df.index,df)).items() ] ax.pie(df,labels=lables,shadow = False,autopct ='%3.1f%%') plt.axis('equal') plt.savefig('/WorkOrderSystemData/plotings/late_work_order.png')  #保存为图片

使用apply()函数修正不规则的时间格式

 

1.2.对多列进行函数运算 applymap(函数表达式)

#applymap(函数表达式)：对多列进行相同的函数运算
def rows_add(row1): return row1+1000

print(df1[['总分','名次']].applymap(rows_add))

print(df1[['总分','名次']].applymap(rows_add))

 

1.3.在指定位置 插入新的列

#在指定位置 插入新的列，zhuy
df2.insert(1,'nwe',df1.总分.apply(rows_add)) print(df2)

df2.insert(1,'nwe',df1.总分.apply(rows_add))

 

1.4.df.assign 不修改原 DataFreme,而是生成新的df

#df.assign 不修改原 DataFreme,而是生成新的df
df2=df1.assign(new=df1.总分.apply(rows_add))

df2=df1.assign(new=df1.总分.apply(rows_add))

import pandas as pd import numpy,math pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk',index_col='学校名称') # 设置 学校名称 为索引列
 df1['new_row']=df1.总分+df1.名次+1     #对列进行操做 新增1列
df1.new_row=numpy.sqrt(df1.new_row)     #求新增列的平方根
df1.new_row=numpy.sqrt(df1.new_row)     #求新增列的平方根
df1.new_row=df1.总分.apply(math.sqrt)+10 #使用math模块计算平方根+10 apply



#apply( 函数表达式)：对单列进行函数运行
def m_head(tmpstr): return tmpstr[:1] df1.new_row=df1.所在省份.apply(m_head) #applymap(函数表达式)：对多列进行相同的函数运算
def rows_add(row1): return row1+1000

print(df1[['总分','名次']].applymap(rows_add)) #df.assign 不修改原 DataFreme,而是生成新的df
df2=df1.assign(new=df1.总分.apply(rows_add)) #在指定位置 插入新的列，zhuy
df2.insert(1,'nwe',df1.总分.apply(rows_add)) print(df2)

代码

 

1.15.在最后的位置插入新的列 

successful_df.insert(len(successful_df.columns),'probability',[ successful_df_count/total_count for i in range(len(successful_df))])

 

 

2.列中内容替换

2.1.对应数值的替换

import pandas as pd import numpy,math pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') # 设置 学校名称 为索引列

#精确替换单个值
df1.loc[1,'所在城市']='铁岭' #索引为3的行的 所在所在城市列 替换为唐县

#批量替换单个值
print(df1.replace('北京市','帝都',inplace=False)) #列表形式批量替换 多个值
print(df1.replace(['北京市','上海市'],['帝都','魔都'],inplace=False)) #字典形式
print(df1.replace({'北京市':"帝都",'上海市':"魔都"},inplace=False))

print(df1.replace('北京市','帝都',inplace=False))

 

2.2.指定范围替换

import pandas as pd import numpy,math,re pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') # 设置 学校名称 为索引列
 df2=df1.replace(regex=r'.*大学',value='野鸡大学') #正则表达式替换

正则df1.replace(regex=r'.*大学',value='野鸡大学')

import pandas as pd import numpy,math,re pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') # 设置 学校名称 为索引列
 df2=df1.replace(regex=r'.*大学',value='野鸡大学') #正则表达式替换
print(df2) df1.loc[0:2,'总分']=250           #将前两行 总分列替换为250 # print(df1)
df1.loc[df1.名次 < 10,'总分']=20  #将前10行的 总分列替换为20 # print(df1.head(10))
df1.loc[df1.query('名次 < 10 and 类型 == "综合"').index,'总分']=110 #将排名前10的类型等于综总分修改成110 # print(df1)

df1.loc

 

2.3.哑变量转换

虚拟变量（dummy variable），有的书上也称哑变量、假变量。我我的更喜欢虚拟变量这个称谓。由于“虚拟”这个词直接表达出了这个变量的含义。 虚拟，是与真实相对的，表示这个变量不是一个真实的变量。好比性别，用0和1表示，这里的0和1不是个真实的数值，而只是男和女的代码。我能够用0 和1表示，也能够用1和2表示，还能够用4和8表示，不管什么数值均可以表示，只不过咱们习惯于用0和1表示而已。他们的差值也没有任何实际意义，不能说男和女相差1-0=1。0和1仅仅是个代码，这就是虚拟的含义。 现实中，虚拟变量通常用于多分类变量的不少状况下。好比，若是自变量是血型，分A、B、O、AB型。若是...

import pandas as pd import numpy,math,re pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') # 设置 学校名称 为索引列 # print(pd.get_dummies(df1.类型,prefix='pre'))

print(pd.get_dummies(df1,columns=['类型'])) ''' data:但愿转换的数据框、变量列 prefix:哑变量名称的前缀 prefix_sep:前缀和变量名称之间的分隔符 '''

哑变量转换

 

2.4.数值分段

相似于对学生成绩作 优良中差划分

import pandas as pd import numpy,math,re pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('univ.csv',encoding='gbk') # 设置 学校名称 为索引列
df1['cls']=pd.cut(df1.名次,bins=[1,3,7],right=False) #数据值变量分段
''' 名次 学校名称 总分 类型 所在省份 所在城市 办学方向 主管部门 cls 0 1 北京大学 100.00 综合 北京 北京市 中国研究型 教育部 [1, 3) 1 2 清华大学 98.50 理工 北京 北京市 中国研究型 教育部 [1, 3) 2 3 复旦大学 82.79 综合 上海 上海市 中国研究型 教育部 [3, 7) 3 4 武汉大学 82.43 综合 湖北 武汉市 中国研究型 教育部 [3, 7) 4 5 浙江大学 82.38 综合 浙江 杭州市 中国研究型 教育部 [3, 7) '''
print(df1.head(10))

df1['cls']=pd.cut(df1.名次,bins=[1,3,7],right=False)

 

8、DataFrame 数据框架管理

前面是对DataFrame的导入、索引、行、列的操做，下面主要讲述的是对 DataFrame数据的拆分、分组、汇总、结构调整、连表操做；

 

1.分组拆分和汇总

1.0.分组

注意：若是上下2行相同就会合并为1条记录，因此groupby有去重的效果；

# #说明、公共属性、自定义事件表=1个事件表
df = pd.read_excel(io="pandas.xlsx",header=None) df.columns = ['name','gender','age']#赋予变量给列
df1=df.groupby(['name'])['age'].unique() for value in df1.index.values: # if len(df1[value]) > 1:
        print(df1[value])

去重

 

 

 

 

 

 

 

顾名思义就是 MySQL中的 group by；

import pandas as pd import numpy,math,re pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('a.csv',sep='|') # 设置 个体ID 、年龄 为索引列

print(df1.groupby('名称').groups)     # .groupby进行分组，.groups查看分组状况
print(df1.groupby('名称').describe()) #分析 各组的每一个数值列 的计数，平均值，标准差，最小值，最大值以及较低的百分位。
print(df1.groupby(['名称','ID']).mean()) #对 数据进行 多重分组，并对每一个求出 全部数字列的均值
print(df1.groupby(['类型']).get_group('农林').mean()) #获取其中的一组，求均值


print(df1.groupby('名称')['排名'].min())   #按名称分组，求每组中 排名列 的 最小值
print(df1.groupby('名称')['排名'].mean()) #按名称分组，求每组中 排名列 的 均值
print(df1.groupby('名称')['排名'].max())  #按名称分组，求每组中 排名列 的 最大值

df1.groupby('名称')

1.1.汇总

分组汇总如图所示 就是 先拆分也就是分组，而后运用 pandas的API 对每组数据进求和、求平均.... 

Split--->Apply--->Combine

 

 

 

import pandas as pd import numpy,math,re pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_csv('a.csv',sep='|') # 设置 个体ID 、年龄 为索引列
 df2=df1.groupby('名称') #1.split 分组
def mymean(x): return x.mean() print(df2.agg('count'))  #求每组的个数
print(df2.agg(['mean','median' ])) #求均数、中位数（涉及全部数值列）
df2.agg(mymean)                      #自定义分组函数

.agg 拆分以后的汇总操做

 

 2.长形格式和宽形格式相互转换

2.0.什么是长形格式和宽形格式？

长形格式：每1个个体的 每1次测量都会被单独 记录为1个 Case（行），有几回测量就会有几行！

特征：同1个个体的信息会重复出现

宽形格式：每一个个体被记录为1个case，不一样的测量指标被记录为不一样的变量

特征：1个个体的信息不会重复出现

 

2.1.长形和宽形格式如何相互转换？

import pandas as pd import numpy,math,re pd.options.display.max_rows=10 #配置最多输出多少行
df1=pd.read_excel('children.xlsx',index_col=[0,2]) #Pandas基于多重索引，作长形和宽形相互转换
df2=df1.stack() #转换成最简的 多重索引模式 #print(df2.unstack(level=1)) # level=你要unstack 的索引级别（也就是把那列 进行分组 展开变成列） # print(df2.unstack([1,2])) #把 level 1的年龄列和 性别 测量值都展开变成列 # print(df1.T) #数据转置（列变行）

print(df2.unstack([1,2]))

 

3.多数据源的合并

如何把2个或者多个 Excel文件、CSV文件在Pandas中合并起来呢？读取了数据库中的2中有外键关系的表如何进行连表呢？

 

3.0.纵向合并

纵向合并就是把 用有相同列属性 的数据上下合并在一块儿；

import pandas as pd import numpy,math,re from sqlalchemy import create_engine import matplotlib.pyplot as plt import matplotlib as mpl mpl.rcParams['font.sans-serif'] = ['KaiTi'] mpl.rcParams['font.serif'] = ['KaiTi'] pd.options.display.max_rows=50 #配置最多输出多少行
df1=pd.read_csv('a.csv',sep='|') df2=pd.read_csv('b.csv',sep='|') # print(df1.append(other=df2,ignore_index=True,verify_integrity=True)) #other：合并链接的对象 ignore_index：忽略原来的索引 verify_integrity 验证索引的错误报错
print(df1.append(other=[df2[:10],df2[10:]],ignore_index=True,verify_integrity=True))   #合并多个数据源 使用列表[ 传参]；

print(df1.append(other=[df2[:10],df2[10:]],ignore_index=True,verify_integrity=True))

import pandas as pd bj08=pd.read_csv(filepath_or_buffer='PM25\Beijing_2008_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj09=pd.read_csv(filepath_or_buffer='PM25\Beijing_2009_HourlyPM25_created20140709.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj10=pd.read_csv(filepath_or_buffer='PM25\Beijing_2010_HourlyPM25_created20140709.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj11=pd.read_csv(filepath_or_buffer='PM25\Beijing_2011_HourlyPM25_created20140709.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj12=pd.read_csv(filepath_or_buffer='PM25\Beijing_2012_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj13=pd.read_csv(filepath_or_buffer='PM25\Beijing_2013_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj14=pd.read_csv(filepath_or_buffer='PM25\Beijing_2014_HourlyPM25_created20150203.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj15=pd.read_csv(filepath_or_buffer='PM25\Beijing_2015_HourlyPM25_created20160201.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj16=pd.read_csv(filepath_or_buffer='PM25\Beijing_2016_HourlyPM25_created20170201.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj=bj08.append(other=[bj09,bj10,bj11,bj12,bj13,bj14,bj15,bj16],ignore_index=True,verify_integrity=True) print(bj.to_html())

append纵向合并北京PM2.5

 

3.1 横向合并

横向合并 相似 MySQL中的join连表操做，在Pandas中使用pd.merge、join、concat 方法都可实现，Actually 吾生有崖，学无涯，So I only studied meger method of Pandas， 如下是merge()接受的参数；

left: 拼接的左侧DataFrame对象 right: 拼接的右侧DataFrame对象 how:left/right/inner（和MySQL的SQL连表规则是同样同样的） let: 左侧链接（显示左侧表所有数据，若是右侧表没有对应的数据，NAN代替） right:右侧链接（显示右侧表所有数据，若是左侧表没有对应的数据，NAN代替） inner:等值链接（公平 只显示有关联的数据） left_index=True/False: 使用左侧表的索引去链接 right_index=True/Fales: 使用右侧表的索引去链接 sort=True:是否排序 indicator:新增1列 标记数据来源 right_only/left_only/both

 

import numpy,math,re from sqlalchemy import create_engine import matplotlib.pyplot as plt import matplotlib as mpl mpl.rcParams['font.sans-serif'] = ['KaiTi'] mpl.rcParams['font.serif'] = ['KaiTi'] pd.options.display.max_rows=50 #配置最多输出多少行
df1=pd.read_csv('a.csv',sep='|') df2=pd.read_csv('b.csv',sep='|') df3=pd.read_csv('c.csv',sep='|') df4=df1.append(df2) df5=pd.merge(df3,df4) print(df5)

pd.merge()

import pandas as pd from sqlalchemy import create_engine pd.options.display.max_rows=20 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web?charset=utf8') df1=pd.read_sql(sql='cmdb_host',con=mysql_con,columns=['hostname','ip_addr','port','idc_id'])[:20] df2=pd.read_sql(sql='cmdb_idc',con=mysql_con,columns=['id','name'])[:20] # print(df1) # print(df2)
print(pd.merge(left=df1,right=df2,how='right',left_on='idc_id',right_on='id',sort=True,indicator='来源标记')) ''' left: 拼接的左侧DataFrame对象 right: 拼接的右侧DataFrame对象 how:left/right/inner let: 左侧链接（显示左侧表所有数据，若是右侧表没有对应的数据，NAN代替） right:右侧链接（显示右侧表所有数据，若是左侧表没有对应的数据，NAN代替） inner:等值链接（公平 只显示有关联的数据） left_index=True/False: 使用左侧表的索引去链接 right_index=True/Fales: 使用右侧表的索引去链接 sort=True:是否排序 indicator:新增1列 标记数据来源 right_only/left_only/both '''

Pandas.merge（）模拟数据库链接操做

 

 

 

9、Pandas数据清洗

以上内容介绍了Panda如何读取数据源、创建索引，如何修改、筛选行和列，如何合并、连表多个数据源，数据准备好了，接下来就是数据清洗工做了。

 

1.设置缺失值 

若是 DataFrame中 某些数据 是不须要参与计算、分析的，咱们能够把他们设置为系统缺失值；

在DataFrame中默认有2种缺失值  None/np.nan，使用df.isnan()进行 True/False判断。

 

1.0.系统缺失True/False判断、检查

a.检查每一个单元格是否为缺失值？

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna())              #检查每一个单元格是否为缺失值？

print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna())

b.检查 指定列 中是否包含缺失值？

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') # print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna()) #检查每一个单元格是否为缺失值？
print(df1.replace(to_replace=['北京',100],value=numpy.nan).名次.isna())          #检查指定列是否包含缺失？

print(df1.replace(to_replace=['北京',100],value=numpy.nan).名次.isna())

c.检查每行是否包含缺失值？

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') # print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna()) #检查每一个单元格是否为缺失值？ # print(df1.replace(to_replace=['北京',100],value=numpy.nan).名次.isna()) #检查指定列是否包含缺失？
print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1))       #检查每行是否包含缺失值？

print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1))

d.把包含缺失值的行 显示出来

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') # print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna()) #检查每一个单元格是否为缺失值？ # print(df1.replace(to_replace=['北京',100],value=numpy.nan).名次.isna()) #检查指定列是否包含缺失？ # print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1)) #检查每行是否包含缺失值？
print(df1[df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1)])   #把包含缺失值的行 显示出来

print(df1[df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1)])

 

 

1.1.缺失值设置为None/numpy.nan的区别

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') print(None==None)             #True
print(numpy.nan == numpy.nan)  #False 不能够和自身进行比较

None能够和自身比较，np.nan不能够；

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') df2=df1.replace(to_replace=['北京'],value=[numpy.nan]) #会把全部的 "北京" 彻底替换成 NaN
print(df1.所在省份.replace(to_replace=['北京'],value=None))#若是把缺失值设置为None时，使用左右、原来其余值代替；
''' 0 北京 1 北京 2 上海 3 湖北 '''

把缺失值设置为None时，缺失值不会变成None

 

PS.把缺失值设置为Nan

 

2.处理缺失值

对于缺失值的处理方法无非2种，替换或者删除,；

 

2.0.替换成指定数字、字符串fillna()

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') # print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna()) #检查每一个单元格是否为缺失值？ # print(df1.replace(to_replace=['北京',100],value=numpy.nan).名次.isna()) #检查指定列是否包含缺失？ # print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1)) #检查每行是否包含缺失值？ # print(df1[df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1)]) #把包含缺失值的行 显示出来
 df2=df1.replace(to_replace=['北京',100],value=numpy.nan).fillna('未知')             #把缺失值替换成 指定字符串
df3=df1.replace(to_replace=['北京',100,1,2,3],value=numpy.nan).fillna(df1.mean())    #把缺失值替换成 中位数（若是当前列的数据类型为数字 不然仍然是nan）

.fillna('未知')

根据邻近得值进行填充

new_part_pd=pd.concat([part_df,public_attr,],axis=0,sort=True,join='outer').fillna(method='pad',axis=0)##按照列（横向填充）NaN上1和

method: 根据什么规则进行填充？ pad/ffill：用前一个非缺失值去填充该缺失值,用左边的非缺失值去填充该缺失值 backfill/bfill：用下一个非缺失值填充该缺失值,用右边的非缺失值去填充该缺失值 None：指定一个值去替换缺失值（默认这种方式) limit参数：限制填充个数 axis参数：修改填充方向,默认为纵向填充,axis=1的时候,横向填充

 

 

2.1.删除缺失值 dropna()

''' axis:0 0表明行 1表明列 how: any任何1个单元格出现NAN就删除，all 全部单元格都出现 NAN才删除 thresh: 设置删除行或者列的数量 subset:指定删除的行/列 '''

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') # print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna()) #检查每一个单元格是否为缺失值？ # print(df1.replace(to_replace=['北京',100],value=numpy.nan).名次.isna()) #检查指定列是否包含缺失？ # print(df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1)) #检查每行是否包含缺失值？ # print(df1[df1.replace(to_replace=['北京',100],value=numpy.nan).isna().any(1)]) #把包含缺失值的行 显示出来


# df2=df1.replace(to_replace=['北京',100],value=numpy.nan).fillna('未知') #把缺失值替换成 指定字符串 # df3=df1.replace(to_replace=['北京',100,1,2,3],value=numpy.nan).fillna(df1.mean()) #把缺失值替换成 中位数（若是当前列的数据类型为数字 不然仍然是nan）
 df4=df1.replace(to_replace=['北京',100],value=numpy.nan).dropna(axis=0,how='any',thresh=3,subset=['总分','所在省份','名次']) ''' axis:0 0表明行 1表明列 how: any任何1个单元格出现NAN就删除，all 全部单元格都出现 NAN才删除 thresh: 设置删除行或者列的数量 subset:指定删除的行/列 '''
print(df4)

dropna(axis=0,how='any',thresh=3,subset=['总分','所在省份','名次'])

 

 

3.数据查重  .duplicated(）和重复行删除.drop_duplicates()

3.0. 新增 dup 列 标识出 重复行

PS.只有 第二次出现的才会被标识出来

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') df1['dup']=df1.duplicated(['类型','所在省份']) #标识出 '类型','所在省份'两列重复的行
print(df1)

df1['dup']=df1.duplicated(['类型','所在省份']) #标识出 '类型','所在省份'两列重复的行

 

3.1.检查索引是否重复并标识出来 index.duplicated()

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') # df1['dup']=df1.duplicated(['类型','所在省份']) #标识出 '类型','所在省份'两列重复的行 # print(df1)
 df1['dup']=df1.set_index(['类型','所在省份']).index.duplicated() print(df1)

df1['dup']=df1.set_index(['类型','所在省份']).index.duplicated()

print(sa_df.duplicated(subset=['SAevent_en','SAevent_cn', 'SAproperty_en', 'SAproperty_cn', 'SAproperty_data_type']).any())

 

 3.2.删除出现重复的行  df1.drop_duplicates()

subset:设置重复的列或者索引列 keep:重复以后删除规则（first/last/False,first保留第1个,last保留最后1个,False所有删除）

import pandas as pd import numpy df1=pd.read_csv(filepath_or_buffer='univ.csv',encoding='gbk') #  # df1['dup']=df1.duplicated(['类型','所在省份']) #标识出 '类型','所在省份'两列重复的行 # print(df1) #  # df1['dup']=df1.set_index(['类型','所在省份']).index.duplicated()

print(df1.drop_duplicates(subset=['类型','所在省份'],keep=False)) ''' subset:设置重复的列或者索引列 keep:重复以后删除规则（first/last/False,first保留第1个,last保留最后1个,False所有删除） '''

print(df1[~df1.duplicated(subset=['类型','所在省份'],keep=False)]) #简洁语法

print(df1[~df1.duplicated(subset=['类型','所在省份'],keep=False)])

 

3.3 df.empty 判断一个dataframe非空

if df_design.empty: logs.append('事件设计错误，请再检查一下事件设计！') return render(request, 'update_cname.html', {"logs": logs, "is_update": True})

 

10、处理 日期、时间数据

不少数据分析都是以时间轴为基础进行的，Maybe 小时的订单量、天天的订单量whatever....

因此咱们须要把DataFreme中时间转换成Pandas理解的时间，而后创建时间索引，进行灵活、切边 再进行汇总分析；

 

Pandas中有4种时间类型

Timestamp：　　 表示具体的日期时间(精确到秒) DatetimeIndex：　　基于Timestamp创建日期时间索引 Period： 　　 Timestamp表示精确时间而Period能够表示1段时间 Forexample （2019年6月这1月 、2019年6月1号 这1天） PeriodIndex：　　 若是基于Period时间段创建索引就是PeriodIndex

 

1.建立Timestamp和Period日期时间类型

import pandas as pd from datetime import datetime print(pd.Timestamp(datetime(1993,6,25))) #datetime become Timestamp
print(pd.Period('1993-05',freq='D'))

建立Timestamp和Period

 

2.将已有数据转成Timestamp时间类型（pd.to_datetime）

既然使用Pandas作数据分析，就得把您的日期时间数据转换成Pandas理解的时间类型

import pandas as pd from datetime import datetime bj08=pd.read_csv(filepath_or_buffer='PM25\Beijing_2008_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) print(pd.Timestamp(bj08['Date (LST)'][0])) #转换单个字符串
print(bj08['Date (LST)'].apply(pd.Timestamp)) #转成整行

#以上的日期时间转换方式若是不尽如你意，可使用to_datatime()
print(pd.to_datetime(datetime(1993,6,30,8,26))) #转换单个datetime日期
print(pd.to_datetime("1993-6-30 8:26")) #转换单个字符串日期
print(pd.to_datetime(['1993/6/30','1993.6.30'])) #转换列表日期
print(pd.to_datetime(bj08['Date (LST)'],format='%Y-%m-%d %H:%M')) #批量转换
print(pd.to_datetime(bj08[['Year','Month','Day','Hour']])) #将多列合并转换成 Timestamp时间类型

pd.to_datetime()

 

3.DatatimeIndex索引时间类型

把日期时间数据转成Timestamp时间类型后，面临如下几个问题；

如何根据时间的层级提取数据 ?(年/月/日/....）

如何快速提取指定时间的数据？

如何按照时间范围提取数据？（提取8-9月的订单）

因此最后须要创建DatatimeIndex时间索引；

import pandas as pd from datetime import datetime bj08=pd.read_csv(filepath_or_buffer='PM25\Beijing_2008_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) # print(pd.date_range('1/1/2012',periods=5,freq='M')) #生成 2012 1-5月的数据 5条记录
 bj08idx=bj08.set_index(pd.to_datetime(bj08['Date (LST)'])) #转成Datetimestamp时间类型，而后创建DatetimeIndex时间索引 # print(type(bj08idx.index)) #<class 'pandas.core.indexes.datetimes.DatetimeIndex'>

print(bj08idx['2008-11-1':'2008-11-5 9:00']) #基于DatetimeInde时间索引 切片 # print(bj08idx['2008-11-1']) #基于DatetimeIndex时间索引 获取某天的数据x

代码

 

4.基于DatatimeIndex时间索引进行分组汇总

能够根据日期时间，灵活切割数据以后，就是对数据的分组、汇总、分析了；

resample()有不少参数，参考官网；

import pandas as pd from datetime import datetime bj08=pd.read_csv(filepath_or_buffer='PM25\Beijing_2008_HourlyPM2.5_created20140325.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj08idx=bj08.set_index(pd.to_datetime(bj08['Date (LST)'])) #转成Datetimestamp时间类型，而后创建DatetimeIndex时间索引

# every_hour_data=bj08idx.index.hour #获取每一个小时的数据 # print(bj08idx.groupby(every_hour_data).max()) #获取每一个小时PM2.5的最大值


print(bj08idx.resample('3D').mean()) #按3天进行分组，而后求平均值
''' 2008-04-08 15:00:00 2008.0 4.000000 9.625000 11.500000 87.361111 2008-04-11 15:00:00 2008.0 4.000000 12.625000 11.500000 78.236111 2008-04-14 15:00:00 2008.0 4.000000 15.625000 11.500000 186.083333 2008-04-17 15:00:00 2008.0 4.000000 18.625000 11.500000 131.555556 '''

print(bj08idx.resample('3D').mean()) #按3天进行分组，而后求平均值

 

5.对时间索引缺失值的处理

若是时间索引列  的时间数据是固定时间频率，某个时间值缺失也是能够填充的；

2009-02-01 00:00:00  Beijing  2009-02-17 17:00  2009.0    2.0  17.0  17.0   
2009-02-01 01:00:00  Beijing  2009-02-17 17:00  2009.0    2.0  17.0  17.0   
2009-02-01 NAN       Beijing  2009-02-17 17:00  2009.0    2.0  17.0  17.0   
2009-02-01 03:00:00  Beijing  2009-02-17 17:00  2009.0    2.0  17.0  17.0

步骤以下

一、筛选出 value值大于0的索引（筛选出有效数据）

二、利用date_range生成崭新的完整索引

3.删除缺失值 从新创建索引

import pandas as pd from datetime import datetime bj09=pd.read_csv(filepath_or_buffer='PM25\Beijing_2009_HourlyPM25_created20140709.csv',header=2,usecols=[0,2,3,4,5,6,7,9,10]) bj09idx=bj09.set_index(pd.to_datetime(bj09['Date (LST)'])) #一、筛选出 value值大于0的索引（筛选出有效数据）
bj09idx=bj09idx[bj09idx.Value > 0] # print(bj09idx) #二、利用date_range生成崭新的完整索引
idx=pd.date_range(start='2009-02-1 00:00:00',end='2009-12-31 23:00:00',freq='H') # bj09idx.reindex(idx) #把新的索引给 bj09idx 创建新索引

#print(bj09idx[bj09idx.index.duplicated()]) #显示重复的索引，发现2个2009-03-08 03:00:00 索引 # 2009-03-08 03:00:00 1 Hr Valid #2009-03-08 03:00:00 1 Hr Valid # print(bj09idx['2009-03-08']) #

#3.删除缺失值 从新创建索引
bj10idx10=bj09idx[~bj09idx.index.duplicated()].reindex(idx,method='bfill') #print(bj10idx10.shift(3)) #序列数值平移

代码

 

 

11、基于Pandas对数据绘图

import numpy,math,re from sqlalchemy import create_engine import matplotlib.pyplot as plt import matplotlib as mpl import pandas as pd mpl.rcParams['font.sans-serif'] = ['KaiTi'] mpl.rcParams['font.serif'] = ['KaiTi'] pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['agent','fault_category']).query('fault_category in [0,1,2,3]',inplace=False) pd.value_counts(data.agent).plot.barh() plt.title('运维平台用户2018年工单建立量') plt.xlabel('数量') plt.ylabel('用户') plt.savefig('1.png')#保存图片（把图片保存在服务器，就能够经过前端 src啦！）
plt.show()

统计运维平台用户工单建立量

 

from sqlalchemy import create_engine import matplotlib.pyplot as plt import matplotlib as mpl import pandas as pd mpl.rcParams['font.sans-serif'] = ['KaiTi'] mpl.rcParams['font.serif'] = ['KaiTi'] pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,index_col='seach',columns=['agent','fault_category']).query('fault_category in [0,1,2,3]',inplace=False) df=pd.value_counts(data.agent) fig = plt.figure()                              #在任何绘图以前，咱们须要一个Figure对象，能够理解成咱们须要一张画板才能开始绘图。
ax = fig.add_subplot(111)                       #添加每个 Axes能够理解成为真正能够做画的纸。
 ax.set_xlabel('员工姓名')                    #plt.gcf() #获取当前Figure/plt.gca()#获取当前Axes
ax.set_ylabel('工单处理数量') ax.set_title('2018年员工工单处理数量') for a,b in zip(df.index,df.values):          #plt.text(第一个参数是x轴坐标,第二个参数是y轴坐标,第三个参数是要显式具体数字 )
    plt.text(a,b,b, ha='center', va='bottom', fontsize=19) ax.bar(df.index,df.values) #画bar条图
plt.show()

bar水平条图

 

数据读入-->创建索引---->清洗完毕了------>千辛万苦得把数据整理完了，下面就是经过 matplotlib模块绘图，来了解一下数据的概况了；

 

1.调整刻度大小

 

2.df1.plot参数

df1.plot(x=df1.index, title='工单月建立量',kind='line',figsize=(25,15))

'''
x:x轴变量名称
y:y轴的变量名称
kind:指定要绘制的图形种类
line 线图
bar 垂直的条图
barh 水平的条图
hist 方图
density 密度图
box 箱图
area面积图
pie 饼图

label:对图的描述
figsize:指定图形的宽、高

xlim/ylim：X轴Y轴的取值范围
'''

from sqlalchemy import create_engine import pandas as pd import matplotlib.pyplot as plt #导入python绘图模块
import seaborn import matplotlib.dates as mdate plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['font.serif'] = ['KaiTi'] seaborn.set_style('whitegrid',{'font.sans-serif':['simhei','Arial']}) #seaborn模块美化绘图的模块 加上白色空格
 mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') data=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,columns=['alarm_time','agent','fault_category']).query('fault_category not in [0,1,2,3]',inplace=False) df1=data.set_index(pd.to_datetime(data['alarm_time'],format='%Y.%m.%d_%H:%M:%S')).resample('M').agent.count() df1.plot(x=df1.index, title='工单月建立量',kind='line',figsize=(25,15)) plt.tick_params(axis="both",which="major",labelsize=8) plt.show() #plt.savefig('1.png')#保存图片（把图片保存在服务器，就能够经过前端 src啦！）






''' x:x轴变量名称 y:y轴的变量名称 kind:指定要绘制的图形种类 line 线图 bar 垂直的条图 barh 水平的条图 hist 方图 density 密度图 box 箱图 area面积图 pie 饼图 label:对图的描述 figsize:指定图形的宽、高 xlim/ylim：X轴Y轴的取值范围 '''

代码

 

 

3.设置matplotlib x轴的时间刻度、显示格式 参考

import numpy,math,re from sqlalchemy import create_engine import pandas as pd import matplotlib.pyplot as plt #导入python绘图模块
import seaborn import matplotlib.dates as mdate from matplotlib.dates import DateFormatter,datestr2num,DateFormatter # plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['font.serif'] = ['KaiTi'] seaborn.set_style('whitegrid',{'font.sans-serif':['simhei','Arial']}) #seaborn模块美化绘图的模块 加上白色空格
 mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') data=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,columns=['alarm_time','agent','fault_category']).query('fault_category not in [0,1,2,3]',inplace=False) df1=data.set_index(pd.to_datetime(data['alarm_time'],format='%Y.%m.%d_%H:%M:%S')). resample('M').count() fig = plt.figure()                              #在任何绘图以前，咱们须要一个Figure对象，能够理解成咱们须要一张画板才能开始绘图。
ax = fig.add_subplot(111)                       #添加每个 Axes能够理解成为真正能够做画的纸。
 formatter = DateFormatter('%m')                 #设置时间显示格式 为/月
ax.xaxis.set_major_locator(mdate.MonthLocator()) ax.xaxis.set_major_formatter(formatter) ax.set_xlabel('时间(月份)')                    #plt.gcf() #获取当前Figure/plt.gca()#获取当前Axes
ax.set_ylabel('数量') ax.set_title('2018年工单建立状况') ax.plot(df1.index,df1['fault_category'],color='r') plt.show() # plt.savefig('3.png') #保存图片

代码

 

 

4.plt.text()在图形中添加纯文本注释，显示具体数值。

plt.text(第一个参数是x轴坐标,第二个参数是y轴坐标,第三个参数是要显式具体数字 )

for a,b in zip(df.index,df.values): plt.text(a, b,b, ha='center', va='bottom', fontsize=9)

plt.text(a, b,b, ha='center', va='bottom', fontsize=9)

 

 

5.pie饼图

from sqlalchemy import create_engine import matplotlib.pyplot as plt import matplotlib as mpl import pandas as pd mpl.rcParams['font.sans-serif'] = ['KaiTi'] mpl.rcParams['font.serif'] = ['KaiTi'] pd.options.display.max_rows=10 #配置最多输出多少行
mysql_con=create_engine('mysql+pymysql://webproject:xxxxxx1234@172.17.10.112:3306/web') oracle_conn=create_engine('oracle+cx_oracle://scott:tiger@172.16.22.16:1521/ecdb') data=pd.read_sql(sql='cmdb_worker_order',con=mysql_con,columns=['initiator','fault_category','is_late','agent']).query('fault_category in [0,1,2,3,4] and is_late == True',inplace=False) df=pd.value_counts(data.agent) fig = plt.figure()                              #在任何绘图以前，咱们须要一个Figure对象，能够理解成咱们须要一张画板才能开始绘图。
ax = fig.add_subplot(111)                       #添加每个 Axes能够理解成为真正能够做画的纸。
ax.set_title('当前超时工单信息') print(dict(zip(df.index,df))) lables=[ i+' 数量：'+str(v)  for i,v in dict(zip(df.index,df)).items() ] ax.pie(df,labels=lables,shadow = False,autopct ='%3.1f%%') plt.axis('equal') plt.savefig('late_work_order.png')  #保存为图片

饼图

 

以上是我对pandas0.20.0版本的使用，如下是我对pandas0.25.1版本的使用

行操做

获取df中的第X行数据

xls = pd.ExcelFile('pandas.xlsx') df = xls.parse(header=None) print(df.iloc[3]) ''' 0 小王 1 12 2 女 Name: 3, dtype: object '''
#若是是仅有1列的df可以使用函数

df.columns=['name','age','gender']
df1=df.groupby(by='name').size().loc[lambda x: x == 1]
print(df['name'].loc[lambda x:x=='小丽'])

 

 

获取df的每1行数据以及索引

xls = pd.ExcelFile('pandas.xlsx') df = xls.parse( header=None) for index, item in df.iterrows(): print(item) ''' 0 姓名 1 年龄 2 性别 Name: 0, dtype: object 0 张根 1 18 2 男 Name: 1, dtype: object '''

 

 精确获取第X行中的第X个数据

xls = pd.ExcelFile('pandas.xlsx') df = xls.parse(header=None) print(df.iloc[4,0])#位于第4行中的第0个元素

 

 

拆分1个大的单元格

for index, item in df.iterrows(): if index == 0: item[1] = '公共属性' item[2] = '公共属性'
        elif not pd.isnull(item[1]): pass
        else: item[1] = df.iloc[index - 1, 1].replace('\n','') item[2] = df.iloc[index - 1, 2] item[7] = df.iloc[index - 1, 7] item[8] = df.iloc[index - 1, 8]

 

使用df.iloc[:,:3]获取X列数据

print(df.iloc[:,:3]) #获取3列数据

 

 获取1-最后1行数据（掐头）

df1[1:]

 

删除重复行

print(df1.iloc[:,0:5].drop_duplicates())#去除相同的行

 

行查询

df.columns=['os','app_version','event','item_type','e_item_id','i_item_id','i_item_type'] df_group=df.groupby(['os','app_version','event']) successful_df_list=[] unsuccessful_df_list=[] for title,item in df_group: successful_df=item.loc[(item['i_item_id'] !=numpy.NaN) & (item['item_type'] ==item['i_item_type'])] unsuccessful_df=item.loc[~((item['i_item_id'] !=numpy.NaN) & (item['item_type'] ==item['i_item_type']))]

 

 

合并操做

merge(left_on='gender', right_on='gender1')

左边和右边的df中相同的部分去掉，不一样的部分显示出来；（求2者差集）

xls = pd.ExcelFile('pandas.xlsx') df1 = xls.parse( header=None) df1.columns=['name','age','gender'] xls = pd.ExcelFile('pandas1.xlsx') df2 = xls.parse( header=None) df2.columns=['name1','age1','gender1'] df3=df1.merge(df2, left_on='gender', right_on='gender1')#左边表里的和右表里面的列是同样的我就合并
print(df3)

 

 

 

 

 

Matplotlib详解图像各个部分

Matplotlib基本用法

Pandas官网