【Python 数据分析学习】Pandas基础与应用（1）

1 Pandas 简介

1.1 主要特征

Pandas 是Python中的一个高效易用的数据结构和数据分析的第三方库。Pandas是Python中数据分析的基础，旨在成为最实用最便利的开源数据分析的工具。其主要特性如下：

• 善于处理浮点数和非浮点数的数据缺失（用NaN来表示）；
• 大小可变：数据的行列能够从DataFrame或者更高维度的数据结构中添加或者删除；
• 自动数据对齐：目标会被显式地根据标签对齐，使用者也可以忽略标签，直接利用DataFrame、Series来自动对齐；
• 功能强大，灵活的分组功能，可对数据执行拆分-应用-组合的一系列操作，以便聚合和转换数据；
• 可以很方便地把其他Python和NumPy的杂乱的数据结构转换成DataFrame对象；
• 基于智能标签的切片、花式索引和子集化大数据集；
• 直观的合并和连接数据集；
• 灵活的重塑(reshape)和数据集的旋转；
• 轴的分层标签（每个标记可能有多个标签）；
• 强大的IO工具，用于从原始文件（CSV）、Excel文件、数据库中加载数据，以及从超快速HDF5格式保存/加载数据；
• 时间序列-特定功能：日期范围生成和频率转换、移动窗口统计、移动窗口线 性回归、日期移动和滞后等。

1.2 Pandas 安装

Anaconda环境中默认已集成了Numpy和Pandas等第三方工具包，如想自行安装，可使用pip命令或conda命令。

安装包方法：

1. pip命令，语法格式为：pip install pandas
2. conda命令，语法格式为：conda install pandas

还可以使用conda list pandas查看已安装的pandas包的版本信息。

2 Pandas中的数据结构

2.1 Series 数据结构和操作

2.1.1 Series的数据结构

Series 是一个一维的标签数组，一种类似于一维数组的对象，它由一组数据以及一组与之相对应的数据标签（即索引）组成。创建Series的语法为：
Series = pd.Series(data, index=index, name=name, dtype=dtype)

参数说明：

• data: 一维数组或列表，包含 Series 的数据。
• index: 可选参数，索引标签。如果未指定，将默认使用整数索引（从 0 开始）。
• name: 可选参数，为 Series 设置名称。
• dtype: 可选参数，指定数据类型。如果未指定，Pandas 会根据 data 自动推断数据类型。
  

1. 使用标量创建Series：index参数必须设置，如未设置index，默认状态时生成只有一组数据（1个data和一个索引）的Series。

代码演示：

s1 = pd.Series(66, index = [1,2,3])
print("数据为标量，索引为[1,2,3]，会按照索引的数目用该标量补充:\n",s1)s2 = pd.Series(66)
print("数据为标量，设置index，默认状态时生成只有一组数据:\n",s2)

2. 列表或数组创建Series，自定义内容

代码演示：

s1 = pd.Series(data = np.arange(5,10))
print("数组或列表创建Series，index默认，索引默认从0开始:\n",s1)print("--------------")
s2 = pd.Series(data = np.arange(1,6),index = ['A','B','C','D',"E"], name = "自然数", dtype = "float32")
print("自定义索引、数据类型，命名为自然数：\n",s2)

3. 字典创建Series：当index默认时，会自动以字典的key作为索引，并按照排序后排列。自定义索引时，字典中的key和标签不匹配就不显示value，多出的标签填空值。
   代码演示：

dic = {'b':6, 'c':3, 'a':2, 'w': 8}
s1 = pd.Series(data =dic )
print("字典创建Series,index默认：\n",s1)print("--------------")
s2 = pd.Series(data = dic,index = ['a','b','c','d'])
print("字典创建Series，index为 ['A','B','C','D']：\n",s2)
print("注：字典中的key和标签不匹配就不显示value，多出的标签填空值")

2.1.2 Seres的操作

对于Series对象的使用，主要取决于其创建对象的相关操作。由于数组和字典都可以用来创建Series，所以Series除了具备基本属性外，还适用数组、字典的相关操作。Series支持许多数组类型的操作。如：索引、切片等，以及许多NumPy的函数也适用于Series，其返回值仍是Series

