Hợp nhất các tệp html

Đặt logic trên các trục khác

Khi dán nhiều DataFrame lại với nhau, bạn có thể lựa chọn cách xử lý các trục khác [không phải là trục được nối]. Điều này có thể được thực hiện theo hai cách sau

• Hãy hợp nhất tất cả,

  37. Đây là tùy chọn mặc định vì nó không làm mất thông tin

• Đi đến ngã tư,

  38

Dưới đây là một ví dụ về từng phương pháp này. Đầu tiên, hành vi

Đây là điều tương tự với

Cuối cùng, giả sử chúng tôi chỉ muốn sử dụng lại chỉ mục chính xác từ DataFrame ban đầu

Tương tự, chúng ta có thể lập chỉ mục trước khi nối

Bỏ qua các chỉ mục trên trục nối

Đối với các đối tượng

Kết nối với ndims hỗn hợp

Bạn có thể nối kết hợp các đối tượng

Ghi chú

Vì chúng tôi đang nối một

Nếu

Vượt qua

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Kết nối nhiều hơn với các phím nhóm

Một cách sử dụng khá phổ biến của đối số

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Thông qua đối số

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Hãy xem xét một biến thể của ví dụ đầu tiên được trình bày

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Bạn cũng có thể chuyển một lệnh tới

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

MultiIndex được tạo có các mức được xây dựng từ các khóa đã truyền và chỉ mục của các phần

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Nếu bạn muốn chỉ định các cấp độ khác [đôi khi sẽ xảy ra trường hợp này], bạn có thể làm như vậy bằng cách sử dụng đối số

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Điều này khá bí truyền, nhưng nó thực sự cần thiết để triển khai những thứ như GroupBy trong đó thứ tự của một biến phân loại có ý nghĩa

Nối các hàng vào DataFrame

Nếu bạn có một chuỗi mà bạn muốn nối dưới dạng một hàng vào một

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Bạn nên sử dụng

Sơ lược về các phương pháp hợp nhất [đại số quan hệ]

Người dùng có kinh nghiệm về cơ sở dữ liệu quan hệ như SQL sẽ quen thuộc với thuật ngữ được sử dụng để mô tả các hoạt động nối giữa hai cấu trúc giống như bảng SQL [đối tượng ____041]. Có một số trường hợp cần xem xét rất quan trọng để hiểu

• tham gia một đối một. ví dụ: khi nối hai đối tượng

  41 trên chỉ mục của chúng [phải chứa các giá trị duy nhất]

• liên kết nhiều-một. ví dụ: khi nối một chỉ mục [duy nhất] với một hoặc nhiều cột trong một

  41 khác

• liên kết nhiều-nhiều. nối cột trên cột

Ghi chú

Khi nối các cột trên các cột [có thể là nối nhiều-nhiều], mọi chỉ mục trên các đối tượng

Rất đáng để dành thời gian tìm hiểu kết quả của trường hợp tham gia nhiều-nhiều. Trong SQL/đại số quan hệ tiêu chuẩn, nếu tổ hợp phím xuất hiện nhiều lần trong cả hai bảng, bảng kết quả sẽ có tích Đề các của dữ liệu được liên kết. Đây là một ví dụ rất cơ bản với một tổ hợp phím duy nhất

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Đây là một ví dụ phức tạp hơn với nhiều phím tham gia. Chỉ có các khóa xuất hiện trong

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Đối số

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

phương pháp hợp nhất

Tên tham gia SQL

Sự miêu tả

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Chỉ sử dụng các phím từ khung bên trái

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Chỉ sử dụng các phím từ khung bên phải

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Sử dụng liên kết các phím từ cả hai khung

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Sử dụng giao điểm của các phím từ cả hai khung

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Tạo sản phẩm cartesian của các hàng của cả hai khung

Bạn có thể hợp nhất Sê-ri nhiều chỉ mục và Khung dữ liệu, nếu tên của Đa chỉ mục tương ứng với các cột từ Khung dữ liệu. Chuyển đổi Sê-ri thành Khung dữ liệu bằng cách sử dụng trước khi hợp nhất, như minh họa trong ví dụ sau

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Đây là một ví dụ khác với các khóa tham gia trùng lặp trong DataFrames

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Cảnh báo

Tham gia/hợp nhất trên các khóa trùng lặp có thể gây ra khung trả về là phép nhân của kích thước hàng, điều này có thể dẫn đến tràn bộ nhớ. Người dùng có trách nhiệm quản lý các giá trị trùng lặp trong các khóa trước khi tham gia các Khung dữ liệu lớn

Kiểm tra các khóa trùng lặp

Người dùng có thể sử dụng đối số

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Trong ví dụ sau, có các giá trị trùng lặp của

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Nếu người dùng biết về các bản sao trong

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Chỉ số hợp nhất

chấp nhận đối số

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Nguồn gốc quan sát

giá trị

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

02

Hợp nhất phím chỉ trong khung

88

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

04

Hợp nhất phím chỉ trong khung

89

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

06

Hợp nhất phím trong cả hai khung

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

08

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Đối số

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Hợp nhất các loại

Hợp nhất sẽ bảo toàn dtype của các phím tham gia

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Chúng tôi có thể bảo tồn các khóa tham gia

