go数据分析 pandas python数据分析活用pandas库

一、　　Pandas简介

1、Python Data Analysis Library 或 pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。Pandas 纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具。pandas提供了大量能使我们快速便捷地处理数据的函数和方法。你很快就会发现，它是使Python成为强大而高效的数据分析环境的重要因素之一。

2、Pandas

3、数据结构：

Series：一维数组，与Numpy中的一维array类似。二者与Python基本的数据结构List也很相近，其区别是：List中的元素可以是不同的数据类型，而Array和Series中则只允许存储相同的数据类型，这样可以更有效的使用内存，提高运算效率。

Time- Series：以时间为索引的Series。

DataFrame：二维的表格型数据结构。很多功能与R中的data.frame类似。可以将DataFrame理解为Series的容器。以下的内容主要以DataFrame为主。

Panel ：三维的数组，可以理解为DataFrame的容器。

Pandas 有两种自己独有的基本数据结构。读者应该注意的是，它固然有着两种数据结构，因为它依然是 Python 的一个库，所以，Python 中有的数据类型在这里依然适用，也同样还可以使用类自己定义数据类型。只不过，Pandas 里面又定义了两种数据类型：Series 和 DataFrame，它们让数据操作更简单了。

二、　　Pandas安装

因为pandas是python的第三方库所以使用前需要安装一下，直接使用pip install pandas 就会自动安装pandas以及相关组件。

三、　　Pandas使用

注：本次操作是在ipython中进行

1、导入pandas模块并使用别名，以及导入Series模块，以下使用基于本次导入。

In [1]: from pandas import Series

In [2]: import pandas as pd

2、Series

Series 就如同列表一样，一系列数据，每个数据对应一个索引值。

Series 就是“竖起来”的 list：

In [3]: s = Series([1,4,'ww','tt'])

In [4]: s
Out[4]:
0　　 1
1　　 4
2　　 ww
3　　 tt
dtype: object

另外一点也很像列表，就是里面的元素的类型，由你任意决定（其实是由需要来决定）。

这里，我们实质上创建了一个 Series 对象，这个对象当然就有其属性和方法了。比如，下面的两个属性依次可以显示 Series 对象的数据值和索引：

In [5]: s.index
Out[5]: RangeIndex(start=0, stop=4, step=1)

In [8]: s.values
Out[8]: array([1, 4, 'ww', 'tt'], dtype=object)

列表的索引只能是从 0 开始的整数，Series 数据类型在默认情况下，其索引也是如此。不过，区别于列表的是，Series 可以自定义索引：

In [9]: s2 = Series(['wangxing','man',24],index=['name','sex','age'])

In [10]: s2
Out[10]:
name 　　 wangxing
sex　　     man
age 　　   24
dtype: object

每个元素都有了索引，就可以根据索引操作元素了。还记得 list 中的操作吗？Series 中，也有类似的操作。先看简单的，根据索引查看其值和修改其值：

In [12]: s2['name']
Out[12]: 'wangxing'

In [45]: s2['name'] = 'wudadiao'

In [46]: s2
Out[46]:
name 　　 wudadiao
sex 　　　man
age　　　24
dtype: object

这是不是又有点类似 dict 数据了呢？的确如此。看下面就理解了。

读者是否注意到，前面定义 Series 对象的时候，用的是列表，即 Series() 方法的参数中，第一个列表就是其数据值，如果需要定义 index，放在后面，依然是一个列表。除了这种方法之外，还可以用下面的方法定义 Series 对象：

In [13]: sd = {'python':9000,'c++':9001,'c#':9000}

In [14]: s3 = Series(sd)

In [15]: s3
Out[15]:
c# 　　　9000
c++ 　　　9001
python 　　9000
dtype: int64

现在是否理解为什么前面那个类似 dict 了？因为本来就是可以这样定义的。

这时候，索引依然可以自定义。Pandas 的优势在这里体现出来，如果自定义了索引，自定的索引会自动寻找原来的索引，如果一样的，就取原来索引对应的值，这个可以简称为“自动对齐”。

In [16]: s4 = Series(sd,index=['java','c++','c#'])

In [17]: s4
Out[17]:
java 　　 NaN
c++ 　　 9001.0
c# 　　 9000.0
dtype: float64

