从0开始学python-day14-pandas1

一、基础

1、概述

• Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来

• Pandas 名字衍生自术语 "panel data"（面板数据）和 "Python data analysis"（Python 数据分析）

• Pandas 是一个开放源码、BSD 许可的库，提供高性能、易于使用的数据结构和数据分析工具

• Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据

• Pandas 的出现使得 Python 做数据分析的能力得到了大幅度提升，它主要实现了数据分析的五个重要环节：加载数据、整理数据、操作数据、构建数据模型、分析数据

2、安装

在Anaconda Prompt下：

conda activate python-basic

pip install pandas -i https://pypi.tuna.tsinghua.edu.cn/simple/
pip list

3、内置数据结构

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

• Series 是带标签的一维数组，标签可以理解为索引，这个索引并不局限于整数，它也可以是字符类型，比如 a、b、c 等

• DataFrame 是一种表格型数据结构，它既有行标签，又有列标签

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

4、Series

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

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

结构图：

• 0、1、2 表示行索引

• 李四、王五、张三表示数据值

• dtype 表示数据值的类型

4.1 创建 Series 对象的方式

4.1.1 创建 Series 空对象

import pandas as pd
​
# Series 空对象
def one():series_one = pd.Series(dtype='f8')print('空对象：\n', series_one)

直接赋值创建Series 对象

series_one = pd.Series([1,2,3,4,5], dtype='f8')
print('Series对象：\n', series_one)

4.1.2 ndarray 创建 Series 对象

import pandas as pd
import numpy as np
​
# ndarray 创建 Series 对象
def two():array_one = np.array(['小明','小红','小紫'])index = np.arange(3)series_one = pd.Series(data=array_one, index=index)print('ndarray 创建 Series 对象：')print(series_one)

4.1.3 字典创建 Series 对象

import pandas as pd
​
# 字典创建 Series 对象
def three():data = {"name":"陈蕾","gender":"男"}result = pd.Series(data=data)print('字典创建 Series 对象：')print(result)

4.1.4 标量创建 Series 对象

# 标量创建 Series 对象
def four():result = pd.Series(data=5,index=[1,2,3,4,5])print('标量创建 Series 对象：')print(result)

4.2 访问 Series 数据

import pandas as pd
​
def five():data = {"name": "陈蕾", "gender": "男"}result = pd.Series(data=data)print(result["name"])print(result[1])

4.3 Series 常用属性

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

案例：

import pandas as pd
​
def six():result = pd.Series(['a','b','c','d','e'])print("以列表的形式返回所有行索引标签：",result.axes)print("返回对象的数据类型：",result.dtype)print("返回一个布尔值，用于判断数据对象是否为空",result.empty)print("返回输入数据的维数：",result.ndim)print("返回输入数据的元素数量：",result.size)print("以 ndarray 的形式返回 Series 对象：",result.values)print("返回一个 RangeIndex 对象，用来描述索引的取值范围：",result.index)

输出：

以列表的形式返回所有行索引标签： [RangeIndex(start=0, stop=5, step=1)]
返回对象的数据类型： object
返回一个布尔值，用于判断数据对象是否为空： False
返回输入数据的维数： 1
返回输入数据的元素数量： 5
以 ndarray 的形式返回 Series 对象： ['a' 'b' 'c' 'd' 'e']
返回一个 RangeIndex 对象，用来描述索引的取值范围： RangeIndex(start=0, stop=5, step=1)

import pandas as pd
import numpy as np
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],index=['a','b','c'])print(s2)print(s2['a'])print(s2[1])#会弹警告，这种方法已经过时了
​#根据ndarray创建Series对象arr=np.array([1,2,3,4])s3=pd.Series(arr)print(s3)
​#根据字典创建Series对象dic={'name':'zhangsan','age':20,'sex':0}s4=pd.Series(dic)print(s4)
​#通过标量创建Series对象，如果不指定index，则创建一行，如果指定index，则按照index的数量创建行，每行的值都是标量值s5=pd.Series(5,index=[0,1,2,3,4,5])print(s5)if __name__=='__main__':pd_series()
​
def pd_series_attr():s=pd.Series(['a','b','c','d','e'])#获取series对象的索引信息print(s.axes)#获取数据类型print(s.dtype)#判断series对象是否为空print(s.empty)#获取数组维度print(s.ndim)#获取series对象中的元素个数print(s.size)#获取series对象的值，返回一个ndarray的数组print(s.values)#numpy里面的数组没有逗号['a' 'b' 'c' 'd' 'e']#获取索引信息print(s.index)
​
if __name__=='__main__':d_series_attr()

