python——pandas关于数据处理的库

矫情吗；* 2021-09-27 04:16 451阅读 0赞

很多函数基于numpy库，主要用于数据的预处理阶段。

## 一、数据读取 ##

pandas.read\_csv()：读取数据文件

DataFrame类型：和矩阵很像，有行有列。可以包含几种类型的结构，其中将字符型的值称作“object”。

.head函数：显示刚才读取的前几条数据，默认是5

.tail()函数：显示最后几行的数据

.columns：显示列名

.shape：看矩阵的大小（样本数，指标数）

dtype的类型有这些：object(String value)/ int/ float/ datatime/bool

import pandas
    
    food_info=pandas.read_csv('food_info.csv')
    print(type(food_info)) #查看food_info的数据类型 dataFrame类型
    print(food_info.dtypes) #查看food_info中每一项数据是什么类型
    print(food_info.columns) # 查看所有的列名称，返回一个元组类型
    print(help(pandas.read_csv)) #获取帮助
    
    print(food_info.head(3))
    print(food_info.tail(2))
    print(food_info.shape) #(8618, 36)

## 二、索引与计算 ##

1. 访问行、列（记录，属性）

# 访问行：一行，特定的几行，从某行到某行
    print(food_info.loc[0]) #注意：这个同矩阵不同，输出的并不是实际表格中的第一行，二是第二行，也就是表格中的第一个记录
    print(food_info.loc[[1,2]]) #将要想要访问的行数以列表的形式传入
    print(food_info.loc[1:3]) #注意，此时只有一个大括号
    
    # 访问列：一列，特定的几列
    print(food_info["Water_(g)"]) #打印Water_(g)这一列的所有值
    print(food_info[['NDB_No','Water_(g)']]) #打印 'NDB_No','Water_(g)'这两列的值
    
    # 输出所有列名
    col_name=food_info.columns.tolist() #以列的形式输出所有的属性名称
    print(col_name)
    
    # 输出以“”为结尾的列
    gram_columns=[]
    for c in col_name:
        if c.endswith('(g)'):
            gram_columns.append(c) #python原有的，列表的常用函数，增加元素
    gram_df=food_info[gram_columns]
    print(gram_df)

2. 运算，增加属性（就像字典那样，直接增加，但是要注意，维度要相等）

# 除法：将单位是mg等人化为g，并放在一个新的列中
    Iron_gram=food_info['Iron_(mg)']/1000
    print(food_info.shape) #(8618, 36)
    food_info['Iron_(g)']=Iron_gram
    print(food_info.shape) #(8618, 37)
    
    #乘法,相同维度的，就是点乘了，对应位置相乘
    water_energy=food_info['Water_(g)']*food_info['Energ_Kcal']
    print(water_energy)

3. 寻找最大值

# 查找最大值
    max_calories=food_info['Energ_Kcal'].max()
    print(max_calories)

4. 排序

# 排序    NAN是缺失值，都是放在最后的
    food_info.sort_values('Sodium_(mg)',inplace=True) #对Sodium_(mg)这一列进行从小到大排序，并生成一个新的dataframe
    print(food_info)
    food_info.sort_values('Sodium_(mg)',inplace=True,ascending=False) #关闭升序，相当于进行从大到小

### 5. 实例：泰坦尼克竞赛那题 ###

（1）判断元素是否为空，计算为空的个数

import numpy as np
    import pandas as pd
    
    titanic_survival=pd.read_csv('titanic_train.csv')
    print(titanic_survival.head(3))
    
    # pandas.isnull() 用于元素判断为空
    age=titanic_survival['Age'] #访问Age这一列
    age_is_null=pd.isnull(age) #逐一判断是否为空
    # print(age_is_null) #输出就是false/true，告诉你哪个为空
    age_null_true=age[age_is_null] #把true的部分提取出来，赋值给age_null_true
    # print(age_null_true)
    print('为空的数目：'+str(len(age_null_true))) #177

# 删去为空的记录
    drop_na_column=titanic_survival.dropna(axis=1)
    new_titanic_survival=titanic_survival.dropna(axis=0,subset=['Age','Sex'])
    print(new_titanic_survival)

（2）计算平均值（错误范例，按类别计算平均值。。）

# 计算平均值
    # 错误计算,把空值也包括进去
    mean_age=sum(titanic_survival['Age'])/len(titanic_survival['Age'])
    print(mean_age) #nan
    
    # 正确
    good_age=titanic_survival["Age"][age_is_null==False] #！！！将Age这一列中，非空的行取出来，放在good_age中
    correct_mean_age=sum(good_age)/len(good_age)
    print(correct_mean_age) #29.69911764705882
    
    # 更加简便的方式,mean()函数
    # 然而这种方式将缺失值直接删去的
    correct_mean_age2=titanic_survival['Age'].mean()
    print(correct_mean_age2) #29.69911764705882