Tất nhiên, nếu bạn thiếu các giá trị được giới thiệu, thì dtype kết quả sẽ được cập nhật

Việc hợp nhất sẽ bảo tồn

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

khung bên trái

khung bên phải

Kết quả hợp nhất

Ghi chú

Các loại danh mục phải hoàn toàn giống nhau, nghĩa là cùng danh mục và thuộc tính được sắp xếp. Nếu không, kết quả sẽ ép buộc vào dtype của danh mục

Ghi chú

Hợp nhất ________ 567 dtypes giống nhau có thể khá hiệu quả so với hợp nhất ________ 569 dtype

Tham gia vào chỉ mục

là một phương pháp thuận tiện để kết hợp các cột của hai

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Tương tự như trên, nhưng với

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Căn chỉnh dữ liệu ở đây là trên các chỉ mục [nhãn hàng]. Hành vi tương tự này có thể đạt được bằng cách sử dụng

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Tham gia các cột chính trên một chỉ mục

lấy một đối số

Rõ ràng bạn có thể chọn bất kỳ hình thức nào bạn thấy thuận tiện hơn. Đối với các phép nối nhiều người [trong đó một trong số các

Để tham gia trên nhiều khóa, DataFrame đã qua phải có một

Bây giờ điều này có thể được nối bằng cách chuyển hai tên cột chính

Giá trị mặc định cho

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Như bạn có thể thấy, thao tác này loại bỏ bất kỳ hàng nào không khớp

Tham gia một Chỉ mục duy nhất vào Đa chỉ mục

Bạn có thể tham gia một

Điều này tương đương nhưng ít dài dòng hơn và bộ nhớ hiệu quả hơn/nhanh hơn điều này

Tham gia với hai MultiIndexes

Điều này được hỗ trợ theo một cách hạn chế, với điều kiện là chỉ mục cho đối số bên phải được sử dụng hoàn toàn trong liên kết và là tập hợp con của các chỉ mục trong đối số bên trái, như trong ví dụ này

Nếu điều kiện đó không được thỏa mãn, có thể thực hiện phép nối với hai đa chỉ mục bằng cách sử dụng đoạn mã sau

Hợp nhất trên sự kết hợp của các cột và cấp độ chỉ mục

Các chuỗi được truyền dưới dạng tham số

Ghi chú

Khi DataFrames được hợp nhất trên một chuỗi khớp với cấp chỉ mục trong cả hai khung, cấp chỉ mục được giữ nguyên dưới dạng cấp chỉ mục trong DataFrame kết quả

Ghi chú

Khi DataFrames được hợp nhất chỉ bằng một số cấp độ của

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Ghi chú

Nếu một chuỗi khớp với cả tên cột và tên cấp chỉ mục, thì cảnh báo sẽ được đưa ra và cột đó được ưu tiên. Điều này sẽ dẫn đến lỗi mơ hồ trong phiên bản tương lai

Cột giá trị chồng lấp

Đối số hợp nhất

có các đối số

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Tham gia nhiều DataFrames

Một danh sách hoặc bộ dữ liệu của

pd.concat[
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
]

Hợp nhất các giá trị với nhau trong các cột Sê-ri hoặc Khung dữ liệu

Một tình huống khá phổ biến khác là có hai đối tượng

Đối với điều này, sử dụng phương pháp

Lưu ý rằng phương pháp này chỉ nhận các giá trị từ bên phải

Hợp nhất dữ liệu có thứ tự

Một chức năng cho phép kết hợp chuỗi thời gian và dữ liệu được sắp xếp khác. Cụ thể, nó có một từ khóa

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

sáp nhập

A tương tự như phép nối trái có thứ tự ngoại trừ việc chúng tôi khớp với khóa gần nhất thay vì các khóa bằng nhau. Đối với mỗi hàng trong

Tùy chọn hợp nhất asof có thể thực hiện hợp nhất theo nhóm. Điều này khớp với khóa

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]

Ví dụ;

Theo mặc định, chúng tôi đang sử dụng dấu ngoặc kép

Chúng tôi chỉ cập nhật trong vòng

In [1]: df1 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A0", "A1", "A2", "A3"],
   ...:         "B": ["B0", "B1", "B2", "B3"],
   ...:         "C": ["C0", "C1", "C2", "C3"],
   ...:         "D": ["D0", "D1", "D2", "D3"],
   ...:     },
   ...:     index=[0, 1, 2, 3],
   ...: ]
   ...: 

In [2]: df2 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A4", "A5", "A6", "A7"],
   ...:         "B": ["B4", "B5", "B6", "B7"],
   ...:         "C": ["C4", "C5", "C6", "C7"],
   ...:         "D": ["D4", "D5", "D6", "D7"],
   ...:     },
   ...:     index=[4, 5, 6, 7],
   ...: ]
   ...: 

In [3]: df3 = pd.DataFrame[
   ...:     {
   ...:         "A": ["A8", "A9", "A10", "A11"],
   ...:         "B": ["B8", "B9", "B10", "B11"],
   ...:         "C": ["C8", "C9", "C10", "C11"],
   ...:         "D": ["D8", "D9", "D10", "D11"],
   ...:     },
   ...:     index=[8, 9, 10, 11],
   ...: ]
   ...: 

In [4]: frames = [df1, df2, df3]

In [5]: result = pd.concat[frames]