Python数据分析之Pandas核心使用进阶

DateFrame 行级遍历的两种方法

在Pandas中，有两种常见的方法可以进行DataFrame的行级遍历：使用iterrows()和使用iteritems()。

1. 使用iterrows()方法： iterrows()方法返回一个迭代器，可以按行遍历DataFrame。每次迭代返回一个包含行索引和该行数据的元组。

import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'Name': ['Alice', 'Bob', 'Charlie'],
                   'Age': [25, 30, 35],
                   'City': ['New York', 'London', 'Paris']})

# 使用iterrows()方法遍历DataFrame
for index, row in df.iterrows():
    print(f"Row index: {index}")
    print(f"Row data:\n{row}")
    print("----------")

输出结果为：

Row index: 0
Row data:
Name         Alice
Age             25
City     New York
Name: 0, dtype: object
----------
Row index: 1
Row data:
Name        Bob
Age          30
City     London
Name: 1, dtype: object
----------
Row index: 2
Row data:
Name    Charlie
Age          35
City       Paris
Name: 2, dtype: object
----------

在上面的例子中，我们使用iterrows()方法遍历了DataFrame对象df的每一行。在每次迭代中，我们可以通过index获取行索引，通过row获取该行的数据。

1. 使用iteritems()方法： iteritems()方法返回一个迭代器，可以按列遍历DataFrame。每次迭代返回一个包含列名和该列数据的元组。

import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'Name': ['Alice', 'Bob', 'Charlie'],
                   'Age': [25, 30, 35],
                   'City': ['New York', 'London', 'Paris']})

# 使用iteritems()方法遍历DataFrame
for column_name, column_data in df.iteritems():
    print(f"Column name: {column_name}")
    print(f"Column data:\n{column_data}")
    print("----------")

输出结果为：

Column name: Name
Column data:
0      Alice
1        Bob
2    Charlie
Name: Name, dtype: object
----------
Column name: Age
Column data:
0    25
1    30
2    35
Name: Age, dtype: int64
----------
Column name: City
Column data:
0    New York
1      London
2       Paris
Name: City, dtype: object
----------

在上面的例子中，我们使用iteritems()方法遍历了DataFrame对象df的每一列。在每次迭代中，我们可以通过column_name获取列名，通过column_data获取该列的数据。

操作Pandas的index三种方法

重新设置行index

在Pandas中，可以使用set_index()方法重新设置DataFrame的行索引。set_index()方法接受一个参数，用于指定新的行索引列或列的名称。

下面是重新设置行索引的示例：

import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3],
                   'B': [4, 5, 6],
                   'C': [7, 8, 9]})

print("原始DataFrame:")
print(df)

# 重新设置行索引为新的整数序列
df = df.set_index(pd.Index([10, 20, 30]))

print("重新设置行索引后的DataFrame:")
print(df)

输出结果为：

原始DataFrame:
   A  B  C
0  1  4  7
1  2  5  8
2  3  6  9

重新设置行索引后的DataFrame:
    A  B  C
10  1  4  7
20  2  5  8
30  3  6  9

在上面的例子中，我们首先创建了一个DataFrame对象df，然后使用set_index()方法将新的整数序列作为新的行索引。重新设置行索引后，原来的行索引被替换掉。

如果要使用已有的列作为新的行索引，可以直接将列名传递给set_index()方法：

df = df.set_index('A')

这样会将列A作为新的行索引。

如果想保留原来的行索引为一列数据，可以使用reset_index()方法：

df = df.reset_index()

这样会将原来的行索引恢复为默认的整数索引，并将原来的行索引作为新的列添加到DataFrame中。

将某列设置为index

要将某列设置为DataFrame的行索引，可以使用set_index()方法，并指定要设置为索引的列名作为参数。下面是一个示例：

import pandas as pd

# 创建一个DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3],
                   'B': [4, 5, 6],
                   'C': [7, 8, 9]})

print("原始DataFrame:")
print(df)

# 将列'A'设置为行索引
df = df.set_index('A')

print("设置'A'列为行索引后的DataFrame:")
print(df)

输出结果为：

原始DataFrame:
   A  B  C
0  1  4  7
1  2  5  8
2  3  6  9

