Pandas 用法汇总

一、生成数据表

1、首先导入pandas 库，一般会用到 numpy 库，所以我们先导入备用：

import numpy as np

import pandas as pd

2、生成 CSV 或者 xlsx 文件：

df = pd.DataFrame(pd.read_csv( 'name.csv', header = ))

df = pd.DataFrame(pd.read_excel('name.xlsx'))

3、用 pandas 创建数据表：

import numpy as np
import pandas as pd

df = pd.DataFrame({"id":[,,,,,],
 "date":pd.date_range('', periods=),
  "city":['Beijing ', 'SH', ' guangzhou ', 'Shenzhen', 'shanghai', 'BEIJING '],
 "age":[,,,,,],
 "category":['100-A','100-B','110-A','110-C','210-A','130-F'],
  "price":[,np.nan,,,np.nan,]},
  columns =['id','date','city','category','age','price'])

print(df)

       id          date    city    category    age    price
        --    Beijing    -A        1200.0
        --    SH         -B        NaN
        --    guangzhou  -A        2133.0
        --    Shenzhen   -C        5433.0
        --    shanghai   -A        NaN
        --    BEIJING    -F        4432.0

二、数据表信息查看

1、维度查看：

df.shape

( ,  )

2、数据表基本信息（维度，列名称，数据格式， 所占空间）：
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex:  entries,  to
Data columns (total  columns):
id           non-null int64
date         non-null datetime64[ns]
city         non-null object
category     non-null object
age          non-null int64
price        non-null float64
dtypes: datetime64[ns](), float64(), int64(), object()
memory usage: 368.0+ bytes

3、每一列的数据格式：

df.dtypes

id                   int64
date        datetime64[ns]
city                object
category            object
age                  int64
price              float64
dtype: object

4、某一列格式：
df[ 'id' ].dtype

dtype('int64')

5、空值：
df.isnull()

    id    date    city    category    age    price
    False    False    False    False    False    False
    False    False    False    False    False    True
    False    False    False    False    False    False
    False    False    False    False    False    False
    False    False    False    False    False    True
    False    False    False    False    False    False

6、查看某一列的空值：

df['price'].isnull()

    False
     True
    False
    False
     True
    False
Name: price, dtype: bool

7、查看某一列的唯一值：

df['id'].unique()

array([, , , , , ], dtype=int64)

8、查看数据表的值：
df.values

array([[, Timestamp('2013-01-02 00:00:00'), 'Beijing ', '100-A', ,
        1200.0],
       [, Timestamp('2013-01-03 00:00:00'), 'SH', '100-B', , nan],
       [, Timestamp('2013-01-04 00:00:00'), ' guangzhou ', '110-A',
        , 2133.0],
       [, Timestamp('2013-01-05 00:00:00'), 'Shenzhen', '110-C', ,
        5433.0],
       [, Timestamp('2013-01-06 00:00:00'), 'shanghai', '210-A', ,
        nan],
       [, Timestamp('2013-01-07 00:00:00'), 'BEIJING ', '130-F', ,
        4432.0]], dtype=object)

9、查看列名称：

df.columns

Index(['id', 'date', 'city', 'category', 'age', 'price'], dtype='object')

10、查看前10列数据、后10行数据：
df.head()       // 默认前10行数据

       id          date    city    category    age    price
        --    Beijing     -A        1200.0
        --    SH          -B        NaN
        --    guangzhou   -A        2133.0
        --    Shenzhen    -C        5433.0
        --    shanghai    -A        NaN

df.tail()          // 默认后10行数据

       id          date    city    category    age    price
        --    SH          -B        NaN
        --    guangzhou   -A        2133.0
        --    Shenzhen    -C        5433.0
        --    shanghai    -A        NaN
        --    BEIJING     -F        4432.0

三、数据表清洗

1、用数字 0 填充空值：

df.fillna(value = 0)

       id          date    city    category    age    price
        --    Beijing     -A        1200.0
        --    SH          -B        0.0
        --    guangzhou   -A        2133.0
        --    Shenzhen    -C        5433.0
        --    shanghai    -A        0.0
        --    BEIJING     -F        4432.0

2、使用列 price 的均值对 NA 进行填充：

