Pandas是python的一个数据分析包，主要用于数据挖掘和数据分析，通过Pandas我们可以高效地操作大型数据集。下面将给大家介绍一下Pandas中的两大主要结构：Series和DataFrame及其索引操作。

1. pandas主要结构

1.1 Series

系列(Series)是能够保存任何类型的数据(整数，字符串，浮点数，Python对象等)的一维标记数组。

1.1.1 创建Series

pandas.Series(data,index,dtype,copy)

• data：数据采取各种形式，如：ndarray,list

• index：索引值必须是唯一的和散列的，与数据的长度相同。

• dtype：指定数据类型。如果没有，将推断数据类型

• copy：复制数据，默认为false

可以通过输入数组、字典等方式来创建一个系列

import pandas as pd

import numpy as np

data1 = np.array(['a','b','c','d'])

data2 = {'a':0.,'b':1.,'c':2.}

s1 = pd.Series() # 创建一个空的Series

s2 = pd.Series(data1) # 从ndarray创建一个Series.这里没有传递任何索引

s3 = pd.Series(data1,index=[100,101,102,103]) #这里传递了索引值。

s4 = pd.Series(data2) # 从字典中创建一个Series.注意，字典键用于构建索引

s5 = pd.Series(data2,index=['b','c','d','a']) # 索引顺序保持不变，缺少的元素使用NaN填充

s6 = pd.Series(5,index=[0,1,2,3]) # 从标量创建一个Series

print(s1,s2,s3,s4,s5,s6)

输出结果

#s1

Series([], dtype: float64)

#s2 默认情况下，分配了从0到len(data)-1的索引

0 a

1 b

2 c

3 d

dtype: object

#s3 可以在输出中看到自定义的索引值

100 a

101 b

102 c

103 d

dtype: object

#s4

a 0.0

b 1.0

c 2.0

dtype: float64

#s5

b 1.0

c 2.0

d NaN

a 0.0

dtype: float64

#s6

0 5

1 5

2 5

3 5

dtype: int64

1.1.2 访问数据

系列(Series)中的数据可以使用类似于访问ndarray中的数据来访问。

1)从具有位置的Series中访问数据：

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

print(s[0]) # 检索第一个元素

print(s[:3]) # 检索Series中前三个元素

print(s[-3:]) # 检索最后三个元素

输出结果

#s[0]

1

#s[:3]

a 1

b 2

c 3

dtype: int64

#s[-3:]

c 3

d 4

e 5

dtype: int64

2)使用标签检索数据

# 一个Series就像一个固定大小的字典，可以通过索引标签获取和设置值

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

print(s['a']) # 使用索引标签值检索单个元素

print(s[['a','b','c']]) # 使用索引标签值检索多个元素。注意，如果索引不存在的标签，则会报错

输出结果：

#s['a']

1

#s[['a','b','c']]

a 1

b 2

c 3

dtype: int64

1.1.3 Series 基本功能

基本功能如下所示：

下面我们通过举例来加深印象~

s = pd.Series(np.random.randn(4))

print(s.axes) # 返回Series的标签列表

print(s.empty) # 返回布尔值，表示对象是否为空

print(s.ndim) # 返回对象的维数

print(s.size) # 返回Series的大小

print(s.values) # 以数组形式返回Series中的实际数据值

print(s.head(2)) # 显示前2行

print(s.tail(2)) # 返回最后2行

输出结果：

#s.axes

[RangeIndex(start=0, stop=4, step=1)]

#s.empty

False

#s.ndim

1

#s.size

4

#s.values

[ 0.9376181 -0.15342991 -1.85860809 -0.9484854 ]

#s.head(2)

0 0.937618

1 -0.153430

dtype: float64

#s.tail(2)

2 -1.858608

3 -0.948485

dtype: float64

1.2 DataFrame

数据帧(DataFrame)是二维数据结构，即数据以行和列的表格方式排列。

1.2.1 DataFrame创建

pandas.DataFrame(data,index,columns,dtype,copy)

• data: 数据采用各种形式，如:ndarray,series,lists,dict或另一个DataFrame

• index: 行标签,如果没有传入，默认为np.arange(n)

• columns: 列标签，如果没有传入索引，则默认np.arange(n)

• dtype: 每列的数据类型

• copy: 默认值为False，则此命令用于复制数据

DataFrame可以通过以下方法进行创建

data1 = [1,2,3,4,5]

data2 = [['A',10],['B',12],['C',13]]

df1 = pd.DataFrame() # 创建一个空的DataFrame

df2 = pd.DataFrame(data1) # 从列表创建DataFrame