在 Pandas 中，如果没有值，都对齐赋给 NaN。

Pandas 有专门的方法来判断值是否为空。

In [19]: pd.isnull(s4)
Out[19]:
java 　　 True
c++　　 False
c# 　　 False
dtype: bool

此外，Series 对象也有同样的方法：

In [20]: s4.isnull()
Out[20]:
java 　　 True
c++　　 False
c# 　　 False
dtype: bool

其实，对索引的名字，是可以从新定义的：

In [21]: s4.index = ['语文','数学','English']

In [22]: s4
Out[22]:
语文 　　 NaN
数学　　 9001.0
English 　　 9000.0
dtype: float64

对于 Series 数据，也可以做类似下面的运算（关于运算，后面还要详细介绍）：

In [23]: s4 * 2
Out[23]:
语文 　　 NaN
数学 　　 18002.0
English 　　 18000.0
dtype: float64

In [24]: s4[s4 > 9000]
Out[24]:
数学 9001.0
dtype: float64

Series就先简要写到这，下面看pandas的另一种数据结构DataFrame.

DataFrame

DataFrame 是一种二维的数据结构，非常接近于电子表格或者类似 mysql 数据库的形式。它的竖行称之为 columns，横行跟前面的 Series 一样，称之为 index，也就是说可以通过 columns 和 index 来确定一个主句的位置。

首先来导入模块

In [27]: from pandas import Series,DataFrame

In [26]: data = {"name":['google','baidu','yahoo'],"marks":[100,200,300],"price":[1,2,3]}

In [28]: f1 = DataFrame(data)

In [29]: f1
Out[29]:
　　marks　　 name 　　 price
0 　　 100 　　 google 　　 1
1 　　 200 　　 baidu 　　 2
2　　 300 　　 yahoo 　　 3

这是定义一个 DataFrame 对象的常用方法——使用 dict 定义。字典的“键”（"name"，"marks"，"price"）就是 DataFrame 的 columns 的值（名称），字典中每个“键”的“值”是一个列表，它们就是那一竖列中的具体填充数据。上面的定义中没有确定索引，所以，按照惯例（Series 中已经形成的惯例）就是从 0 开始的整数。从上面的结果中很明显表示出来，这就是一个二维的数据结构（类似 excel 或者 mysql 中的查看效果）。

上面的数据显示中，columns 的顺序没有规定，就如同字典中键的顺序一样，但是在 DataFrame 中，columns 跟字典键相比，有一个明显不同，就是其顺序可以被规定，向下面这样做：

In [31]: f2 = DataFrame(data,columns=['name','price','marks'])

In [32]: f2
Out[32]:
　　name 　　 price 　　 marks
0 　google 　　1 　　     100
1 　baidu 　　 2　　       200
2　 yahoo 　　3 　　      300

跟 Series 类似的，DataFrame 数据的索引也能够自定义

In [35]: f3 = DataFrame(data,columns=['name','marks','price'],index=['a','b','c'])

In [36]: f3
Out[36]:
　　name 　　 marks 　　 price
a 　 google      100 　　     1
b     baidu          200 　　    2
c     yahoo         300            3

定义 DataFrame 的方法，除了上面的之外，还可以使用“字典套字典”的方式。

In [40]: newdata = {'lang':{'first':'python','second':'java'},'price':{'first':5000,'second':2000}}

In [41]: f4 = DataFrame(newdata)

In [42]: f4
Out[42]:
　　　　lang 　　 price
first　　 python 　 5000
second   java 　　 2000

在字典中就规定好数列名称（第一层键）和每横行索引（第二层字典键）以及对应的数据（第二层字典值），也就是在字典中规定好了每个数据格子中的数据，没有规定的都是空。

DataFrame 对象的 columns 属性，能够显示素有的 columns 名称。并且，还能用下面类似字典的方式，得到某竖列的全部内容（当然包含索引）：

>>> newdata = {"lang":{"firstline":"python","secondline":"java"}, "price":{"firstline":8000}} 
>>> f4 = DataFrame(newdata) 
>>> f4 
              lang     price 
firstline     python   8000 
secondline    java     NaN