df[ 'price' ].fillna(df['price'].mean())

    1200.0
    3299.5
    2133.0
    5433.0
    3299.5
    4432.0
Name: price, dtype: float64

3、清楚 city 字段的字符空格：

df[ 'city' ] = df[ 'city' ].map(str.strip)

4、大小写转换：

df[ 'city' ] = df[ 'city' ].str.lower()

       id           date    city    category    age    price
        --    beijing      -A        1200.0
        --    sh           -B        NaN
        --    guangzhou    -A        2133.0
        --    shenzhen     -C        5433.0
        --    shanghai     -A        NaN
        --    beijing      -F        4432.0

5、更改数据格式：

df[ 'price' ].astype( 'int' )

6、更改列名称：

df.rename(columns = { 'category' : 'category-size' })

       id          date    city    category-size    age    price
        --    Beijing    -A        1200.0
        --    SH         -B        NaN
        --    guangzhou  -A        2133.0
        --    Shenzhen   -C        5433.0
        --    shanghai   -A        NaN
        --    BEIJING    -F        4432.0

7、删除后出现的重复值:

df[ 'city' ].drop_duplicates()

       Beijing
             SH
     guangzhou
       Shenzhen
       shanghai
       BEIJING
Name: city, dtype: object

8、删除先出现的重复值：

df[ 'city' ].drop_duplicates(keep = 'last' )

       Beijing
             SH
     guangzhou
       Shenzhen
       shanghai
       BEIJING
Name: city, dtype: object

9、数据替换：
df[ 'city' ].replace( 'sh' , 'shanghai' )

四、数据预处理

df1=pd.DataFrame({

"id":[,,,,,,,],
"gender":['male','female','male','female','male','female','male','female'],
"pay":['Y','N','Y','Y','N','Y','N','Y',],
"m-point":[,,,,,,,]})

1、数据表合并：
1.1merge

df_inner = pd.merge(df, df1, how = 'inner') # 匹配合并 交集

       id          date    city    category    age    price    gender    pay   m-point
        --    Beijing     -A        1200.0    male      Y
        --    SH          -B        NaN       female    N
        --    guangzhou   -A        2133.0    male      Y
        --    Shenzhen    -C        5433.0    female    Y
        --    shanghai    -A        NaN       male      N
        --    BEIJING     -F        4432.0    female    Y    

df_left = pd.merge(df, df1, how = 'left')

       id          date    city    category    age    price    gender    pay   m-point
        --    Beijing    -A        1200.0    male       Y
        --    SH         -B        NaN       female     N
        --    guangzhou  -A        2133.0    male       Y
        --    Shenzhen   -C        5433.0    female     Y
        --    shanghai   -A        NaN       male       N
        --    BEIJING    -F        4432.0    female     Y    

df_right = pd.merge(df, df1, how = 'right')
df_outer = pd.merge(df, df1, how = 'outer') # 并集

输出结构同上

1.2 append

result = df1.append(df2)

1.3 join

reault = left.join( right, on='key' )

1.4 concat

pd.concat(
　　　　　　objs, 
　　　　　　axis=, 
　　　　　　join = 'outer', 
　　　　　　join_axes = None, 
　　　　　　ignore_index = False, 
　　　　　　keys = None, 
　　　　　　levels = None, 
　　　　　　names=None, 
　　　　　　verify_integrity=false, 
　　　　　　copy = True)

objs；一个序列系列、综合或面板对象的映射。如果字典中传递，将作为键参数，使用序的键，除非它传递，在这种情况下的值将会选择（见上下文）。任何没有任何反对将默默的的丢弃，除非他妈嗯都没有在这种情况下将引发 VslueError。

axis：{0,1,2，...}，默认值为0，要连接沿轴。

join：{‘内部’、‘外’}，默认 ‘外’。如何处理其他axis（es）上的索引。联盟内，外的交叉口。