1. 显示Series对象的属性。Series的常用属性包括values和index，还有name和index.name 属性。

代码演示：

s = pd.Series(data = np.arange(1,7),index = np.arange(1,7),name = "学习", dtype = "int32")
print("Series:\n",s)
print("------------")
print("Serise的属性values：",s.values)
print("Serise的属性index：",s.index)
print("Serise的属性name：", s.name)
print("Serise的属性dtype：", s.dtype)

2. Series支持数组类型的操作。如：索引（索引的是标签对应的值）、 切片（切片的是位置对应的值，第一个值的位置是0） 等。
   索引：索引的是 标签对应的值
   代码演示：

dic = {'b':6, 'c':3, 'a':2, 'w': 8}
s1 = pd.Series(data =dic )
print("Series:\n",s1)
print("用索引a，s1['a']:", s1['a'])print("------------")
s2 = pd.Series(data = np.arange(5,10),index = np.arange(1,6))
print("Series:\n",s2)
print("用索引1，实际打印出的是标签对应的数，s2[1]:", s2[1])print("------------")
s3 = pd.Series(data = [1,2,3,4], index = [6,8,6,8])
print("用索引6,实际打印的是标签全为6 index和value :\n",s3[6])

切片：
代码演示：

s2 = pd.Series(data = np.arange(5,10),index = np.arange(1,6))
print("Series:\n",s2)
print("用切片 s2[2:5] ,位置2-位置4对应的 index和value ：\n",s2[2:5])
print("用切片 s2[0:1] ，位置0对应的 index和value ：\n",s2[0:1])

3. Series还适用于字典的基本操作，如in()和get()。in()用来查看Series中是否有某个标签，返回值为True或False；get() 来索引不存在的标签，有该标签返回对应的value，反之返回值为Nan。

代码演示：

s = pd.Series(data = ['a','b','c','d','e'],index = np.arange(1,6))
print("Series:\n",s)
print( "索引标签 1, 'b' in s：", 1 in s)
print( "索引标签 9, 'z' in s：", 9 in s)
print("索引标签 1 ，s.get(1)，直接返回对应的值：", s.get(1) )
print("索引标签‘j' ，s.get('j')，每该标签返回值为Nan：", s.get('a') )

4. Series还支持一些向量化操作。如两个Series相加、数乘等。

代码演示：

s1 = pd.Series(data = np.arange(1,6))
s2 = pd.Series(data = np.arange(9,4,-1))
print("Series:\n",s1)
print("Series:\n",s2)
#加减乘车类似
print("s1 + s2:\n",s1+s2)

2.2 DataFrame 数据结构和操作

2.2.1 DataFrame 数据结构

DataFrame是一个结构类似于二维数组或表格的数据类型，可以看作一张表格，它含有一组有序的列，每一列的数据类型都是一致的。DataFrame类对象由索引和数据组成，与Series类对象相比，该对象有两组索引，分别是行索引(index)和列索引(columns)。DataFrame的数据结构如下图所示。

创建DataFrame的语法为：
pandas.DataFrame(data = data, index = index, columns= columns, dtype= dtype, copy = copy)

参数说明：

• data: 可以是多种类型的数据结构，如 NumPy ndarray, dict, nested list, Series, another DataFrame 等。
• index: 行标签的数组，长度必须与 data 的长度匹配。如果未提供，则自动使用整数索引。
• columns: 列标签的数组。如果 data 是一个 dict 并且 columns 没有提供，则使用字典的键作为列名。
• dtype: 数据类型，可选，默认为 None，表示自动检测数据类型。
• copy: 如果为 True，则对传递的数据进行深拷贝。
  

1. 由数组构建DataFrame。系统自动分配列索引和行索引，也可以自定义。

代码演示：

data = np.arange(0,9).reshape(3,3)
df1 = pd.DataFrame(data = data)
print("默认行索引和列索引：\n",df1)
print("------------")
df2 = pd.DataFrame(data = data,index = ['a','b','c'],columns = ['A','B','C'])
print("自定义行索引和列索引：\n",df2)

2. 列表类型是字典时，一般不需另外指定列的索引，会自动采用字典的key竖向作为列索引，并排序后输出，但支持指定行索引。

