提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、数据结构介绍

两个常用的工具数据结构：Series、DataFrame

1. Series

Series是一种一维的数组型对象，它包含了一个只序列，并包含了数据标签，称为索引（index）。

In [1]: import pandas as pd

# 最简单的序列
In [2]: obj = pd.Series([4,7,-5,3])
In [3]: obj
Out[3]:
0    4
1    7
2   -5
3    3
dtype: int64
# Series对象值（numpy.ndarray对象）
In [5]: obj.values
Out[5]: array([ 4,  7, -5,  3], dtype=int64)
# Series对象索引
In [7]: obj.index
Out[7]: RangeIndex(start=0, stop=4, step=1)

# 创建索引序列，用标签标识每个数据点
In [10]: obj2 = pd.Series([4,7,-5,3], index=['d','b','a','c'])
In [11]: obj2
Out[11]:
d    4
b    7
a   -5
c    3
dtype: int64

# 从数据中选择数据的时候使用标签来进行索引
In [12]: obj2['a']
Out[12]: -5
# 对obj2['a']此元素进行修改，原数组改变
In [13]: obj2['a'] = 5
# 按照索引进行取值，['a','b','c']作为索引列表
In [20]: obj2[['a','b','c']]
Out[20]:
a    5
b    7
c    3
dtype: int64
# 使用布尔值数组进行过滤
In [21]: obj2[obj2>3]
Out[21]:
d    4
b    7
a    5
dtype: int64
# 与标量相乘
In [22]: obj2[obj2>3] * 2
Out[22]:
d     8
b    14
a    10
dtype: int64
# 应用数学函数
In [28]: np.exp(obj2) # 计算每个元素的自然指数值e^x
Out[28]:
d      54.598150
b    1096.633158
a     148.413159
c      20.085537
dtype: float64

# 另一个角度考虑Series,他是一个长度固定且有序的字典（字典本身无序）
In [30]: 'b' in obj2
Out[30]: True
In [31]: 'e' in obj2
Out[31]: False

