精华内容
下载资源
问答
  • Python pandas数据分析常用方法

    万次阅读 多人点赞 2017-03-20 23:33:48
    fillna 用指定值或插值方法(如ffill或bfill)填充确实数据 isnull 返回一个含有布尔值的对象,这些布尔值表示哪些值是缺失值/NA,该对象的类型与源类型一样 notnull isnull的否定式 存在三种方法来完善连续数字特征...

    官方教程

    读取写入文件

    官方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:])
    
    展开全文
  • python数据分析

    万次阅读 多人点赞 2018-07-22 19:43:44
    python绘图、python数据分析、python库、股票分析

    所有资料汇总学习:点这里

    利用python进行数据分析

    数据在这里下载

    github连接

    记得点个star!!!

    里面还放着一些陈年老代码,都是机器学习和数据分析相关的。(没怎么整理,都在里面,看到隐私别慌~)

    Numpy

    Numpy简单使用(入门)

    Pandas入门

    Pandas入门系列(一)-- Series
    Pandas入门系列(二)-- DataFrame
    Pandas入门系列(三)-- 深入理解Series和DataFrame
    Pandas入门系列(四) – Pandas io操作
    Pandas入门系列(五) – Indexing和Selecting
    Pandas入门系列(六) – reindex
    Pandas入门系列(七) – NaN
    Pandas入门系列(八) – 多级index
    Pandas入门系列(九) – Map和replace

    pandas进阶

    Pandas玩转数据(一) – 简单计算
    Pandas玩转数据(二) – Series和DataFrame排序
    Pandas玩转数据(三) – DataFrame重命名
    Pandas玩转数据(四) – DataFrame的merge
    Pandas玩转数据(五) – Concatenate和Combine
    Pandas玩转数据(六) – 通过apply对数据进行处理
    Pandas玩转数据(七) – Series和DataFrame去重
    Pandas玩转数据(八) – 时间序列简单操作
    Pandas玩转数据(九) – 时间序列的采样和画图
    Pandas玩转数据(十) – 数据分箱技术Binning
    Pandas玩转数据(十一) – 数据分组技术Groupby
    Pandas玩转数据(十二) – 数据聚合技术Aggregation
    Pandas玩转数据(十三) – 透视表
    Pandas玩转数据(十四) – 分组和透视功能实战

    Matplotlib入门

    Matplotlib简单画图(一) – plot
    Matplotlib简单画图(二) – subplot
    Matplotlib简单画图(三) – pandas绘图之Series
    Matplotlib简单画图(四) – pandas绘图之DataFrame
    Matplotlib简单画图(五) – 直方图和密度图

    Matplotlib扩展之Seaborn

    Seaborn简单画图(一) – 散点图
    Seaborn简单画图(二) – 直方图和密度图
    Seaborn简单画图(三) – 柱状图和热力图
    Seaborn简单画图(四) – 设置图形显示效果
    Seaborn简单画图(五) – Seaborn调色功能

    获取数据的一个库Tushare

    Tushare获取数据

    简单实战

    股票市场分析实战

    展开全文
  • python数据分析常用

    万次阅读 2019-04-30 09:52:12
    numpy 创建矩阵: ...常用方法: 矩阵元素个数 a.size 矩阵形状 a.shape 矩阵维度 a.ndim 矩阵元素类型 a.dtpye 矩阵的加减乘除 。np.dot(x,y) pandas Pandas 是基于 NumPy 的一个开源 Python 库,它...

    numpy
    创建矩阵:
    引入numpy库并生成矩阵

    import numpy as np
    a = np.array([[1,2,3],[4,5,6]])
    

    常用方法:

    矩阵元素个数 a.size
    矩阵形状 a.shape
    矩阵维度 a.ndim
    矩阵元素类型 a.dtpye
    矩阵的加减乘除 。np.dot(x,y)
    

    pandas
    Pandas 是基于 NumPy 的一个开源 Python 库,它被广泛用于快速分析数据,以及数据清洗和准
    备等工作。它的名字来源是由‚ Panel data‛(面板数据,一个计量经济学名词)两个单词拼
    成的。简单地说,你可以把 Pandas 看作是 Python 版的 Excel。

    DataFrame对象的构建:
    DataFrame是一种表格型数据结构,它含有一组有序的列,每列可以是不同的值。
    DataFrame既有行索引,也有列索引,可以根据dict进行创建,以及读取csv或者txt文件来创建
    引入pandas包:

    import pandas as pd
    

    pandas相关简单设置:

    pd.set_option('display.max_columns', None)#显示所有列
    pd.set_option('display.max_rows', None)#显示所有行
    pd.set_option('expand_frame_repr',False)#在一行显示
    pd.set_option('display.unicode.ambiguous_as_wide', True)#中文对齐
    pd.set_option('display.unicode.east_asian_width', True)#中文对齐
    

    打开并转换为DataFrame格式:

    a=pd.read_csv('d:/a11.csv',sep=',',encoding='utf-8')
    df1= pd.DataFrame(a)
    

    其他的一些方法:

    #print(df1.columns)#列名字,标签
    #print(df.dtypes)#每列的数据类型
    #print(df.shape)#df的形状
    #print(df.ndim)#df维度
    #print(df.describe())#每列的描述,通常用来判断是否有缺失
    

    DataFrame的数据提取方法:

    主要用到的三个函数:loc,iloc,loc函数按标签值进行提取,iloc按位置进行提取。
    1、按索引提取单行的数值
    df_inner.loc[3]
    2、按索引提取区域行数值
    df_inner.iloc[0:5]
    3、使用iloc按位置区域提取数据
    df_inner.iloc[:3,:2] #冒号前后的数字不再是索引的标签名称,而是数据所在的位置,从0开始,前三行,前两列。
    4、适应iloc按位置单独提起数据
    df_inner.iloc[[0,2,5],[4,5]] #提取第0、2、5行,4、5列
    

    绘图库
    Matplotlib
    Matplotlib是一个Python 2D绘图库,它可以在各种平台上以各种硬拷贝格式和交互式环境生成
    出具有出版品质的图形。

    #画线
    import matplotlib.pyplot as plt
    plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
    plt.plot([1,2,34])
    plt.ylabel("温度")
    plt.show()
    

    在这里插入图片描述

    #画线步骤
    import matplotlib.pyplot as plt
    plt.rcParams['font.sans-serif']=['SimHei']
    x_values=[1,2,3,4,5]
    y_values=[1,4,9,16,25]
    plt.plot(x_values,y_values,linewidth=5)
    plt.title("每月入学人数",fontsize=20)
    plt.xlabel("月份",fontsize=10)
    plt.ylabel("人数",fontsize=10)
    plt.tick_params(axis='both',labelsize=20)
    plt.show()
    

    在这里插入图片描述

    #画散点
    import matplotlib.pyplot as plt
    import numpy as np
    plt.rcParams['font.sans-serif']=['SimHei']
    x_values=np.random.rand(10)
    y_values=np.random.rand(10)
    plt.scatter(x_values,y_values)
    plt.show()
    

    在这里插入图片描述

    #画柱状图
    import matplotlib.pyplot as plt
    import numpy as np
    plt.rcParams['font.sans-serif']=['SimHei']
    x_values=np.arange(10)
    y_values=np.random.randint(0,30,10)
    plt.bar(x_values,y_values)
    plt.show()
    

    在这里插入图片描述

    #画饼图
    import matplotlib.pyplot as plt
    import numpy as np
    plt.rcParams['font.sans-serif']=['SimHei']
    x_values=np.random.randint(1,10,3)
    print(x_values)
    plt.pie(x_values,None,['男','女','未知'])
    plt.show()
    

    在这里插入图片描述
    Matplotlib常用绘制图形:

    折线图matplotlib.pyplot.plot
    柱状图matplotlib.pyplot.bar
    散点图matplotlib.pyplot.scatter
    饼图matplotlib.pyplot.pie
    

    ##################################################################
    三个库的综合比较
    Numpy:基础的数学计算模块,以矩阵为主。

    来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多,本身是由C语言开发
    。这个是很基础的扩展,其余的扩展都是以此为基础。数据结构为ndarray。
    

    Pandas:提供一套名为DataFrame的数据结构,适合统计分析中的表结构,以及做数据分析

    基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型,
    提供了高效地操作大型数据集所需的工具。最具有统计意味的工具包,某些方面优于R软件。数据结构有一维的
    Series,二维的DataFrame(类似于Excel或者SQL中的表,Pandas和SQL有很多相似的地方)。
    包括:
    1.汇总和计算统计,处理缺失值
    2.清理、转换、合并、重塑
    3.日期和时间数据类型及工具
    

    Matplotlib::绘图模块

    Python中最著名的绘图模块
    包括:
    1.散点图,折线图,条形图,直方图,饼状图等的绘制。
    2.坐标轴的调整,添加文字注释,区域填充,及特殊图形patches的使用
    
    展开全文
  • python数据分析常用函数

    千次阅读 2017-02-13 17:18:26
    python for循环的一般格式:第一行是要先定义一个赋值目标(迭代变量),和要遍历(迭代)的对像;首行后面是要执行的语句块。 for 目标 in 对像:  print 赋值目标 1.for循环字符串操作 >>>a = '...

    for语句的基本格式

    python for循环的一般格式:第一行是要先定义一个赋值目标(迭代变量),和要遍历(迭代)的对像;首行后面是要执行的语句块。

    for 目标 in 对像:
        print 赋值目标


    1.for循环字符串操作

    >>>a = 'iplaypython.com'
    >>>for i in a:
    >>>    print i

    案例中的 i 相当于目标,字符串变量a是遍历(迭代)对像。当运行for循环语句时,每一次迭代时,i 都会从遍历(迭代)对像a中接收一个新值输出。结束循环后,目标(迭代变量)会保留最后一个值。


    2.for 循环元组赋值

    in后面的是一个元祖数组,比如这种 [(1,2),(3,4),(5,6)]

    >>>x =[('hello','python'),('very','good')]
    >>>for (a,b) in x:
    >>>    print (a,b)
    ('hello', 'python')
    ('very', 'good')


    3.scipy导入文件

    scipy.io.loadmat(file_name, mdict=None, appendmat=True, **kwargs)


    4.numpy.mean()数组求均值计算

    numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<class numpy._globals._NoValue at 0x40b6a26c>

    a--------------运算矩阵

    axis----axis后面的值是指定一个轴做运算
    eg:
    
    >>> a = np.array([[1, 2], [3, 4]])
    >>> np.mean(a)
    2.5
    >>> np.mean(a, axis=0)
    array([ 2.,  3.])
    >>> np.mean(a, axis=1)
    array([ 1.5,  3.5])
    
    
    

    5.python中enumerate()函数的使用

    • enumerate()是python的内置函数
    • enumerate在字典上是枚举、列举的意思
    • 对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串),enumerate将其组成一个索引序列,利用它可以同时获得索引和值
    • enumerate多用于在for循环中得到计数
    5.1----------如果对一个列表,既要遍历索引又要遍历元素时,首先可以这样写:
    list1 = ["这", "是", "一个", "测试"]
    for i in range (len(list1)):
        print i ,list1[i]
    5.2---------------------上述方法有些累赘,利用enumerate()会更加直接:
    list1 = ["这", "是", "一个", "测试"]
    for index, item in enumerate(list1):
        print index, item
    >>>
    012 一个
    3 测试
    5.3-----------------enumerate还可以接收第二个参数,用于指定索引起始值,如:
    list1 = ["这", "是", "一个", "测试"]
    for index, item in enumerate(list1, 1):
        print index, item
    >>>
    123 一个
    4 测试

    5.4------------若统计文件的行数,可以这样写:

    count = len(open(filepath, 'r').readlines())


    这种方法简单,但是可能比较慢,当文件比较大时甚至不能工作。

    可以利用enumerate():

    count = -1 
    for index, line in enumerate(open(filepath,'r')): 
        count += 1


    展开全文
  • Python数据分析常用的8款工具

    千次阅读 2018-11-09 15:22:25
    Python是数据处理常用工具,可以处理数量级从几K至几T不等的数据,具有较高的开发效率和可维护性,还具有较强的通用性和...Python数据分析需要安装的第三方扩展库有:Numpy、Pandas、SciPy、Matplotlib、Scikit-Lea...
  • Python数据分析常用工具

    千次阅读 2017-07-21 12:09:03
    1. Numpy: ...基于Numpy,最初被作为金融数据分析工具而开发出来,一般用于处理结构化数据。 $ pip install pandas 3. Matplotlib: 绘制数据图表 $ pip install matplotlib 4. Seabor
  • python数据分析常用第三方库

    千次阅读 2020-12-10 11:30:00
    1.数据收集 scrapy:网页采集、爬虫。 scrapy-redis:分布式爬虫。 selenium:web测试、仿真浏览器。 2.数据处理 beautifulsoup:网页解释库,提供lxml的支持。...3.数据分析 numpy:基于矩阵的数学计
  • 系列一:《python数据分析基础与实践》 章节1Python概况 课时2Python简介 章节2Python安装 课时3安装Anaconda 课时4使用Anaconda 章节3数据准备 课时5数据类型 – 布尔型 课时6数据类型 – 数值型 课时7数据类型 – ...
  • Python数据分析常用图像特征

    千次阅读 2019-05-04 21:37:44
    Python数据分析常用图像特征 常用图像特征 颜色特征 纹理特征 形状特征 skimage中的特征方法 skimage.feature 颜色特征 图像检索中应用最为广泛的视觉特征 颜色直方图:从256种灰度颜色分为k个区间,然后计算...
  • Python数据分析几个比较常用方法

    千次阅读 2019-05-19 19:24:04
    1,表头或是excel的索引如果是中文的话,输出会出错 ...需求情况:有的时候,数据很多,但是只要仅仅对部分列的数据进行分析的话,要怎么做? 解决方法: df = pandas.read_excel('1.xls',sheetname= '...
  • Python数据分析几个比较常用方法
  • 常用Python数据分析工具

    千次阅读 2018-08-29 18:11:03
    Python是数据处理常用工具,可以处理数量级从几K至几T不等的数据,具有较高的开发效率和可维护性,还具有较强的通用性和跨...Python数据分析需要安装的第三方扩展库有:Numpy、Pandas、SciPy、Matplotlib、Scikit-Le...
  • Python sklearn数据分析常用方法

    千次阅读 2017-08-01 15:50:15
    一、数据处理 随机划分训练集和测试集: from sklearn.model_selection import train_test_split X_all = data_train.drop(['Survived', 'PassengerId'], axis=1) #只包含特征集,不包含预测目标 y_all = data_...
  • Pandas想必从事数据分析的各位都懂,这是一个开源的,BSD许可的库,为Python编程语言提供高性能,易于使用的数据结构和数据分析工具。还不熟悉的新手可以复制官网链接,10分钟快速了解下:...
  • Python:3.5上节讲到数据分析和挖掘需要的库,其中最主要的是Pandas,Matplotlib。 Pandas:主要是对数据分析,计算和统计,如求平均值,方差等。 Matplotlib:主要结合Pandas生成图像。两者往往结合使用的。Pandas...
  • Python常用数据分析工具

    千次阅读 2019-04-17 16:09:37
    Python数据分析工具 Python 本身的数据分析功能不强,需要安装一些第三方扩展库来增强它的能力。常用 的库有Numpy 、Scipy 、Matplotlib 、Pandas 、Scikit-Learn 、Keras 和Gensim 等,下面将对 这些库的安装和...
  • Python数据分析学习总结

    千次阅读 2017-10-02 22:43:19
    Python数据分析学习总结 概述数据分析的含义与目标方法:统计分析方法目标:提取有用信息手段:研究、概括、总结 Python与数据分析Python特点:简洁、开发效率高、运算速度慢、胶水特性(集成C语言)Python数据分析...
  • python数据分析基础

    千人学习 2021-01-17 10:20:14
    8个常用python工具库 + 10小时以上视频课程 + 50个工作常用技能 + 4个爬虫案例 + 10个行业数据分析案例, 介绍python数据分析、爬虫基础技巧, 助你提升职场竞争力, 转行、应聘简历加分。 课程介绍python数据读取、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 134,000
精华内容 53,600
关键字:

python数据分析常用方法

python 订阅