df3 = pd.DataFrame(data2,columns=['Name','Age']) # 传入多个列表来创建DataFrame

df4 = pd.DataFrame(data2,columns=['Name','Age'],dtype = float) #dtype将Age列的类型更改为浮点

print(df1,df2,df3,df4)

输出结果：

#df1

Empty DataFrame

Columns: []

Index: []

#df2

0

0 1

1 2

2 3

3 4

4 5

#df3

Name Age

0 A 10

1 B 12

2 C 13

#df4

Name Age

0 A 10.0

1 B 12.0

2 C 13.0

除此之外，还可以使用字典来创建dataframe：

data3 = {'Name':['T','J','S','R'],'Age':[28,34,29,42]}

data4 = [{'a':1,'b':2},{'a':5,'b':10,'c':20}]

data5 = {'one':pd.Series([1,2,3],index=['a','b','c']),

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

# 从ndarrays/Lists的字典来创建DataFrame。

# 所有的ndarrays必须具有相同的长度。如果传递了索引(index)，则索引的长度应等于数组的长度。

df5 = pd.DataFrame(data3)

df6 = pd.DataFrame(data3,index=['rank1','rank2','rank3','rank4']) # 通过index参数，设置index的名字

df7 = pd.DataFrame(data4) # 从列表创建DataFrame，NaN附加在缺失的区域

df8 = pd.DataFrame(data5) # 从Series的字典来创建DataFrame

输出结果：

#df5

Age Name

0 28 T

1 34 J

2 29 S

3 42 R

#df6

Age Name

rank1 28 T

rank2 34 J

rank3 29 S

rank4 42 R

#df7

a b c

0 1 2 NaN

1 5 10 20.0

#df8

one two

a 1.0 1

b 2.0 2

c 3.0 3

d NaN 4

1.2.2 列、行相关操作

(1)列选择

从数据帧(DataFrame)中选择一列。

data = {'one':pd.Series([1,2,3],index=['a','b','c']),

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

df = pd.DataFrame(data)

print(df['one']) # 查询某一列

print(df[['one','two']]) # 查询多列

输出结果：

#df['one']

a 1.0

b 2.0

c 3.0

d NaN

Name: one, dtype: float64

#df[['one','two']]

one two

a 1.0 1

b 2.0 2

c 3.0 3

d NaN 4

(2)列添加

向现有数据框添加一个新列

# 向现有数据框添加一个新列

df['three'] = pd.Series([10,20,30],index=['a','b','c'])

df['four'] = df['one'] + df['two'] # 观测结果发现，NAN与其他常数相加的结果还是为NaN

print(df)

输出结果：

one two three four

a 1.0 1 10.0 2.0

b 2.0 2 20.0 4.0

c 3.0 3 30.0 6.0

d NaN 4 NaN NaN

(3)列删除

列可以删除或弹出。使用del函数进行删除：

# 删除one列

del df['one']

df

输出结果

two three four

a 1 10.0 2.0

b 2 20.0 4.0

c 3 30.0 6.0

d 4 NaN NaN

使用pop函数进行弹出：

# 弹出two列

df.pop('two')

df

输出结果

three four

a 10.0 2.0

b 20.0 4.0

c 30.0 6.0

d NaN NaN

(4)行选择，添加和删除

可以通过将行标签传递给loc()函数来选择行,也可以使用 : 运算符选择多行进行切片：

d = {'one' : pd.Series([1, 2, 3], index=['a', 'b', 'c']),

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

df = pd.DataFrame(d)

print(df.loc['b']) # 查询index为b的行

print(df[2:4]) #选择第3-4行

输出结果：

#df.loc['b']

one 2.0

two 2.0

Name: b, dtype: float64

#df[2:4]

one two

c 3.0 3

d NaN 4

还可以使用append()函数将新行添加到DataFrame，使用drop()函数从DataFrame中删除行。

df = pd.DataFrame([[1, 2], [3, 4]], columns = ['a','b'])

df2 = pd.DataFrame([[5, 6],[7, 8]],columns=['a','b'])

print(df)

df = df.append(df2)

print(df)

df = df.drop(0) # 根据index来删除

print(df)

输出结果：

a b

0 1 2

1 3 4

#增加行

a b

0 1 2

1 3 4

0 5 6

1 7 8

#删除行

a b

1 3 4

1 7 8

1.2.3 DataFrame基本功能

基本功能如下所示：

具体使用案例如下：

# 生成样例数据

d = {'Name':pd.Series(['T','J','R','V','S','M','Ja']),

'Age':pd.Series([25,26,25,23,30,29,23]),

'Rating':pd.Series([4.23,3.24,3.98,2.56,3.20,4.6,3.8])}

df = pd.DataFrame(d)

print(df.T) #T 转置

print(df.axes) # 返回行轴标签和列轴标签列表

print(df.dtypes) # 返回每列的数据类型

print(df.empty) # 表示对象是否为空

print(df.ndim) # 返回对象的维度

print(df.shape) # 返回DataFrame的维度元组

print(df.size) # 返回DataFrame中的元素数

print(df.values) # 将DataFrame中的实际数据作为NDarray返回

print(df.head()) # 显示前5行

print(df.tail()) # 显示最后5行

输出结果：

#df.T

0 1 2 3 4 5 6

Name T J R V S M Ja

Age 25 26 25 23 30 29 23

Rating 4.23 3.24 3.98 2.56 3.2 4.6 3.8

#df.axes

[RangeIndex(start=0, stop=7, step=1), Index(['Name', 'Age', 'Rating'], dtype='object')]

#df.dtypes

Name object

Age int64

Rating float64

dtype: object

#df.empty

False

#df.ndim

2

#df.shape

(7, 3)

#df.size

21

#df.values

[['T' 25 4.23]

['J' 26 3.24]

['R' 25 3.98]

['V' 23 2.56]

['S' 30 3.2]

['M' 29 4.6]

['Ja' 23 3.8]]

#df.head()

Name Age Rating

0 T 25 4.23

1 J 26 3.24

2 R 25 3.98

3 V 23 2.56

4 S 30 3.20

#df.tail())

Name Age Rating

2 R 25 3.98

3 V 23 2.56

4 S 30 3.20

5 M 29 4.60

6 Ja 23 3.80

2. pandas索引使用

2.1 Pandas索引和选择数据

Pandas支持三种类型的多轴索引，描述如下：

2.1.1 .loc()

loc 具有多种访问方式，具体可以查看以下例子：

df = pd.DataFrame(np.random.randn(4,2),index = ['a','b','c','d'],columns=['A','B'])

print(df.loc[:,'A']) # 查询所有行的'A'列

print(df.loc[:,['A','B']]) # 查询多列

print(df.loc[['a','b'],['A','B']]) # 根据标签查询对应的行和列

print(df.loc['a':'d']) # 查询a行到h列

print(df.loc['a']>0)

输出结果：

#df.loc[:,'A']

a 2.377338

b 1.042437

c 0.708036

d -1.308075

Name: A, dtype: float64

#df.loc[:,['A','B']]

A B

a 2.377338 -0.330571

b 1.042437 -0.058175

c 0.708036 1.611788

d -1.308075 0.947314

#df.loc[['a','b'],['A','B']]

A B

a 2.377338 -0.330571

b 1.042437 -0.058175

#df.loc['a':'d']

A B

a 2.377338 -0.330571

b 1.042437 -0.058175

c 0.708036 1.611788

d -1.308075 0.947314

#df.loc['a']>0

A True

B False

Name: a, dtype: bool

2.1.2 纯整数索引

.iloc()的索引方法与loc类似

print(df.iloc[:4]) # 查询前4行

print(df.iloc[1:3,1:]) # 查询第2-3行和第一列之外的列

输出结果：

#df.iloc[:4]

A B

a 2.377338 -0.330571

b 1.042437 -0.058175

c 0.708036 1.611788

d -1.308075 0.947314

#df.iloc[1:3,1:]

B

b -0.058175

c 1.611788

2.1.3 ix索引

Pandas还提供了一种使用.ix()运算符进行选择和子集化对象的混合方法。

df = pd.DataFrame(np.random.randn(4, 2), columns = ['A', 'B', 'C', 'D'])

print(df.ix[:4]) # 查询标签为0到4的行

print(df.ix[:,'A']) # 查找A列

输出结果：

#df.ix[:4]

A B C

0 -0.413357 -0.167940 0.542721

1 1.695521 -0.447831 -0.433989

2 1.040637 -0.429264 0.945254

#df.iloc[df.ix[:,'A']]

0 -0.413357

1 1.695521

2 1.040637

Name: A, dtype: float64

2.2 Pandas重建索引

重新索引会更改DataFrame的行标签和列标签。

可以通过索引来实现多个操作:

• 重新排序现有数据以匹配一组新的标签

• 在没有标签数据的标签位置插入缺失值(NA)标记

df = pd.DataFrame({

'A': pd.date_range(start='2019-01-01',periods=20,freq='D'),

'x': np.linspace(0,stop=20-1,num=20),

'y': np.random.rand(20),

'C': np.random.choice(['Low','Medium','High'],20).tolist(),

'D': np.random.normal(100, 10, size=(20)).tolist()

})

# 重建索引

df_reindexed = df.reindex(index=[0,2,5],columns=['A','C','B']) # 原本没有B列，所以B列的值都为NaN

print(df_reindexed)

输出结果：

A C B

0 2019-01-01 High NaN

2 2019-01-03 Medium NaN

5 2019-01-06 High NaN

2.2.1 重建索引与其他对象对齐

如果想让一个对象和另一个对象的轴标记相同。那么我们可以通过如下方法来实现

# 构建样例数据

df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])

df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])