设置'A'列为行索引后的DataFrame:
   B  C
A      
1  4  7
2  5  8
3  6  9

在上面的例子中，我们首先创建了一个DataFrame对象df，然后使用set_index()方法将列'A'设置为新的行索引。设置行索引后，列'A'变成了行索引，原来的行索引被替换掉。

如果要保留原来的行索引为一列数据，可以在设置行索引之前使用reset_index()方法：

df = df.reset_index()

这样会将原来的行索引恢复为默认的整数索引，并将原来的行索引作为新的列添加到DataFrame中。

将index 设置为列

要将DataFrame的行索引设置为列，可以使用reset_index()方法。reset_index()方法会将行索引恢复为默认的整数索引，并将原来的行索引作为新的列添加到DataFrame中。

下面是一个示例：

import pandas as pd

# 创建一个带有行索引的DataFrame对象
df = pd.DataFrame({'A': [1, 2, 3],
                   'B': [4, 5, 6],
                   'C': [7, 8, 9]},
                  index=['X', 'Y', 'Z'])

print("原始DataFrame:")
print(df)

# 将行索引设置为列
df = df.reset_index()

print("将行索引设置为列后的DataFrame:")
print(df)

输出结果为：

原始DataFrame:
   A  B  C
X  1  4  7
Y  2  5  8
Z  3  6  9

将行索引设置为列后的DataFrame:
  index  A  B  C
0     X  1  4  7
1     Y  2  5  8
2     Z  3  6  9

在上面的例子中，我们首先创建了一个带有行索引的DataFrame对象df。然后，使用reset_index()方法将行索引恢复为默认的整数索引，并将原来的行索引作为新的列添加到DataFrame中。

如何理解Pandas的列自动对齐

Pandas的列自动对齐是指在进行DataFrame操作（例如计算、合并、拼接等）时，Pandas会根据列的名称自动对齐数据，以确保数据在正确的位置进行操作。

具体来说，当对两个或多个DataFrame进行操作时，Pandas会根据列名称进行匹配。如果两个DataFrame具有相同的列名称，操作将在这些列之间进行，而不考虑它们的位置或顺序。这使得数据操作更加方便，无需手动处理不同DataFrame中列的顺序。

考虑以下示例：

import pandas as pd

# 创建两个DataFrame对象
df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [4, 5, 6],
                    'C': [7, 8, 9]})

df2 = pd.DataFrame({'B': [10, 20, 30],
                    'A': [40, 50, 60],
                    'D': [70, 80, 90]})

# 对两个DataFrame进行相加操作
df_sum = df1 + df2

print("相加操作后的DataFrame:")
print(df_sum)

输出结果为：

相加操作后的DataFrame:
    A   B   C   D
0  41  14 NaN NaN
1  52  25 NaN NaN
2  63  36 NaN NaN

在上面的例子中，我们创建了两个DataFrame对象df1和df2。它们具有相同的列名A和B，但是顺序不同，同时df2还有额外的列D。当我们执行df1 + df2的操作时，Pandas会根据列名称自动对齐数据，并在对应的位置进行相加操作。即使列的顺序不同，Pandas也会正确匹配并执行操作。

这种自动对齐的功能使得在处理和操作DataFrame时更加方便和灵活，无需手动调整或对齐列的顺序。Pandas会根据列名的匹配来自动处理数据对齐的细节，简化了数据操作的过程。

空值检查和填充

在Pandas中，可以使用isnull()和notnull()方法进行空值检查，以及使用fillna()方法进行空值填充。

1. 空值检查：
   • isnull()方法会返回一个布尔型的DataFrame，其中值为True表示对应位置上的元素为空值。
   • notnull()方法与isnull()相反，返回一个布尔型的DataFrame，其中值为True表示对应位置上的元素不为空值。

下面是一个示例：

import pandas as pd

# 创建一个包含空值的DataFrame对象
df = pd.DataFrame({'A': [1, 2, None],
                   'B': [4, None, 6],
                   'C': [None, 8, 9]})

print("原始DataFrame:")
print(df)

# 检查DataFrame中的空值
null_check = df.isnull()

print("空值检查结果:")
print(null_check)

输出结果为：

原始DataFrame:
     A    B    C
