pandas库——基础

1.概述

Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来
Pandas 名字衍生自术语 "panel data"（面板数据）和 "Python data analysis"（Python 数据分析）
Pandas 已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具
Pandas 是 Python 语言的一个扩展程序库，用于数据分析
Pandas 是一个开放源码、BSD 许可的库，提供高性能、易于使用的数据结构和数据分析工具
Pandas 一个强大的分析结构化数据的工具集，基础是 Numpy（提供高性能的矩阵运算）
Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据
Pandas 可以对各种数据进行运算操作，比如归并、再成形、选择，还有数据清洗和数据加工特征
Pandas 广泛应用在学术、金融、统计学等各个数据分析领域
Pandas 的出现使得 Python 做数据分析的能力得到了大幅度提升，它主要实现了数据分析的五个重要环节：加载数据、整理数据、操作数据、构建数据模型、分析数据

2.内置数据结构

Pandas 在 ndarray 数组（NumPy 中的数组）的基础上构建出了两种不同的数据结构，分别是 Series（一维数据结构）、DataFrame（二维数据结构）：

Series 是带标签的一维数组，这里的标签可以理解为索引，但这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等
DataFrame 是一种表格型数据结构，它既有行标签，又有列标签

数据结构	维度	说明
Series	1	该结构能够存储各种数据类型，比如字符数、整数、浮点数、Python 对象等，Series 用 name 和 index 属性来描述数据值。Series 是一维数据结构，因此其维数不可以改变
DataFrame	2	DataFrame 是一种二维表格型数据的结构，既有行索引，也有列索引。行索引是 index，列索引是 columns。在创建该结构时，可以指定相应的索引值

3.Series

Pandas Series 类似表格中等一个列（column），类似于一维数组，可以保存任何数据类型 Series 由索引（index）和列组成

语法：

pandas.Series(data,index,dtype)

参数说明：

data：一组数据（ndarray 类型）
index：数据索引标签，如果不指定，默认从 0 开始
dtype：数据类型，默认会自己判断 copy：表示对 data 进行拷贝，默认为 False

1.创建Series对象

1.创建Series空对象

2.ndarray创建Seriess对象

3.字典创建Series对象

说明：

字典的键为索引，值为数据

4.标量创建Series对象

说明：

如果不指定index 则创建一行
指定多个索引值按照索引值的数量创建行每行都是标量值

代码示例：

def pd_series():
    # 创建一个空Series对象
    s = pd.Series()
    print(s)
    # 创建一个Series对象 用python列表初始化
    s1 = pd.Series(["张三","李四","王五"])
    print(s1)
    # 根据编号取值
    print(s1[0])

    # 创建Series 指定对象索引值
    s2 = pd.Series([1,2,3],["A","B","C"])
    print(s2)
    # 根据指定的索引进行取值
    print(s2["A"])
    # 通过下标也能取出值 但会被警告
    print(s2[0])

    # 根据ndarray创建Series对象
    arr = np.array([1,2,3,4])
    s3 = pd.Series(arr)
    print(s3)

    # 根据字典创建Series对象
    dic = {"name": "张三", "age": 20, "sex": "男"}
    s4 = pd.Series(dic)
    print(s4)

    # 根据标量创建Series对象
    # 如果不指定index 则创建一行
    # 指定多个索引值 按照索引值的数量创建行 每行都是标量值
    s5 = pd.Series(5, index=[0, 1, 2, 3, 4, 5])
    print(s5)

2.访问Series数据

1.直接通过下标位置索引（会被警告，但不会报错）

2.通过索引对象索引

代码示例：

s1 = pd.Series(["张三","李四","王五"])
print(s1)
# 根据编号取值
print(s1[0])
# 创建Series 指定对象索引值
s2 = pd.Series([1,2,3],["A","B","C"])
print(s2)
# 根据指定的索引进行取值
print(s2["A"])
# 通过下标也能取出值 但会被警告
print(s2[0])

