背景#

polars学习系列文章，第9篇数据框关联与拼接（Join 、Concat）

该系列文章会分享到github，大家可以去下载jupyter文件，进行参考学习

仓库地址：https://github.com/DataShare-duo/polars_learn

小编运行环境#

1
import sys
2

3
print('python 版本：',sys.version.split('|')[0])
4
#python 版本： 3.11.9
5

6
import polars as pl
7

8
print("polars 版本：",pl.__version__)
9
#polars 版本： 1.2.1

数据框关联 Join#

polars 通过指定参数 how，支持以下方式的关联：

inner：类似sql中的 inner join,取2个数据框共同的部分
left：类似sql中的 left join,取左边数据框所有数据，匹配右边数据框数据，能匹配到的进行匹配，匹配不到的用 null 填充
full：类似sql中的 full outer join，返回2个数据框的全量数据，匹配不到的用 null 填充
cross：2个数据框的笛卡尔积，数据行数为，len(A) × len(B)
semi：用的相对比较少，左边数据框中关联字段同时存在右边数据框中，只返回左边数据框的行，有点类似 inner join,但是不全完一样，即使右边数据框有多行的，左边返回的还是单行，也就是遇到关联字段存在于右边数据框，就返回
anti：用的相对比较少，返回左边数据框中关联字段不存在右边数据框中的行，与 semi 相反

数据准备#

1
df_customers = pl.DataFrame(
2
    {
3
        "customer_id": [1, 2, 3],
4
        "name": ["Alice", "Bob", "Charlie"],
5
    }
6
)
7

8
print(df_customers)
9
#shape: (3, 2)
10
┌─────────────┬─────────┐
11
│ customer_id ┆ name    │
12
│ ---         ┆ ---     │
13
│ i64         ┆ str     │
14
╞═════════════╪═════════╡
15
│ 1           ┆ Alice   │
16
│ 2           ┆ Bob     │
17
│ 3           ┆ Charlie │
18
└─────────────┴─────────┘
19

20
df_orders = pl.DataFrame(
21
    {
22
        "order_id": ["a", "b", "c"],
23
        "customer_id": [1, 2, 2],
24
        "amount": [100, 200, 300],
25
    }
26
)
27

28
print(df_orders)
29
#shape: (3, 3)
30
┌──────────┬─────────────┬────────┐
31
│ order_id ┆ customer_id ┆ amount │
32
│ ---      ┆ ---         ┆ ---    │
33
│ str      ┆ i64         ┆ i64    │
34
╞══════════╪═════════════╪════════╡
35
│ a        ┆ 1           ┆ 100    │
36
│ b        ┆ 2           ┆ 200    │
37
│ c        ┆ 2           ┆ 300    │
38
└──────────┴─────────────┴────────┘

Inner join#

1
df_inner_customer_join = df_customers.join(df_orders,
2
                                           on="customer_id",
3
                                           how="inner")
4

5
print(df_inner_customer_join)
6
#shape: (3, 4)
7
┌─────────────┬───────┬──────────┬────────┐
8
│ customer_id ┆ name  ┆ order_id ┆ amount │
9
│ ---         ┆ ---   ┆ ---      ┆ ---    │
10
│ i64         ┆ str   ┆ str      ┆ i64    │
11
╞═════════════╪═══════╪══════════╪════════╡
12
│ 1           ┆ Alice ┆ a        ┆ 100    │
13
│ 2           ┆ Bob   ┆ b        ┆ 200    │
14
│ 2           ┆ Bob   ┆ c        ┆ 300    │
15
└─────────────┴───────┴──────────┴────────┘

Left join#

1
df_left_join = df_customers.join(df_orders,
2
                                 on="customer_id",
3
                                 how="left")
4

5
print(df_left_join)
6
#shape: (4, 4)
7
┌─────────────┬─────────┬──────────┬────────┐
8
│ customer_id ┆ name    ┆ order_id ┆ amount │
9
│ ---         ┆ ---     ┆ ---      ┆ ---    │
10
│ i64         ┆ str     ┆ str      ┆ i64    │
11
╞═════════════╪═════════╪══════════╪════════╡
12
│ 1           ┆ Alice   ┆ a        ┆ 100    │
13
│ 2           ┆ Bob     ┆ b        ┆ 200    │
14
│ 2           ┆ Bob     ┆ c        ┆ 300    │
15
│ 3           ┆ Charlie ┆ null     ┆ null   │
16
└─────────────┴─────────┴──────────┴────────┘