>>> DataFrame(newdata, index=["firstline","secondline","thirdline"]) 
              lang     price 
firstline     python   8000 
secondline    java     NaN 
thirdline     NaN      NaN 

DataFrame 对象的 columns 属性，能够显示素有的 columns 名称。并且，还能用下面类似字典的方式，得到某竖列的全部内容（当然包含索引）：

In [44]: f3['name']
Out[44]:
a google
b baidu
c yahoo
Name: name, dtype: object

下面操作是给同一列赋值

newdata1 = {'username':{'first':'wangxing','second':'dadiao'},'age':{'first':24,'second':25}}

In [67]: f6 = DataFrame(newdata1,columns=['username','age','sex'])

In [68]: f6
Out[68]:
　　username 　　 age 　　 sex
first wangxing 　　 24 　　 NaN
second dadiao　　 25 　　 NaN

In [69]: f6['sex'] = 'man'

In [70]: f6
Out[70]:
　　username  age 　　 sex
first wangxing　　 24 　  man
second dadiao 　　25    man

也可以单独的赋值，除了能够统一赋值之外，还能够“点对点”添加数值，结合前面的 Series，既然 DataFrame 对象的每竖列都是一个 Series 对象，那么可以先定义一个 Series 对象，然后把它放到 DataFrame 对象中。如下：

ssex = Series(['男','女'],index=['first','second'])

In [72]: f6['sex'] = ssex

In [73]: f6
Out[73]:
　　username 　　 age 　　sex
first wangxing　　   24 　　   男
second dadiao 　　 25 　　 女

还可以更精准的修改数据吗？当然可以，完全仿照字典的操作：

In [74]: f6['age']['second'] = 30

In [75]: f6
Out[75]:
　　username 　　 age 　　 sex
first wangxing 　　 24 　　       男
second dadiao 　　30 　　　　女

 

 

 

pandas 数据排序.sort_index()和.sort_values()

1. df. sort_values()

作用：既可以根据列数据，也可根据行数据排序。
注意：必须指定by参数，即必须指定哪几行或哪几列；无法根据index名和columns名排序（由.sort_index()执行）

调用方式

DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last')
axis：{0 or ‘index’, 1 or ‘columns’}, default 0，默认按照列排序，即纵向排序；如果为1，则是横向排序。
by：str or list of str；如果axis=0，那么by="列名"；如果axis=1，那么by="行名"。
ascending：布尔型，True则升序，如果by=['列名1','列名2']，则该参数可以是[True, False]，即第一字段升序，第二个降序。
inplace：布尔型，是否用排序后的数据框替换现有的数据框。
kind：排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。似乎不用太关心。
na_position：{‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面。

例：

原数据

df = pd.DataFrame({'b':[1,2,3,2],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3]) 
    b   a   c
2   1   4   1
0   2   3   3
1   3   2   8
3   2   1   2

1.按b列升序排序

df.sort_values(by='b') #等同于df.sort_values(by='b',axis=0)
    b   a   c
2   1   4   1
0   2   3   3
3   2   1   2
1   3   2   8

2.先按b列降序，再按a列升序排序

df.sort_values(by=['b','a'],axis=0,ascending=[False,True]) #等同于df.sort_values(by=['b','a'],axis=0,ascending=[False,True]) 
    b   a   c
1   3   2   8
3   2   1   2
0   2   3   3
2   1   4   1

3.按行3升序排列

df.sort_values(by=3,axis=1) #必须指定axis=1
    a   b   c
2   4   1   1
0   3   2   3
1   2   3   8
3   1   2   2

4.按行3升序，行0降排列

df.sort_values(by=[3,0],axis=1,ascending=[True,False])
    a   c   b
2   4   1   1
0   3   3   2
1   2   8   3
3   1   2   2

注意：指定多列（多行）排序时，先按排在前面的列（行）排序，如果内部有相同数据，再对相同数据内部用下一个列（行）排序，以此类推。如何内部无重复数据，则后续排列不执行。即首先满足排在前面的参数的排序，再排后面参数

2. df. sort_index()

作用：默认根据行标签对所有行排序，或根据列标签对所有列排序，或根据指定某列或某几列对行排序。
注意：df. sort_index()可以完成和df. sort_values()完全相同的功能，但python更推荐用只用df. sort_index()对“根据行标签”和“根据列标签”排序，其他排序方式用df.sort_values()。

调用方式

sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)
axis：0按照行名排序；1按照列名排序
level：默认None，否则按照给定的level顺序排列---貌似并不是，文档
ascending：默认True升序排列；False降序排列
inplace：默认False，否则排序之后的数据直接替换原来的数据框
kind：排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。似乎不用太关心。
na_position：缺失值默认排在最后{"first","last"}
by：按照某一列或几列数据进行排序，但是by参数貌似不建议使用

