今天主要带大家来实操学习下Pandas，因为篇幅原因，分为了两部分，本篇为上。

1 数据结构的简介

pandas中有两类非常重要的数据结构，就是序列Series和数据框DataFrame.Series类似于NumPy中的一维数组，可以使用一维数组的可用函数和方法，而且还可以通过索引标签的方式获取数据，还具有索引的自动对齐功能；DataFrame类似于numpy中的二维数组，同样可以使用numpy数组的函数和方法，还具有一些其它灵活的使用。

1.1 Series的创建  三种方法

通过一维数组创建序列m

import pandas as pd
import numpy as nparr1=np.arange(10)
print("数组arr1：",arr1)
print("arr1的数据类型：",type(arr1))
s1=pd.Series(arr1)
print("序列s1:\n",s1)
print("s1的数据类型：",type(s1))

---

数组arr1： [0 1 2 3 4 5 6 7 8 9]
arr1的数据类型： <class 'numpy.ndarray'>
序列s1:
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9
dtype: int32
s1的数据类型： <class 'pandas.core.series.Series'>

通过字典的方式创建序列

dict1={'a':1,'b':2,'c':3,'d':4,'e':5}
print("字典dict1：",dict1)
print("dict1的数据类型：",type(dict1))
s2=pd.Series(dict1)
print("序列s2：",s2)
print("s2的数据类型：",type(s2))

---

