认识pandas

才不是小emo的小杨

已于 2023-09-23 20:42:10 修改

阅读量1.1k

点赞数 1

分类专栏： pandas 文章标签： pandas

于 2023-09-20 16:57:54 首次发布

本文链接：https://blog.csdn.net/xiaoyang01234/article/details/133078500

版权

pandas 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1 认识pandas

Pandas 是一个开源的第三方 Python 库，从 Numpy 和 Matplotlib 的基础上构建而来，享有数据分析“三剑客之一”的盛名（NumPy、Matplotlib、Pandas）。Pandas 已经成为 Python 数据分析的必备高级工具，它的目标是成为强大、灵活、可以支持任何编程语言的数据分析工具。

1.1 pandas主要特点

Pandas 主要包括以下几个特点：

它提供了一个简单、高效、带有默认标签（也可以自定义标签）的 DataFrame 对象。
能够快速得从不同格式的文件中加载数据（比如 Excel、CSV 、SQL文件），然后将其转换为可处理的对象；
能够按数据的行、列标签进行分组，并对分组后的对象执行聚合和转换操作；
能够很方便地实现数据归一化操作和缺失值处理；
能够很方便地对 DataFrame 的数据列进行增加、修改或者删除的操作；
能够处理不同格式的数据集，比如矩阵数据、异构数据表、时间序列等；
提供了多种处理数据集的方式，比如构建子集、切片、过滤、分组以及重新排序等。

1.2 pandas的优势

与其它语言的数据分析包相比，Pandas 具有以下优势

Pandas 的 DataFrame 和 Series 构建了适用于数据分析的存储结构；
Pandas 简洁的 API 能够让你专注于代码的核心层面；
Pandas 实现了与其他库的集成，比如 Scipy、scikit-learn 和 Matplotlib；

1.3 下载安装

pip install pandas

2 pandas内置数据结构

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

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

2.1 Pandas Series

2.1.1 创建series对象

Pandas 使用 Series() 函数来创建 Series 对象，通过这个对象可以调用相应的方法和属性，从而达到处理数据的目的

import pandas as pd
seriec_obj = pd.Series(data, index, dtype, copy)

# data  输入的数据，可以是列表、常量、ndarray 数组等。
# index 索引值必须是惟一的，如果没有传递索引，则默认为 np.arrange(n)。
# dtype dtype表示数据类型，如果没有提供，则会自动判断得出。
# copy  表示对 data 进行拷贝，默认为 False。

ndarray创建Series对象

arr_one = np.array(['a', 'b', 'c', 'd'])
arr_obj = pd.Series(arr_one, index=('a', 'b', 'c', 'd'))
arr_obj_two = pd.Series(arr_one, index=(1, 2, 3, 4))
print(arr_obj)
print("arr_obj_two为：\n", arr_obj_two)


代码的运行结果为：
a    a
b    b
c    c
d    d
dtype: object
arr_obj_two为：
 1    a
2    b
3    c
4    d
dtype: object

ndarray 是 NumPy 中的数组类型，当 data 是 ndarry 时，传递的索引必须具有与数组相同的长度。假如没有给 index 参数传参，在默认情况下，索引值将使用是 range(n) 生成，其中 n 代表数组长度

上述示例中没有传递任何索引，所以索引默认从 0 开始分配，其索引范围为 0 到len(data)-1，即 0 到 3。这种设置方式被称为“隐式索引”。

“显式索引”的方法定义索引标签

arr_str = np.array(['张三', '李四', '王五', '赵六'])
# 自定义索引标签（即显示索引）
ser_obj = pd.Series(arr_str, index=[1, 2, 3, 4])
print(ser_obj)


代码的运行结果为：
1    张三
2    李四
3    王五
4    赵六
dtype: object

dict创建Series对象

data = {'a': 0., 'b': 1., 'c': 2.}
ser_data = pd.Series(data)
print(ser_data)

代码的运行结果为：
a    0.0
b    1.0
c    2.0
dtype: float64