4.4 Series 常用方法

4.4.1 head() 和 tail()

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

案例：

import pandas as pd
​
# head() 返回前 n 行数据，默认显示前 5 行数据，tail() 返回后 n 行数据，默认为后 5 行
def seven():result = pd.Series(['a','b','c','d','e','f'])print("head() 返回前 5 行数据：")print(result.head())print("tail() 返回后 5 行数据：")print(result.tail())

def pd_series_func():s=pd.Series(['a','b','c','d','e','f',None])print(s)#获取series对象前n行数据，默认n=5print(s.head())#默认前5行print(s.head(3))# 获取series对象后n行数据，默认n=5print(s.tail())#默认后5行print(s.tail(2))#None会被取到
​#判断series对象中的元素是否为None，是则为True，否-则为Falseprint(s.isnull())#True是为空的#notnull判断series对象中的元素是否不为None，是则为True，否-则为Falseprint(s.notnull())#True是为不空的#根据判断条件过滤元素print(s[s.notnull()])#不为空的布尔索引
#3.4.5.6相对常用
if __name__=='__main__':pd_series_func()

4.4.2 isnull() 和 nonull()

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

• isnull()：如果为值不存在或者缺失，则返回 True

• notnull()：如果值不存在或者缺失，则返回 False

案例：

import pandas as pd
​
'''isnull() 和 nonull() 用于检测 Series 中的缺失值isnull()：如果为值不存在或者缺失，则返回 Truenotnull()：如果值不存在或者缺失，则返回 False
'''
def eight():result = pd.Series(['a','b','c','d','e','f',None])print("isnull()如果为值不存在或者缺失，则返回 True：")print(result.isnull())print("notnull()如果值不存在或者缺失，则返回 False：")print(result.notnull())#过滤掉缺失值print(result[result.notnull()])

5、DataFrame

• DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。其结构图示意图，如下所示：

• DataFrame 的每一列数据都可以看成一个 Series 结构，只不过，DataFrame 为这些行中每个数据值增加了一个列标签

• 同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应当然你也可以用“显式索引”的方式来设置行标签

• DataFrame 构造方法如下：

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

5.1 创建 DataFrame 对象

创建 DataFrame 对象的方式：

• 列表

• 字典

• Series

• Numpy ndarrays

• 另一个 DataFrame

5.1.1 创建 DataFrame 空对象

import pandas as pd
​
# 创建 DataFrame 空对象
def one():result = pd.DataFrame()print(result)

5.1.2 列表创建 DataFrame 对象

案例：

import pandas as pd
​
# 列表创建 DataFrame 对象
def three():data = ['小明','小红','小紫']column = ['name']result = pd.DataFrame(data=data,columns=column)print(result)

5.1.2 列表嵌套列表创建 DataFrame 对象

案例：

import pandas as pd
​
# 列表创建 DataFrame 对象
def three():data = [['小米', 18], ['小红', 19], ['小紫', 20]]result = pd.DataFrame(data=data,columns=['name','age'])print(result)

5.1.3 列表嵌套字典创建 DataFrame 对象

案例：如果其中某个元素值缺失，也就是字典的 key 无法找到对应的 value，将使用 NaN 代替。

import pandas as pd
​
# 列表嵌套字典创建 DataFrame 对象
def four():data = [{'name': "张三", 'age': 18},{'name': "小红", 'gender': "男", 'age': 19}]result = pd.DataFrame(data=data)print(result)

5.1.4 字典创建 DataFrame 对象

案例：

import pandas as pd
​
# 典创建 DataFrame 对象
def five():data = {"name":['小米','小红','小紫'],"age":[18,19,20]}result = pd.DataFrame(data=data)print(result)

5.1.5 字典嵌套列表创建一个 DataFrame 对象