0  1.0  4.0  NaN
1  2.0  NaN  8.0
2  NaN  6.0  9.0

空值检查结果:
       A      B      C
0  False  False   True
1  False   True  False
2   True  False  False

在上面的例子中，我们创建了一个包含空值的DataFrame对象df。然后，使用isnull()方法对DataFrame进行空值检查，并将结果保存在null_check中。输出的结果显示了DataFrame中每个位置上的元素是否为空值。

1. 空值填充：
   • fillna()方法用于填充DataFrame中的空值。它接受一个参数，用于指定要使用的填充值。
   • 可以使用单个值、字典或Series来指定填充值。填充可以针对整个DataFrame、特定列或特定行进行。

下面是一些示例：

import pandas as pd

# 创建一个包含空值的DataFrame对象
df = pd.DataFrame({'A': [1, 2, None],
                   'B': [4, None, 6],
                   'C': [None, 8, 9]})

print("原始DataFrame:")
print(df)

# 填充整个DataFrame中的空值为特定值
df_filled = df.fillna(0)

print("填充空值后的DataFrame:")
print(df_filled)

# 填充特定列中的空值为特定值
df['A'] = df['A'].fillna(10)

print("填充'A'列空值后的DataFrame:")
print(df)

# 使用字典指定不同列的填充值
fill_values = {'B': 20, 'C': 30}
df_filled_columns = df.fillna(fill_values)

print("填充不同列空值后的DataFrame:")
print(df_filled_columns)

输出结果为：

原始DataFrame:
     A    B    C
0  1.0  4.0  NaN
1  2.0  NaN  8.0
2  NaN  6.0  9.0

填充空值后的DataFrame:
     A    B    C
0  1.0  4.0  0.0
1  2.0  0.0  8.0
2  0.0  6.0  9.0

填充'A'列空值后的DataFrame:
      A    B    C
0   1.0  4.0  NaN
1   2.0  NaN  8.0
2  10.0  6.0  9.0

填充不同列空值后的DataFrame:
      A     B     C
0   1.0   4.0  30.0
1   2.0  20.0   8.0
2  10.0   6.0   9.0

在上面的示例中，我们首先创建了一个包含空值的DataFrame对象df。然后，使用fillna()方法对DataFrame中的空值进行填充。在第一个示例中，我们使用单个值0来填充整个DataFrame；在第二个示例中，我们使用特定值10来填充列'A'中的空值；在第三个示例中，我们使用字典指定了不同列的填充值。输出的结果显示了填充空值后的DataFrame。

对数据集DataFrame去重

要对DataFrame数据集进行去重操作，可以使用drop_duplicates()方法。drop_duplicates()方法会删除DataFrame中的重复行，并返回一个去重后的DataFrame。

下面是一个示例：

import pandas as pd

# 创建一个带有重复行的DataFrame对象
df = pd.DataFrame({'A': [1, 2, 2, 3, 4],
                   'B': [4, 5, 5, 6, 7],
                   'C': [7, 8, 8, 9, 10]})

print("原始DataFrame:")
print(df)

# 对DataFrame进行去重
df_deduplicated = df.drop_duplicates()

print("去重后的DataFrame:")
print(df_deduplicated)

输出结果为：

原始DataFrame:
   A  B   C
0  1  4   7
1  2  5   8
2  2  5   8
3  3  6   9
4  4  7  10

去重后的DataFrame:
   A  B   C
0  1  4   7
1  2  5   8
3  3  6   9
4  4  7  10

在上面的例子中，我们创建了一个带有重复行的DataFrame对象df。然后，使用drop_duplicates()方法对DataFrame进行去重，并将去重后的结果保存在df_deduplicated中。输出的结果显示了去重后的DataFrame，其中重复的行被删除。

drop_duplicates()方法默认会对所有列进行去重判断，如果一行中所有列的值都相同，则判定为重复行。如果只想针对特定列进行去重，可以通过subset参数指定要考虑的列名，例如df.drop_duplicates(subset=['A', 'B'])。

在处理DataFrame数据集时，去重操作是常见的数据清洗步骤，可以去除重复的数据行，确保数据的唯一性。

对DataFrame分组