您可以把 dict 作为输入数据。如果没有传入索引时会按照字典的键来构造索引；反之，当传递了索引时需要将索引标签与字典中的值一一对应

data = {'a': 0., 'b': 1., 'c': 2.}
ser_data = pd.Series(data, index=['b', 'c', 'd', 'a'])
print(ser_data)


代码的运行结果为：
b    1.0
c    2.0
d    NaN
a    0.0
dtype: float64

当传递的索引值无法找到与其对应的值时，使用 NaN（非数字）填充。

标量创建Series对象

ser_data = pd.Series(5, index=[0, 1, 2, 3])
print(ser_data)


代码的运行结果为：
0    5
1    5
2    5
3    5
dtype: int64

2.1.2 访问Series数据

访问 Series 序列中元素，分为两种方式，一种是位置索引访问；另一种是索引标签访问。

位置索引访问

ser_data = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print(ser_data)
print(ser_data[0])  # 位置下标
print(ser_data['a'])  # 标签下标
print(ser_data['b'])


代码的运行结果为：
a    1
b    2
c    3
d    4
e    5
dtype: int64
1
1
2

这种访问方式与 ndarray 和 list 相同，使用元素自身的下标进行访问。我们知道数组的索引计数从 0 开始，这表示第一个元素存储在第 0 个索引位置上，以此类推，就可以获得 Series 序列中的每个元素

通过切片的方式访问 Series 序列中的数据

ser_data = pd.Series([1, 2, 3, 4, 5], index=['a', 'b', 'c', 'd', 'e'])
print(ser_data[:3])
print(ser_data[:7])
print(ser_data[1:3])


代码的运行结果为：
a    1
b    2
c    3
dtype: int64
a    1
b    2
c    3
d    4
e    5
dtype: int64
b    2
c    3
dtype: int64

索引标签访问

Series 类似于固定大小的 dict，把 index 中的索引标签当做 key，而把 Series 序列中的元素值当做 value，然后通过 index 索引标签来访问或者修改元素值。

ser_data = pd.Series([6, 7, 8, 9, 10], index=['a', 'b', 'c', 'd', 'e'])
print(ser_data[['a', 'c', 'd']])

代码的运行结果：
a    6
c    8
d    9
dtype: int64

2.1.3 Series常用属性

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

ser_data = pd.Series(np.array([10, 20, 30, 40, 50]))
print("ser_data:\n", ser_data)

print("axes:\n", ser_data.axes)
print("dtype为:\n", ser_data.dtype)
print("empty:\n", ser_data.empty)
print("ndim:\n", ser_data.ndim)
print("size:\n", ser_data.size)
print("values:\n", ser_data.values)
print("index:\n", ser_data.index)


代码的运行结果为：
ser_data:
 0    10
1    20
2    30
3    40
4    50
dtype: int32
axes:
 [RangeIndex(start=0, stop=5, step=1)]
dtype为:
 int32
empty:
 False
ndim:
 1
size:
 5
values:
 [10 20 30 40 50]
index:
 RangeIndex(start=0, stop=5, step=1)

2.1.4 Series常用方法

2.1.4.1 head()&tail()

如果想要查看 Series 的某一部分数据，可以使用 head() 或者 tail() 方法

ser_data = pd.Series(np.random.randn(5))
print(ser_data)
# 返回前三行数据
print(ser_data.head(3))


代码的运行结果为：
0    1.863595
1   -1.478136
2   -0.632712
3   -0.046976
4    1.435217
dtype: float64
0    1.863595
1   -1.478136
2   -0.632712
dtype: float64

head() 返回前 n 行数据，默认显示前 5 行数据

ser_data = pd.Series(np.array([1, 2, 3, 4, 5, 6, 7]))
print(ser_data.tail)
# 返回后三行数据
print(ser_data.tail(3))


代码的运行结果：
1    2
2    3
3    4
4    5
5    6
6    7
dtype: int32>
4    5
5    6
6    7
dtype: int32

tail() 返回的是后 n 行数据，默认为后 5 行

2.1.4.2 isnull()&nonull()