分别求每个舱位的平均价格

# 分别求每个舱位的平均价格
    passager_classes=[1,2,3]
    fares_by_class={}
    for this_class in passager_classes:
        pclass_rows=titanic_survival[titanic_survival['Pclass']==this_class] #将某一舱位的所有乘客信息存在pclass_rows中
        pclass_fares=pclass_rows['Fare'] #将这一舱位的所有价格提取出来，存在pclass_fares中
        fare_for_class=pclass_fares.mean() #计算平均值
        fares_by_class[this_class]=fare_for_class #在存储‘舱位-价格’的字典中，添加数据
    print(fares_by_class) #{1: 84.1546875, 2: 20.662183152173913, 3: 13.675550101832993}
    
    # 更加便捷的方式!!!
    fares_by_class2=titanic_survival.pivot_table(index='Pclass', values='Fare',aggfunc=np.mean) #默认是进行平均计算
    print(fares_by_class2)
    
    port_stats=titanic_survival.pivot_table(index='Embarked',values=['Fare','Survived'],aggfunc=np.sum)
    print(port_stats) #强化练习：按港口售出的船票总价和获救人数

（3）定位到具体的一个数据项

# 定位到一个具体的值
    row_index_83_age=titanic_survival.loc[83,'Age'] #索引83，所以是第84条记录处的年龄
    print(row_index_83_age)

（4）排序

#排序
    new_titanic_survival=titanic_survival.sort_values('Age',ascending=False) #对年龄这一列进行降序排列
    print(new_titanic_survival.head(10))
    titanic_reindexed=new_titanic_survival.reset_index(drop=True) #重新排序
    print(titanic_reindexed)

（5）自定义函数

# 自定义函数操作apply
    # 自定义的一个函数，返回某dataframe的第99行
    def hundred_row(column):
        hundredth_item=column[99]
        return hundredth_item
    
    hundredth_row=titanic_survival.apply(hundred_row)
    print(hundredth_row)
    
    # 例2：计算每个列的缺失值并输出,这个有一点点不理解，先记着
    def null_count(column):
        column_null=pd.isnull(column)
        null=column[column_null]
        return len(null)
    column_null_count=titanic_survival.apply(null_count)
    print(column_null_count)

（6）其他：通过set\_index函数可以设置其他index，可以是字符串，但同时，数字的索引还是可以用的

## 三、Series结构 ##

1. 含义：series can be regarded as a collection of values, 而 DataFrame ——collection of Series objects

pandas内部定义的，DataFrame相当于数据读进来之后的那个矩阵，Series就是一行或者一列

2. 操作

（1）读取csv文件，将其中某列读取为series格式，观察

import numpy as np
    import pandas as pd
    from pandas import Series
    
    fandango=pd.read_csv('fandango_score_comparison.csv')
    series_film=fandango['FILM']
    print(type(series_film)) #<class 'pandas.core.series.Series'>
    print(series_film[0:5]) # 输出前5条记录的电影名称
    
    film_name=series_film.values #把电影名全部赋值给film_name
    print(film_name)
    print(type(film_name)) #<class 'numpy.ndarray'>，所以说，建立在numpy的基础之上呀

（2）series的特殊操作：将两个相同维度的series合并为一个大的series，并指定一个作为index

series_rt=fandango['RottenTomatoes']
    rt_scores=series_rt.values
    series_custom=Series(rt_scores,index=film_name) #将RT这个电影院的分数和电影的名称这两列（series）组成一个大的series，像一个矩阵一样，其中index是电影名称
    print(series_custom[['The Lazarus Effect (2015)','Phoenix (2015)']])
    #此时，数字索引同样可以用
    print(series_custom[0:3])
    # print(type(series_custom)) #<class 'pandas.core.series.Series'>

（3）排序（用得少）

# 排序
    original_index=series_custom.index.tolist()
    sorted_index=sorted(original_index)  #重新排序，按字母的顺序排序
    sorted_by_index=series_custom.reindex(sorted_index)
    print(sorted_by_index)

（4）运算，一个series的计算，两个series相同index可进行计算

# 运算
    print(np.add(series_custom,series_custom))
    print(np.sin(series_custom))
    print(np.max(series_custom))
    
    series_custom_greater_than_60=series_custom[series_custom>60]
    print(series_custom_greater_than_60)
    
    #两个series的index相同的时候，对象项可以相加减
    rt_cri=Series(fandango['RottenTomatoes'].values,index=fandango['FILM'])
    rt_users=Series(fandango['RottenTomatoes_User'].values,index=fandango['FILM'])
    rt_mean=(rt_cri+rt_users)/2
    print(rt_mean)