3.Series的常用属性

名称	属性
axes	以列表的形式返回所有行索引标签
dtype	返回对象的数据类型
empty	返回一个布尔值，用于判断数据对象是否为空
ndim	返回输入数据的维数
size	返回输入数据的元素数量
values	以 ndarray 的形式返回 Series 对象
index	返回一个RangeIndex对象，用来描述索引的取值范围

代码示例：

def pd_Series_attr():
    s = pd.Series(['a', 'b', 'c', 'd', 'e'])
    # 获取Series的索引信息
    print(s.axes)
    # 获取数据类型
    print(s.dtype)
    # 判断是否为空
    print(s.empty)
    # 获取数组维度
    print(s.ndim)
    # 获取Series对象中的元素个数
    print(s.size)
    # 获取Series对象的值 返回ndarray的数组
    print(s.values)
    # 返回s.values的类型
    a = s.values
    print(type(a))
    # 获取索引信息
    print(s.index)

4.Series常用方法

1.head（）和tail（）

查看 Series 的某一部分数据，使用 head() 或者 tail() 方法。其中 head() 返回前 n 行数据，默认显示前 5 行数据，tail() 返回后 n 行数据，默认为后 5 行

2.isnull（）和notnull（）

isnull() 和 nonull() 用于检测 Series、DataFrame 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少

isnull()：判断series对象中的元素是否为None 是则为True 否则为False
notnull()：判断series对象中的元素是否不为None 是则为True 否则为False

代码示例：

def pd_series_func():
    s = pd.Series(['a', 'b', 'c', 'd', 'e', 'f', None])
    print(s)
    # 获取series对象前n行数据 默认n = 5
    print(s.head())

    print(s.head(3))
    # # 获取series对象后n行数据 默认n = 5
    print(s.tail())
    print(s.tail(3))
    # 判断series对象中的元素是否为None 是则为True 否则为False
    print(s.isnull())
    # 判断series对象中的元素是否不为None 是则为True 否则为False
    print(s.notnull())
    # 根据判断条件过滤元素
    print(s[s.notnull()])

4.DataFrame

DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。其结构图示意图，如下所示：
DataFrame 的每一行数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列标签
同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应当然你也可以用“显式索引”的方式来设置行标签

语法：

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

参数说明：

data：一组数据（ndarray、series, map, lists, dict 等类型）
index：索引值，或者可以称为行标签
coumns：列标签，默认为 RangeIndex （0, 1, 2, …, n）
dtype：数据类型 copy：默认为 False，表示复制数据 data

1.创建DataFrame对象

创建 DataFrame 对象的方式：

列表
字典
Series
Numpy ndarrays
另一个 DataFrame

1.创建一个DataFrame空对象

df = pd.DataFrame()
print(df)

2.用列表创建DataFrame对象

columns可以指定列名，如果不指定，则为默认位置参数（0，1，2，3，...)
index可以指定名，如果不指定，则为默认位置参数（0，1，2，3，...)
注：行名和列名都要和数据的数量对象的上，否则会报错

df1 = pd.DataFrame(['张三', '李四', '王五'])
print(df1)
df2 = pd.DataFrame(['张三', '李四', '王五'], columns=["name"])
print(df2)

3.列表嵌套列表创建DataFrame对象

外层列表元素个数表示有几行
外层列表的元素不能为数字类型，其他如字符串、元组、列表、集合、字典（字典取键作为数据）都可以
内存列表元素个数表示有几列
内层列表数据类型可以为任何数据类型
如果不指定列名，内层列表的元素可以不一致，列的数量为内层列表长度最长的列表，排列时某些缺省的会用None填补
如果不指定行名，内层列表的元素可以不一致，行的数量为外层列表的长度
可以用columns指定列名，列名数需要和内层列表元素个数一致
可以用index指定行名，行名需与外层列表元素一致