注意：字典值的长度必须相同，否则会报错。

代码演示：

dic = { "name":['Tom','jacker','dog'], "age":[18, 19, 18], "number":[111,222,333]}
df = pd.DataFrame(data = dic)
print(df)

3. DataFrame的常用属性包括values、index、columns、dtypes、size、ndim和shape等，分别可以显示DataFrame的数据、索引、列名、类型、元素个数、维度和形状等。

属性	属性含义
.values	显示DataFrame的数据
.index	显示DataFrame的索引
.columns	显示DataFrame的列名
.dtypes	显示DataFrame的数据类型
.sizes	显示DataFrame元素个数
.ndim	显示DataFrame的维度数
.shape	显示DataFrame的形状（x行y列）

2.2.2 Dataframe 操作

pandas.DataFrame 对象提供了两种主要的方式来访问和操作数据：.loc 和 .iloc。这两种方法分别基于标签和基于位置来进行索引。

我们定义一个DataFrame对象：
dic = { "name":['Tom','jacker','dog'], "age":[18, 19, 18], "number":[111,222,333]}
df = pd.DataFrame(data = dic)

访问数据的方式	说明
df[ ]	只能索引一个列的标签
df.loc[ ][ ]	df.loc[行的标签][列的标签]索引某个值
df.loc[ ]	df.loc[]只能索引一个行的标签
df.loc[ [ ] ]	df.loc[[行标签的列表]]索引n行的标签
df.loc[ : ,[ ] ]	df.loc[:,[列标签的列表]]索引m列的标签
df.loc[ [ ] , [ ] ]	df.loc[[行标签的列表][列标签的列表]]索引n行m列
df.iloc[ [ ], [ ] ]	df.iloc[行标签的位置][列标签的位置]索引n行m列

代码演示：

dic = { "name":['Tom','jacker','dog'], "age":[18, 19, 18], "number":[111,222,333]}
df = pd.DataFrame(data = dic)
print(df)
print("------------")
print("df[]只能索引一个列的标签：\n",df["name"])
print("------------")
print("df.loc[行的标签][列的标签]索引某个值：",df.loc[0]['name'])
print("------------")
print("df.loc[]只能索引一个行的标签：\n:",df.loc[1])
print("------------")
print("df.loc[[行标签的列表]]索引行的标签：\n:",df.loc[[1, 2]])
print("------------")
print("df.loc[:,[列标签的列表]]索引m列的标签：\n:",df.loc[:,["name", "age"]])
print("------------")
print("df.loc[[行标签的列表][列标签的列表]]索引n行m列：\n",df.loc[[1,2],['name','number']])
print("------------")
print("df.iloc[行标签的位置][列标签的位置]索引n行m列，：\n",df.iloc[[1,2],[1,2]])

2.2.3 DateFrame 的特殊操作

加入条件后的操作。
代码演示：

dic = { "name":['Tom','jacker','dog'], "age":[18, 19, 18], "number":[111,222,333]}
df = pd.DataFrame(data = dic)data1 = df.loc[:,"name":"number"]
print("使用切片 'name':'number' ：\n",data1)
print("-----------")
data2 = df.loc[df['age']<19,"name":"number"]
print('使用条件和切片 .loc[df["age"]<19,"name":"number"]：\n',data2)

2.3 Series 和 DataFrame 的联系和转换

2.3.1 联系

1. DataFrame 的列是 Series:
   DataFrame 的每一列实际上就是一个 Series。这意味着你可以通过列名来获取 DataFrame 中的某一列，并且得到的结果将是一个 Series。
2. 转换 Series 为 DataFrame:
   可以通过将一个 Series 转置（使用 .to_frame() 或 .to_frame(name) 方法）或将多个 Series 放入一个字典中然后创建 DataFrame 来从 Series 创建 DataFrame。

2.3.2 {s.name: s.values}型转换

把Seirs对象的名字作为DataFrame的列索引，Series对象的值作为DataFrame的值，index索引默认。

代码演示：