在Pandas中，可以使用groupby()方法对DataFrame进行分组操作。groupby()方法根据指定的列或多个列对DataFrame进行分组，并返回一个GroupBy对象。

下面是一个示例：

import pandas as pd

# 创建一个DataFrame对象
data = {'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
        'B': ['one', 'one', 'two', 'two', 'two', 'one', 'two', 'one'],
        'C': [1, 2, 3, 4, 5, 6, 7, 8],
        'D': [9, 10, 11, 12, 13, 14, 15, 16]}
df = pd.DataFrame(data)

print("原始DataFrame:")
print(df)

# 按列'A'进行分组
grouped = df.groupby('A')

# 对分组后的数据进行聚合操作（例如求和）
sum_by_group = grouped.sum()

print("按列'A'分组后的聚合结果:")
print(sum_by_group)

输出结果为：

原始DataFrame:
     A    B  C   D
0  foo  one  1   9
1  bar  one  2  10
2  foo  two  3  11
3  bar  two  4  12
4  foo  two  5  13
5  bar  one  6  14
6  foo  two  7  15
7  foo  one  8  16

按列'A'分组后的聚合结果:
     C   D
A        
bar  12  36
foo  24  64

在上面的例子中，我们创建了一个DataFrame对象df，包含了’A’、‘B’、'C’和’D’四个列。然后，使用groupby()方法对DataFrame按列’A’进行分组，得到一个GroupBy对象grouped。接下来，我们可以对该分组对象进行聚合操作，例如求和，通过调用sum()方法。最终得到按列’A’分组后的聚合结果sum_by_group。

可以根据具体的需求，选择不同的列或多个列进行分组。除了groupby()方法外，GroupBy对象还提供了许多其他方法和操作，如count()、mean()、max()、min()、agg()等，用于对分组后的数据进行统计和聚合。

使用join连接两个DataFrame和四种join方法

要连接两个DataFrame，可以使用join()方法。join()方法在Pandas中用于按照索引或列进行连接操作，并返回连接后的新DataFrame。

下面是一个示例，展示如何使用join()方法连接两个DataFrame：

import pandas as pd

# 创建两个DataFrame对象
df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [4, 5, 6]})

df2 = pd.DataFrame({'C': [7, 8, 9],
                    'D': [10, 11, 12]})

# 使用join()方法连接两个DataFrame，默认使用索引进行连接
df_join = df1.join(df2)

print("连接后的DataFrame:")
print(df_join)

输出结果为：

连接后的DataFrame:
   A  B  C   D
0  1  4  7  10
1  2  5  8  11
2  3  6  9  12

在上面的例子中，我们创建了两个DataFrame对象df1和df2，每个DataFrame包含两列。然后，我们使用join()方法将它们连接起来，由于没有指定连接的列，所以默认使用索引进行连接。连接后的结果保存在df_join中，输出显示了连接后的DataFrame。

除了默认的索引连接，join()方法还提供了不同的连接方法，可以通过how参数进行指定。常见的连接方法有四种：

1. 内连接（Inner Join）：保留两个DataFrame中的交集部分，使用how='inner'进行指定。
2. 左连接（Left Join）：保留左侧DataFrame的所有行，并与右侧DataFrame进行匹配，未匹配到的部分填充为缺失值，使用how='left'进行指定。
3. 右连接（Right Join）：保留右侧DataFrame的所有行，并与左侧DataFrame进行匹配，未匹配到的部分填充为缺失值，使用how='right'进行指定。
4. 外连接（Outer Join）：保留两个DataFrame的所有行，并进行匹配，未匹配到的部分填充为缺失值，使用how='outer'进行指定。

下面是一个示例，展示如何使用不同的连接方法：

import pandas as pd

# 创建两个DataFrame对象
df1 = pd.DataFrame({'A': [1, 2, 3],
                    'B': [4, 5, 6]})

df2 = pd.DataFrame({'B': [4, 5, 6],
                    'C': [7, 8, 9]})

# 内连接
df_inner = df1.join(df2, how='inner')
print("内连接:")
print(df_inner)

# 左连接
df_left = df1.join(df2, how='left')
print("左连接:")
print(df_left)

# 右连接
df_right = df1.join(df2, how='right')
print("右连接:")
print(df_right)