isnull() 和 nonull() 用于检测 Series 中的缺失值。所谓缺失值，顾名思义就是值不存在、丢失、缺少。
在实际的数据分析任物中，数据的收集往往要经历一个繁琐的过程。在这个过程中难免会因为一些不可抗力，或者人为因素导致数据丢失的现象。这时，我们可以使用相应的方法对缺失值进行处理，比如数据补齐等方法。

# None代表缺失数据
ser_data = pd.Series([1, 2, 5, None])
print(pd.isnull(ser_data))  # 是空值返回True



代码的运行结果为：
0    False
1    False
2    False
3     True
dtype: bool

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

# None代表缺失数据
ser_data = pd.Series([1, 2, 5, None])
print(pd.notnull(ser_data))  # 空值返回False

代码的运行结果为：
0     True
1     True
2     True
3    False
dtype: bool

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

2.2 Pandas DataFrame

DataFrame 是 Pandas 的重要数据结构之一，也是在使用 Pandas 进行数据分析过程中最常用的结构之一，可以这么说，掌握了 DataFrame 的用法，你就拥有了学习数据分析的基本能力。
DataFrame 一个表格型的数据结构，既有行标签（index），又有列标签（columns），它也被称异构数据表，所谓异构，指的是表格中每列的数据类型可以不同，比如可以是字符串、整型或者浮点型等。

url

DataFrame 结构类似于 Execl 的表格型，表格中列标签的含义如下所示：

index	student_id	student_name	student_num
0	1001	James	82.6
1	1002	Pitter	76.5
2	1003	Jack	92.3
3	1004	Alice	88.5

同 Series 一样，DataFrame 自带行标签索引，默认为“隐式索引”即从 0 开始依次递增，行标签与 DataFrame 中的数据项一一对应。上述表格的行标签从 0 到 3，共记录了 4 条数据（图中将行标签省略）。当然你也可以用“显式索引”的方式来设置行标签。

下面对 DataFrame 数据结构的特点做简单地总结，如下所示：

DataFrame 每一列的标签值允许使用不同的数据类型；
DataFrame 是表格型的数据结构，具有行和列；
DataFrame 中的每个数据值都可以被修改。
DataFrame 结构的行数、列数允许增加或者删除；
DataFrame 有两个方向的标签轴，分别是行标签和列标签；
DataFrame 可以对行和列执行算术运算。

2.2.1 创建DataFrame对象

使用下列方式创建一个空的 DataFrame，这是 DataFrame 最基本的创建方法

df = pd.DataFrame()
print(df)

代码的运行结果为：
Empty DataFrame
Columns: []
Index: []

列表创建DataFame对象

data = [1, 2, 3, 4, 5]
df = pd.DataFrame(data)
print(df)

代码的运行结果为：
   0
0  1
1  2
2  3
3  4
4  5

使用嵌套列表创建 DataFrame 对象

data = [['Alex', 10], ['Bob', 12], ['Clarke', 13]]
df = pd.DataFrame(data, columns=['Name', 'Age'])
print(df)

代码的运行结果为：
     Name  Age
0    Alex   10
1     Bob   12
2  Clarke   13

字典嵌套列表创建

data = {'Name': ['Tom', 'Jack', 'Steve', 'Ricky'], 'Age': [28, 34, 29, 42]}
df = pd.DataFrame(data)
print(df)


代码的运行结果为：
    Name  Age
0    Tom   28
1   Jack   34
2  Steve   29
3  Ricky   42

data 字典中，键对应的值的元素长度必须相同（也就是列表长度相同）。如果传递了索引，那么索引的长度应该等于数组的长度；如果没有传递索引，那么默认情况下，索引将是 range(n)，其中 n 代表数组长度。

添加自定义的行标签

data = {'Name': ['Tom', 'Jack', 'Steve', 'Ricky'], 'Age': [28, 34, 29, 42]}
df = pd.DataFrame(data, index=['rank1', 'rank2', 'rank3', 'rank4'])
print(df)

代码的运行结果为：
        Name  Age
rank1    Tom   28
rank2   Jack   34
rank3  Steve   29
rank4  Ricky   42

