Pandas的基本用法

约定不等于承诺〃 2021-11-04 15:20 468阅读 0赞

Pandas是使用python进行数据分析不可或缺的第三方库。我们已经知道，NumPy的ndarray数据结构能够很好地进行数组运算，但是当我们需要进行为数据添加标签，处理缺失值，对数据分组，创建透视表等任务时，NumPy的的限制就非常明显了。而Pandas是在NumPy基础上建立的新程序库，提供了高效的Series和DataFrame数据结构。DataFrame本质上是一种带行列标签，支持同类型数据和缺失值的二维数组（Series是一维数组）。在此之前，”数据清洗“（Data Munging）往往要耗费人们大量的时间和精力，而Pandas给人们进行提供了一个有效的工具。

一. 导入pandas库

import pandas as pd

二. **创建Series对象**

1. **通过python列表创建**

data=pd.Series([1,2,3,4], index=['a','b','c','d'])

a    1
    b    2
    c    3
    d    4

（注：Series对象和numpy数组的区别：numpy数组通过隐式定义的整数索引获取数值；而pandas的Series对象用显式定义的索引与数值关联。）

2. **通过python字典创建**

data=pd.Series({
        'A':1,'B':2,'C':4})

A    1
    B    2
    C    4

三. **创建DataFrame对象**

1. **通过python字典创建**

data=pd.DataFrame({
        'a':[1,2,3],'b':'foo','c':pd.Categorical(['me','you','it'])})

a    b    c
    0  1  foo   me
    1  2  foo  you
    2  3  foo   it

2. **通过Series对象创建**

series=pd.Series({
        'A':1,'B':2,'C':4})
    data=pd.DataFrame(series, columns=['number'])

number
    A       1
    B       2
    C       4

3. **通过由Series对象构成的字典创建**

series1=pd.Series({
        'A':1,'B':2,'C':4})
    series2=pd.Series([1,2,3,4], index=['A','B','C','D'])
    data=pd.DataFrame({
        'number1':series1, 'number2':series2})

number1  number2
    A      1.0        1
    B      2.0        2
    C      4.0        3
    D      NaN        4

4. **通过numpy二维数组创建**

data=pd.DataFrame(np.random.rand(3,2), index=['a','b','c'], columns=['N1','N2'])

N1        N2
    a  0.642597  0.869653
    b  0.160318  0.663777
    c  0.807979  0.043525

5. **从文件中读取**

**pd.read\_excel(*filepath*)** \--- 读取excel文件

**pd.read\_csv(*filepath, sep=', '*)** \--- 读取csv文件，sep表示分隔符，默认以逗号分隔，可改成其他，如以tab分隔---sep='\\t'

**pd.read\_json(*filepath*)** \--- 读取json文件

四. **查看数据的属性（attributes）**

1. **info()** \--- 查看数据属性简介，包括行列索引，数据类型，占用多少内存

2. **shape** \--- 查看数据的形状（每个维度的大小）

3. **index** \--- 查看Series对象和DataFrame对象的行索引

4. **columns** \--- 查看DataFrame对象的列标签

5. **values** \--- 查看对象的值

6. **dtypes** \--- 查看数据类型

五. **索引（Indexing）和切片（Slicing）**

1. **data.loc\[row\_index\_name, : \]** \--- 显式选取某行

2. **data.iloc\[row\_index\_from\_zero, : \]** \--- 隐式选取某行

3. **data\['column\_name'\]** \--- 选取某列

4. **data.loc\[row\_index\_name1: row\_index\_name2, : \]** \--- 显式选取连续的几行

5. **data.iloc\[row\_index\_from\_zero1: row\_index\_from\_zero2, : \]** \--- 隐式选取连续的几行

6. **data.loc\[ : , 'column\_name1': 'column\_name2'\]** \--- 显式选取连续的几列

7. **data.iloc\[ : , column\_index\_from\_zero1: column\_index\_from\_zero2\]** \--- 隐式选取连续的几列

8. **data.loc\[row\_index\_name1: row\_index\_name2, 'column\_name1': 'column\_name2'\]** \--- 显式选取连续的几行几列

9. **data.iloc\[row\_index\_from\_zero1: row\_index\_from\_zero2, column\_index\_from\_zero1: column\_index\_from\_zero2\]** \--- 隐式选取连续的几行几列