s1 = pd.Series(data = np.arange(1,4),name = "序列")
s2 = pd.Series(data = ["李明","李华", "小明"], name = "name")
df = pd.DataFrame(data = {s1.name:s1.values, s2.name: s2.values})
print("打印 s1 ：\n",s1)
print("打印 s2 ：\n",s2)
print("打印 s1和s2 的组合转换 :\n",df)

2.3.3 {s.name: s}型转换

这种转换会把 相同的行标签 对应的值放在同一行（自动对齐），对齐后空缺值用NaN补全。

代码演示：

s1 = pd.Series(data = np.arange(1,4), index = [1,2,3],name = "序列")
s2 = pd.Series(data = ["李明","李华", "小明"],index = [1,2,3] ,name = "name")
df1 = pd.DataFrame(data = {s1.name:s1, s2.name: s2})
print("打印 s1 ：\n",s1)
print("打印 s2 ：\n",s2)
print("s1和s2的索引都一致:\n",df1)
print("------------")s3 = pd.Series(data = np.arange(1,4), index = [1,2,3],name = "序列")
s4 = pd.Series(data = ["李明","李华", "小明"],index = [2,3,4] ,name = "name")
df2 = pd.DataFrame(data = {s3.name:s3, s4.name: s4})
print("打印 s3 ：\n",s3)
print("打印 s4 ：\n",s4)
print("s3和s4的索引不一致:\n",df2)

3 pandas中数据的基本操作

3.1 数据的写入

3.1.1 写入 csv 文件

CSV（逗号分隔值）文件是一种常见的数据交换格式。Pandas 提供了 to_csv 方法来将 DataFrame 写入 CSV 文件（csv文件其实也是一个文本文件，用excel直接打开后为表格形式）。

语法格式：pd.to_csv(路径，index，encoding)

• index=False：默认情况下，Pandas 会在 CSV 文件中包含索引列。如果你不想包含索引列，可以设置 index=False。
• encoding=‘utf-8’：指定输出文件的编码，默认是 utf-8，但也可以指定其他编码，如 gbk。

代码演示：

data = {'Name': ['Alice', 'Bob', 'Charlie'],'Age': [25, 30, 35],'City': ['北京', '上海', '广州']
}df = pd.DataFrame(data)
# 写入 CSV 文件
df.to_csv('output.csv')

用记事本打开：

用excel打开：

3.1.2 写入excel文件

excel 文件的扩展名是 .xlsx ,exce文件是表格文件。

代码演示：

data = {'Name': ['Alice', 'Bob', 'Charlie'],'Age': [25, 30, 35],'City': ['北京', '上海', '广州']
}df = pd.DataFrame(data)
# 写入 excel 文件
df.to_excel('output.xlsx', index=False)

3.1.3 写入 json文件

JSON（JavaScript 对象表示法）是一种轻量级的数据交换格式。Pandas 使用 to_json 方法来将 DataFrame 写入 JSON 文件。

代码演示：

data = {'Name': ['Alice', 'Bob', 'Charlie'],'Age': [25, 30, 35],'City': ['北京', '上海', '广州']
}df = pd.DataFrame(data)
# # 写入 JSON 文件
df.to_json('output.json', orient='records', force_ascii=False)

• orient=‘records’：指定 JSON 数据的格式。‘records’ 使得每一行成为一个独立的对象，整个 DataFrame 被表示为一个对象数组。
• force_ascii=False：允许非 ASCII 字符直接写入，这样中文字符不会被转义。

3.2 数据的读取

3.2.1 语法格式

Pandas支持多种文件格式的数据读取与写入，包括txt、Excel、csv、sql、table、html和json等众多格式。读取文件的语法格式为：

File = pd.read_xxx(file, encoding)

其中，read_xxx()函数的选择取决于要读取文件的格式，在实际操作中可以tab键补全函数；file是指将要读取的文件路径；encoding是指读取文件的编码格式，一般常用的有utf-8、utf-16、gbk及gb2312。
Dataframe数据也可以保存在各种格式的文件中，需要使用的函数是.to_xxx()函数。

3.2.2 读取 csv 文件

将CSV中的数据转换为DataFrame对象是非常便捷的。和一般文件读写不一样, 它不需要你做打开文件、读取文件、关闭文件等操作。相反,您只需要一行代码就可以完成上述所有步骤，并将数据存储在DataFrame中。

