pandas python 新建_python pandas excel 新建 - CSDN
精华内容
参与话题
  • 创建一个空白文件 ...import pandas as pd import numpy as np import re #from datetime import datetime from pytz import timezone import pytz import os def creat_Firfile(): shibiao,z...

    创建一个空白文件

    import datetime
    import time
    import pandas as pd
    import numpy as np
    import re
    #from datetime import datetime
    from pytz import timezone
    import pytz
    import os
    def creat_Firfile():
    
        shibiao,zhiling=[],[]
        for i in range(20*3600):
            shibiao.append(i+1)
            zhiling.append(0)
        cd=[shibiao,zhiling,zhiling,zhiling,zhiling,zhiling,zhiling,zhiling]
        listb = [[r[ionk] for r in cd] for ionk in range(len(zhiling))]
        test = pd.DataFrame(data=listb)
    
    
    
    
        test.to_csv(r'c:\Users\Administrator\Desktop\ms.csv',index=False,mode='a+',encoding='utf-8')
    
    
    
    if __name__ == '__main__':
    
        creat_Firfile()
        print('all_done')
    
    展开全文
  • 在使用python处理数据的过程中,经常需要做一些数据读取和写入的工作,比较常用的数据格式是csv,csv文件是一种以逗号分割字符的文件形式 例如:demo.csv,一个很简单的csv文件 name,score alex,1 jon,2 sansa,...

    在使用python处理数据的过程中,经常需要做一些数据读取和写入的工作,比较常用的数据格式是csv,csv文件是一种以逗号分割字符的文件形式

    例如:demo.csv,一个很简单的csv文件
    name,score
    alex,1
    jon,2
    sansa,3

    读写csv文件常用的有两种方式,一种是使用csv,一种是使用pandas

    ##1 使用pandas进行读写

    pandas 是一个非常好用的工具,能够按照格式读入和方便的写出csv文件,下面是一个简单的读文件的例子:

    import pandas as pd
    
    file = pd.read_csv('demo.csv')
    df = pd.DataFrame(file)
    
    print(df)
    

    output:
    title score 0 alex 1 1 jon 2 2 sansa 3

    如果想要一行一行的读取dataframe中的内容:

    import pandas as pd
    
    file = pd.read_csv('demo.csv')
    df = pd.DataFrame(file)
    
    for i in range(len(df)):
        document = df[i:i+1]
        print(document,'\n')
    

    output:
    title score
    0 alex 1

    title score
    1 jon 2

    title score
    2 sansa 3

    要取到document中的每个值:

    for i in range(len(df)):
        document = df[i:i+1]
        title = document['title'][i]
        score = document['score'][i]
        print(title,score,'\n')
    

    output:
    alex 1

    jon 2

    sansa 3

    使用pandas将dictionary写入csv文件,按列写入

    import pandas as pd
    
    file = pd.read_csv('demo.csv')
    df = pd.DataFrame(file)
    
    dict = {}
    for i in range(len(df)):
        document = df[i:i+1]
        title = document['title'][i]
        score = document['score'][i]
        dict[title] = score
    
    new_df = pd.DataFrame.from_dict(dict,orient='index')
    new_df.to_csv('pandas_new.csv')
    

    结果文件pandas_new.csv
    ,0
    alex,1
    jon,2
    sansa,3

    Plus:一个不错的介绍链接

    ##2 使用csv进行读写

    import csv
    
    with open('demo.csv', 'r') as csvfile:
        spamreader = csv.reader(csvfile)
        for row in spamreader:
            print(row)# type of row: list
    

    output:
    ['title,score'] ['alex,1'] ['jon,2'] ['sansa,3']

    Hints:
    When you read the csv file, if you use ‘rb’, means Read the file in Binary mode.
    while if you use ‘rt’, means Read the file in Text mode.
    I usually just use ‘r’.

    #####写

    import csv
    
    with open('new.csv','w') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow(['country','language'])#这里要以list形式写入,writer会在新建的csv文件中,一行一行写入
    

    output:
    csv文件,content:
    country,language

    Plus:如果想要以dictionary的形式读取和写入,csv也提供了DictReader,DIctWriter的方法。

    展开全文
  • Python pandas数据分析中常用方法

    万次阅读 多人点赞 2020-06-22 13:23:01
    官方教程 读取写入文件 官方IO 读取 写入 read_csv to_csv read_excel to_excel read_hdf to_hdf read_sql to_sql read_json to_json read_msgpack (experimenta...

    官方教程

    读取写入文件

    官方IO
    读取 写入
    read_csv       to_csv
    read_excel      to_excel
    read_hdf       to_hdf
    read_sql       to_sql
    read_json      to_json
    read_msgpack (experimental)   to_msgpack (experimental)
    read_html       to_html
    read_gbq (experimental)     to_gbq (experimental)
    read_stata       to_stata
    read_sas
    read_clipboard    to_clipboard
    read_pickle      to_pickle//速度比csv快
    读取CSV文件:

    pd.read_csv('foo.csv')   //读取CSV
    # header参数指定从第几行开始生成,且将header行的数据作为列的name(键),header行以前的数据将不会处理。取值为None表示csv中行不做为列的name(键),取值为0表示将csv的第0行作为列的name。| 如果没有传递参数names那么header默认为0;如果传递参数names,那么header默认为None。 
    

    存储为csv文件:

    submission = pd.DataFrame({ 'PassengerId': test_df['PassengerId'],'Survived': predictions })
    submission.to_csv("submission.csv", index=False)
    # index参数是否写入行names键
    

    从dict生成:

    pd.DataFrame.from_dict(df, orient='index')
    
    pd.DataFrame({'a':[1,2], 'b':[2,3]}, columns=['a','b'])  //a,b分别为列
    a	b
    0	1	2
    1	2	3
    
    pd.DataFrame.from_dict({'a':[1,2], 'b':[2,3]}, orient='index') .  //a,b分别为一行
    0	1
    a	1	2
    b	2	3
    

    选择数据

    官方选择教程
    官方多index选择教程

    []:

    df['A']  通过列name(键)选择列
    df[['A', 'B']]  通过list选择列
    df[0:3]  通过隐含的序列(index所在行值)选择行
    df['20130102':'20130104']   通过行index(键)选择行
    dataset[(dataset['Sex'] == i) & (dataset['Pclass'] == j+1)]['Age']        #布尔运算选择数据,以其他列为条件筛选数据,注意做布尔运算时最好将每个运算用括号括起来,像以下这种就会容易出问题:dataset[dataset['TARGET'].notnull() & dataset['need_pre']!=1 ]
    
    加不加[],生成的类型是不同的
    type(data["A1"])
    pandas.core.series.Series
    type(data[["A1"]])
    pandas.core.frame.DataFrame
    

    loc:

    dataset.loc[ dataset.Age.isnull(),'BB']  //age不是null的数据中选择BB列
    train_df.loc[:, ['Age*Class', 'Age', 'Pclass']].head(10)
    dataset.loc[ EID,'Age']  //根据index(注意这个是index的取值,而不是index所在行)选取列Age单元数据
    

    iloc:
    iloc是选择DataFrame第几行第几列(类似于数组,数值下标从0开始)

    df.iloc[3:5,0:2]
    df.iloc[1:3,:]
    df.iat[1,1]
    

    Multi-index索引:

    In [536]: result_df = df.loc[(df.index.get_level_values('A') > 1.7) & (df.index.get_level_values('B') < 666)]
    
    In [537]: result_df
    Out[537]: 
              C
    A   B      
    3.3 222  43
        333  59
    5.5 333  56
    
    In [17]: df.query('0 < A < 4 and 150 < B < 400')                            
    Out[17]:                                                                    
              C                                                                 
    A   B                                                                       
    1.1 222  40                                                                 
    3.3 222  20                                                                 
        333  11
    
    x = df.reset_index()
    In [16]: x.loc[(x.B>=111.0)&(x.B<=500.0)].set_index(['A','B'])
    Out[16]: 
              C
    A   B      
    1.1 111  81
        222  45
    3.3 222  98
        333  13
    5.5 333  89
    

    循环行数据:

    for i, row in colTypes.iterrows():
    # i为dataFrame的index,row为一行数据
    

    使用另一series作为dataframe的筛选条件:

    import numpy as np
    import pandas as pd
    df = pd.DataFrame({ 'A' : [1,2,3,4],
                         'B' : [4,5,6,7]
                      })  
    a = pd.Series([1,2,3,1])
    
    # 对series进行筛选
    (a==1).sum()
    >>>2
    
    # 对dataframe进行筛选
    df[a==1].sum(0)
    >>>
    A     5
    B    11
    dtype: int64
    

    判断是否在序列中筛选:

    meta_df = meta_df[meta_df['asin'].isin( reviews_df['asin'].unique() )]
    new_rate = new_rate[~new_rate['reviewerID'].isin(low_index)]  # not in,取反
    

    计算数据

    重复数值个数统计:

    Series.value_counts() //统计重复重现的数据的个数。返回以数据作为key,以重复个数为value的对象。
    X[c].value_counts().index[0] //最多的那个数
    

    中值计算:

    Series.median() //计算某个轴的中值
    

    计算均值和偏差:

    age_mean = guess_df.mean()
    # 计算均值
    age_std = guess_df.std()
    # 计算标准差
    

    计算众值:

    # freq_port = train_df.Embarked.dropna().mode()[0]
    # mode返回出现最多的数据,可能出现多个,因此返回数组
    

    其他:
    方法            说明
    count          非NA值得数量
    describe        针对series或各dataframe列计算汇总统计
    min max        计算最小值和最大值
    argmin,argmax    计算能够获取到最小值和最大值的索引位置(整数)

    much_nuclei = df_img['nuclei'].argmax()
    plt.imshow(imgs[much_nuclei])
    

    idxmin , idxmax     计算获取到最小值和最大值索引值

    df.idxmax()   //按列
    df.idxmax(axis=1)  //按行
    

    quantile        计算样本的分位数(0到1)
    sum           值得总和

    df.sum()   //按列求和
    df.sum(axis=1)  //按行求和
    

    mean          值得平均数

    df.mean(axis=1) //按行求和,注意,如果存在Nan值会忽略,如果整个都为nan,则取nan
    df.mean(axis=1, skipna = False) //禁止忽略nan值
    

    median         值的算数中位数
    mad           根据平均值计算平均绝对离差
    var            样本值得方差
    std            样本值得标准差
    skew          样本值得偏度(三阶矩)
    kurt           样本值的峰度(四阶矩)
    cumsum         样本值的累计和,累计累积,也就是说从开始位置到当前位置的总和

    df.cumsum()   //按列求累积和,如果当前位置为nan,直接返回nan,如果不是,而前面某个位置是,则忽略前面位置的nan
    df.cumsum(axis=1)  //按行求累积和
    

    cummin,cummax    样本值的累计最大值和累计最小值
    cumprod          样本值的累计积
    diff           计算一阶差分(对时间序列很有用)
    pct_change         计算百分数变化
    isin           判断series,dataframe数据是否在另一个变量其中

    缺失值处理

    性质:
    np.nan == np.nan
    >>> False
     
    np.isnan(np.nan)
    >>> True
     
    np.nan is None
    >>> False
     
    type(np.nan)
    >>> float
    
    检测:
    np.isnan(df)
    pd.isnull(df)
    

    方法       说明
    count      非NA值得数量
    dropna      根据各标签的值中是否存在缺失数据对轴标签进行过滤,可通过阈值调节对缺失值得容忍度
    fillna      用指定值或插值方法(如ffill或bfill)填充确实数据
    isnull      返回一个含有布尔值的对象,这些布尔值表示哪些值是缺失值/NA,该对象的类型与源类型一样
    notnull      isnull的否定式

    存在三种方法来完善连续数字特征:
    1、简单方式:在中值和标准偏差间产生一个随机数
    2、准确方式:通过相关特征猜测缺失值
    3、联合1、2基于特征组合,在中值和偏差间产生一个随机数
    显示缺失值行列:

    train_cat[train_cat.isnull().values==True]
    

    判断某列是否包含nan:

    df.isnull().any() # 判断列是否有 NaN
    df.isnull().all()  # 判断列是否全部为NaN
    

    删除缺失行:

    df.dropna(axis=0, how='any', inplace=True)
    

    缺失值填充:

    dataset['E'] = dataset['E'].fillna(f)
    
    # 对缺失值处进行填充0,参数value可为 scalar, dict, Series, 或者DataFrame,但不能是list;Series应用于每个index,DataFrame应用于每个列。如果不在dict/Series/DataFrame中,将不会被填充
    
    清除空值:.dropna()
    
    dataset.loc[ (dataset.Age.isnull()) & (dataset.Sex == i) & (dataset.Pclass == j+1),'Age'] = guess_ages[i,j]
    # 多条件填充
    

    方法1:

    for dataset in full_data:
        age_avg 	   = dataset['Age'].mean()
        age_std 	   = dataset['Age'].std()
        age_null_count = dataset['Age'].isnull().sum()
        
        age_null_random_list = np.random.randint(age_avg - age_std, age_avg + age_std, size=age_null_count)
        dataset['Age'][np.isnan(dataset['Age'])] = age_null_random_list
        dataset['Age'] = dataset['Age'].astype(int)
    

    方法3:

    # 生成一个空数组来存储Age的猜测值:
            # guess_ages = np.zeros((2,3))
            # guess_ages
    # 遍历Sex和Pclass来猜测Age猜测值:
            # for dataset in combine:
            #     for i in range(0, 2):
            #         for j in range(0, 3):
            #             guess_df = dataset[(dataset['Sex'] == i) & (dataset['Pclass'] == j+1)]['Age'].dropna()
            # 根据相关特征值Pclass,Sex选取数据并除空值
                    #     age_mean = guess_df.mean()
                    # 计算均值
                    #     age_std = guess_df.std()
                    # 计算标准差
                    #     age_guess = rnd.uniform(age_mean - age_std, age_mean + age_std)
    				# 产生随机值
                    #     age_guess = guess_df.median()
    				# 或计算中值
                    #     Convert random age float to nearest .5 age
                    #     guess_ages[i,j] = int( age_guess/0.5 + 0.5 ) * 0.5   
    for i in range(0, 2):
          for j in range(0, 3):
                dataset.loc[ (dataset.Age.isnull()) & (dataset.Sex == i) & (dataset.Pclass == j+1),'Age'] = guess_ages[i,j]
                # 赋值
                dataset['Age'] = dataset['Age'].astype(int)
    

    填充众值:

    # freq_port = train_df.Embarked.dropna().mode()[0]
    # mode返回出现最多的数据,可能出现多个,因此返回数组
    # 填充:
    # for dataset in combine:
    #     dataset['E'] = dataset['E'].fillna(freq_port)
    

    查看数据

    查看键和值:

    train_data = pd.read_csv('train.csv')
    # 查看数据的行键index(index.values)、列键columns(columns.values)、值values
    print(train_data.index)
    print(train_data.index.values)
    

    查看数据统计:

    train_data.info()
    # 主要统计有各列键非空数据数量(便于后面填充空值)、各列数据类型、及数据类型统计(一般object表示字符串对象数量)。
    
    print(train_data.describe())
    # 默认统计数值型数据每列数据平均值,标准差,最大值,最小值,25%,50%,75%比例。
    print(train_data.describe(include=['O']))
    # 统计字符串型数据的总数,取不同值数量,频率最高的取值。其中include参数是结果数据类型白名单,O代表object类型,可用info中输出类型筛选。
    
    print("Before", train_data.shape)
    # 数据行数和列数
    
    describe增强sum形式
    def describe(df):
        return pd.concat([df.describe().T,
                          df.sum().rename('sum'),
                         ], axis=1).T
    
    对行describe
    top = 25
    pd.concat([query_tmp.drop(['0.51800015001004000'], axis=1).head(top).apply(pd.DataFrame.describe, axis=1)
               , query_pd.head(top)['query'],
              query_tmp.head(top)['0.51800015001004000']
              ], axis=1)
    

    查看部分数据内容:

    # 查看前五条和后五条数据,大致了解数据内容
    print(train_data.head())
    print(train_data.tail())
    # 选取三条数据
    data_train.sample(3)
    

    排序:

    features.sort_values(by='EID', ascending=True)
    features.sort_index(axis=1, ascending=True)
    
    python原生排序list和dict
    sorted([wifi for wifi in line[5]], key=lambda x:int(x[1]), reverse=True)[:5]  // 默认从小到大
    sorted(dict.items(),key=lambda x:x[1],reverse=True)[0][0]
    sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) //x,y代表前后两个元素
    

    输出格式控制:

    pandas dataframe数据全部输出,数据太多也不用省略号表示。
    pd.set_option('display.max_columns',None)
    或者
    with option_context('display.max_rows', 10, 'display.max_columns', 5):
    

    某列字符长度统计

    lens = train.comment_text.str.len()
    lens.mean(), lens.std(), lens.max()
    
    print('mean text len:',train["comment_text"].str.count('\S+').mean())
    print('max text len:',train["comment_text"].str.count('\S+').max())
    

    分析数据相关性

    groupby数据:

    train_data[['Pclass','Survived']].groupby(['Pclass'], as_index=False).mean().sort_values(by='Survived',ascending=False)
    # 选取数据中两列,以Pclass分组,计算每个分组内平均值,最后根据Survived平均值降序排列。其中as_index=False不以Pclass做结果行键。
    

    分组后,可以通过size()分组内数据数量,sum()分组内数据和,count()分组内:

    df = DataFrame({'key1':['a','a','b','b','a'],'key2':['one','two','one','two','one'],'data1':np.random.randn(5),'data2':np.random.randn(5)})  
    df  
    #[Out]#       data1     data2 key1 key2  
    #[Out]# 0  0.439801  1.582861    a  one  
    #[Out]# 1 -1.388267 -0.603653    a  two  
    #[Out]# 2 -0.514400 -0.826736    b  one  
    #[Out]# 3 -1.487224 -0.192404    b  two  
    #[Out]# 4  2.169966  0.074715    a  one
    group2 = df.groupby(['key1','key2'])   
    
    group2.size()   
    #[Out]# key1  key2  
    #[Out]# a     one     2     //注意size返回的对象2,1,1,1没有列键
    #[Out]#       two     1  
    #[Out]# b     one     1  
    #[Out]#       two     1  
    #[Out]# dtype: int64  
    group2.count()  
    #[Out]#            data1  data2    
    #[Out]# key1 key2                
    #[Out]# a    one       2      2    //注意count返回的对象2,1,1,1有列键data1,data2
    #[Out]#      two       1      1  
    #[Out]# b    one       1      1  
    #[Out]#      two       1      1
    group2.sum()
    		                data1	data2
    key1	key2		
    a	    one	          0.222249	1.188488
            two	          0.627373	0.406101
    b	    one	         -2.527461	0.267850
            two	         -0.594238	-0.137129  
    
    自定义组内统计函数:
    BRA_CLOSE_DECADE = branch2[['EID', 'B_ENDYEAR']].groupby('EID').agg(lambda df:df[df['B_ENDYEAR']>2007].count())
    
    分组后循环:
    for reviewerID, hist in reviews_df.groupby('reviewerID'):
      pos_list = hist['asin'].tolist()
    

    crosstab数据:
    这里写图片描述

    pd.crosstab(train_data['Title'], train_data['Sex'])
    # 分别以Title(Mrs,Mr等)为行,Sex(female,male)为例,计算出现频数。观察二者的对应关系。
    

    Pivot数据:

    impute_grps = data.pivot_table(values=["LoanAmount"], index=["Gender","Married","Self_Employed"], aggfunc=np.mean)
    

    这里写图片描述
    COV(),CORR()计算
    协方差cov():表示线性相关的方向,取值正无穷到负无穷。协方差为正值,说明一个变量变大另一个变量也变大;协方差取负值,说明一个变量变大另一个变量变小,取0说明两个变量咩有相关关系。
    相关系数corr():不仅表示线性相关的方向,还表示线性相关的程度,取值[-1,1]。也就是说,相关系数为正值,说明一个变量变大另一个变量也变大;取负值说明一个变量变大另一个变量变小,取0说明两个变量没有相关关系。同时,相关系数的绝对值越接近1,线性关系越显著。
    corrwith():计算DataFrame的列(axis=0,默认)或行(axis=1)跟另外一个Series或DataFrame之间的相关系数。
    这里写图片描述
    这里写图片描述

    删除数据

    print(df.drop(0,axis=0)) #删除行,注意原数据不变,返回一个新数据
    print(df.drop(['col1'],axis=1,inplace=True)) #删除列,inplace=True表示直接在原数据修改而不新建对象
    

    合并数据

    对于不同列名,但是内容相同时,可以先修改表的列名。
    concat:
    相同字段的表首尾相接

    result = pd.concat([df1, df2, df3], keys=['x', 'y', 'z']) //keys给合并的表来源加一个辨识号
    

    注意多张表concat后可能会出现index重复情况,这是最好使用reset_index重新组织下index。

    result.reset_index(drop=True)
    
    pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
           keys=None, levels=None, names=None, verify_integrity=False)
    

    append方式:

    # append方式
    result = df1.append([df2, df3])  //将df2,df3追加到df1后返回
    # [官方合并教程](http://pandas.pydata.org/pandas-docs/stable/merging.html#)
    

    pandas的DataFrame的append方法详细介绍
    merge方式:
    merge(left, right, how=‘inner’, on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=True, suffixes=(’_x’, ‘_y’), copy=True, indicator=False)
    merge方式用于通过一个或多个键将两个数据集的行连接起来,类似于 SQL 中的 JOIN
    on=None 用于显示指定列名(键名),如果该列在两个对象上的列名不同,则可以通过 left_on=None, right_on=None 来分别指定。或者想直接使用行索引作为连接键的话,就将left_index=False, right_index=False 设为 True。如果没有指定且其他参数也未指定则以两个DataFrame的列名交集做为连接键.
    how=‘inner’ 参数指的是当左右两个对象中存在不重合的键时,取结果的方式:inner 代表交集;outer 代表并集;left 和 right 分别为取一边。
    suffixes=(’_x’,’_y’) 指的是当左右对象中存在除连接键外的同名列时,结果集中的区分方式,可以各加一个小尾巴。
    对于多对多连接,结果采用的是行的笛卡尔积。

    # merge方式
    # 其中how取值 : {‘left’, ‘right’, ‘outer’, ‘inner’}, default ‘inner’类似于SQL中 left outer join,right outer join, full outer join,inner join
    >>> A              >>> B
        lkey value         rkey value
    0   foo  1         0   foo  5
    1   bar  2         1   bar  6
    2   baz  3         2   qux  7
    3   foo  4         3   bar  8
    >>> A.merge(B, left_on='lkey', right_on='rkey', how='outer')
       lkey  value_x  rkey  value_y
    0  foo   1        foo   5
    1  foo   4        foo   5
    2  bar   2        bar   6
    3  bar   2        bar   8
    4  baz   3        NaN   NaN
    5  NaN   NaN      qux   7
    

    join方式:
    其中参数的意义与merge方法基本相同,只是join方法默认为左外连接how=left。默认按索引合并,可以合并相同或相似的索引。主要用于索引上的合并

    join(self, other, on=None, how='left', lsuffix='', rsuffix='',sort=False): 
    

    修改数据

    从数据中提取数据:

    dataset['Title'] = dataset.Name.str.extract(' ([A-Za-z]+)\.', expand=False)
    # 左边dataset['Title']为DataFrame添加一列,右边dataset.Name取出DataFrame的name列,然后对于该Series里的string匹配正则,返回匹配到的正则子集。[官方api](http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.str.extract.html)
    
    # 对列使用函数处理
    meta_df['categories'] = meta_df['categories'].map(lambda x: x[-1][-1])
    
    data['sum_Times']=data['Times'].groupby(['userID']).cumsum()     //统计单个userid组内到当前行之前的所有time和
    

    替换数据:

    dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')
    dataset['Title'].replace('Ms', 'Miss')
    #将一列中数据Ms替换Miss,[详解](https://jingyan.baidu.com/article/454316ab4d0e64f7a6c03a41.html)
    

    将分类数据数值化:

    title_mapping = {"Mr": 1, "Miss": 2, "Mrs": 3, "Master": 4, "Rare": 5}
    for dataset in combine:
         dataset['Title'] = dataset['Title'].map(title_mapping)
    # dataset['Sex'] = dataset['Sex'].map( {'female': 1, 'male': 0} ).astype(int)
    

    转成矩阵:

    big_X_imputed[0:train_df.shape[0]].as_matrix()  //将DataFrame对象转成numpy矩阵
    

    将连续值分成几部分:

    # 自动
    pd.cut(np.array([.2, 1.4, 2.5, 6.2, 9.7, 2.1]), 3,
               labels=["good","medium","bad"])
    [good, good, good, medium, bad, good]
    
    # 手动,一般手动前先自动分析一波。
    # train_df['AgeBand'] = pd.cut(train_df['Age'], 5)
    # train_df[['AgeBand', 'Survived']].groupby(['AgeBand'], as_index=False).mean().sort_values(by='AgeBand', ascending=True)
    # 手动区分
    # for dataset in combine:    
    #     dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0
    #     dataset.loc[(dataset['Age'] > 16) & (dataset['Age'] <= 32), 'Age'] = 1
    #     dataset.loc[ dataset['Age'] > 64, 'Age'] = 4
    

    对每一行或每一列应用函数:

    def num_missing(x):
      return sum(x.isnull())
    #应用列:
    print data.apply(num_missing, axis=0)
    #应用行:
    print data.apply(num_missing, axis=1).head()
    
    def get_title(name):
    	title_search = re.search(' ([A-Za-z]+)\.', name)
    	# If the title exists, extract and return it.
    	if title_search:
    		return title_search.group(1)
    	return ""
    
    for dataset in full_data:
        dataset['Title'] = dataset['Name'].apply(get_title)
    
    df.Cabin = df.Cabin.apply(lambda x: x[0])
    

    将字符型数据转成数值型数值:

    from sklearn import preprocessing
    def encode_features(df_train, df_test):
        features = ['Fare', 'Cabin', 'Age', 'Sex', 'Lname', 'NamePrefix']
        df_combined = pd.concat([df_train[features], df_test[features]])
        
        for feature in features:
            le = preprocessing.LabelEncoder()
            le = le.fit(df_combined[feature])
            df_train[feature] = le.transform(df_train[feature])
            df_test[feature] = le.transform(df_test[feature])
        return df_train, df_test
        
    data_train, data_test = encode_features(data_train, data_test)
    

    除去离群点:
    通过画图如果发现数据中出现一些离群点,应将其除去,使用pandas布尔运算即可:

    train = train[abs(train['length'])<10]
    

    categorial无序特征哑编码one-hot:
    星期为无序特征,如果该特征有三种取值:星期一、星期二、星期三,那么可用三维向量分别表示(1,0,0)(0,1,0)(0,0,1)。使用pd.get_dummies(),如果特征取值过多就应根据数据分布规律将不重要的几个取值归为一类。
    这里写图片描述
    去重相同行:

    alter.duplicated()   //返回每行是否重复的bool值,frame.duplicated(['state'])可选择指定列进行查重。
    alter.duplicated().value_counts()
    alter2 = alter.drop_duplicates()  //除去相同行,注意返回新数据,而不是在旧有的上面修改
    df.drop_duplicates(subset='column A', keep='last') //根据特定列去重,且保留最后一个
    

    修改index名,列键名:

    df.columns = ['a', 'b', 'c', 'd', 'e']
    df.columns = df.columns.str.strip('$')
    df.columns = df.columns.map(lambda x:x[1:])
    
    df.rename(columns=('$a': 'a', '$b': 'b', '$c': 'c', '$d': 'd', '$e': 'e'}, inplace=True) 
    df.rename(columns=lambda x:x.replace('$',''), inplace=True)
    
    investFeature.index.rename('EID', inplace=True)
    

    列转index、index转列:

     df.set_index('date', inplace=True)
    
    df['index'] = df.index
    df.reset_index(level=0, inplace=True)
    df.reset_index(level=['tick', 'obs'])
    df['si_name'] = df.index.get_level_values('si_name') # where si_name is the name of the subindex.
    

    删除index

    df_load.reset_index(inplace=True)
    del df_load['index']
    

    合并列名不同的列:
    先修改列名

    train_cat = train[[0,1,2,3,4]]
    col = train_cat.columns
    for i in range(5,20,4):
        tem = train[[0,i,i+1,i+2,i+3]]
        tem.columns = col
        train_cat = pd.concat([train_cat,tem])
    train_cat.head()
    

    设置一列类型:

    df[[column]] = df[[column]].astype(str)
    

    深浅复制:
    Shallow copy shares data and index with original.
    Deep copy has own copy of data and index.
    Updates to the data shared by shallow copy and original is reflected in both; deep copy remains unchanged.

    deep = s.copy()
    shallow = s.copy(deep=False)
    

    apply返回series数据:
    这样组合成的仍然是dataframe类型

    def mer(x):
        sss = []
        for i,line in x.iterrows():
            sss.extend([line[1],line['pre']])
        return pd.Series(sss)
    merged = sub_cat.groupby([0]).apply(mer)
    

    根据键值和列名合并:

    save.merge(merged, left_on=['a'], right_index=True)
    

    groupby后筛选数据:
    使用filter或transform

    np.random.seed(130)
    df=pd.DataFrame(np.random.randint(3, size=(10,2)), columns=['item_id_copy','sales_quantity'])
    print (df)
       item_id_copy  sales_quantity
    0             1               1
    1             1               2
    2             2               1
    3             0               1
    4             2               0
    5             2               0
    6             0               1
    7             1               2
    8             1               2
    9             1               2
    
    df1 = df.groupby('item_id_copy').filter(lambda x: len(x["asin"].unique()) >= 4)
    print (df1)
       item_id_copy  sales_quantity
    0             1               1
    1             1               2
    7             1               2
    8             1               2
    9             1               2
    
    df1 = df[df.groupby('item_id_copy')['sales_quantity'].transform('size') >= 4]
    print (df1)
       item_id_copy  sales_quantity
    0             1               1
    1             1               2
    7             1               2
    8             1               2
    9             1               2
    

    pandas进行one-hot编码:

    import pandas as pd
    df = pd.DataFrame([  
                ['green' , 'A'],   
                ['red'   , 'B'],   
                ['blue'  , 'A']])  
    df.columns = ['color',  'class'] 
    df = pd.get_dummies(df)
    

    在这里插入图片描述
    one-hot后:
    在这里插入图片描述

    apply返回多列:

    def myfunc1(row):
        C = row['A'] + 10
        D = row['A'] + 50
        return pd.Series([C, D])
    
    df[['C', 'D']] = df.apply(myfunc1 ,axis=1)
    
    def sizes(s):    
        return locale.format("%.1f", s / 1024.0, grouping=True) + ' KB', \
            locale.format("%.1f", s / 1024.0 ** 2, grouping=True) + ' MB', \
            locale.format("%.1f", s / 1024.0 ** 3, grouping=True) + ' GB'
    df_test['size_kb'],  df_test['size_mb'], df_test['size_gb'] = zip(*df_test['size'].apply(sizes))
    

    按列最大最小值归一化

    In [11]: df
    Out[11]:
        a    b
    A  14  103
    B  90  107
    C  90  110
    D  96  114
    E  91  114
    
    In [12]: df -= df.min()
    
    In [13]: df /= df.max() 
    
    In [14]: df
    Out[14]:
              a         b
    A  0.000000  0.000000
    B  0.926829  0.363636
    C  0.926829  0.636364
    D  1.000000  1.000000
    E  0.939024  1.000000
    

    判断一列数据是不是类型混合:

    sorted(sad["size"].unique())
    
    '<' not supported between instances of 'str' and 'float'
    

    对df的某一行的某些值进行修改:

    aad.loc[aad["type"]==2,"cdate"] = aad.loc[aad["type"]==2,"adid"].map(lambda x: cdate_map[x] if x in cdate_map.keys() else -1)
    

    groupby 后提取前多少数据,并生成pandas

    orgin = reviews_map.sort_values(["reviewerID","unixReviewTime"]).groupby("reviewerID",group_keys=False)
    print(orgin.get_group(1))
    history = orgin.apply(lambda df: df[:-2])
    ads = orgin.apply(lambda df: df[-2:])
    
    展开全文
  • pythonpandas数据导入

    千次阅读 2018-08-30 16:45:13
    pandas数据导入 学习python最好的学习方法就是带着自己的工作需求或者目标去学习。pandas库不多介绍,先放一些最基础的内容帮助学习。 pandas导入/导出数据是非常方便的,可以快速的导入现在常见的excel、csv、txt...

    pandas数据导入

    学习python最好的学习方法就是带着自己的工作需求或者目标去学习。pandas库不多介绍,先放一些最基础的内容帮助学习。

    pandas导入/导出数据是非常方便的,可以快速的导入现在常见的excel、csv、txt,以下就是一些常用的

    导入数据:

    • 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是数据

    导出数据:

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

    导入导出参数说明:

    pd.read_excel(io, sheetname=0, header=0, skiprows=None, skip_footer=0, index_col=None, names=None, parse_cols=None, parse_dates=False, date_parser=None, na_values=None, thousands=None, convert_float=True, has_index_names=None, converters=None, dtype=None, true_values=None, false_values=None, engine=None, squeeze=False, **kwds )

    io:数据源地址例如:pd.read_excel(r'C:\Users\Desktop\新建工作表.xlsx')  注意:中文路径的话建议用n=open(r'C:\中文路径\excel.xlsx') 再用data=pd.read_excel(n)

    sheetname:你需要导入的数据在工作簿的那张表,可以为数据也可以为直接取表名。0代表工作簿第一张表,如表名叫name,那么sheet_name='name'进行取数

    header :你导入数据的表头字段名在哪一行,默认为第一行。也可以手动指定行数来确定表头字段名

    index_col:指定索引位置,列(0索引)用作DataFrame的行标签。如果没有这样的列,则通过None。如果传递了一个列表,那么这些列将合并为一个MultiIndex

    dtype :导入指定数据列的数据类型,例如:dtype= {'column_name' : str} 

    常用的导入数据举例:

    # -*- coding: utf-8 -*-
    """
    @author: huangjunwen
    """
    import pandas as pd
    #导入xlsx格式的数据文件
    data=pd.read_excel(r'C:\Users\Desktop\excel表格.xlsx',sheetname='Sheet1')
    
    #导入csv格式的数据文件
    data=pd.read_csv(r'C:\Users\Desktop\CSV表格.csv',sheetname='Sheet1')
    
    #导入txt格式的数据文件,可能会涉及编码问题或者中文路径需要先用open函数打开连接,并进行转码
    op=open(r'C:\Users\Desktop\TXT数据.txt',encoding='utf-8')
    data=pd.read_table(op)
    
    #导入sql查询结果,需要涉及另外一个库pymysql(因本人用的mysql数据库所以使用该库进行连接)
    import pandas as pd
    import pymysql as mysql
    sql_cmd='select * from XXXX'#输入你的SQL语句
    connection=mysql.connect(host='数据库IP',port=数据库端口,user='登录账户',password='登录密码',db='具体连接的库',charset='utf8')#创建数据库链接属性
    data=pd.read_sql(sql=sql_cmd,con=connection)#导入数据库查结果为DataFrame

     

    展开全文
  • 利用Python处理Excel数据——pandas

    千次阅读 多人点赞 2020-01-20 19:07:55
    新建一个excel表格(table1.csv)用于案例讲解: 一、导库 import pandas as pd import numpy as np 二、读取数据 df = pd.read_excel('table1.xlsx') # 相对路径 # df = pd.read_excel(r'E:\Anaconda\hc\...
  • Python pandas写入excel, 并建立多个sheet // code import xlwt import pandas as pd path = 'path.xls' writer = pd.ExcelWriter(path) df1.to_excel(excel_writer=writer,sheet_name='sheet1') df2.to_excel...
  • pythonpandas.DataFrame添加一行

    万次阅读 2017-06-02 17:34:32
    from pandas import * from random import * df = DataFrame(columns=('lib', 'qty1', 'qty2'))#生成空的pandas表 for i in range(5):#插入一行 df.loc[i] = [randint(-1,1) for n in range(3)] print df
  • 量化-windows下如何安装Pythonpandas

    千次阅读 2016-06-28 23:59:30
    本篇内容主要讲如何安装PythonpandasPython比较好安装,而pandas比较难装,当时装了我一整天。pandasPython下面的一个package,专门用于金融数据的分析,简直是神器。这里有pandas的简单入门介绍...
  • 目录 ...Pandas的名称来自于面板数据(panel data)和Python数据分析(data analysis)。 Pandas是一个强大的分析结构化数据的工具集,基于NumPy构建,提供了高级数据结构和数据操作工具,它是...
  • 文章目录1.创建DataFrame类型方法1: 通过列表创建方法2: 通过numpy对象创建方法3: 通过字典的方式创建;2.DataFrame基本操作1). 查看基础属性2). 数据整体状况的查询head头部的几行tail尾部几行info相关信息的预览...
  • Pythonpandas使用简介

    2018-06-26 16:01:16
    2018/04/15 看到一个博主写得很全,大家也可以看看转:https://blog.csdn.net/u011089523/article/details/60349591 http://blog.sina.com.cn/s/blog_154861eae0102xbsq.html其实我主要也是为了加强自己的记忆,...
  • PandasPython 的一个数据分析包,最初由 AQR Capital Management 于2008年4月开发,并于2009年底开源出来,目前由专注于 Python 数据包开发的 PyData 开发团队继续开发和维护,属于 PyData 项目的一部分。...
  • 文章来源:实战统计学作者:梁斌炜PandasPython 的核心数据分析支持库,提供了快速、灵活、明确的数据结构,旨在简单、直观地处理关系型、标记...
  • 一、pandas创建excel文档 1,创建文档 任务:在F:/file/day0918目录下创建newexcel.xlsx的文件 import pandas as pd #在path目录下创建newexcel.xlsx path=‘F:/file/day0918/newexcel.xlsx’ df=pd.DataFrame...
  • 一、ORM技术 对象关系映射技术,即ORM(Object-Relational Mapping)技术,指的是把关系数据库...在Python中,最有名的ORM框架是SQLAlchemy。Java中典型的ORM中间件有: Hibernate, ibatis, speedframework。 二、SQL...
  • 创建数据和行append数据 >>> df = pd.DataFrame([['AA', 1.00], ['Ks', 2.00]], columns=['name', 'age']) >>> df name age 0 AA 1.0 ... df.append(pd.Series({'name': 'hha'...
  • pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的,是数据分析必学的一个库。 运行环境和编译工具 Python环境是Python3 安装pandans库 pip install pandas 我使用的编译工具是 jupyter ...
  • python-pandas创建Series数据类型

    千次阅读 2019-02-27 12:00:14
    什么是pandas2.查看pandas版本信息3.常见数据类型4.pandas创建Series数据类型对象1). 通过列表创建Series对象2). 通过numpy的对象Ndarray创建Series;3). 通过字典创建Series对象;5.Series基本操作1). 修改Series...
  • 前言: python操作excel表格文件的增删读写,一般需要用到的第三方库有xlwt,xlrd。xlrd负责读取excel,xlwt负责写入excel文件。这种操作方法比较繁琐,效率...Pandas是xlwt,xlrd库的封装库,拥有更全面的操作对象,csv...
  • pandas新建excel文件

    千次阅读 2018-12-14 08:11:52
    import pandas as pd # 构建数据 df = pd.DataFrame({'ID': [1, 2, 3], 'Name':['Luck', 'NIck', 'Vickor']}) # 设置ID为索引(默认再添加一列新的数据) df = df.set_index('ID') # 写入数据(to_excel方法(此处...
1 2 3 4 5 ... 20
收藏数 5,321
精华内容 2,128
关键字:

pandas python 新建