10. **data.loc\[\[row\_index\_name1,row\_index\_name2, ...\], :\]** \--- 显式选取不连续的几行

11. **data.iloc\[\[row\_index\_from\_zero1, row\_index\_from\_zero2, ...\], :\]** \--- 隐式选取不连续的几行

12. **data.loc\[ :, \[column\_name1, column\_name2, ...\]\]** \--- 显式选取不连续的几列

13. **data.iloc\[ :, \[column\_index\_from\_zero1, column\_index\_from\_zero2, ...\]\]** --- 隐式选取不连续的几行

六. **添加数据**

1. **data.loc\[new\_row\_index\]=\[.....\]** \--- 添加新行

2. **data\['new\_column\_name'\]=\[.....\]** \--- 添加新列

3. **data.insert(column\_index, 'new\_column\_name',\[...\])** \--- 在指定位置插入列

七. **删除数据**

1. **data.drop(row\_index\_from\_zero, axis=0)** \--- 删除某行

2. **data.drop('column\_name', axis=1)** \--- 删除某列

八. **更改数据**

1. **rename(columns=\{'old\_column\_name':'new\_column\_name'\}, inplace=True)** \--- 更改某个列名

2.**set\_index('col\_name')** \--- 更改索引（索引变为选择的列）

3.**reset\_index()** \--- 更新索引

4.** replace(new\_value, old\_value, inplace=True)** \--- 替换数据

九. **重复值**

1. **duplicated()** \--- 根据数据每一行是否有重复值，返回相应的布尔值

2. **drop\_duplicates()** \--- 返回已剔除有重复值的行的数据

十. **缺失值**

1. **isnull(data)** \--- 返回一个布尔类型的掩码，标记数据是否有缺失值，如有缺失值则标记True

2.** notnull(data)** \---  返回一个布尔类型的掩码，标记数据是否没有缺失值，如没有缺失值则标记True

3. **dropna(axis=0, how='any')** \--- 返回剔除缺失值的数据

4. **fillna(value, axis=0, method='backfill')** \--- 返回填充了缺失值的数据副本

十一. **唯一值**

1. **pd.unique(values)** \--- 显示唯一值

2. **nunique(axis=0, dropna=True)** \--- 显示唯一值的个数

十二. **转换数据类型**

1. **astype(dtype) **     注：可转换的数据类型有：int, str, float ...  ;

2. **pd.to\_datetime(str)** \--- 转换成时间序列

十三. **使用掩码过滤(（Mask Arrays）**

1. **data\[mask\] **             注：一些条件表示方法：&（and） ，|（or），-（not），.isin（in）

十四. **排序**

1.** sort\_index(axis=0, ascending=True)** \--- 按索引排序

2. **sort\_values(by, axis=0, ascending=True)** \--- 按内容排序

十五. **数据分组**

1.** groupby(by=None, axis=0)** \--- 把数据按某一列分组             注： groupby()是一个数据分组的对象，它实际上还没有进行任何计算，只是一个暂时存储的容器，要使用累计方法后才会进行计算。因此，groupby一般与累计函数搭配使用。

**累计方法有：count(), mean(), median(), min(), max(), std(), prod(), sum() 等等**            注：参数axis=0表示按行进行计算，axis=1表示按列进行计算，默认axis=1；如果需要对特定Series使用两个及以上的累计方法，请使用**agg()**。如果需要对整个DataFrame（按行或按列）使用自定义的累计方法，请使用**apply()**。

十六. **透视表**

1. **pd.pivot\_table(data, values=None, index=None, columns=None, aggfunc='mean')** \--- 以index为行索引，columns为列索引，累计方法为aggfunc，对data的values作透视表

十七. **合并数据**

1. **pd.concat(\[d1,d2\], axis=0, join='outer', ignore\_index=False)** \--- 按某一个轴的方向合并d1和d2

2. **d1.merge(d2, how='inner', on=None, left\_on=None, right\_on=None)** \--- 把某一列作为键进行合并，假如两张表作为键的列名称不一致，那么可以通过设置left\_on和left\_on来解决

注：how可选"left", "right", "outer", "inner"

"left"：类似于SQL的left outer join；

"right"：类似于SQL的right outer join；

"outer"：并集，类似于SQL的full outer join；

"inner"：交集，类似于SQL的inner join；

3.** d1.join(d2, on=None, how='left')** \--- 按索引合并d1和d2

十八. **分隔数据**