pandas主要操作 & 读取数据文件

【转载】

本文原创出处： http://www.cnblogs.com/xiaoxuebiye/p/7223774.html 导入数据： pd.

一、pandas主要操作

1、导入数据：

pd.read_csv(filename)：从CSV文件导入数据
pd.read_table(filename)：从限定分隔符的文本文件导入数据
pd.read_excel(filename)：从Excel文件导入数据
pd.read_sql(query, connection_object)：从SQL表/库导入数据
pd.read_json(json_string)：从JSON格式的字符串导入数据
pd.read_html(url)：解析URL、字符串或者HTML文件，抽取其中的tables表格
pd.read_clipboard()：从你的粘贴板获取内容，并传给read_table()
pd.DataFrame(dict)：从字典对象导入数据，Key是列名，Value是数据

2、导出数据：

df.to_csv(filename)：导出数据到CSV文件
df.to_excel(filename)：导出数据到Excel文件
df.to_sql(table_name, connection_object)：导出数据到SQL表
df.to_json(filename)：以Json格式导出数据到文本文件

3、创建测试对象：

pd.DataFrame(np.random.rand(20,5))：创建20行5列的随机数组成的DataFrame对象
pd.Series(my_list)：从可迭代对象my_list创建一个Series对象
df.index = pd.date_range(‘1900/1/30’, periods=df.shape[0])：增加一个日期索引

4、查看、检查数据：

df.head(n)：查看DataFrame对象的前n行
df.tail(n)：查看DataFrame对象的最后n行
df.shape()：查看行数和列数
df.info() ：查看索引、数据类型和内存信息
df.describe()：查看数值型列的汇总统计
s.value_counts(dropna=False)：查看Series对象的唯一值和计数
df.apply(pd.Series.value_counts)：查看DataFrame对象中每一列的唯一值和计数

5、数据选取：

df[col]：根据列名，并以Series的形式返回列
df[[col1, col2]]：以DataFrame形式返回多列
df.iloc[0]：按位置选取数据
df.loc[‘index_one’]：按索引选取数据
df.iloc[0,:]：返回第一行
df.iloc[0][0]：返回第一列的第一个元素

6、数据统计：

df.describe()：查看数据值列的汇总统计
df.mean()：返回所有列的均值
df.corr()：返回列与列之间的相关系数
df.count()：返回每一列中的非空值的个数
df.max()：返回每一列的最大值
df.min()：返回每一列的最小值
df.median()：返回每一列的中位数
df.std()：返回每一列的标准差

7、数据合并：

df1.append(df2)：将df2中的行添加到df1的尾部
df.concat([df1,df2],axis=1)：将df2中的列添加到df1的尾部
df1.join(df2,on=col1,how=‘inner’)：对df1的列和df2的列执行SQL形式的join

8、数据处理：

df[df[col] > 0.5]：选择col列的值大于0.5的行
df.sort_values(col1)：按照列col1排序数据，默认升序排列
df.sort_values(col1, ascending=False)：按照列col1降序排列数据 df.sort_values([col1,col2], ascending=[True,False])：先按列col1升序排列，后按col2降序排列数据
df.groupby(col)：返回一个按列col进行分组的Groupby对象
df.groupby([col1,col2])：返回一个按多列进行分组的Groupby对象
df.groupby(col1)[col2]：返回按列col1进行分组后，列col2的均值
df.pivot_table(index=col1, values=[col2,col3], aggfunc=max)：创建一个按列col1进行分组，并计算col2和col3的最大值的数据透视表
df.groupby(col1).agg(np.mean)：返回按列col1分组的所有列的均值
df.apply(np.mean)：对DataFrame中的每一列应用函数np.mean
df.apply(np.max,axis=1)：对DataFrame中的每一行应用函数np.max

9、数据清理：