# 外连接
df_outer = df1.join(df2, how='outer')
print("外连接:")
print(df_outer)

输出结果为：

内连接:
   A  B  B  C
0  1  4  4  7
1  2  5  5  8
2  3  6  6  9

左连接:
   A  B    B    C
0  1  4  4.0  7.0
1  2  5  5.0  8.0
2  3  6  6.0  9.0

右连接:
   A    B  B  C
0  1  4.0  4  7
1  2  5.0  5  8
2  3  6.0  6  9

外连接:
   A    B    B    C
0  1  4.0  4.0  7.0
1  2  5.0  5.0  8.0
2  3  6.0  6.0  9.0

在上面的例子中，我们创建了两个DataFrame对象df1和df2，其中df1包含列’A’和’B’，df2包含列’B’和’C’。然后，我们使用join()方法并通过how参数指定不同的连接方法进行连接。输出结果显示了使用不同连接方法得到的连接后的DataFrame。

使用pivot_table 透视DateFrame

pivot_table()是Pandas中的一个函数，用于创建透视表（pivot table）。透视表是一种根据一个或多个键对数据进行聚合的方式，可以在不同维度上汇总和分析数据。

下面是一个示例，展示如何使用pivot_table()函数创建透视表：

import pandas as pd

# 创建一个DataFrame对象
data = {'A': ['foo', 'foo', 'bar', 'bar', 'foo', 'foo'],
        'B': ['one', 'two', 'one', 'two', 'one', 'two'],
        'C': [1, 2, 3, 4, 5, 6],
        'D': [7, 8, 9, 10, 11, 12]}
df = pd.DataFrame(data)

print("原始DataFrame:")
print(df)

# 创建透视表
pivot_table = pd.pivot_table(df, values='C', index='A', columns='B', aggfunc='sum')

print("透视表:")
print(pivot_table)

输出结果为：

原始DataFrame:
     A    B  C   D
0  foo  one  1   7
1  foo  two  2   8
2  bar  one  3   9
3  bar  two  4  10
4  foo  one  5  11
5  foo  two  6  12

透视表:
B    one  two
A            
bar    3    4
foo    6    8

在上面的例子中，我们创建了一个DataFrame对象df，包含了’A’、‘B’、‘C’和’D’四个列。然后，使用pivot_table()函数创建了一个透视表，通过指定values参数为’C’列、index参数为’A’列、columns参数为’B’列，以及aggfunc参数为’sum’，进行聚合操作。聚合的结果以透视表的形式输出。

透视表中的行表示’A’列的唯一值，列表示’B’列的唯一值，单元格中的值表示’C’列在对应’A’和’B’的组合上的聚合结果（这里使用了求和操作）。如果在数据中有多个相同的’A’和’B’组合，则会对相同组合的值进行聚合。

pivot_table()函数还可以接受其他参数，如fill_value用于填充缺失值、margins用于添加边际汇总等，可以根据具体需求进行调整。

Pandas 中插入一行数据的2种方法

在Pandas中，可以使用两种方法来插入一行数据到DataFrame中。

方法一：使用loc方法

import pandas as pd

# 创建一个DataFrame对象
data = {'A': [1, 2, 3],
        'B': [4, 5, 6]}
df = pd.DataFrame(data)

print("原始DataFrame:")
print(df)

# 插入一行数据
new_row = {'A': 7, 'B': 8}
df.loc[len(df)] = new_row

print("插入后的DataFrame:")
print(df)

方法二：使用append()方法

import pandas as pd

# 创建一个DataFrame对象
data = {'A': [1, 2, 3],
        'B': [4, 5, 6]}
df = pd.DataFrame(data)

print("原始DataFrame:")
print(df)

# 插入一行数据
new_row = {'A': 7, 'B': 8}
df = df.append(new_row, ignore_index=True)

print("插入后的DataFrame:")
print(df)

以上两种方法都可以在DataFrame的末尾插入一行新数据。方法一使用了loc方法，通过指定索引位置为len(df)（即最后一行的下一行），并将新数据作为一行添加进去。方法二使用了append()方法，将新数据作为一个DataFrame对象进行追加，并通过ignore_index=True参数保证新行的索引递增。