案例：如果键 key 在字典键中不存在，对应值为 NaN。

import pandas as pd
​
# 字典嵌套列表创建一个 DataFrame 对象
def six():data = [{'name': "张三", 'age': 18},{'name': "小红", 'gender': "男", 'age': 19}]result = pd.DataFrame(data=data,index=['one','two'],columns=['name','age'])result1 = pd.DataFrame(data=data,index=['one','two'],columns=['name','gender'])print(result)print(result1)

5.1.6 Series 创建 DataFrame 对象

案例：对于 one 列而言，此处虽然显示了行索引 'd'，但由于没有与其对应的值，所以它的值为 NaN。

import pandas as pd
​
# Series 创建 DataFrame 对象
def seven():data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}result = pd.DataFrame(data=data)print(result)

第一列Series比第二列少一个元素，则以NaN填充，数据类型转换为float

def pd_df():#1.创建Dataframe空对象df=pd.DataFrame()print(df)#2.通过一维数组创建Dataframe对象df1=pd.DataFrame(['zhangsan','lisi','wangwu'])print(df1)#通过columns指定列名df2 = pd.DataFrame(['zhangsan', 'lisi', 'wangwu'],columns=['name'])print(df2)#3.通过二维数组创建Dataframe对象df3=pd.DataFrame([['zhangsan',20],['lisi',21],['wangwu',22]],columns=['name','age'])print(df3)#4.通过数组嵌套字典（json）创建Dataframe对象arr=[{'name':'zhangsan','age':'20'},{'name':'lisi','age':'21','sex':1}]df4=pd.DataFrame(data=arr)print(df4)#NaN:not a number#5.通过字典创建，字典中每个key对应的value是一维数组dic={'name':['zhangsan','lisi','wangwu'],'age':[20,21,22]}df5=pd.DataFrame(dic)print(df5)#6.通过字典和Series创建，字典中每个key对应一个Series对象dic1={'one':pd.Series([1,2,3]),'two':pd.Series([4,5,6,7])}df6=pd.DataFrame(dic1)print(df6)if __name__=='__main__':pd_df()

5.2 列索引操作

DataFrame 可以使用列索（columns index）引来完成数据的选取、添加和删除操作

5.2.1 选取数据

import pandas as pd
​
# 选取数据
def eight():data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}result = pd.DataFrame(data=data)print(result)print(result['one'])

5.2.2 添加数据

案例1：添加新列

import pandas as pd
​
# 添加数据
def nine():data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}result = pd.DataFrame(data=data)result['three'] = pd.Series(data=[11, 22, 33], index=['a', 'b', 'c'])print("使用 df['列'] = 值，插入新的数据列：")print(result)

案例2：在指定的位置插入新列

使用insert方法在指定位置插入新列，参数：

• loc: 插入位置的列索引。

• column: 新列的名称。

• value: 要插入的 Series。

# 创建一个 DataFrame
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'])
​
# 使用 insert 方法在位置 1 插入新列 'D'
df.insert(1, 'D', [13, 14, 15, 16])
​
print("插入新列后的 DataFrame:")
print(df)

5.2.3 修改数据