df.duplicated() :判断各行是重复，False为非重复值 df.drop_duplicates()：删除重复行
df.fillna(0)：用实数0填充na
df.dropna()：按行删除缺失数据，使用参数axis=0；按列删除缺失值，使用参数axis=1，how = “all” 全部是NA才删，"any"只要有NA就删除
del df[‘col1’]：直接删除某列
df.drop([‘col1’,……],axis=1)：删除指定列，也可以删除指定行
df.rename(index={‘row1’:‘A’},columns ={‘col1’:‘B’})：重命名索引名和列名
df.replace()：替换df值，前后值可以用字典表,{‘1’:‘A’,'2:‘B’}
hr_data[‘col1’].map(function)：Series.map，对指定列进行函数转换
pd.merge(df1,df2,on=‘col1’,how=‘inner’,sort=True)：合并两个df，按照共有的列作内连接（交集），outter为外连接（并集），结果排序。
pd.concat([df1,df2])：多个Series堆叠成多行。
df1.combine_first(df2)：用df2的数据补充df1的缺失值NAN。

10、其它操作：

改列名：

方法1 a.columns = [‘a’,‘b’,‘c’]

方法2 a.rename(columns={‘A’:‘a’, ‘B’:‘b’, ‘C’:‘c’}, inplace = True)

插入行列

http://www.jianshu.com/p/7df2593a01ce

相关参考链接：****

参考
http://www.qingpingshan.com/rjbc/dashuju/228593.html

十分钟搞定
http://python.jobbole.com/84416/

官方文档
http://pandas.pydata.org/pandas-docs/stable/index.html

操作索引
https://www.dataquest.io/blog/images/cheat-sheets/pandas-cheat-sheet.pdf

进阶

取数（元素）：

取df中某一个具体的数据 iloc index locate 举例 ：
print df.iloc[0,0]
print df.iloc[1, 1]
print df.iloc[19, 7]

如果 df 是日期索引 + a,b,c 列名，用 loc locate

df.loc[ ‘2017-01-01’, ‘A’ ]

取数（行）：

one_row = df.iloc[4]
one_row2 = df.loc['2013-01-02']
print type(one_row)

取某一行， 取出来后之后的数据类型是 Series 可以 one_row.iloc[1], 再访问 Series 里的数据

print one_row.iloc[1]
print one_row.loc['A']

取数（列）：

column2 = df[‘A’]

column2 是一个 Series 类型

print type( column2 )

可访问 列里面的数据
print column2[0]
print column2[‘2013-01-03’]

取数（切片）：

行模式切片

dfsub1 = df.iloc[4:5]
print type( dfsub1 )
print dfsub1

dfsub2 = df.loc[‘2013-01-03’:‘2013-01-05’]
print dfsub2

切片的结果 还是df, 而且改变 dfsub, 会同时改变 df

列模式
print ’ get sub by column mode ’
dfsub = df[[‘A’,‘B’]]
print type( dfsub )
print dfsub

子集 row x column
方式一：
print ’ get sub by row X column mode ’
dfsub = df.loc[‘20130102’:‘20130104’, [‘A’, ‘B’]]
print type( dfsub )
print dfsub
方式二
dfsub = df.iloc[ 1:3, 1:3 ]

取数（条件切片）：

dfsub = df[ (df.A > 0) and (df.B > 0) ] 结果类型是 df

这个玩意很想数据库里的 select where

送一个特殊条件

print df[ df > 0 ]

行遍历 ：

def testForeach():

        df = pd.read_table('D:/run/data/sz002626\_2017-01-04.cvs', encoding='gbk')  # ,header=0
        df = df.sort_index(axis=0, ascending=False)
        df.columns = [1, 2, 3, 4, 5, 6]
        df[7] = 'kong'
        print  df

        # 清洗
        df\[3\] = df\[3\].replace('--', '0.00')
        df\[3\] = df\[3\].astype(float)

        #遍历
        df\[7\] = df.apply(lambda r: dorec(r), axis=1)
        print df
        pass

def dorec(rec):
        if (rec\[3\] > 0):
            return '涨'
        if (rec\[3\] < 0):
            return '跌'
        else:
            return '平'

二、参考：pandas读写数据文件

1、插入相关模块

## snippets -- import pandas
from __future__ import print_function, division
import numpy as np
import pandas as pd
from openpyxl import load_workbook
import os

print(os.listdir('..\D_DataBank\csvdata'))  # 查看当前目前下的文件

2、读取excel、csv文件

##################  snippets -- read_excel_csv

io_='./datas/excel.xls'    # 根据实际需要更新
sheet_name_=0              # 根据实际需要更新
header_=6                  # 根据实际需要，选择相应的行，作为列字段名
usecols_ = None
dtype_ = None
# usecols_ = ['保单号', '批单号', '二级机构代码', '车牌号', '光博分']    # 根据实际需要更新
# dtype_ = {'保单号': 'string','光博分': 'int64'}                       # 根据实际需要调整

my_excel = pd.read_excel(io=io_,sheet_name=sheet_name_,                                 # 指定文件 
                         header=header_, skipfooter =0,usecols=usecols_, dtype=dtype_   # 选择首行，末行，指定列，指定列数据类型
                        )

dtype_dict = dict( my_excel.dtypes)  
print(dtype_dict.keys())                         # 读取列字段名
print({k:str(v) for k,v in dtype_dict.items()})  # 获取每个列字段的格式

my_excel.head()


################ snippets -- read_csv

inputfile_='./datas/csv.csv'  # 根据实际需要更新
sheet_name_=0                 # 根据实际需要更新
header_=6                     # 根据实际需要，选择相应的行，作为列字段名
usecols_ = None
dtype_ = None
# usecols_ = ['保单号', '批单号', '二级机构代码', '车牌号', '光博分']    # 根据实际需要更新
# dtype_ = {'保单号': 'string','光博分': 'int64'}                       # 根据实际需要调整

my_csv = pd.read_csv(filepath_or_buffer=inputfile_,encoding='utf-8',sep=r',	',engine='python',  # 指定文件，编码模式，分隔符，编译方式 
                     header=header_, skipfooter =0,usecols=usecols_, dtype=dtype_                # 选择首行，末行，指定列，指定列数据类型
                     )

dtype_dict = dict( my_csv.dtypes)
print(dtype_dict.keys())                          # 读取列字段名
print({k:str(v) for k,v in dtype_dict.items()})  # 获取每个列字段的格式
# my_csv.to_excel('excel2.xlsx',index=False,)

my_csv.tail()

3、dataframe写入excel文件

## snippets -- dataframe_to_excel

## ------------直接写入一个excel表中
# my_excel.to_excel('to_sheets1.xlsx',index=False,)  #生成新的excel表格，如果之前有，删除重新新建一个表

## ------------写入到多个sheet中(测试未通过)
bookname_='aa.xlsx'     # 根据需要，更新需要写入的excel工作簿路径及文件名
sheetname_='sheet2'           # 根据需要，更新需要写入的sheet名
result2=[('a','2','ss'),('b','2','33'),('c','4','bbb')]    #列表数据
writer = pd.ExcelWriter(bookname_,engine='openpyxl')       #可以向不同的sheet写入数据
book=load_workbook(bookname_)                              #
writer.book = book
df = pd.DataFrame(result2,columns=['xuhao','id','name'])   #列表数据转为数据框
df.to_excel(writer, sheet_name=sheetname_)                 #将数据写入excel中的sheetname_表,sheet_name改变后即是新增一个sheet
writer.save()#保存

##------------在同一个sheet中追加数据 (测试未通过)

result2=[('a','2','ss'),('b','2','33'),('c','4','bbb')]#需要新写入的数据
df = pd.DataFrame(result2,columns=['xuhao','id','name'])#列表数据转为数据框
df1 = pd.DataFrame(pd.read_excel('123.xlsx',sheet_name='aa')) #读取原数据文件和表
writer = pd.ExcelWriter('123.xlsx',engine='openpyxl')
book=load_workbook('123.xlsx')
writer.book = book
writer.sheets = dict((ws.title, ws) for ws in book.worksheets)
df_rows = df1.shape[0] #获取原数据的行数
df.to_excel(writer, sheet_name='aa',startrow=df_rows+1, index=False, header=False)#将数据写入excel中的aa表,从第一个空行开始写
writer.save()#保存

4、读、写mysql数据表

# -------------  snippets read_write mysql
# 注：如果不提供dtype,to_sql会自动根据df列的dtype选择默认的数据类型输出，比如字符型会以sqlalchemy.types.TEXT类型输出，相比NVARCHAR，TEXT类型的数据所占的空间更大，所以一般会指定输出为NVARCHAR；而如果df的列的类型为np.int64时，将会导致无法识别并转换成INTEGER型，需要事先转换成int类型（用map，apply函数可以方便的转换）。

# 导入必要模块
import pandas as pd
from sqlalchemy import create_engine
import pymysql

# 初始化数据库连接，使用pymysql模块  '数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名'
# MySQL的用户：root, 密码:root, 端口：3306,数据库：ex
connection_str = 'mysql+pymysql://root:root@localhost:3306/ex'
engine = create_engine(connection_str)

# 根据sql语句,将数据库表中的数据写入DataFrame中
# read_sql_query的两个参数: sql语句， 数据库连接
df = pd.read_sql_query('select * from students', engine)

#  执行sql语句
# conn =engine.connect()
# conn.execute('select * from students')  # 执行sql 语句
# conn.close()

# 将dataframe 数据写入数据表
sql = '''    
    select name,male,age from students     
    union
    select name,male,age from students2
'''
df = pd.read_sql_query(
    sql, engine)  # read_sql_query的两个参数: sql语句， 数据库连接, 将查询结果写入dataframe
df.to_sql('temp__students', engine, index=False,
          if_exists='replace')   # 将dataframe 数据存入临时表
# print(df)

# 将dataframe中数据写添加到数据库表中,如果不存在,则追加,如果存在,则更新

table_name = 'students'   # 需要导入更新的表名称
df = pd.read_sql_query('select * from students2', engine)   # 获得取dataframe 数据
unique_field = ['name', 'male']  # 唯一字段列表，当该列表中字段全部相等时，判断为重复字段

# 将dataframe 表中数据,添加到数据库表table_name中,按照指定字段decide replace or append


def replace_into_table(engine, table_name, df, unique_field):
    '''
        # engine 为数据库的连接
        # table_name 为被追加或更新的数据表
        # df 为拟追加或更新到table_name 的dataframe 数据,
        # unique_field 为唯一字段列表
    '''
    conn = engine.connect()  # 建立与数据库的连接
    #  --  生成临时表，用于存储dataframe 数据
    try:
        conn.execute('drop table temp__%s' % (table_name))   # 删除临时表
    except:
        pass
        print('Unknown table \'temp__%s\'' %
              (table_name))   # 如果，临时表不存在，打印临时表不存在提示信息
    conn.execute('create table temp__%s like %s' %
                 (table_name, table_name))  # 创建临时表，用于查询，并删除被更新表中在临时表中存在记录

    #  --  并将dataframe 数据写入临时表
    df.to_sql('temp__%s' % (table_name), engine,
              index=False, if_exists='append')

    # --  删除被更新表中的重复项 & 删除临时表
    unique_field_rep = ','.join(
        list(map(lambda x: 'rep_.'+x, unique_field)))     # 被更新表的唯一字段字符串
    unique_field_temp = ','.join(
        list(map(lambda x: 'temp_.'+x, unique_field)))    # 拟导入临时表的唯一字段字符串

    del_re_sql = 'delete from %s rep_ where (%s) in (select %s from temp__%s temp_)' % (
        table_name, unique_field_rep, unique_field_temp, table_name)         # 将被更新表中，存在于拟导入表中的记录删除的sql语句
    conn.execute(del_re_sql)   # 执行删除重复项操作
    conn.execute('drop table temp__%s' % (table_name))  # 执行sql，删除临时表
    conn.close()  # 关闭连接

    # --  将dataframe表中数据写入到 table_name表中
    df.to_sql(table_name, engine, index=False, if_exists='append')


replace_into_table(engine, table_name, df, unique_field)  # 执行程序