ignore_index︰ 布尔值、 默认 False。如果为 True，则不要串联轴上使用的索引值。由此产生的轴将标记 0，…，n-1。这是有用的如果你串联串联轴没有有意义的索引信息的对象。请注意在联接中仍然受到尊重的其他轴上的索引值。 
join_axes︰ 索引对象的列表。具体的指标，用于其他 n-1 轴而不是执行内部/外部设置逻辑。 
keys︰ 序列，默认为无。构建分层索引使用通过的键作为最外面的级别。如果多个级别获得通过，应包含元组。 
levels︰ 列表的序列，默认为无。具体水平 （唯一值） 用于构建多重。否则，他们将推断钥匙。 
names︰ 列表中，默认为无。由此产生的分层索引中的级的名称。 
verify_integrity︰ 布尔值、 默认 False。检查是否新的串联的轴包含重复项。这可以是相对于实际数据串联非常昂贵。 
副本︰ 布尔值、 默认 True。如果为 False，请不要，不必要地复制数据。

例子：

　　1、frames  =  [df1, df2, df3]

　　2、result = pd.concat(frames)

2、设置索引列

df_inner.set_index('id')

               date    city    category    age    price    gender    pay   m-point
id
    --    Beijing      -A        1200.0    male      Y
    --    SH           -B        NaN       female    N
    --    guangzhou    -A        2133.0    male      Y
    --    Shenzhen     -C        5433.0    female    Y
    --    shanghai     -A        NaN       male      N
    --    BEIJING      -F        4432.0    female    Y    

3、按照特定列的值排序：
df_inner.sort_values(by = [‘age’])

      id            date    city    category    age    price    gender    pay   m-point
        --    Beijing    -A         1200.0    male       Y
        --    Shenzhen   -C         5433.0    female     Y
        --    BEIJING    -F         4432.0    female     Y
        --    shanghai   -A         NaN       male       N
        --    SH         -B         NaN       female     N
        --    guangzhou  -A         2133.0    male       Y    

4、按照索引排序：
df_inner.sort_index()

       id           date    city    category    age    price    gender    pay   m-point
        --    Beijing    -A          1200.0    male      Y
        --    SH         -B          NaN       female    N
        --    guangzhou  -A          2133.0    male      Y
        --    Shenzhen   -C          5433.0    female    Y
        --    shanghai   -A          NaN       male      N
        --    BEIJING    -F          4432.0    female    Y    

5、如果price列的值 > 3000, group列显示 high，否则显示 low：

df_inner['group'] = np.where(df_inner['price'] > 3000,'high','low')

       id          date    city    category    age    price    gender    pay    m-point   group
        --    Beijing    -A          1200.0    male      Y            low
        --    SH         -B          NaN       female    N            low
        --    guangzhou  -A          2133.0    male      Y            low
        --    Shenzhen   -C          5433.0    female    Y            high
        --    shanghai   -A          NaN       male      N            low
        --    BEIJING    -F          4432.0    female    Y            high

6、对符合多个条件的数据进行分组标记：
      df_inner.loc[(df_inner['city'] == 'beijing')&(df_inner['price'] >= 4000), 'sign'] = 1

       id           date    city    category    age    price    gender    pay    m-point    group    sign
        --    Beijing    -A          1200.0    male      Y               low     NaN
        --    SH         -B          NaN       female    N               low     NaN
        --    guangzhou  -A          2133.0    male      Y               low     NaN
        --    Shenzhen   -C          5433.0    female    Y               high    NaN
        --    shanghai   -A          NaN       male      N               low     NaN
        --    BEIJING    -F          4432.0    female    Y               high    NaN

7、对category字段的值依次进行分列，并创建数据表，索引值为 df_inner 的索引列，列名称为 category 和 size

　　　　pd.DataFrame((x.split(‘-‘) for x in df_inner[‘category’]),index=df_inner.index,columns=[‘category’,’size’]))

8、将完成分裂的数据表和原df_inner 数据表进行匹配：

　　df_inner=pd.merge(df_inner,split,right_index=True, left_index=True)

五、数据提取

主要用到三个函数： loc、iloc 和 ix。

　　loc  函数按标签值进行提取

　　iloc 按位置进行提取

　　ix    可以同时按标签和位置进行提取

1、按索引提取单行的数值

　　df_inner.loc[3]

id
date        -- ::
city                   Shenzhen
category                  -C
age
price
gender                   female
pay                           Y
m-point
group                      high
sign                        NaN
Name: , dtype: object