例：

源数据

import pandas as pd  
df = pd.DataFrame({'b':[1,2,2,3],'a':[4,3,2,1],'c':[1,3,8,2]},index=[2,0,1,3]) 
    b   a   c
2   1   4   1
0   2   3   3
1   3   2   8
3   2   1   2

1.默认按“行标签”升序排列（推荐）

df.sort_index() #默认按“行标签”升序排序，或df.sort_index(axis=0, ascending=True)
    b   a   c
0   2   3   3
1   3   2   8
2   1   4   1
3   2   1   2

2.按“列标签”升序排列（推荐）

df.sort_index(axis=1) #按“列标签”升序排序
    a   b   c
2   4   1   1
0   3   2   3
1   2   3   8
3   1   2   2

3.指定“多列”排序（不推荐）

#先按b列“降序”排列，因为b列中有相同值，相同值再按a列的“升序”排列
df.sort_index(by = ['b','a'],ascending = [False,True]) 
    b   a   c
1   3   2   8
3   2   1   2
0   2   3   3
2   1   4   1
#先按a列“降序”排列，而a列中没有相同值，因此这里按b列的“升序”排列不起作用。
df.sort_index(by = ['a','b'],ascending = [False,True]) 
    b   a   c
2   1   4   1
0   2   3   3
1   3   2   8
3   2   1   2

 