import pandas as pd
​
# 修改数据
def ten():data = {'one': pd.Series(data=[1, 2, 3], index=['a', 'b', 'c']),'two': pd.Series(data=[1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}result = pd.DataFrame(data=data)print(result)result['two'] = pd.Series(data=[1,2,3],index=['a','b','c'])print("修改数据：")print(result)

5.2.4 删除数据

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

语法：

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

参数：

1. labels：

   • 类型：单个标签或列表。

   • 描述：要删除的行或列的标签。如果 axis=0，则 labels 表示行标签；如果 axis=1，则 labels 表示列标签。

2. axis：

   • 类型：整数或字符串，默认为 0。

   • 描述：指定删除的方向。axis=0 或 axis='index' 表示删除行，axis=1 或 axis='columns' 表示删除列。

3. index：

   • 类型：单个标签或列表，默认为 None。

   • 描述：要删除的行的标签。如果指定，则忽略 labels 参数。

4. columns：

   • 类型：单个标签或列表，默认为 None。

   • 描述：要删除的列的标签。如果指定，则忽略 labels 参数。

5. level：

   • 类型：整数或级别名称，默认为 None。

   • 描述：用于多级索引（MultiIndex），指定要删除的级别。

6. inplace：

   • 类型：布尔值，默认为 False。

   • 描述：如果为 True，则直接修改原 DataFrame，而不是返回一个新的 DataFrame。

7. errors：

   • 类型：字符串，默认为 'raise'。

   • 描述：指定如何处理不存在的标签。'raise' 表示抛出错误，'ignore' 表示忽略错误。

案例1：删除列

import pandas as pd
​
result = pd.DataFrame()
result['one'] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
result['two'] = pd.Series([5, 6, 7, 8], index=['a', 'b', 'c', 'd'])
print(result)
​
result1 = result.drop(['one'],axis=1)
print(result1)

案例2：删除行

result = pd.DataFrame()
result['one'] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
result['two'] = pd.Series([5, 6, 7, 8], index=['a', 'b', 'c', 'd'])
print(result)
​
result1 = result.drop(['a'],axis=0)
print(result1)

案例3：直接删除原DataFrame和行或列

result = pd.DataFrame()
result['one'] = pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
result['two'] = pd.Series([5, 6, 7, 8], index=['a', 'b', 'c', 'd'])
print(result)
​
result.drop(['a'], axis=0, inplace=True)
print(result)

def pd_df_col():df=pd.DataFrame({'name':['zhangsan','lisi','wangwu'],'age':[20,21,22]})namelist=df['name']print(namelist)
​agelist = list(df['age'])print(agelist)#向df添加新列，可以用列表、ndarray、series添加#列表和ndarray添加的时候，行数要和源df中数据行数一致，series的行数不一致，缺省的值自动补为NaNdf['address']=['四川省','重庆市','陕西省']#不能少写df['id'] = np.array([1, 2, 3])#不能少写df['sex']=pd.Series([1,0])#少写会自动补充NaNprint(df)#insert:在指定列插入一列数据#loc：指定列的索引值#column：要插入新列的列名#value：要插入的列值df.insert(1,'password',pd.Series([111,111,111]))print(df)#修改某一列的值df['password']=pd.Series([123,123,123])print(df)
​#drop:删除列#labels：要删除的列（行）标签#axis：轴，axis=0：按行删除；axis=1：按列删除#inplace：是否在源Dataframe上删除，为True则在源Dataframe上删除，为False则返回一个新的Dataframe，源Dataframe不受影响，默认为Falsedeleted_df = df.drop(labels=['id'], axis=1)#inplace=True,直接修改原dataframeprint(f"deleted_df:{deleted_df}")print(f"df:{df}")
​del_df = df.drop(labels=['id'], axis=1, inplace=True)  # inplace=True,直接修改原dataframeprint(f"del_df:{del_df}")#del_df为空print(f"df:{df}")if __name__=='__main__':pd_df_col()

5.3 行索引操作

5.3.1 loc 选取数据

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

loc方法返回的数据类型：

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

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

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

语法：

DataFrame.loc[row_indexer, column_indexer]

参数：

• row_indexer：行标签或布尔数组。

• column_indexer：列标签或布尔数组。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
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'])
​
# 使用 loc 选择数据
print(df.loc['a'])  # 选择行标签为 'a' 的行
print(df.loc['a':'c'])  # 选择行标签从 'a' 到 'c' 的行
print(df.loc['a', 'B'])  # 选择行标签为 'a'，列标签为 'B' 的元素
print(df.loc[['a', 'c'], ['A', 'C']])  # 选择行标签为 'a' 和 'c'，列标签为 'A' 和 'C' 的数据

5.3.2 iloc 选取数据

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

语法：

DataFrame.iloc[row_indexer, column_indexer]

参数：

• row_indexer：行位置或布尔数组。

• column_indexer：列位置或布尔数组。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
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'])
​
# 使用 iloc 选择数据
print(df.iloc[0])  # 选择第 0 行的数据
print(df.iloc[0:2])  # 选择第 0 到 1 行的数据
print(df.iloc[0, 1])  # 选择第 0 行，第 1 列的元素
print(df.iloc[[0, 2], [0, 2]])  # 选择第 0 和 2 行，第 0 和 2 列的数据

5.3.3 切片多行选取

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

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
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'])
​
# 使用 df[0:2] 选择前两行
result = df[0:2]
print(type(result))  # 输出: <class 'pandas.core.frame.DataFrame'>
print(result)

切片获取行和通过iloc方法获取行从结果上没有区别，切片是基于位置的切片操作，iloc是基于位置的索引操作。

5.3.4 添加数据行

append() 方法用于将一个 Series 或 DataFrame 追加到另一个 DataFrame 的末尾。（pandas 1.4版本后已经弃用）

语法：

DataFrame.append(other, ignore_index=False, verify_integrity=False, sort=False)

参数：

1. other：

   • 类型：Series 或 DataFrame。

   • 描述：要追加的数据。

2. ignore_index：

   • 类型：布尔值，默认为 False。

   • 描述：如果为 True，则忽略原 DataFrame 的索引，并生成新的整数索引，索引值默认从0开始。

3. verify_integrity：

   • 类型：布尔值，默认为 False。

   • 描述：如果为 True，则在创建具有重复索引的 DataFrame 时引发 ValueError。

4. sort：

   • 类型：布尔值，默认为 False。

   • 描述：如果为 True，则在追加之前对列进行排序。

案例：

import pandas as pd
​
# 创建一个示例 DataFrame
data = {'A': [1, 2, 3],'B': [4, 5, 6]
}
df = pd.DataFrame(data, index=['a', 'b', 'c'])
​
# 创建一个示例 Series
new_row = pd.Series({'A': 7, 'B': 8}, name='d')
​
# 使用 append 追加 Series
df = df.append(new_row)
​
print(df)
​
# 创建另一个示例 DataFrame
new_data = {'A': [9, 10],'B': [11, 12]
}
new_df = pd.DataFrame(new_data, index=['e', 'f'])
​
# 使用 append 追加 DataFrame
df = df.append(new_df)
​
print(df)

案例2：添加新行

使用loc方法添加新行

# 创建一个 DataFrame
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'])
​
# 添加新行 'e'
df.loc['e'] = [17, 18, 19, 20]
​
print("添加新行后的 DataFrame:")
print(df)

5.3.5 删除数据行

您可以使用行索引标签，从 DataFrame 中删除某一行数据。如果索引标签存在重复，那么它们将被一起删除。使用的是 drop 函数

案例：

import pandas as pd# 删除数据行
def sixteen():data = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])}result = pd.DataFrame(data=data)print("原数据：")print(result)print("drop 函数删除值：", )result2 = result.drop('a')print(result2)

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中的行或列，如果获取一行或一列则返回Series对象，如果获取到多行多列则返回Dataframe对象#根据索引标签获取a行的数据，返回结果是Series对象print(df.loc['a'])#单行是Series#通过切片的方式获取a行到c行的数据，返回结果是Dataframe,切片范围是左闭右闭区间print(df.loc['a':'c'])#多行是Dataframe#获取a行和B列对应的数据，返回结果是一个数值print(df.loc['a','B'])#根据a行c行和A列C列获取对应的数据，返回结果是Dataframeprint(df.loc[['a','c'],['A','C']])#loc方法不能使用行所在位置的索引进行获取#print(df.loc[0]) 不能用
​#iloc:根据行所在的位置进行获取，不能通过行或列索引标签来获取数据#print(df.iloc['a'])#获取行索引位置为0的行数据print(df.iloc[0])#通过切片获取索引位置为0-2的行数据，切片的取值范围是左闭右开区间print(df.iloc[0:2])#通过行索引位置和列索引位置获取对应的数据，返回的是一个数值print(df.iloc[0,1])#通过多个行索引位置和多个列索引位置获取对应的数据print(df.iloc[[0,2],[0,2]])
​#直接通过切片获取多行数据，切片取值范围是左闭右开区间print(df[0:2])
​
​
# def pd_df_row_append():
#     # append：待验证
#     data = {'A': [1, 2, 3], 'B': [4, 5, 6]}
#     df = pd.DataFrame(data, index=['a', 'b', 'c'])
#
#     s = pd.Series([7, 8],name='d')
#     df1=df._append(s)
#     print(df1)
if __name__=='__main__':pd_df_row()​
def pd_df_row_append():data = {'A': [1, 2, 3], 'B': [4, 5, 6]}df = pd.DataFrame(data, index=['a', 'b', 'c'])df.loc['d']=[7,8]print(df)
​#print(df.index.size)# idx=df.index.size+1# df.iloc[idx]=[9,10]# print(df)
​#drop:删除行，axis默认为0，即按行删除#根据行标签删除行数据，然后返回新的Dataframedf1 = df.drop(['d'])print(df1)#生成新的Dataframe#inolace为True表示在原Dataframe上删除行df.drop(['d'],inplace=True)#在源Dataframe上进行删除print(df)if __name__=='__main__':pd-df_row_append()