字典dict1： {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
dict1的数据类型： <class 'dict'>
序列s2：a    1
b    2
c    3
d    4
e    5
dtype: int64
s2的数据类型： <class 'pandas.core.series.Series'>

通过已有DataFrame创建

由于涉及到了DataFrame的概念，所以等后面介绍了DataFrame之后补充下如何通过已有的DataFrame来创建Series。

1.2 DataFrame的创建 三种方法

通过二维数组创建数据框

print("第一种方法创建DataFrame")
arr2=np.array(np.arange(12)).reshape(4,3)
print("数组2：",arr2)
print("数组2的类型",type(arr2))df1=pd.DataFrame(arr2)
print("数据框1：\n",df1)
print("数据框1的类型：",type(df1))

---

第一种方法创建DataFrame
数组2： [[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
数组2的类型 <class 'numpy.ndarray'>
数据框1：0   1   2
0  0   1   2
1  3   4   5
2  6   7   8
3  9  10  11
数据框1的类型： <class 'pandas.core.frame.DataFrame'>

通过字典列表的方式创建数据框

print("第二种方法创建DataFrame")
dict2={'a':[1,2,3,4],'b':[5,6,7,8],'c':[9,10,11,12],'d':[13,14,15,16]}
print("字典2-字典列表：",dict2)
print("字典2的类型",type(dict2))df2=pd.DataFrame(dict2)
print("数据框2：\n",df2)
print("数据框2的类型：",type(df2))

---

第二种方法创建DataFrame
字典2-字典列表： {'a': [1, 2, 3, 4], 'b': [5, 6, 7, 8], 'c': [9, 10, 11, 12], 'd': [13, 14, 15, 16]}
字典2的类型 <class 'dict'>
数据框2：a  b   c   d
0  1  5   9  13
1  2  6  10  14
2  3  7  11  15
3  4  8  12  16
数据框2的类型： <class 'pandas.core.frame.DataFrame'>

通过嵌套字典的方式创建数据框

dict3={'one':{'a':1,'b':2,'c':3,'d':4},'two':{'a':5,'b':6,'c':7,'d':8},'three':{'a':9,'b':10,'c':11,'d':12}}
print("字典3-嵌套字典：",dict3)
print("字典3的类型",type(dict3))df3=pd.DataFrame(dict3)
print("数据框3：\n",df3)
print("数据框3的类型：",type(df3))

---

字典3-嵌套字典： {'one': {'a': 1, 'b': 2, 'c': 3, 'd': 4}, 'two': {'a': 5, 'b': 6, 'c': 7, 'd': 8}, 'three': {'a': 9, 'b': 10, 'c': 11, 'd': 12}}
字典3的类型 <class 'dict'>
数据框3：one  three  two
a    1      9    5
b    2     10    6
c    3     11    7
d    4     12    8
数据框3的类型： <class 'pandas.core.frame.DataFrame'>

有了DataFrame之后，这里补充下如何通过DataFrame来创建Series。

s3=df3['one'] #直接拿出数据框3中第一列
print("序列3：\n",s3)
print("序列3的类型：",type(s3))
print("------------------------------------------------")
s4=df3.iloc[0] #df3['a'] #直接拿出数据框3中第一行--iloc
print("序列4：\n",s4)
print("序列4的类型：",type(s4))

---

序列3：a    1
b    2
c    3
d    4
Name: one, dtype: int64
序列3的类型： <class 'pandas.core.series.Series'>
------------------------------------------------
序列4：one      1
three    9
two      5
Name: a, dtype: int64
序列4的类型： <class 'pandas.core.series.Series'>

2 数据索引index

无论数据框还是序列，最左侧始终有一个非原始数据对象，这个就是接下来要介绍的数据索引。通过索引获取目标数据，对数据进行一系列的操作。

2.1 通过索引值或索引标签获取数据

s5=pd.Series(np.array([1,2,3,4,5,6]))
print(s5) #如果不给序列一个指定索引值，序列会自动生成一个从0开始的自增索引

---

0    1
1    2
2    3
3    4
4    5
5    6
dtype: int32

通过index属性获取序列的索引值

s5.index

---

RangeIndex(start=0, stop=6, step=1)

为index重新赋值

s5.index=['a','b','c','d','e','f']
s5

---

a    1
b    2
c    3
d    4
e    5
f    6
dtype: int32

通过索引获取数据

s5[3]

4

---

s5['e']

5

---

s5[[1,3,5]]

b    2
d    4
f    6
dtype: int32

---

s5[:4]

a    1
b    2
c    3
d    4
dtype: int32

---

s5['c':]

c    3
d    4
e    5
f    6
dtype: int32

---

s5['b':'e']  #通过索引标签获取数据，末端标签的数据也是返回的，

b    2
c    3
d    4
e    5
dtype: int32

2.2 自动化对齐

#当对两个
s6=pd.Series(np.array([10,15,20,30,55,80]),index=['a','b','c','d','e','f'])
print("序列6：",s6)
s7=pd.Series(np.array([12,11,13,15,14,16]),index=['a','c','g','b','d','f'])
print("序列7：",s7)print(s6+s7)  #s6中不存在g索引，s7中不存在e索引，所以数据运算会产生两个缺失值NaN。
#可以注意到这里的算术运算自动实现了两个序列的自动对齐
#对于数据框的对齐，不仅是行索引的自动对齐，同时也会对列索引进行自动对齐，数据框相当于二维数组的推广
print(s6/s7)

---

序列6： a    10
b    15
c    20
d    30
e    55
f    80
dtype: int32
序列7： a    12
c    11
g    13
b    15
d    14
f    16
dtype: int32
a    22.0
b    30.0
c    31.0
d    44.0
e     NaN
f    96.0
g     NaN
dtype: float64
a    0.833333
b    1.000000
c    1.818182
d    2.142857
e         NaN
f    5.000000
g         NaN
dtype: float64

3 pandas查询数据

通过布尔索引有针对的选取原数据的子集，指定行，指定列等。

test_data=pd.read_csv('test_set.csv')
# test_data.drop(['ID'],inplace=True,axis=1)
test_data.head()

非数值值特征数值化

test_data['job'],jnum=pd.factorize(test_data['job'])
test_data['job']=test_data['job']+1test_data['marital'],jnum=pd.factorize(test_data['marital'])
test_data['marital']=test_data['marital']+1test_data['education'],jnum=pd.factorize(test_data['education'])
test_data['education']=test_data['education']+1test_data['default'],jnum=pd.factorize(test_data['default'])
test_data['default']=test_data['default']+1test_data['housing'],jnum=pd.factorize(test_data['housing'])
test_data['housing']=test_data['housing']+1test_data['loan'],jnum=pd.factorize(test_data['loan'])
test_data['loan']=test_data['loan']+1test_data['contact'],jnum=pd.factorize(test_data['contact'])
test_data['contact']=test_data['contact']+1test_data['month'],jnum=pd.factorize(test_data['month'])
test_data['month']=test_data['month']+1test_data['poutcome'],jnum=pd.factorize(test_data['poutcome'])
test_data['poutcome']=test_data['poutcome']+1test_data.head()

查询数据的前5行

test_data.head()

查询数据的末尾5行

test_data.tail()

查询指定的行

test_data.iloc[[0,2,4,5,7]]

查询指定的列

test_data[['age','job','marital']].head()

查询指定的行和列

test_data.loc[[0,2,4,5,7],['age','job','marital']]

查询年龄为51的信息

#通过布尔索引实现数据的自己查询test_data[test_data['age']==51].head()

查询工作为5以上的年龄在51的信息

test_data[(test_data['age']==51) & (test_data['job']>=5)].head()