Outer join#

1
df_outer_join = df_customers.join(df_orders,
2
                                  on="customer_id",
3
                                  how="full")
4

5
print(df_outer_join)
6
#shape: (4, 5)
7
┌─────────────┬─────────┬──────────┬───────────────────┬────────┐
8
│ customer_id ┆ name    ┆ order_id ┆ customer_id_right ┆ amount │
9
│ ---         ┆ ---     ┆ ---      ┆ ---               ┆ ---    │
10
│ i64         ┆ str     ┆ str      ┆ i64               ┆ i64    │
11
╞═════════════╪═════════╪══════════╪═══════════════════╪════════╡
12
│ 1           ┆ Alice   ┆ a        ┆ 1                 ┆ 100    │
13
│ 2           ┆ Bob     ┆ b        ┆ 2                 ┆ 200    │
14
│ 2           ┆ Bob     ┆ c        ┆ 2                 ┆ 300    │
15
│ 3           ┆ Charlie ┆ null     ┆ null              ┆ null   │
16
└─────────────┴─────────┴──────────┴───────────────────┴────────┘

Cross join#

1
df_colors = pl.DataFrame(
2
    {
3
        "color": ["red", "blue", "green"],
4
    }
5
)
6
print(df_colors)
7
#shape: (3, 1)
8
┌───────┐
9
│ color │
10
│ ---   │
11
│ str   │
12
╞═══════╡
13
│ red   │
14
│ blue  │
15
│ green │
16
└───────┘
17

18
df_sizes = pl.DataFrame(
19
    {
20
        "size": ["S", "M", "L"],
21
    }
22
)
23
#print(df_sizes)
24

25
df_cross_join = df_colors.join(df_sizes,
26
                               how="cross")
27

28
print(df_cross_join)
29
#shape: (9, 2)
30
┌───────┬──────┐
31
│ color ┆ size │
32
│ ---   ┆ ---  │
33
│ str   ┆ str  │
34
╞═══════╪══════╡
35
│ red   ┆ S    │
36
│ red   ┆ M    │
37
│ red   ┆ L    │
38
│ blue  ┆ S    │
39
│ blue  ┆ M    │
40
│ blue  ┆ L    │
41
│ green ┆ S    │
42
│ green ┆ M    │
43
│ green ┆ L    │
44
└───────┴──────┘

Semi join#

1
df_cars = pl.DataFrame(
2
    {
3
        "id": ["a", "b", "c"],
4
        "make": ["ford", "toyota", "bmw"],
5
    }
6
)
7
print(df_cars)
8
shape: (3, 2)
9
┌─────┬────────┐
10
│ id  ┆ make   │
11
│ --- ┆ ---    │
12
│ str ┆ str    │
13
╞═════╪════════╡
14
│ a   ┆ ford   │
15
│ b   ┆ toyota │
16
│ c   ┆ bmw    │
17
└─────┴────────┘
18

19
df_repairs = pl.DataFrame(
20
    {
21
        "id": ["c", "c"],
22
        "cost": [100, 200],
23
    }
24
)
25
print(df_repairs)
26
#shape: (2, 2)
27
┌─────┬──────┐
28
│ id  ┆ cost │
29
│ --- ┆ ---  │
30
│ str ┆ i64  │
31
╞═════╪══════╡
32
│ c   ┆ 100  │
33
│ c   ┆ 200  │
34
└─────┴──────┘
35

36
df_semi_join = df_cars.join(df_repairs,
37
                            on="id",
38
                            how="semi")
39
print(df_semi_join)
40
#shape: (1, 2)
41
┌─────┬──────┐
42
│ id  ┆ make │
43
│ --- ┆ ---  │
44
│ str ┆ str  │
45
╞═════╪══════╡
46
│ c   ┆ bmw  │
47
└─────┴──────┘

Anti join#