df3 = pd.DataFrame([['张三', '20'], ['李四', '21'], ['王五', 22,"n",(1,2,3),{1:2}], {1:2,2:3},(1,2,3,4),np.array([111])])
print(df3)

4. 列表嵌套字典创建DataFrame对象（json类型）

字典的键为列名，值为数据，有多少键就有多少列
行数为列表中字典的个数
行名可以用index指定，有多少个字典就要指定多少个行名
不能放空字典

arr = [{'name':'张三',1:2}, {'name': '李四', 'age': '21'},]
df4 = pd.DataFrame(data = arr)

5.字典创建DataFrame对象

字典的键为列
值可以为元组、列表、ndarray对象、数字、字符串
若值为列表和元组ndarray对象，他们里面的元素个数必需一致，他们元素的个数决定了行的数量，数字和字符串则会复制自身进行填充

dic = {"name": ['zhangsan', 'lisi'],"age":[15,21],"sex":(2,1),1:2,2:"a",3:"abc",4:np.array([2,3])}
df5 = pd.DataFrame(dic)
print(df5)

6.通过字典和Series创建DataFrame对象

key是列数
Series的元素数量最多的是行数
Deries元素数量不够的，自动用NaN填充

dic1 = {'one':pd.Series([1,2,3]), 'two':pd.Series([4,5,6,7])}
df6 = pd.DataFrame(dic1)
print(df6)

2.列索引操作

1.直接用下标索引

直接用列名的标签进行索引，返回一个Series对象
可以通过列名加布尔索引拿到具体想拿的某一行
可以直接用布尔索引筛选数据，拿到想要拿到的某一行

df = pd.DataFrame({"name":['zhangsan','lisi','wangwu'],'age':[14,24,37]})
namelist = df['name']
print(df[df['age']==14]) # 拿到age为14的那一行数据
print(type(df['age']))
print(namelist)

2.添加新列

语法：

df[列名] = 列数据内容

可以用列表、ndarray、Series添加
列表和ndarray添加的时候行数要和原df中数据行数一致
series的行数可以不一致缺省值自动补充NaN

3.在指定位置插入新列

语法：

df.insert(loc,column,value)

参数说明：

loc: 插入位置的列索引。
column: 新列的名称。
value: 要插入的 Series

value说明：

value参数可以为列表、元组、字典、字符串、数字、ndarray对象、Serise对象
列表、元组、ndarray对象的元素个数都需要和行数对应上
数字和字符串会直接填充到每行一样的数据
Serise对象少会填充为NaN，多则是数前几位和行数对应的元素
字典则是键=行名，该行数据就为值，否则填充NaN

4.修改数据

下标索引列 = 元素数量与行数对应的列表、元组
下标索引列 = Serise对象少会填充为NaN，多则是数前几位和行数对应的元素
下标索引列 = 数字和字符串会直接填充到每行一样的数据
下标索引列 = 字典的键=行名，该行数据就为值，否则填充NaN

5.删除数据

通过drop方法删除 DataFrame 中的数据，默认情况下，drop() 不会修改原 DataFrame，而是返回一个新的 DataFrame。

语法：

DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

参数说明：

labels：
- 类型：单个标签或列表。
- 描述：要删除的行或列的标签。如果 axis=0，则 labels 表示行标签；如果 axis=1，则 labels 表示列标签。
axis：
- 类型：整数或字符串，默认为 0。
- 描述：指定删除的方向。axis=0 或 axis='index' 表示删除行，axis=1 或 axis='columns' 表示删除列。
index：
- 类型：单个标签或列表，默认为 None。
- 描述：要删除的行的标签。如果指定，则忽略 labels 参数。
columns：
- 类型：单个标签或列表，默认为 None。
- 描述：要删除的列的标签。如果指定，则忽略 labels 参数。
level：
- 类型：整数或级别名称，默认为 None。
- 描述：用于多级索引（MultiIndex），指定要删除的级别。
inplace：
- 类型：布尔值，默认为 False。
- 描述：如果为 True，则直接修改原 DataFrame，而不是返回一个新的 DataFrame。
errors：
- 类型：字符串，默认为 'raise'。
- 描述：指定如何处理不存在的标签。'raise' 表示抛出错误，'ignore' 表示忽略错误。