1. csv文件实际也是一个文本文件，读取.txt 文件用的是读取csv文件的方式。csv文件的分隔符通常为‘ ，’，默认情况下我们不用设置sep。

分隔符为‘，’：

代码演示：

df = pd.read_csv("test.txt",encoding = "utf-8")
print(df)

2. ①. csv文件有表头并且是第- -行，那么names和header都无需指定;
   ②. csv文件有表头、但表头不是第- -行，可能从下面几行开始才是真正的表头和数据，这个时候指定header即可;
   ③. csv文件没有表头， 全部是纯数据，那么我们可以通过names手动生成表头;
   ④. csv文件有表头、但是这个表头你不想用，这个时候同时指定names和header。先用header选出表头和数据，然后再用names将表头替换掉，就等价于将数据读取进来之后再对列名进行rename;

3. 改文件的索引（index_col），把时间改为时间戳

代码演示：

df = pd.read_csv("test.txt",index_col = "birthday")
print("打印df对象：\n",df)
print("此时的行索引为：",df.index)
print("object 类型是整体类型，不是时间戳")
print("---------")
print("把整体类型的时间改为时间戳,时间戳是pandas可以直接索引的类型")
df.index = pd.to_datetime(df.index)
print(df.index)
print("---------")
print("打印df对象：\n",df)
print("打印df中2003年出生的同学：\n",df.loc["2003"])

3.2.3 读取 excel 文件

1. 表格完整，直接读取
   

代码演示：

df = pd.read_excel("test.xlsx")
print(df)

2. 表格没有表头，读取时会把数据第一行作为表头，那我们应该怎么处理呢？设置参数header = None。如果想自定义一个表头，需要设置参数header = None，name = []。

不设置参数直接读取：

添加参数后的代码为：

df = pd.read_excel("test.xlsx",header= None, names= ["序列号","姓名", "年龄"])
print(df)

3.3 数据的编辑

3.3.1 数据的增加

1. 可以通过给新列直接赋值来为DataFrame增加新列。默认状态下，新增加的列将排在原对象的后面；
2. 可以使用insert()方法，将列添加到指定位置。用法为：df1.insert(iloc,column,value)，其中，第一个参数是增加列的位置，第二个参数是增加列的索引，第三个位置是增加列的内容。

代码演示：

s2 = pd.Series(data = ["李明","李华", "小明"], name = "name")
df = pd.DataFrame(data = {s1.name:s1.values, s2.name: s2.values})
print("打印df对象：\n",df)df['test1'] = 66
print("增加一列test1：\n", df)
df['test2'] = pd.Series([77,77,77], index = np.arange(0,3))
print("增加一列test2：\n", df)
df.insert(1,'test3',df['test2'])
print('增加一列test3, 在位置1，名为test3，值为df["test2"]：\n', df)

3.3.2 删除数据

可用关键词 del 或者 pop() 方法删除指定列。还可以使用drop()方法，并设置axis参数指定要删除的是行还是列，默认不改变原数据，若要在原数据中删除，需要设置参数inplace=True。

代码演示：

s1 = pd.Series(data = np.arange(1,4),name = "序列")
s2 = pd.Series(data = ["李明","李华", "小明"], name = "name")
df = pd.DataFrame(data = {s1.name:s1.values, s2.name: s2.values})
df['test1'] = 66
df['test2'] = pd.Series([77,77,77], index = np.arange(0,3))
df.insert(1,'test3',df['test2'])print("打印df对象：\n",df)
del df['test3']
print("删除数据test3：\n",df)
df.pop('test2')
print("删除数据test2：\n",df)

3.3.3 修改数据

对选定的数据直接赋值即可修改数据，数据的修改操作无法撤销，且是在原数据上直接修改，因此需要实现做好数据的备份。
代码演示：

s1 = pd.Series(data = np.arange(1,4),name = "序列")
s2 = pd.Series(data = ["李明","李华", "小明"], name = "name")
df = pd.DataFrame(data = {s1.name:s1.values, s2.name: s2.values})
print("打印df对象：\n",df)df.loc[0,"name"] = "***"
print("打印修改后的df对象：\n",df)

3.4 数据的合并