5.4 常用属性和方法

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

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

案例：

data = {"A": [1, 2, 3, 4], "B": [5, 6, 7, 8]}
df = pd.DataFrame(data=data, index=['a', 'b', 'c', 'd'])
print(df.T)
print(df.axes)
print(df.dtypes)
print(df.empty)
print(df.ndim)
print(df.shape)
print(df.size)
print(df.values)
print(df.head(3))
print(df.tail(3))

​
​
def pd_df_attr():df=pd.DataFrame({'A':[1,2,3,4,5,6],'B':[7,8,9,10,11,12]})print(df)print('----------')#DataFrame转置print(df.T)print('----------')# DataFrame的行、列索引信息print(df.axis)print('----------')# DataFrame每列的数据类型print(df.dtypes)print('----------')# 判断DataFrame是否为空，DataFrame中的元素为None或NaN，也认为不为空df1 = pd.DataFrame()#Truedf1=pd.DataFrame([np.nan])#Falsedf1 = pd.DataFrame([None])#Falseprint(df1.empty)print('----------')#DataFrame的维度print(df.ndim)print('----------')# DataFrame的形状print(df.shape)print('----------')# DataFrame中所有元素的数量print(df.size)print('----------')#返回ndarray的数组，二维数组print(df.values)#2维数组print('----------')# 返回DataFrame的前n行数据，默认n=5print(df.head())print('----------')# 返回DataFrame的后n行数据，默认n=5print(df.tail())print('----------')if __name__=='__main__':pd_df_attr()