# 使用字典生成Series
In [33]: sdata
Out[33]: {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 当把字典传给Series构造函数时，产生的Series的索引将是排序好的字典键
In [34]: pd.Series(sdata)
Out[34]:
a    1
b    2
c    3
d    4
dtype: int64
# 也可以将字典按照所想要的顺序传递给构造函数
In [40]: pd.Series(sdata, index=['d','b','c','a','e'])
Out[40]:
d    4.0
b    2.0
c    3.0
a    1.0
e    NaN	# 由于e没有出现在sdata的键中，所以值为空
dtype: float64
# pandas中使用isnull和notnull函数检查缺失数据（也是Series的实例方法），返回Series布尔数组

# 数学操作中自动对齐索引（重点）
In [49]: obj2
Out[49]:
d    4
b    7
a    5
c    3
dtype: int64
In [50]: obj3
Out[50]:
e    NaN
b    2.0
c    3.0
a    1.0
dtype: float64
In [51]: obj2+obj3
Out[51]:
a    6.0
b    9.0
c    6.0
d    NaN
e    NaN
dtype: float64

# Series对象自身和索引都有name属性
In [53]: obj2.name = 'name_obj2'
In [54]: obj2.index.name = 'obj2_index_name'
In [55]: obj2
Out[55]:
obj2_index_name
d    4
b    7
a    5
c    3
Name: name_obj2, dtype: int64

# Series索引可以通过按位置赋值方式进行改变
In [56]: obj
Out[56]:
0    4
1    7
2   -5
3    3
dtype: int64
In [57]: obj.index = ['aa','bb','cc','dd']
In [58]: obj
Out[58]:
aa    4
bb    7
cc   -5
dd    3
dtype: int64

2. DataFrame

DataFrame表示的是矩阵的数据表，包含已排序的列集合，每一列可以是不同值类型。
DataFrame既有行索引也有列索引，它可以被视为一个共享相同索引的Series的字典。
DataFrame中，数据被存储为一个以上的二维块，而不是列表、字典或者其他一维数组的集合。
DataFrame是二维的，但可以利用分层索引在DataFrame中展现更高维度的数据。

构建DataFrame

# 利用包含等长度列表或来形成DataFrame
In [14]: data
Out[14]:
{'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'],
 'year': [2000, 2001, 2002, 2000, 2001, 2002],
 'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}
In [15]: frame = pd.DataFrame(data)
# 产生的DataFrame会自动为Sereies分配索引，并且列会按排序的顺序排列
In [16]: frame
Out[16]:
    state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2000  2.4
4  Nevada  2001  2.9
5  Nevada  2002  3.2
# 对于大型DataFrame，head方法将会只选出头部的5行：
In [17]: frame.head()
Out[17]:
    state  year  pop
0    Ohio  2000  1.5
1    Ohio  2001  1.7
2    Ohio  2002  3.6
3  Nevada  2000  2.4
4  Nevada  2001  2.9
# 列按指定columns列表的顺序排列筛选，不论data中有几列，只选columns中的列（如果传的列不包含在字典，将会出现缺失值NaN），index指定行索引
In [22]: pd.DataFrame(data,columns=['year','state','age'],index=['one','two','three','four','five','six'])
Out[22]:
       year   state  age
one    2000    Ohio  NaN
two    2001    Ohio  NaN
three  2002    Ohio  NaN
four   2000  Nevada  NaN
five   2001  Nevada  NaN
six    2002  Nevada  NaN
# DataFrame中的一列，可以按字典型标记或属性那样检索为Series
# 返回的Series于原DataFrame有相同的索引，且Serise的name属性也会被合理地设置
In [8]: frame2['state']
Out[8]:
one        Ohio
two        Ohio
three      Ohio
four     Nevada
five     Nevada
six      Nevada
Name: state, dtype: object
# 通过loc选取行
In [15]: frame2.loc['three']
Out[15]:
year     2002
state    Ohio
age       NaN
Name: three, dtype: object
# 修改列的引用，如age列可以赋值为标量值或值数组
# age列赋值为标量值
In [17]: frame2['age'] = 18 
In [19]: frame2
Out[19]:
       year   state  age
one    2000    Ohio   18
two    2001    Ohio   18
three  2002    Ohio   18
four   2000  Nevada   18
five   2001  Nevada   18
six    2002  Nevada   18
# age列赋值为值数组，值数组长度必须和DataFrame长度相匹配
In [20]: frame2['age'] = np.arange(6.)
In [21]: frame2
Out[21]:
       year   state  age
one    2000    Ohio  0.0
two    2001    Ohio  1.0
three  2002    Ohio  2.0
four   2000  Nevada  3.0
five   2001  Nevada  4.0
six    2002  Nevada  5.0
# 如果将Series赋值给一列时，Series的索引将会按照DaraFrame的索引重新排列，并在空缺的地方填充缺失值
In [24]: val = pd.Series([2,4,6],index=['two','four','six'])
In [26]: frame2['age']=val 
In [27]: frame2
Out[27]:
       year   state  age
one    2000    Ohio  NaN
two    2001    Ohio  2.0
three  2002    Ohio  NaN
four   2000  Nevada  4.0
five   2001  Nevada  NaN
six    2002  Nevada  6.0
# 如果被只被赋值的列age不存在，则会生成一个新的列
In [28]: frame2['ag']=val # frame2.ag是无法创建新的列
In [29]: frame2
Out[29]:
       year   state  age   ag
one    2000    Ohio  NaN  NaN
two    2001    Ohio  2.0  2.0
three  2002    Ohio  NaN  NaN
four   2000  Nevada  4.0  4.0
five   2001  Nevada  NaN  NaN
six    2002  Nevada  6.0  6.0
# del语法用于移除列
In [30]: del frame2['age']
In [31]: frame2
Out[31]:
       year   state   ag
one    2000    Ohio  NaN
two    2001    Ohio  2.0
three  2002    Ohio  NaN
four   2000  Nevada  4.0
five   2001  Nevada  NaN
six    2002  Nevada  6.0
# 从DataFrame中选取的列是数据的视图，而不是拷贝。因此，对Series的修改会映射到DataFrame中。如果需要复制，则应显示地使用Series的copy方法。

# 利用Numpy数组的字典生成DataFrame
In [39]: pop = {'Nevada':{2001:2.4,2002:2.9},'Ohio':{2000:1.5,2001:1.7,2002:3.6}}
# 如果将嵌套字典赋值给DataFrame，pandas会将字典的键作为列，将内部字典的键作为行索引
In [41]: frame3 = pd.DataFrame(pop)
In [42]: frame3
Out[42]:
      Nevada  Ohio
2001     2.4   1.7
2002     2.9   3.6
2000     NaN   1.5

# 使用Numpy语法对DataFrame进行转置操作
In [43]: frame3.T
Out[43]:
        2001  2002  2000
Nevada   2.4   2.9   NaN
Ohio     1.7   3.6   1.5

# 如果已经显示指明行列索引的话，内部字典的键将会按指定行列索引显示
In [46]: pd.DataFrame(pop,columns=['Ohio','Nevada'],index=[2000,2001,2002])
Out[46]:
      Ohio  Nevada
2000   1.5     NaN
2001   1.7     2.4
2002   3.6     2.9

# 包含Series的字典也可以用于构造DataFrame
pdata = {'Ohio':frame3['Ohio'][:-1],'Nevada':frame3['Nevada'][:2]}
In [49]: pd.DataFrame(pdata)
Out[49]:
      Ohio  Nevada
2001   1.7     2.4
2002   3.6     2.9

# 如果DataFrame索引和列用于name属性，则这些name属性也会被显示
In [53]: frame3.index.name = 'year'
In [54]: frame3.columns.name = 'state'
In [55]: frame3
Out[55]:
state  Nevada  Ohio
year
2001      2.4   1.7
2002      2.9   3.6
2000      NaN   1.5

# DataFrame的value属性会将包含在DataFrame中的数据以二维ndarray的形式返回：
In [56]: frame3.values
Out[56]:
array([[2.4, 1.7],
       [2.9, 3.6],
       [nan, 1.5]])
# 如果DataFrame的列是不同的dtypes，则values的dtype会自动选择适合所以列的类型
In [59]: frame2.values
Out[59]:
array([[2000, 'Ohio', nan],
       [2001, 'Ohio', 2.0],
       [2002, 'Ohio', nan],
       [2000, 'Nevada', 4.0],
       [2001, 'Nevada', nan],
       [2002, 'Nevada', 6.0]], dtype=object)

DataFrame构造函数的有效输入

3. 索引对象

pandas中的索引对象是用于存储轴标签和其它元数据的（例如轴名称或标签）
在构造Series或DataFrame时，你所使用的任意数组或标签序列都可以在内部转换为索引对象。

In [60]: obj = pd.Series(range(3),index=['a','b','c'])
In [61]: obj
Out[61]:
a    0
b    1
c    2
dtype: int64
In [62]: obj.index
Out[62]: Index(['a', 'b', 'c'], dtype='object')
In [63]: obj.index[1:]
Out[63]: Index(['b', 'c'], dtype='object')

# 索引对象是不可变的，因此用户是无法修改索引对象的（不变性使得在多种数据结构中分享索引对象更为安全）
In [64]: obj.index[1:] = ['B','C']
---------------------------------------------------------------------------
TypeError: Index does not support mutable operations

#  索引对象也像一个固定大小的集合
In [65]: frame3
Out[65]:
state  Nevada  Ohio
year
2001      2.4   1.7
2002      2.9   3.6
2000      NaN   1.5
In [66]: frame3.columns
Out[66]: Index(['Nevada', 'Ohio'], dtype='object', name='state')
In [68]: 'Ohio' in frame3.columns
Out[68]: True

# 与python集合不同，pandas索引对象可以包含重复标签（根据重复标签进行筛选，会选取所有重复标签对应的数据）
In [70]: dup_lables = pd.Index(['foo','foo','bar','bar'])
In [71]: dup_lables
Out[71]: Index(['foo', 'foo', 'bar', 'bar'], dtype='object')

索引对象常用的方法和属性，如下：

二、基本功能

了解Series或DataFrame中数据交互的基础机制

1.重建索引

reindex 是pandas对象重要方法，该方法用于创建一个符合新索引的新对象。如下：

In [72]: obj = pd.Series([4.5,7.2,-5.3,3.6], index=['d','b','a','c'])
In [73]: obj
Out[73]:
d    4.5
b    7.2
a   -5.3
c    3.6
dtype: float64

# Series调用reindex方法时，会将数据按照新的索引进行排列，如果某个索引值之前并不存在，将引入缺失值：
In [74]: obj2 = obj.reindex(['a','b','c','d','e'])
In [75]: obj2
Out[75]:
a   -5.3
b    7.2
c    3.6
d    4.5
e    NaN
dtype: float64
# method可选参数允许我们使用ffill等方法在重建索引时插值，ffill方法会将值前向填充
In [76]: obj3 = pd.Series(['blue','purple','yellow'], index=[0,2,4])
In [77]: obj3
Out[77]:
0      blue
2    purple
4    yellow
dtype: object
In [78]: obj3.reindex(range(6),method='ffill')
Out[78]:
0      blue
1      blue
2    purple
3    purple
4    yellow
5    yellow
dtype: object

# 在DataFrame中，reindex可以改变行索引、列索引，也可以同时改变二者。当仅传入一个序列时，结果中的行会重建索引
In [81]: frame = pd.DataFrame(np.arange(9).reshape((3,3)), index=['a','c','d'], columns=['Ohio','Texas','California'])
In [82]: frame
Out[82]:
   Ohio  Texas  California
a     0      1           2
c     3      4           5
d     6      7           8
In [83]: frame2 = frame.reindex(['a','b','c','d'])
In [84]: frame2
Out[84]:
   Ohio  Texas  California
a   0.0    1.0         2.0
b   NaN    NaN         NaN
c   3.0    4.0         5.0
d   6.0    7.0         8.0
# 列可以使用colunms关键字重建索引（并不会改变原数组）
In [86]: frame.reindex(columns=['Texas','Utah','California'])
Out[86]:
   Texas  Utah  California
a      1   NaN           2
c      4   NaN           5
d      7   NaN           8

reindex方法的参数，如下：

2.轴向上删除条目

drop方法会返回一个含有指示值或轴向上删除值的新对象：

# Series
In [110]: obj = pd.Series(np.arange(5.),index=['a','b','c','d','e'])
In [111]: obj
Out[111]:
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
dtype: float64
In [112]: new_obj = obj.drop('c')
In [113]: new_obj
Out[113]:
a    0.0
b    1.0
d    3.0
e    4.0
dtype: float64
In [117]: obj.drop(['d','c'])
Out[117]:
a    0.0
b    1.0
e    4.0
dtype: float64

# DataFrame 索引值可以轴向上删除
In [118]: data = pd.DataFrame(np.arange(16).reshape((4,4)), index=['zhao','qian','sun','li'], columns=['one','two','thr
     ...: ee','four'])
In [119]: data
Out[119]:
      one  two  three  four
zhao    0    1      2     3
qian    4    5      6     7
sun     8    9     10    11
li     12   13     14    15
# 在调用drop时，使用标签序列会根据行标签删除值（轴0），删除行zhao，li
In [120]: data.drop(['zhao','li'])
Out[120]:
      one  two  three  four
qian    4    5      6     7
sun     8    9     10    11
# 通过传递axis=1或axis='columns'删除列
In [122]: data.drop('two',axis=1)
Out[122]:
      one  three  four
zhao    0      2     3
qian    4      6     7
sun     8     10    11
li     12     14    15
In [123]: data.drop(['two','four'],axis='columns')
Out[123]:
      one  three
zhao    0      2
qian    4      6
sun     8     10
li     12     14

# 很多函数（参数inplace=True），如drop，会修改Series或DataFrame的尺寸和形状，这些方法直接操作原对象而不返回新对象：
In [127]: obj
Out[127]:
a    0.0
b    1.0
c    2.0
d    3.0
e    4.0
dtype: float64
In [128]: obj.drop('c',inplace=True)
In [129]: obj
Out[129]:
a    0.0
b    1.0
d    3.0
e    4.0
dtype: float64

3.索引、选择与过滤

Series的索引（obj[…]）与Numpy数组索引的功能类似，只不过Series的索引值可以不仅仅是整数。如下：

# series
In [130]: obj = pd.Series(np.arange(4.),index=['a','b','c','d'])
In [131]: obj
Out[131]:
a    0.0
b    1.0
c    2.0
d    3.0
dtype: float64
# obj['b']等于obj[1]
In [132]: obj['b']
Out[132]: 1.0
In [133]: obj[1]
Out[133]: 1.0
# obj[2:4] 与Numpy类似，取2，3
In [137]: obj[2:4]
Out[137]:
c    2.0
d    3.0
dtype: float64
# obj[['b','a','d']] 取['b','a','d']里索引的值
In [139]: obj[['b','a','d']]
Out[139]:
b    1.0
a    0.0
d    3.0
dtype: float64
# obj[[1,3]] 取[1,3]里的值
In [140]: obj[[1,3]]
Out[140]:
b    1.0
d    3.0
dtype: float64
# 取obj中小于2的值
In [142]: obj[obj<2]
Out[142]:
a    0.0
b    1.0
dtype: float64
# Series切片不同的地方
# 标签索引取 b,c,d(包含d)
In [144]: obj['b':'d']
Out[144]:
b    1.0
c    2.0
d    3.0
dtype: float64
# 使用上述方法设值时会修改Sreies相应的部分
In [145]: obj['b':'d']=666
In [146]: obj
Out[146]:
a      0.0
b    666.0
c    666.0
d    666.0
dtype: float64

使用单个值或序列，可以从DataFrame中索引出一个或多个列

In [148]: data['two']
Out[148]:
zhao     1
qian     5
sun      9
li      13
Name: two, dtype: int32
In [149]: data[['two','four']]
Out[149]:
      two  four
zhao    1     3
qian    5     7
sun     9    11
li     13    15
# 行选择语法data[1:]
In [155]: data[1:]
Out[155]:
      one  two  three  four
qian    4    5      6     7
sun     8    9     10    11
li     12   13     14    15
# 这种索引方式也有特殊案例——根据布尔值数组切片选择数据
In [153]: data[data['three']>5]
Out[153]:
      one  two  three  four
qian    4    5      6     7
sun     8    9     10    11
li     12   13     14    15
# 使用布尔值DataFrame进行索引，布尔值DataFrame可以是对标量值进行比较产生的
In [157]: data<5
Out[157]:
        one    two  three   four
zhao   True   True   True   True
qian   True  False  False  False
sun   False  False  False  False
li    False  False  False  False
In [158]: data[data<5] = 0
In [159]: data
Out[159]:
      one  two  three  four
zhao    0    0      0     0
qian    0    5      6     7
sun     8    9     10    11
li     12   13     14    15

DataFrame使用loc和iloc选择数据（ix已弃用）

# 使用轴标签loc或整数标签iloc以Numpy风格语法从DataFrame中选出数组的行和列的子集
In [37]: data = pd.DataFrame(np.arange(16).reshape((4,4)),index=['zhao','qian','sun','li'],columns=['one','two','three'
    ...: ,'four'])
In [38]: data
Out[38]:
      one  two  three  four
zhao    0    1      2     3
qian    4    5      6     7
sun     8    9     10    11
li     12   13     14    15

# 通过标签索引loc选出单行多列的数据
In [160]: data.loc['qian',['two','three']]	# 选出标签为'qian'行，'two','three'列的数据
Out[160]:
two      5
three    6
Name: qian, dtype: int32
# 通过整数标签iloc选出单行多列的数据
In [40]: data.iloc[2,[3,0,1]]
Out[40]:
four    11
one      8
two      9
Name: sun, dtype: int32
# 整数标签索引多行多列（标签索引类似）
In [41]: data.iloc[[0,3],[3,0,1]]
Out[41]:
      four  one  two
zhao     3    0    1
li      15   12   13

# 索引功能进行切片
In [44]: data.loc[:'sun','two']	# 取行[:'sun']包含sun，列为two的数据
Out[44]:
zhao    1
qian    5
sun     9
Name: two, dtype: int32

# 取行0，1，2，列0，1，2中，列three大于大于5的行数据
In [45]: data.iloc[:3,:3][data.three>5]
D:pyScriptsipython:1: UserWarning: Boolean Series key will be reindexed to match DataFrame index.
Out[45]:
      one  two  three
qian    4    5      6
sun     8    9     10

DataFrame索引选项

4.整数索引

pandas对象使用整数索引，使用索引方式（标签索引或位置索引）容易混乱，若非整数索引则不会有潜在的歧义。

为保持一致性，如果有一个包含整数的轴索引，数据选择时请始终使用标签索引。
为了能更精确处理，可以使用loc（用于标签），iloc用于整数。

In [20]: ser = pd.Series(np.arange(3.))
In [21]: ser
Out[21]:
0    0.0
1    1.0
2    2.0
dtype: float64

In [22]: ser[:1]	# 默认是整数索引
Out[22]:
0    0.0
dtype: float64

In [23]: ser.loc[:1]	# 标签索引
Out[23]:
0    0.0
1    1.0
dtype: float64

In [24]: ser.iloc[:1]	# 整数索引
Out[24]:
0    0.0
dtype: float64

5.算数和数据对齐

6.函数应用和映射

7.排序和排名

8.含有重复标签的轴索引

代码如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

2.读入数据

代码如下（示例）：

data = pd.read_csv(
    'https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv')
print(data.head())

该处使用的url网络请求的数据。

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

最后

以上就是高挑大米为你收集整理的Pandas入门一、数据结构介绍二、基本功能总结的全部内容，希望文章能够帮你解决Pandas入门一、数据结构介绍二、基本功能总结所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。