1
df_anti_join = df_cars.join(df_repairs,
2
                            on="id",
3
                            how="anti")
4

5
print(df_anti_join)
6
#shape: (2, 2)
7
┌─────┬────────┐
8
│ id  ┆ make   │
9
│ --- ┆ ---    │
10
│ str ┆ str    │
11
╞═════╪════════╡
12
│ a   ┆ ford   │
13
│ b   ┆ toyota │
14
└─────┴────────┘

数据框拼接 Concat#

有以下3种方式的数据框拼接：

纵向拼接/垂直拼接：2个数据框有相同的字段，拼接后产生更长的数据框
横向拼接/水平拼接：2个数据框没有重叠的字段，拼接后产生更宽的数据框
对角拼接：2个数据框有不同的行与列，既有重叠的字段，也有非重叠的字段，拼接后产生即长又宽的数据框

纵向拼接/垂直拼接 Vertical concatenation#

当没有相同的列字段时，纵向拼接会失败

1
df_v1 = pl.DataFrame(
2
    {
3
        "a": [1],
4
        "b": [3],
5
    }
6
)
7
df_v2 = pl.DataFrame(
8
    {
9
        "a": [2],
10
        "b": [4],
11
    }
12
)
13
df_vertical_concat = pl.concat(
14
    [
15
        df_v1,
16
        df_v2,
17
    ],
18
    how="vertical",
19
)
20
print(df_vertical_concat)
21
#shape: (2, 2)
22
┌─────┬─────┐
23
│ a   ┆ b   │
24
│ --- ┆ --- │
25
│ i64 ┆ i64 │
26
╞═════╪═════╡
27
│ 1   ┆ 3   │
28
│ 2   ┆ 4   │
29
└─────┴─────┘

横向拼接/水平拼接 Horizontal concatenation#

当2个数据框有不同的行数时，拼接后短的行会用 null 进行填充

1
df_h1 = pl.DataFrame(
2
    {
3
        "l1": [1, 2],
4
        "l2": [3, 4],
5
    }
6
)
7
df_h2 = pl.DataFrame(
8
    {
9
        "r1": [5, 6],
10
        "r2": [7, 8],
11
        "r3": [9, 10],
12
    }
13
)
14
df_horizontal_concat = pl.concat(
15
    [
16
        df_h1,
17
        df_h2,
18
    ],
19
    how="horizontal",
20
)
21
print(df_horizontal_concat)
22
#shape: (2, 5)
23
┌─────┬─────┬─────┬─────┬─────┐
24
│ l1  ┆ l2  ┆ r1  ┆ r2  ┆ r3  │
25
│ --- ┆ --- ┆ --- ┆ --- ┆ --- │
26
│ i64 ┆ i64 ┆ i64 ┆ i64 ┆ i64 │
27
╞═════╪═════╪═════╪═════╪═════╡
28
│ 1   ┆ 3   ┆ 5   ┆ 7   ┆ 9   │
29
│ 2   ┆ 4   ┆ 6   ┆ 8   ┆ 10  │
30
└─────┴─────┴─────┴─────┴─────┘

对角拼接 Diagonal concatenation#

1
df_d1 = pl.DataFrame(
2
    {
3
        "a": [1],
4
        "b": [3],
5
    }
6
)
7
df_d2 = pl.DataFrame(
8
    {
9
        "a": [2],
10
        "d": [4],
11
    }
12
)
13

14
df_diagonal_concat = pl.concat(
15
    [
16
        df_d1,
17
        df_d2,
18
    ],
19
    how="diagonal",
20
)
21
print(df_diagonal_concat)
22
#shape: (2, 3)
23
┌─────┬──────┬──────┐
24
│ a   ┆ b    ┆ d    │
25
│ --- ┆ ---  ┆ ---  │
26
│ i64 ┆ i64  ┆ i64  │
27
╞═════╪══════╪══════╡
28
│ 1   ┆ 3    ┆ null │
29
│ 2   ┆ null ┆ 4    │
30
└─────┴──────┴──────┘

历史相关文章#

以上是自己实践中遇到的一些问题，分享出来供大家参考学习，欢迎关注微信公众号：DataShare ，不定期分享干货