print(df1,df2)

样例数据为：

#df1

col1 col2 col3

0 0.116654 -0.920242 -0.094980

1 0.997855 0.085608 -1.738815

2 1.443946 0.019549 0.251528

3 -1.212119 -1.210960 0.147220

4 0.788829 2.812478 -0.393173

5 1.139606 1.718862 -0.949964

6 1.123598 -1.121778 0.035585

7 -0.200309 0.043714 0.287871

8 -0.553097 -0.334700 -0.648229

9 -1.081606 -0.174223 0.057483

#df2

col1 col2 col3

0 1.362711 2.126439 -0.294538

1 1.062274 1.118789 -0.180609

2 -0.446018 -0.036722 -1.754342

3 0.496308 0.287495 -0.544084

4 0.394956 2.235108 -0.087951

5 1.242660 0.346076 0.685478

6 0.094422 0.742144 0.743658

reindex_like()让一个对象和另一个对象有相同的index 和 colums:

df1 = df1.reindex_like(df2) # 将df1的index和columns都转换成跟df2的index、columns一样

print(df1)

结果为：

col1 col2 col3

0 0.116654 -0.920242 -0.094980

1 0.997855 0.085608 -1.738815

2 1.443946 0.019549 0.251528

3 -1.212119 -1.210960 0.147220