列表嵌套字典创建DataFrame对象

data = [{'num': 1, 'result': 2}, {'num': 5, 'result': 10, 'number': 20}]
df = pd.DataFrame(data, index=['first', 'second'])
print(df)

代码的运行结果为：
        num  result  number
first     1       2     NaN
second    5      10    20.0

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

使用字典嵌套列表以及行、列索引表创建一个 DataFrame 对象。

data = [{'a': 1, 'b': 2}, {'a': 5, 'b': 10, 'c': 20}]
df1 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b'])
df2 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'b1'])
df3 = pd.DataFrame(data, index=['first', 'second'], columns=['a', 'c'])
print("df1为：\n", df1)
print("df2为:\n", df2)
print("df3为：\n",df3)


代码的运行结果为：
df1为：
         a   b
first   1   2
second  5  10
df2为:
         a  b1
first   1 NaN
second  5 NaN
df3为：
         a     c
first   1   NaN
second  5  20.0

Series创建DataFrame对象

传递一个字典形式的 Series，从而创建一个 DataFrame 对象，其输出结果的行索引是所有 index 的合集

dict_data = {
    'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
    'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
print(df)


代码的运行结果为：
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4

2.2.2 列索引操作DataFrame

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

列索引选取数据列

dict_data = {
    'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
    'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
print(df['one'])


代码的运行结果为：
a    1.0
b    2.0
c    3.0
d    NaN
Name: one, dtype: float64

列索引添加数据列

dict_data = {
   'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
# 使用df['列']=值，插入新的数据列
df['three'] = pd.Series([10, 20, 30], index=['a', 'b', 'c'])
print(df)
# 将已经存在的数据列做相加运算
df['four'] = df['one'] + df['three']
print(df)


代码的运行结果为：
   one  two  three
a  1.0    1   10.0
b  2.0    2   20.0
c  3.0    3   30.0
d  NaN    4    NaN
   one  two  three  four
a  1.0    1   10.0  11.0
b  2.0    2   20.0  22.0
c  3.0    3   30.0  33.0
d  NaN    4    NaN   NaN

除了使用df[]=value的方式外，您还可以使用 insert() 方法插入新的列

info = [['Jack', 18], ['Helen', 19], ['John', 17]]
df = pd.DataFrame(info, columns=['name', 'age'])
print(df)
# 注意是column参数
# 数值1代表插入到columns列表的索引位置
df.insert(1, column='score', value=[91, 90, 75])
print(df)


代码的运行结果为：
    name  age
0   Jack   18
1  Helen   19
2   John   17
    name  score  age
0   Jack     91   18
1  Helen     90   19
2   John     75   17

这里需要注意的是使用insert函数的时候，传入的value值，传入的数据一定要与原数据列表的数量相同！！！
列索引删除数据列

通过 del 和 pop() 都能够删除 DataFrame 中的数据列

2.2.3 行索引操作DataFrame

理解了上述的列索引操作后，行索引操作就变的简单。下面看一下，如何使用行索引来选取 DataFrame 中的数据。

标签索引选取

可以将行标签传递给 loc 函数，来选取数据

dict_data = {
    'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
    'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
print(df)
print(df.loc[..., "one"])
print(df.loc['b', 'one'])

代码的运行结果为：
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4
a    1.0
b    2.0
c    3.0
d    NaN
Name: one, dtype: float64
2.0

整数索引选取

通过将数据行所在的索引位置传递给 iloc 函数，也可以实现数据行选取

dict_data = {
    'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
    'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
print(df)
print(df.iloc[2])
print(df.iloc[1, :])


代码的运行结果为：
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4
one    3.0
two    3.0
Name: c, dtype: float64
one    2.0
two    2.0
Name: b, dtype: float64

切片操作多行选取

可以使用切片的方式同时选取多行

dict_data = {
   'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']),
   'two': pd.Series([1, 2, 3, 4], index=['a', 'b', 'c', 'd'])
}
df = pd.DataFrame(dict_data)
print(df)
# 左闭右开
print(df[2:4])

代码的运行结果为：
   one  two
a  1.0    1
b  2.0    2
c  3.0    3
d  NaN    4
   one  two
c  3.0    3
d  NaN    4

添加数据行

使用 append() 函数，可以将新的数据行添加到 DataFrame 中，该函数会在行末追加数据行

df = pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=['a', 'b'])
print("df\n", df)
print("df2\n", df2)
# 在行末追加新数据行
df = df._append(df2)
print(df)


代码的运行结果为：
df
    a  b
0  1  2
1  3  4
df2
    a  b
0  5  6
1  7  8
   a  b
0  1  2
1  3  4
0  5  6
1  7  8

删除数据行

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

df = pd.DataFrame([[1, 2], [3, 4]], columns=['a', 'b'])
df2 = pd.DataFrame([[5, 6], [7, 8]], columns=['a', 'b'])
df = df._append(df2)

print(df)
# 注意此处调用了drop()方法

df = df.drop(0)
print(df)


代码的运行结果为：
   a  b
0  1  2
1  3  4
0  5  6
1  7  8
   a  b
1  3  4
1  7  8

2.2.4 DataFrame切片

直接使用中括号时：
- 索引优先对列进行操作
- 切片优先对行进行操作

dict_data = pd.DataFrame(
    data=np.random.randint(60, 90, size=(5, 6)),
    index=['张三', '李四', '王五', '赵六', '坤哥'],
    columns=["语文", "数学", "英语", "地理", "历史", "化学"]
)
print(dict_data)
# 行切片
print(dict_data[1:3])
print(dict_data["张三":"赵六"])
# 列切片
# 对列作切片，也必须先对行做切片
print(dict_data.iloc[:, 1:4])
print(dict_data.loc[:, "数学":"化学"])
# 对行和列作切片操作
print(dict_data.iloc[1:3, 1:4])
print(dict_data.loc["张三":"王五", "语文":"历史"])


代码的运行结果为：
    语文  数学  英语  地理  历史  化学
张三  70  70  78  82  83  81
李四  69  64  74  72  76  70
王五  69  76  69  76  66  83
赵六  88  88  69  76  60  70
坤哥  65  74  84  79  60  72
    语文  数学  英语  地理  历史  化学
李四  69  64  74  72  76  70
王五  69  76  69  76  66  83
    语文  数学  英语  地理  历史  化学
张三  70  70  78  82  83  81
李四  69  64  74  72  76  70
王五  69  76  69  76  66  83
赵六  88  88  69  76  60  70
    数学  英语  地理
张三  70  78  82
李四  64  74  72
王五  76  69  76
赵六  88  69  76
坤哥  74  84  79
    数学  英语  地理  历史  化学
张三  70  78  82  83  81
李四  64  74  72  76  70
王五  76  69  76  66  83
赵六  88  69  76  60  70
坤哥  74  84  79  60  72
    数学  英语  地理
李四  64  74  72
王五  76  69  76
    语文  数学  英语  地理  历史
张三  70  70  78  82  83
李四  69  64  74  72  76
王五  69  76  69  76  66

Process finished with exit code 0

3 常用属性和方法汇总

DataFrame 的属性和方法，与 Series 相差无几

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

dict_data = {
    'Name': pd.Series(['张三', '李四', "王五", '赵六', '坤哥', '凡凡', '峰峰']),
    'age': pd.Series([25, 26, 25, 28, 23, 29, 23]),
    'Height': pd.Series([174.23, 173.24, 173.98, 172.56, 183.20, 174.6, 183.8])
}
# 构建DataFrame
df = pd.DataFrame(dict_data)
# 输出series
print(df)
print("-*-" * 30)
# 输出DataFrame的转置,也就是把行和列进行交换
print(df.T)

print("-*-" * 30)
# 返回一个行标签、列标签组成的列表
print(df.axes)

print("-*-" * 30)
# 输出行、列标签类型
print(df.dtypes)

print("-*-" * 30)
# 判断输入数据是否为空，若为 True 表示对象为空
print("empty:\n", df.empty)

print("-*-" * 30)
# 返回数据对象的维数。DataFrame 是一个二维数据结构
print(df.ndim)

print("-*-" * 30)
# DataFrame的形状
print(df.shape)

print("-*-" * 30)
# DataFrame的中元素个数
print(df.size)

print("-*-" * 30)
# DataFrame的数据
print(df.values)

print("-*-" * 30)
# 获取前3行数据
print(df.head(3))

print("-*-" * 30)
# 获取后2行数据
print(df.tail(2))


代码的运行结果为：
  Name  age  Height
0   张三   25  174.23
1   李四   26  173.24
2   王五   25  173.98
3   赵六   28  172.56
4   坤哥   23  183.20
5   凡凡   29  174.60
6   峰峰   23  183.80
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
             0       1       2       3      4      5      6
Name        张三      李四      王五      赵六     坤哥     凡凡     峰峰
age         25      26      25      28     23     29     23
Height  174.23  173.24  173.98  172.56  183.2  174.6  183.8
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
[RangeIndex(start=0, stop=7, step=1), Index(['Name', 'age', 'Height'], dtype='object')]
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
Name       object
age         int64
Height    float64
dtype: object
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
empty:
 False
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
2
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
(7, 3)
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
21
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
[['张三' 25 174.23]
 ['李四' 26 173.24]
 ['王五' 25 173.98]
 ['赵六' 28 172.56]
 ['坤哥' 23 183.2]
 ['凡凡' 29 174.6]
 ['峰峰' 23 183.8]]
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
  Name  age  Height
0   张三   25  174.23
1   李四   26  173.24
2   王五   25  173.98
-*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*--*-
  Name  age  Height
5   凡凡   29   174.6
6   峰峰   23   183.8

shift()移动行或列

如果您想要移动 DataFrame 中的某一行/列，可以使用 shift() 函数实现。它提供了一个periods参数，该参数表示在特定的轴上移动指定的步幅。

DataFrame.shift(periods=1, freq=None, axis=0)

# peroids   类型为int，表示移动的幅度，可以是正数，也可以是负数，默认值为1。
# freq  日期偏移量，默认值为None，适用于时间序。取值为符合时间规则的字符串。
# axis  如果是 0 或者 "index" 表示上下移动，如果是 1 或者 "columns" 则会左右移动。
# fill_value    该参数用来填充缺失值。

该函数的返回值是移动后的 DataFrame 副本

df = pd.DataFrame({
    'a_data': [40, 28, 39, 32, 18],
    'b_data': [20, 37, 41, 35, 45],
    'c_data': [22, 17, 11, 25, 15]})
# 移动幅度为3
print(df)
new_df = df.shift(periods=1)
print(new_df)
print(df)


代码的运行结果为：
   a_data  b_data  c_data
0      40      20      22
1      28      37      17
2      39      41      11
3      32      35      25
4      18      45      15
   a_data  b_data  c_data
0     NaN     NaN     NaN
1    40.0    20.0    22.0
2    28.0    37.0    17.0
3    39.0    41.0    11.0
4    32.0    35.0    25.0
   a_data  b_data  c_data
0      40      20      22
1      28      37      17
2      39      41      11
3      32      35      25
4      18      45      15

切记这里的shift,返回的是一个副本就类似于python中的深拷贝。shift函数在偏移数据时，并不会使原有的数据消失，而是将其移动到新的位置，并用NaN值填充原来的位置。

使用 fill_value 参数填充 DataFrame 中的缺失值

df = pd.DataFrame({
 'a_data': [40, 28, 39, 32, 18],
 'b_data': [20, 37, 41, 35, 45],
 'c_data': [22, 17, 11, 25, 15]})
# 移动幅度为3
print(df)
new_df = df.shift(periods=3, axis="index", fill_value=100)
print(new_df)


代码的运行结果为：
   a_data  b_data  c_data
0      40      20      22
1      28      37      17
2      39      41      11
3      32      35      25
4      18      45      15
   a_data  b_data  c_data
0     100     100     100
1     100     100     100
2     100     100     100
3      40      20      22