3.4.1 merge函数

操作类似于sql里面的join，实现将2个DataFrame根据一些共有的列连接起来，内含多个参数，具体参数说明见下表。

注：inner 是值的交值作为链接键，outer是值的并集作为链接键，left是按左DataFrame的值作为链接键，right是按右DataFrame的值作为链接键。

默认状态：DataFrame合并时会以列名的交集作为连接键，连接方式是值的交集。

代码演示：

df1  = pd.DataFrame(data = {"score": [80,70,60,50], "name1": ["小明", "小红", "小刚", "小华"]})
df2  = pd.DataFrame(data = {"score": [70,60,50,60], "name2": ["李明", "李华", "张兵", "王军"]})df = pd.merge(df1, df2)
print(df)

默认状态：DataFrame合并时会以列名的交集作为连接键，连接方式是值的交集。若连接列中含有多个相同的值，则采用笛卡尔积的形式进行连接。

设置 on 参数：当DataFrame的列交集不止一项时，可以通过参数 on 来指定连接键，可一个，也可多个。如果合并的DataFrame中还有相同的列索引，可以设置 suffixes 参数，实现对列名的区分。

代码演示 :

df1  = pd.DataFrame(data = {"score": [80,70,60,50], "name": ["小明", "小红", "小刚", "小华"]})
df2  = pd.DataFrame(data = {"score": [70,60,50,40], "name": ["李明", "李华", "张兵", "王军"]})df = pd.merge(df1, df2, on = "score",suffixes = ["_一班", "_二班"])
print(df)

设置how参数：设置连接时的方式，默认状态下是inner（值交集）。当how取值outer时，会采用值并集式合并，缺项以NaN补齐。

代码演示：

df1  = pd.DataFrame(data = {"score": [80,70,60,50], "name": ["小明", "小红", "小刚", "小华"]})
df2  = pd.DataFrame(data = {"score": [70,60,50,40], "name": ["李明", "李华", "张兵", "王军"]})df = pd.merge(df1, df2, on = "score",suffixes = ["_一班", "_二班"], how = "outer")
print(df)

3.4.2 concat 函数

主要实现一些简单的行合并和列合并的操作，其内含多个参数，具体见下表。

1. 设置参数axis：
   axis=0时，纵向合并；
   axis=1时，横向合并，空缺值补NaN。

代码演示：

df1  = pd.DataFrame(data = {"score": [80,70,60,50], "name1": ["小明", "小红", "小刚", "小华"]})
df2  = pd.DataFrame(data = {"score": [70,60,50,40], "name2": ["李明", "李华", "张兵", "王军"]})
df3  = pd.DataFrame(data = {"score": [50,60,30, 40], "name2": ["李明", "李华", "张兵", "王军"]})
#默认axis= 0，纵向合并
data1 = pd.concat([df1,df2])
print(data1)#axis= 1,横向合并
data2 = pd.concat([df1,df2], axis= 1)
print(data2)

2. 设置参数 ignore_index:
   True,不保留原来的索引；
   False(默认),保留原来的索引。

代码演示：

df1  = pd.DataFrame(data = {"score": [80,70,60,50], "name1": ["小明", "小红", "小刚", "小华"]})
df2  = pd.DataFrame(data = {"score": [70,60,50,40], "name2": ["李明", "李华", "张兵", "王军"]})data = pd.concat([df1,df2], axis= 1)
print("原来的data:\n", data)
data = pd.concat([df1,df2], axis= 1, ignore_index= True)
print("ignore_index= True :\n", data)

3. 设置join参数：连接键的方式
   当join参数设置为outer（默认），按并集方法合并，缺少的部分填充NaN。
   当join参数设置为inner时，以交集方式合并，即只合并公共的部分

代码演示：

df1  = pd.DataFrame(data = {"score": [80,70,60,50], "name1": ["小明", "小红", "小刚", "小华"]})
df2  = pd.DataFrame(data = {"score": [70,60,50,40], "name2": ["李明", "李华", "张兵", "王军"]})# join默认是outer
data1 = pd.concat([df1,df2])
print(data1)# join= "inner"
data2 = pd.concat([df1, df2],join= "inner")
print(data2)