2、按索引提取区域行数值

df_inner.iloc[0:3]

       id          date    city    category    age    price    gender    pay    m-point    group  sign
        --    Beijing    -A        1200.0    male       Y              low    NaN
        --    SH         -B        NaN       female     N              low    NaN
        --    guangzhou  -A        2133.0    male       Y              low    NaN

3、重设索引：

df_inner.reset_index()

4、设置日期为索引：
df_inner = df_inner.set_index( 'date' )

5、提取 4 日之前的所有数据

df_inner[: '2013-01-04']

6、使用 iloc 按位置区域提取数据：

df_inner.iloc[:3, :2] # 冒号前后的数字不在是索引的标签名称，而是数据所在的位置，从0 开始，前三行，前两行。

7、适应 iloc 按位置单独提起数据：

df_inner.iloc[[0, 2, 5], [4, 5]] # 提取 0、2、5行，4、5列

8、使用 ix 按索引标签和位置混合提取数据

df_inner[: '2013-01-03', :4] # 2013-01-03 好之前，前四列的数据

9、判断city列的值是否为北京

df_inner['city'].isin(['beijing'])

10、判断 city 列里是否包含bejing 和 shanghai，然后将符合条件的数据提取出来

df_inner.loc[df_inner[ 'city' ].isin([ 'beijing' , 'sahnghai' ] )]

11、提取前三个字符，并生成数据表

pd.DataFrame(category.str[:3])

六、数据筛选

使用与、或、非 三个条件配合大于、小于、等于对数据进行筛选，并进行计数和求和。

1、使用“与” 进行筛选

df_inner.loc(df_inner['age'] > 25)&(df_inner['city'] == 'beijing'),['id','city','age','category','gender'] ]

2、使用 “或”进行删选

df_inner.loc[(df_inner['age']>25) | (df_inner['city' ] == 'beijing'),['id','city','age','category','gender']].sort(['age'])

3、使用 ‘非’ 条件进行筛选

df_inner.loc[(df_inner['city'] != 'beijing'),['id','city','age','category','gender']].sort(['id'])

4、对筛选后的数据按city列进行计数:

df_inner.loc[(df_inner['city'] != 'beijing').['id','city','age','category','gender']].sort(['id']).city.count()

5、使用query函数进行筛选

df_inner.query('city==['beijing','shanghai']')

6、对筛选后的结果按price进行求和

df_inner.query('city ==['beijing', 'shanghai']').price.sum()

七、数据汇总

主要函数是groupby 和 pivote_table

1、对所有的列进行计数汇总

df_inner.groupby('city').count()

2、按城市对 id 字段进行计数

df_inner.groupby('city')['id'].count()

3、对两个字段进行汇总计数

df_inner.groupby(['city', 'size'])['id'].count()

4、对city字段进行汇总，并分别计算price 的合计和均值

df_inner.groupby('city')['price'].agg([len, np.su, np.mean])

八、数据统计

数据采样，计算标准差、协方和相关系数

1、简单的数据采样

df_inner.sample(n = 3)

2、手动设置采样权重

weights = [0, 0, 0, 0, 0.5, 0.5]

df_inner.sample(n = 6, replace = False)

3、采样后不放回

df_inner.sample(n=6, replace = False)

4、采样后放回

df_inner.sample(n = 6, replace = False)

5、数据表描述性统计

df_inner.describe().round(2).T   # round 函数是设置小数位，T表示转置

6、 计算列的标准差

df_inner[ 'price' ].std()

7、计算两个字段间的协方差

df_inner['price'].cov(df_inner['m-point'])

8、数据表中所有的字段间的协方差

df_inner.cov()

9、两个字段间的相关性分析

df_inner['price'].corr(df_inner['m-point']) # 相关系数在 -1 到 1 之间，接近 1 为正相关，接近 -1 为负相关， 0 为不相关

10、数据表的相关分析

df_inner.corr()

九、数据输出

分析后的数据可以输出为 xlsx 格式和 csv 格式

1、写入 Excel

df_inner.to_excel( 'excel_to_python.xlsx', sheet_name = 'bluewhale_cc')

2、写入到 CSV

df_inner.to_csv('excel_to_python.csv')