4 0.788829 2.812478 -0.393173

5 1.139606 1.718862 -0.949964

6 1.123598 -1.121778 0.035585

2.2.2 填充时重新加注

reindex_like()采用可选参数方法，它是一个填充方法，其值如下:

• pad/ffill: 向前填充值

• bfill/backfill: 向后填充值

• nearest: 从最近的索引值填充

# 构建样例数据

df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])

df2 = pd.DataFrame(np.random.randn(2,3),columns=['col1','col2','col3'])

print(df2.reindex_like(df1))

print(df2.reindex_like(df1,method='ffill')) # 向前填充，用前面的值来填充NaN

结果为：

#df2.reindex_like(df1)

col1 col2 col3

0 0.176328 0.841434 -0.714321

1 -0.779040 2.391771 -1.126933

2 NaN NaN NaN

3 NaN NaN NaN

4 NaN NaN NaN

5 NaN NaN NaN

#df2.reindex_like(df1,method='ffill')

col1 col2 col3

0 0.176328 0.841434 -0.714321

1 -0.779040 2.391771 -1.126933

2 -0.779040 2.391771 -1.126933

3 -0.779040 2.391771 -1.126933

4 -0.779040 2.391771 -1.126933

5 -0.779040 2.391771 -1.126933

使用limit参数进行填充限制:

df2.reindex_like(df1,method='ffill',limit=1)

结果为：

col1 col2 col3

0 0.176328 0.841434 -0.714321

1 -0.779040 2.391771 -1.126933

2 -0.779040 2.391771 -1.126933

3 NaN NaN NaN

4 NaN NaN NaN

5 NaN NaN NaN

2.2.3 重命名

使用rename()来更改行名和列名

# 使用rename修改列名

df1.rename(columns={'col1':'c1','col2':'c2'}, # 将col1更改为c1,col2更改为c2

index = {0:'a',1:'b',2:'c'},

inplace=True) # inplace默认为False

print(df1)

结果为：

c1 c2 col3

a 1.393154 0.510697 -1.160332

b -0.952572 -0.257124 2.261260

c -0.196542 -0.817034 1.297915

3 -0.110799 2.349779 -0.869405

4 -0.632141 -1.251734 1.320231

5 -0.576398 -1.051619 -0.053604

---

至此，本次分享已结束如果你喜欢的话，可以转发或者点个“在看”支持一下~点击原文链接，可以下载《Python工具代码速查手册》，可以点个star支持一下哦~简介：浩彬老撕好玩的数据炼丹师，曾经的IBM数据挖掘攻城狮，还没开始就过气数据科学界的段子手，致力于数据科学知识分享，不定期送书活动