Pandas中创建固定频率的时间序列—date_range(）方法解析

 

Pandas中提供了一个date_range()函数，主要用于生成一个具有固定频率的DatetimeIndex对象，该函数的语法格式如下：

pandas.date_range(start=None，end=None，periods=None，freq=None，tz=None，normalize=False，name=None，closed=None，**kwargs)

上述部分参数的含义如下：

start：表示起始日期，默认为None。
end：表示终止日期，默认为None。
periods：表示产生多少个时间戳索引值。若设置为None，则start与end必须不能为None。 //默认生成的时间序列数据是按天计算的，即频率为"D"
freq：表示以自然日为单位，这个参数用来指定计时单位，比如"5H"表示每隔5个小时计算一次。
tz：表示时区，比如Asia、Hong_Kong。
normalize：接收布尔值，默认值为False。如果设为True的话，那么在产生时间戳索引值之前，会将start和end都转化为当日的午夜0点。 //规范化，是否将时间索引重置为当日午夜0点
name：给返回的时间序列索引指定一个名字。
closed：表示start和end这个区间端点是否包含在区间内，可以取值为以下：
（1）left：表示左闭右开区间。
（2）right：表示左开右闭区间。
（3）None：表示两边都是闭区间。
需要注意的是，start、end、periods、freq这四个参数至少要指定三个参数，否则会出现错误。当调用date_range()函数创建DatetimeIndex对象时，如果只是传入了开始日期(start参数)与结束日期(end参数)，则默认生成的时间点是按天计算，即freq参数为D，例子如下：

 

import pandas as pd # date_range()函数创建固定频率的时间序列,主要用于生成一个具有固定频率的 DatetimeIndex 对象
pd.date_range('2018/08/10','2018/08/20')
#只传入开始日期 start参数 和 结束日期 end参数, 则默认生成的时间点是按天计算的,即 freq 参数为D
1
2
3

如果只是传入了开始日期或结束日期，则还需要periods参数指定产生多少个时间戳，例子如下：

 

import pandas as pd #传入start和periods参数
pd.date_range(start='2020-12-04',periods=5)

import pandas as pd #传入end和periods参数
pd.date_range(end='2020-12-04',periods=5) #periods时间戳 5个,出现 5个日期
1
2
3
4
5
由此可见，起始日期与结束日期定义了时间序列索引的严格边界

freq参数的用法例子：

 

import pandas as pd # freq 表示以自然日为单位,这个参数用来指定计时单位
dates_index=pd.date_range('2020-12-02',periods=5,freq='W-SUN')
dates_index # freq 传入 W—SUN ,表示每周日计算一次
1
2
3

normalize参数和tz参数的用法例子：

 

import pandas as pd
pd.date_range(start='2018/8/1 12:13:30',periods=5,tz='Asia/Hong_Kong')

import pandas as pd #normalize=True,规范化时间戳,将时间索引重置为当日的午夜0点
pd.date_range(start='2018/8/1 12:13:30',periods=5,normalize=True,tz='Asia/Hong_Kong')

数据选取

1 引言

　　Pandas是作为Python数据分析著名的工具包，提供了多种数据选取的方法，方便实用。本文主要介绍Pandas的几种数据选取的方法。

　　Pandas中，数据主要保存为Dataframe和Series是数据结构，这两种数据结构数据选取的方式基本一致，本文主要以Dataframe为例进行介绍。

　　在Dataframe中选取数据大抵包括3中情况：

　　1）行（列）选取（单维度选取）：df[]。这种情况一次只能选取行或者列，即一次选取中，只能为行或者列设置筛选条件（只能为一个维度设置筛选条件）。

　　2）区域选取（多维选取）：df.loc[]，df.iloc[]，df.ix[]。这种方式可以同时为多个维度设置筛选条件。

　　3）单元格选取（点选取）：df.at[]，df.iat[]。准确定位一个单元格。

　　接下来，我们以下面的数据为例，分别通过实例介绍这三种情况。

 

>>> import pandas as pd

>>> import numpy as np

>>> data = {'name': ['Joe', 'Mike', 'Jack', 'Rose', 'David', 'Marry', 'Wansi', 'Sidy', 'Jason', 'Even'],

        'age': [25, 32, 18, np.nan, 15, 20, 41, np.nan, 37, 32],

        'gender': [1, 0, 1, 1, 0, 1, 0, 0, 1, 0],

        'isMarried': ['yes', 'yes', 'no', 'yes', 'no', 'no', 'no', 'yes', 'no', 'no']}

>>> labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

>>> df = pd.DataFrame(data, index=labels)

>>> df

    name   age  gender isMarried

a    Joe  25.0       1       yes

b   Mike  32.0       0       yes

c   Jack  18.0       1        no

d   Rose   NaN       1       yes

e  David  15.0       0        no

f  Marry  20.0       1        no

g  Wansi  41.0       0        no

h   Sidy   NaN       0       yes

i  Jason  37.0       1        no

j   Even  32.0       0        no

回到顶部

2 行（列）选取：df[]

　　行（列）选取是在单一维度上进行数据的选取，即以行为单位进行选取或者以列为单位进行选取。Dataframe对象的行有索引（index），默认情况下是[0,1,2，……]的整数序列，也可以自定义添加另外的索引，例如上面的labels，（为区分默认索引和自定义的索引，在本文中将默认索引称为整数索引，自定义索引称为标签索引）。Dataframe对象的每一列都有列名，可以通过列名实现对列的选取。

　　1）选取行

选取行的方式包括三种：整数索引切片、标签索引切片和布尔数组。

　　a）整数索引切片：前闭后开

注意注意注意整数索引切片：前闭后开

• 选取第一行：

>>> df[0:1]

  name   age  gender isMarried

a  Joe  25.0       1       yes

• 选取前两行：

>>> df[0:2]

   name   age  gender isMarried

a   Joe  25.0       1       yes

b  Mike  32.0       0       yes

　　b）标签索引切片：前闭后闭

注意注意注意标签索引切片：前闭后闭

• 选取第一行：

>>> df[:'a']

  name   age  gender isMarried

a  Joe  25.0       1       yes

• 选取前两行：

>>> df['a':'b']

   name   age  gender isMarried

a   Joe  25.0       1       yes

b  Mike  32.0       0       yes

　　注意：整数索引切片是前闭后开，标签索引切片是前闭后闭，这点尤其要注意。

　　c）布尔数组

• 选取前三行

>>> df[[True,True,True,False,False,False,False,False,False,False]]

   name   age  gender isMarried

a   Joe  25.0       1       yes

b  Mike  32.0       0       yes

c  Jack  18.0       1        no

• 选取所有age大于30的行

>>> df[[each>30 for each in df['age']]]

    name   age  gender isMarried

b   Mike  32.0       0       yes

g  Wansi  41.0       0        no

i  Jason  37.0       1        no

j   Even  32.0       0        no

　　通过布尔数组的方式，又可以衍生出下面的选取方式：

• 选取所有age大于30的行

>>> df[df['age']>30]

    name   age  gender isMarried

b   Mike  32.0       0       yes

g  Wansi  41.0       0        no

i  Jason  37.0       1        no

j   Even  32.0       0        no

• 选取出所有age大于30，且isMarried为no的行

>>> df[(df['age']>30) & (df['isMarried']=='no')]

    name   age  gender isMarried

g  Wansi  41.0       0        no

i  Jason  37.0       1        no

j   Even  32.0       0        no

• 选取出所有age为20或32的行

>>> df[(df['age']==20) | (df['age']==32)]

    name   age  gender isMarried

b   Mike  32.0       0       yes

f  Marry  20.0       1        no

j   Even  32.0       0        no

　　注意：像上面这种通过多个布尔条件判断的情况，多个条件最好（一定）用括号括起来，否则非常容易出错。

　　2）列选取

　　列选取方式也有三种：标签索引、标签列表、Callable对象

　　a）标签索引：选取单个列

• 选取name列所有数据

>>> df['name']

a      Joe

b     Mike

c     Jack

d     Rose

e    David

f    Marry

g    Wansi

h     Sidy

i    Jason

j     Even

Name: name, dtype: object

　　b）标签列表：选取多个列

• 选取name和age两列数据

>>> df[['name','age']]

    name   age

a    Joe  25.0

b   Mike  32.0

c   Jack  18.0

d   Rose   NaN

e  David  15.0

f  Marry  20.0

g  Wansi  41.0

h   Sidy   NaN

i  Jason  37.0

j   Even  32.0

　　c）callable对象

• 选取第一列

>>> df[lambda df: df.columns[0]]

a      Joe

b     Mike

c     Jack

d     Rose

e    David

f    Marry

g    Wansi

h     Sidy

i    Jason

j     Even

Name: name, dtype: object

回到顶部

3 区域选取

　　区域选取可以从多个维度（行和列）对数据进行筛选，可以通过df.loc[]，df.iloc[]，df.ix[]三种方法实现。采用df.loc[]，df.iloc[]，df.ix[]这三种方法进行数据选取时，方括号内必须有两个参数，第一个参数是对行的筛选条件，第二个参数是对列的筛选条件，两个参数用逗号隔开。df.loc[]，df.iloc[]，df.ix[]的区别如下：

　　df.loc[]只能使用标签索引，不能使用整数索引，通过便签索引切边进行筛选时，前闭后闭。

　　df.iloc[]只能使用整数索引，不能使用标签索引，通过整数索引切边进行筛选时，前闭后开。；

　　df.ix[]既可以使用标签索引，也可以使用整数索引。

　　下面分别通过实例演示这三种方法。

1.loc函数、iloc函数

loc函数：通过行索引 “Index” 中的具体值来取行数据（如取"Index"为"A"的行）

iloc函数：通过行号来取行数据（如取第二行的数据）

df = pd.DataFrame(np.arange(20).reshape(5,4),index=list('abcde'),columns=['A', 'B', 'C', 'D'])
######### 提取行数据############
#取索引为'a'的行
df.loc['a']
# 输出：
A 0
B 1
C 2
D 3

#取第二行数据，索引为'a'的行就是第一行，所以结果相同
df.iloc[1]
# 输出：
A 4
B 5
C 6
D 7
######### 提取列数据############
#取A、B列的数据
df.loc[:,['A','B']]

 

注意这里当不止选取一列的时候，需要在函数中把行和列的切片都列出来：例如[:,["A","B"]]就代表了所有行的切片中选取列名为A和B的切片，前面的 “ [:, ” 就代表了所有行的切片。

 

# 输出：

A B
a 0 1
b 4 5
c 8 9
d 12 13
e 16 17

#取第0列,第1列的数据
df.iloc[:,[0,1]]
# 输出：

A B
a 0 1
b 4 5
c 8 9
d 12 13
e 16 17

######### 提取指定行、指定列数据############
#提取index为'c','d',列名为'A','B'中的数据
df.loc[['c','d'],['A','B']]

# 输出：
A B
c 8 9
d 12 13

#提取第0、2行，第0、1列中的数据
df.iloc[[0,2],[0,1]]

# 输出：
A B
a 0 1
c 8 9

######### 提取所有数据############
#取所有列的数据
df.loc[:,:]

# 输出：
A B C D
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
e 16 17 18 19

#取所有行数据
df.iloc[:,:]
# 输出：
A B C D
a 0 1 2 3
b 4 5 6 7
c 8 9 10 11
d 12 13 14 15
e 16 17 18 19

2.drop()函数的用法

'''
drop()函数的用法：
DataFrame.drop(labels=None,axis=0, index=None, columns=None, inplace=False)

labels:就是要删除的行列的名字，用列表给定
axis:默认为 0，指删除行，因此删除 columns 时要指定 axis=1；
index:直接指定要删除的行
columns:直接指定要删除的列
inplace=False : 默认该删除操作不改变原数据，而是返回一个执行删除操作后的 新 dataframe；
inplace=True : 则会直接在原数据上进行删除操作，删除后无法返回。

'''df = pd.DataFrame(np.arange(20).reshape(5,4), columns=['A', 'B', 'C', 'D'])
# 删除B,C两列
# 方法一：
df.drop(['B', 'C'], axis=1) #一定要指定axis=1,否则会报错，因为drop默认是删除行数据的
# 方法二：
df.drop(columns=['B', 'C'])

# 删除B,C两列输出结果：
A D
0 0 3
1 4 7
2 8 11
3 12 15
4 16 19

# 删除索引值为1，3的行数据
df.drop(index=[1, 3])

# 输出结果：
A B C D
0 0 1 2 3
2 8 9 10 11
4 16 17 18 19

drop()函数删除指定的行，按照某列的值对df数据行的索引进行筛选并删除
例如：剔除3分的中性评论

// An highlighted block
df[df['score'] == 3] # 找到score这一列中值为3的所有行数据
写法1：
df = df.drop(df[df['Score']==3].index)
写法2：
df=df[df['Score']!=3]
1
2
3
4
5
6
一个表中含有很多的列，我想要删除其中指定的几列’Id’, ‘ProductId’, 'UserId’

df = df.drop(['Id', 'ProductId', 'UserId'],axis=1)

3.3 df.ix[]

　　df.ix[]既可以通过整数索引进行数据选取，也可以通过标签索引进行数据选取，换句话说，df.ix[]是df.loc[]和df.iloc[]的功能集合，且在同义词选取中，可以同时使用整数索引和标签索引。

• 选取第3行的name数据

>>> df.ix[2,'name']

'Jack'

• 选取a行、c行的第1列，第2列和第4列数据

>>> df.ix[['a','c'], [0,1,3]]

   name   age isMarried

a   Joe  25.0       yes

c  Jack  18.0        no

• 选取所有未婚者的姓名和年龄

>>> df.ix[df['isMarried']=='no',['name','age']]

    name   age

c   Jack  18.0

e  David  15.0

f  Marry  20.0

g  Wansi  41.0

i  Jason  37.0

j   Even  32.0

回到顶部

4 单元格选取

　　单元格选取包括df.at[]和df.iat[]两种方法。df.at[]和df.iat[]使用时必须输入两个参数，即行索引和列索引，其中df.at[]只能使用标签索引，df.iat[]只能使用整数索引。df.at[]和df.iat[]选取的都是单个单元格（单行单列），所以返回值都为基本数据类型。

4.1 df.at[]

• 选取b行的name列

>>> df.at['b','name']

'Mike'

4.2 df.iat[]

• 选取第2行第1列

>>> df.iat[1,0]

'Mike'