二、函数

1、常用的统计学函数

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

案例：

# 创建一个示例 DataFrame
data = {'A': [1, 2, 3, 4, 5],'B': [10, 20, 30, 40, 50],'C': [100, 200, 300, 400, 500]
}
df = pd.DataFrame(data)
​
# 计算每列的均值
mean_values = df.mean()
print(mean_values)
​
# 计算每列的中位数
median_values = df.median()
print(median_values)
​
#计算每列的方差
var_values = df.var()
print(var_values)
​
# 计算每列的标准差
std_values = df.std()
print(std_values)
​
# 计算每列的最小值
min_values = df.min()
print("最小值:")
print(min_values)
​
# 计算每列的最大值
max_values = df.max()
print("最大值:")
print(max_values)
​
# 计算每列的总和
sum_values = df.sum()
print(sum_values)
​
# 计算每列的非空值数量
count_values = df.count()
print(count_values)

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

总体方差：

$$
σ^2=\dfrac{1}{N}∑_{i=1}^N(X_i−μ)^2
$$

样本方差：

$$
s^2=\dfrac{1}{N-1}∑_{i=1}^N(X_i−\overline X)^2
$$

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

import pandas as pd
import numpy as np
​
def pd_df_cal():data={'A':[1,2,3,4,5],'B':[10,20,30,40,50],'C':[100,200,300,400,500]}df=pd.DataFrame(data)#求每列的算术平均数print(df.mean())# df['mean']=df.groupby(A).transform('mean')# print(df,'----')#求每列的中位数print(df.median())#求每列的样本方差print(df.var())#求每列的标准方差print(df.std())#求每列的最小值print(df.min())#求每列的最大值print(df.max())#求每列所有元素之和print(df.sum())#求每列非0元素的数量print(df.count())#非零元素的个数
​
​
if __name__=='__main__':pd_df_cal()