def pd_df_col():
    # 列名索引
    df = pd.DataFrame({"name":['zhangsan','lisi','wangwu'],'age':[14,24,37]})
    namelist = df['name']
    print(df[df['age']>23])
    print(type(df['age']))
    print(namelist)

    # 添加新列
    # 可以用列表、ndarray、Series添加
    # 列表和ndarray添加的时候 行数要和原df中数据行数一致
    # series的行数可以不一致 缺省值自动补充NaN
    df["sex"] = ["男","女","男"]
    df["garden"] = pd.Series(["大一","大二"])
    df["address"] = np.array(["cq","sc",'jx'])
    # insert在指定列插入新列
    # loc 新列索引值
    # column 新列列名
    # value 新列列值
    df.insert(1,"id", [1,5,7])
    print(df,1111111)
    # 修改某一列的值
    df["id"] = {"id":1}
    print(df)
    print("-------------------------------------------------------------------------------------------")
    # 删除
    # 列删除 drop
    # labels 要删除的列标签或行标签
    # axis 轴 axis = 0 按行删除
    #        axis = 1 按列删除
    # inplace 是否在原dataframe上删除 为True则在原dataframe上删除 为false则返回一个删除后的dataframe

    df.drop(labels=["id"],axis = 1,inplace=True)
    print(df)

3.行索引

1.loc选取数据

df.loc[] 只能使用标签索引，不能使用整数索引。当通过标签索引的切片方式来筛选数据时，它的取值前闭后闭，也就是只包括边界值标签（开始和结束）

loc方法返回的数据类型：

1.如果选择单行或单列，返回的数据类型为Series

2.选择多行或多列，返回的数据类型为DataFrame

3.选择单个元素(某行某列对应的值)，返回的数据类型为该元素的原始数据类型（如整数、浮点数等）。

语法：

DataFrame.loc[row_indexer, column_indexer]

参数说明：

row_indexer：行标签或布尔数组。
column_indexer：列标签或布尔数组。

2.iloc选取数据

iloc 方法用于基于位置（integer-location based）的索引，即通过行和列的整数位置来选择数据。

语法：

DataFrame.iloc[row_indexer, column_indexer]

参数说明：

row_indexer：行位置或布尔数组
column_indexer：列位置或布尔数组。

3.切片多行选取

通过切片的方式进行多行数据的选取

代码示例：

def pd_df_row():
    data = {
        'A':[1,2,3,4],
        'B':[5,6,7,8],
        'C':[9,10,11,12]
    }
    df = pd.DataFrame(data,index=['a','b','c','d'])
    print(df)
    # 行索引操作
    # loc 通过索引标签获取Dataframe中的行或列
    # 如果获取到多行多列则返回DataFrame对象
    # 根据行索引标签获取a行的数据 返回结果是Series对象
    print(df.loc['a'])
    # 通过切片的方式获取a行到c行的数据 返回结果是DataFrame
    # 切片的范围左闭右闭区间
    print(df.loc['a':'c'])
    # 获取a行和B列对应的数据 返回结果是一个数据
    print(df.loc['a','B'])
    # 根据a行c行 A列C列获取对应的数据 返回结果是Dataframe
    print(df.loc[['a','c'],['A',"C"]])
    # loc方法不能使用行所在位置的索引进行获取
    # print(df.loc[1])
    print("-----------------------------------------------")
    # iloc 用位置索引
    # 根据行所在的位置进行获取 基于位置获取
    # 不能通过行或列索引标签获取数据
    # 获取行索引位置为1的行数据
    print(df.iloc[1])
    # 左闭右开区间
    # 通过切片获取索引位置为0-2的行数据
    # 切片位置左闭右开区间
    print(df.iloc[0:3])
    # 通过行索引位置和列索引位置获取数据 返回的是一个数值
    print(df.iloc[0,1])
    # 通过多个行索引位置和多个列索引位置获取对应的数据
    print(df.iloc[[0,2],[0,2]])
    # 直接通过切片获取多行数据 切片的取值范围是左闭右开区间
    print(df[0:2])

说明：

想要选取某一列可以，返回整列的内容loc和iloc都适用

df[...,[列名]

3.添加行数据

使用loc方法添加新行

语法：

df.loc[行名] = value

4.常用属性和方法

DataFrame 的属性和方法，与 Series 基本相同

名称	属性和方法描述
T	行和列转置。
axes	返回一个仅以行轴标签和列轴标签为成员的列表。
dtypes	返回每列数据的数据类型。
empty	DataFrame中没有数据或者任意坐标轴的长度为0，则返回True。
ndim	轴的数量，也指数组的维数。
shape	返回一个元组，表示了 DataFrame 维度。
size	DataFrame中的元素数量。
values	使用 numpy 数组表示 DataFrame 中的元素值。
head()	返回前 n 行数据。
tail()	返回后 n 行数据。

def pd_df_attr():
    df = pd.DataFrame({'A': [1, 2, 3, 4, 5 ,6], 'B': [7, 8, 9, 10, 11, 12]})
    df1 = pd.DataFrame([None])
    print(df)
    print("---------------------------------------------")
    # Dataframe的装置
    print(df.T)
    print("---------------------------------------------")
    # Dataframe的行列索引信息
    print(df.axes)
    print("---------------------------------------------")
    # Dataframe的每列的数据类型
    print(df.dtypes)
    print("---------------------------------------------")
    # Dataframe是否为空 即使元素为None和NaN也不为空
    print(df1.empty)
    print("---------------------------------------------")
    # Dataframe的维度
    print(df.ndim)
    print("---------------------------------------------")
    # Dataframe的形状
    print(df.shape)
    print("---------------------------------------------")
    # Dataframe中所有元素的数量
    print(df.size)
    print("---------------------------------------------")
    # 返回一个ndarray形式的二维数组
    print(df.values)
    print("---------------------------------------------")
    # 返回Dataframe的前n行数据 默认n=5
    print(df.head())
    print("---------------------------------------------")
    # 返回Dataframe的后n行数据 默认n=5
    print(df.tail())

5.常用的统计函数

函数名称	描述说明
count()	统计某个非空值的数量
sum()	求和
mean()	求均值
median()	求中位数
std()	求标准差
min()	求最小值
max()	求最大值
abs()	求绝对值
prod()	求所有数值的乘积

注意：numpy的方差默认为总体方差，pandas默认为样本方差

总体方差：

$\sigma ^2=\frac{1}{N}\prod \sum _{i=1}^N(X_i-\mu )^2$

样本方差：

$\sigma ^2=\frac{1}{N-1}\prod \sum _{i=1}^N(X_i-{\bar{X}} )^2$

分母为n-1的样本方差的期望等于总体的方差，因此样本方差是总体方差的无偏估计。

def pd_df_cel():
    data = {
        'A': [1, 2, 3, 4, None],
        'B': [10, 20, 30, 0, np.NAN],
        'C': [100, 200, 300, 400, 0]
    }
    df = pd.DataFrame(data)
    print(df)
    # 求每列的算术平均数
    print(df.mean())
    # 求每列的中位数
    print(df.median())
    # 求每列的样本方差
    print(df.var())
    # 求每列的样本标准差
    print(df.std())
    # 求每列的最小值
    print(df.min())
    # 求每列最大值
    print(df.max())
    # 求每列所有元素之和
    print(df.sum())
    # 求每列非空元素的数量
    print(df.count())