Hướng dẫn python join documentation - tài liệu tham gia python

Các đối tượng kết hợp#

Hàm

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

Trước khi lặn vào tất cả các chi tiết của

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

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)

Giống như chức năng anh chị em của nó trên ndarrays,

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

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

• In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
  Out[12]: 
      A   B   C   D    B    D    F
  0  A0  B0  C0  D0  NaN  NaN  NaN
  1  A1  B1  C1  D1  NaN  NaN  NaN
  2  A2  B2  C2  D2   B2   D2   F2
  3  A3  B3  C3  D3   B3   D3   F3
  

  2: Một chuỗi hoặc ánh xạ các đối tượng Data hoặc DataFrame. Nếu một dict được thông qua, các khóa được sắp xếp sẽ được sử dụng làm đối số

  In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
  Out[12]: 
      A   B   C   D    B    D    F
  0  A0  B0  C0  D0  NaN  NaN  NaN
  1  A1  B1  C1  D1  NaN  NaN  NaN
  2  A2  B2  C2  D2   B2   D2   F2
  3  A3  B3  C3  D3   B3   D3   F3
  

  3, trừ khi nó được thông qua, trong trường hợp đó, các giá trị sẽ được chọn (xem bên dưới). Bất kỳ đối tượng nào sẽ được thả một cách âm thầm trừ khi tất cả chúng không có gì trong trường hợp đó sẽ được nâng lên.

• In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
  Out[12]: 
      A   B   C   D    B    D    F
  0  A0  B0  C0  D0  NaN  NaN  NaN
  1  A1  B1  C1  D1  NaN  NaN  NaN
  2  A2  B2  C2  D2   B2   D2   F2
  3  A3  B3  C3  D3   B3   D3   F3
  

  4: {0, 1, Mạnh}, mặc định 0. Trục để nối.

• In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
  Out[12]: 
      A   B   C   D    B    D    F
  0  A0  B0  C0  D0  NaN  NaN  NaN
  1  A1  B1  C1  D1  NaN  NaN  NaN
  2  A2  B2  C2  D2   B2   D2   F2
  3  A3  B3  C3  D3   B3   D3   F3
  

  5: {‘bên trong,‘ bên ngoài}, mặc định ‘bên ngoài. Cách xử lý các chỉ mục trên trục khác (ES). Bên ngoài cho công đoàn và bên trong cho giao lộ.

• In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
  Out[12]: 
      A   B   C   D    B    D    F
  0  A0  B0  C0  D0  NaN  NaN  NaN
  1  A1  B1  C1  D1  NaN  NaN  NaN
  2  A2  B2  C2  D2   B2   D2   F2
  3  A3  B3  C3  D3   B3   D3   F3
  

  6: Boolean, mặc định sai. Nếu đúng, không sử dụng các giá trị chỉ mục trên trục nối. Trục kết quả sẽ được dán nhãn 0,, N - 1. Điều này rất hữu ích nếu bạn đang ghép các đối tượng trong đó trục nối không có thông tin lập chỉ mục có ý nghĩa. Lưu ý các giá trị chỉ mục trên các trục khác vẫn được tôn trọng trong tham gia.

• In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
  Out[12]: 
      A   B   C   D    B    D    F
  0  A0  B0  C0  D0  NaN  NaN  NaN
  1  A1  B1  C1  D1  NaN  NaN  NaN
  2  A2  B2  C2  D2   B2   D2   F2
  3  A3  B3  C3  D3   B3   D3   F3
  

  3: Trình tự, mặc định không có. Xây dựng chỉ số phân cấp bằng cách sử dụng các phím được truyền làm mức ngoài cùng. Nếu nhiều cấp độ trôi qua, nên chứa bộ dữ liệu.

• In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
  Out[12]: 
      A   B   C   D    B    D    F
  0  A0  B0  C0  D0  NaN  NaN  NaN
  1  A1  B1  C1  D1  NaN  NaN  NaN
  2  A2  B2  C2  D2   B2   D2   F2
  3  A3  B3  C3  D3   B3   D3   F3
  

  8: Danh sách các chuỗi, mặc định không có. Các mức cụ thể (giá trị duy nhất) để sử dụng để xây dựng đa dạng. Nếu không, chúng sẽ được suy ra từ các chìa khóa.

• In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
  Out[12]: 
      A   B   C   D    B    D    F
  0  A0  B0  C0  D0  NaN  NaN  NaN
  1  A1  B1  C1  D1  NaN  NaN  NaN
  2  A2  B2  C2  D2   B2   D2   F2
  3  A3  B3  C3  D3   B3   D3   F3
  

  9: Danh sách, mặc định không có. Tên cho các cấp độ trong chỉ số phân cấp kết quả.

• In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)
  

  0: Boolean, mặc định sai. Kiểm tra xem trục được nối mới có chứa các bản sao hay không. Điều này có thể rất tốn kém so với cách ghép dữ liệu thực tế.

• In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)
  

  1: Boolean, mặc định đúng. Nếu sai, không sao chép dữ liệu một cách không cần thiết.

Không có một chút bối cảnh, nhiều trong số những lập luận này không có ý nghĩa gì. Hãy để xem lại ví dụ trên. Giả sử chúng tôi muốn liên kết các khóa cụ thể với từng phần của khung dữ liệu băm nhỏ. Chúng ta có thể làm điều này bằng cách sử dụng đối số

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

Như bạn có thể thấy (nếu bạn đã đọc phần còn lại của tài liệu), chỉ số kết quả của đối tượng có chỉ số phân cấp. Điều này có nghĩa là bây giờ chúng ta có thể chọn từng đoạn bằng khóa:hierarchical index. This means that we can now select out each chunk by key:

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

Nó không phải là một sự kéo dài để xem làm thế nào điều này có thể rất hữu ích. Thêm chi tiết về chức năng này dưới đây.

Ghi chú

Điều đáng chú ý là

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)

frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)

Ghi chú

Điều đáng chú ý là

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)

Khi kết hợp các khung dữ liệu với các trục được đặt tên, gấu trúc sẽ cố gắng bảo tồn các tên chỉ mục/cột này bất cứ khi nào có thể. Trong trường hợp tất cả các đầu vào chia sẻ một tên chung, tên này sẽ được gán cho kết quả. Khi các tên đầu vào không đồng ý, kết quả sẽ không được đặt tên. Điều tương tự cũng đúng với In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False) 5, nhưng logic được áp dụng riêng biệt trên cơ sở theo cấp độ.

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

• Khi dán nhiều khung dữ liệu, bạn có thể lựa chọn cách xử lý các trục khác (trừ cái được nối). Điều này có thể được thực hiện theo hai cách sau:

• Lấy sự kết hợp của tất cả,

  In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)
  

  6. Đây là tùy chọn mặc định vì nó dẫn đến mất thông tin bằng không.

Lấy giao lộ,

In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)

7.

In [8]: df4 = pd.DataFrame(
   ...:     {
   ...:         "B": ["B2", "B3", "B6", "B7"],
   ...:         "D": ["D2", "D3", "D6", "D7"],
   ...:         "F": ["F2", "F3", "F6", "F7"],
   ...:     },
   ...:     index=[2, 3, 6, 7],
   ...: )
   ...: 

In [9]: result = pd.concat([df1, df4], axis=1)

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

In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)

6 mặc định:

In [10]: result = pd.concat([df1, df4], axis=1, join="inner")

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

In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)

7:

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

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 gốc:

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

Tương tự, chúng ta có thể lập chỉ mục trước khi kết hợp:

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

In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)

Kết hợp với các ndims hỗn hợp#

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

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

02 và

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

00.

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

02 sẽ được chuyển đổi thành

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

00 với tên cột là tên của

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

02.

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

0

Ghi chú

Vì chúng tôi đã kết hợp một

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

02 đến

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

00, chúng tôi có thể đã đạt được kết quả tương tự với

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

09. Để kết hợp một số lượng đối tượng gấu trúc tùy ý (

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

00 hoặc

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

02), sử dụng

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

9.

Nếu không tên

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

02 được thông qua, chúng sẽ được đánh số liên tiếp.

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

1

Vượt qua

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

14 sẽ bỏ tất cả các tài liệu tham khảo tên.

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

2

Thêm kết nối với các phím nhóm#

Việc sử dụng khá phổ biến của đối số

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

3 là ghi đè tên cột khi tạo

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

00 mới dựa trên

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

02 hiện có. Lưu ý cách hành vi mặc định bao gồm để cho kết quả

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

00 kế thừa tên cha mẹ ____102, khi chúng tồn tại.

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

3

Thông qua đối số

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

3, chúng ta có thể ghi đè các tên cột hiện có.

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

4

Hãy cùng 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,
)

5

Bạn cũng có thể chuyển một dict cho

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

9 trong trường hợp đó, các khóa Dict sẽ được sử dụng cho đối số

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

3 (trừ khi các khóa khác được chỉ định):

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

6

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

7

Multiindex được tạo ra có các mức được xây dựng từ các khóa được thông qua và chỉ số của các mảnh

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

00:

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

8

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

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

8:

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

9

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

0

Điều này khá bí truyền, nhưng thực sự cần thiết để thực hiện những thứ như Groupby trong đó thứ tự của một biến phân loại là 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 như một hàng duy nhất vào

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

00, bạn có thể chuyển đổi hàng thành

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

00 và sử dụng

In [11]: result = pd.concat([df1, df4], axis=1).reindex(df1.index)

9

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

1

Bạn nên sử dụng

In [12]: pd.concat([df1, df4.reindex(df1.index)], axis=1)
Out[12]: 
    A   B   C   D    B    D    F
0  A0  B0  C0  D0  NaN  NaN  NaN
1  A1  B1  C1  D1  NaN  NaN  NaN
2  A2  B2  C2  D2   B2   D2   F2
3  A3  B3  C3  D3   B3   D3   F3

6 với phương pháp này để hướng dẫn DataFrame loại bỏ chỉ mục của nó. Nếu bạn muốn bảo tồn chỉ mục, bạn nên xây dựng một bản dữ liệu được chỉ định một cách thích hợp và nối hoặc nối các đối tượng đó.

DataFrame kiểu cơ sở dữ liệu hoặc chuỗi được đặt tên tham gia/hợp nhất#

Pandas có các hoạt động tham gia trong bộ nhớ đầy đủ tính năng, hiệu suất cao rất giống với cơ sở dữ liệu quan hệ như SQL. Các phương pháp này thực hiện tốt hơn đáng kể (trong một số trường hợp tốt hơn một thứ tự lớn hơn) so với các triển khai nguồn mở khác (như

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,
)

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,
)

Xem sách dạy nấu ăn cho một số chiến lược nâng cao.cookbook for some advanced strategies.

Người dùng quen thuộc với SQL nhưng mới với gấu trúc có thể quan tâm đến việc so sánh với SQL.comparison with SQL.

Pandas cung cấp một chức năng duy nhất,

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,
)

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

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

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

  34: Đối tượng DataFrame hoặc được đặt tên là đối tượng.

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

  35: Một đối tượng DataFrame hoặc được đặt tên khác.

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

  36: Tên cấp độ hoặc chỉ mục để tham gia. Phải được tìm thấy trong cả đối tượng DataFrame và/hoặc Series bên trái. Nếu không được thông qua và

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

  37 và

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

  38 là

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

  39, giao điểm của các cột trong các khung dữ liệu và/hoặc chuỗi sẽ được suy ra là các phím tham gia.

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

  40: Cột hoặc cấp chỉ mục từ DataFrame hoặc Sê -ri bên trái để sử dụng làm khóa. Có thể là tên cột, tên cấp chỉ mục hoặc mảng có độ dài bằng độ dài của DataFrame hoặc Sê -ri.

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

  41: Cột hoặc cấp chỉ mục từ DataFrame hoặc Sê -ri bên phải để sử dụng làm khóa. Có thể là tên cột, tên cấp chỉ mục hoặc mảng có độ dài bằng độ dài của DataFrame hoặc Sê -ri.

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

  37: Nếu

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

  43, hãy sử dụng chỉ mục (nhãn hàng) từ DataFrame bên trái hoặc chuỗi làm khóa nối của nó. Trong trường hợp của DataFrame hoặc Sê -ri có đa dạng (phân cấp), số lượng cấp độ phải khớp với số khóa tham gia từ DataFrame hoặc Sê -ri 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,
  )
  

  38: sử dụng tương tự như

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

  37 cho đúng DataFrame hoặc Sê -ri

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

  46: một trong số

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

  47,

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

  48,

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

  49,

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

  50,

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

  51. Mặc định là

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

  52. Xem bên dưới để biết mô tả chi tiết hơn về từng phương pháp.

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

  53: Sắp xếp kết quả DataFrame theo các khóa tham gia theo thứ tự từ vựng. Mặc định là

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

  43, cài đặt thành

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

  39 sẽ cải thiện hiệu suất đáng kể trong nhiều trường hợp.

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

  56: Một bộ hậu tố chuỗi để áp dụng cho các cột chồng chéo. Mặc định là

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

  57.

• In [13]: result = pd.concat([df1, df4], ignore_index=True, sort=False)
  

  1: Luôn sao chép dữ liệu (mặc định

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

  43) từ các đối tượng DataFrame được truyền hoặc các đối tượng được đặt tên, ngay cả khi không cần thiết phải tái lập. Không thể tránh được trong nhiều trường hợp nhưng có thể cải thiện việc sử dụng hiệu suất / bộ nhớ. Các trường hợp sao chép có thể tránh được có phần bệnh lý nhưng tùy chọn này dù sao cũng được cung cấp.

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

  60: Thêm một cột vào DataFrame đầu ra được gọi là

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

  61 với thông tin về nguồn của mỗi hàng.

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

  61 là loại phân loại và nhận được giá trị

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

  63 cho các quan sát có khóa hợp nhất chỉ 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,
  )
  

  47 DataFrame hoặc Sê-ri,

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

  65 cho các quan sát có khóa hợp nhất chỉ 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,
  )
  

  48 .

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

  68: Chuỗi, mặc định Không có. Nếu được chỉ định, kiểm tra nếu Merge thuộc loại được chỉ định.

  • Một lần nữa, một trong hai bộ dữ liệu bên trái và bên phải.

  • Một lần nữa, One One_To_Many, hoặc 1: M ': Kiểm tra xem các phím hợp nhất có phải là duy nhất trong bộ dữ liệu bên trái không.

  • Càng nhiều_to_one, hoặc M M: 1: Kiểm tra xem các phím hợp nhất có phải là duy nhất trong bộ dữ liệu bên phải không.

  • Càng nhiều_to_many, hoặc M M: Mùi: được phép, nhưng không dẫn đến séc.

Ghi chú

Hỗ trợ chỉ định các mức chỉ mục là các tham 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,
)

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,
)

Loại trả lại sẽ giống như

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,
)

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,
)

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,
)

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,
)

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,
)

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

Phương thức

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,
)

Sao mồi ngắn gọn về phương pháp hợp nhất (đại số quan hệ)#

Người dùng có kinh nghiệm của các 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 tham gia giữa hai cấu trúc SQL Table như các cấu trúc (

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

00 đối tượng). Có một số trường hợp cần xem xét rất quan trọng để hiểu:

• Tham gia một-một: Ví dụ: khi tham gia hai đối tượng

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

  00 trên các chỉ mục của chúng (phải chứa các giá trị duy nhất). joins: for example when joining two

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

  00 objects on their indexes (which must contain unique values).

• Tham gia nhiều-một: Ví dụ: khi tham gia một chỉ mục (duy nhất) với một hoặc nhiều cột trong một

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

  00 khác. joins: for example when joining an index (unique) to one or more columns in a different

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

  00.

• Nhiều người tham gia: tham gia các cột trên các cột. joins: joining columns on columns.

Ghi chú

Hỗ trợ chỉ định các mức chỉ mục là các tham số

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

36,

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

40 và

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

41 đã được thêm vào phiên bản 0.23.0. Hỗ trợ hợp nhất các đối tượng

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

02 đã được thêm vào phiên bản 0.24.0.will be discarded.

Loại trả lại sẽ giống như

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

34. Nếu

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

34 là

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

00 hoặc được đặt tên

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

02 và

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

35 là một lớp con của

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

00, loại trả lại vẫn sẽ là

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

00.many-to-many join case. In SQL / standard relational algebra, if a key combination appears more than once in both tables, the resulting table will have the Cartesian product of the associated data. Here is a very basic example with one unique key combination:

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

3

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

80 là một chức năng trong không gian tên Pandas và nó cũng có sẵn dưới dạng phương thức phiên bản

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

00

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

31, với cuộc gọi

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

00 được coi là đối tượng bên trái trong tham gia.

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

4

Phương thức

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

84 liên quan, sử dụng nội bộ cho chỉ số chỉ mục (theo mặc định) và (s) -on-on-chỉ số tham gia. Nếu bạn chỉ tham gia vào chỉ mục, bạn có thể muốn sử dụng

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

86 để tiết kiệm cho mình một số gõ.does not appear in either the left or right tables, the values in the joined table will be

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

96. Here is a summary of the

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

46 options and their SQL equivalent names:

Sao mồi ngắn gọn về phương pháp hợp nhất (đại số quan hệ)#	Người dùng có kinh nghiệm của các 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 tham gia giữa hai cấu trúc SQL Table như các cấu trúc ( pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 00 đối tượng). Có một số trường hợp cần xem xét rất quan trọng để hiểu:	Tham gia một-một: Ví dụ: khi tham gia hai đối tượng pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 00 trên các chỉ mục của chúng (phải chứa các giá trị duy nhất).
pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 34	pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 99	Tham gia nhiều-một: Ví dụ: khi tham gia một chỉ mục (duy nhất) với một hoặc nhiều cột trong một pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 00 khác.
pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 35	In [6]: result = pd.concat(frames, keys=["x", "y", "z"]) 01	Nhiều người tham gia: tham gia các cột trên các cột.
In [6]: result = pd.concat(frames, keys=["x", "y", "z"]) 02	In [6]: result = pd.concat(frames, keys=["x", "y", "z"]) 03	Khi tham gia các cột trên các cột (có khả năng tham gia nhiều-nhiều), bất kỳ chỉ mục nào trên các đối tượng pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 00 đã được loại bỏ sẽ bị loại bỏ.
pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 52	In [6]: result = pd.concat(frames, keys=["x", "y", "z"]) 05	Điều đáng để dành một chút thời gian để hiểu kết quả của vụ án tham gia nhiều-nhiều. Trong đại số quan hệ SQL / tiêu chuẩn, nếu một sự kết hợp chính xuất hiện nhiều lần trong cả hai bảng, bảng kết quả sẽ có sản phẩm Cartesian của dữ liệu liên quan. Dưới đây là một ví dụ rất cơ bản với một kết hợp khóa duy nhất:
In [6]: result = pd.concat(frames, keys=["x", "y", "z"]) 06	In [6]: result = pd.concat(frames, keys=["x", "y", "z"]) 07	Dưới đây là một ví dụ phức tạp hơn với nhiều khóa 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, ) 34 và pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 35 mới có mặt (giao điểm), vì pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, ) 93 theo mặc định.

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

5

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

6

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

7

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

8

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

9

Đối số

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

46 cho

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

80 Chỉ định cách xác định các khóa nào sẽ được đưa vào bảng kết quả. Nếu một kết hợp khóa không xuất hiện trong các bảng bên trái hoặc bên phải, các giá trị trong bảng được nối sẽ là

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

96. Dưới đây là bản tóm tắt các tùy chọn

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

46 và tên tương đương SQL của chúng:

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

0

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

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

1

Tên tham gia SQL

Sự mô tả

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

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

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

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,
)

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 [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

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

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

In [7]: result.loc["y"]
Out[7]: 
    A   B   C   D
4  A4  B4  C4  D4
5  A5  B5  C5  D5
6  A6  B6  C6  D6
7  A7  B7  C7  D7

In [6]: result = pd.concat(frames, keys=["x", "y", "z"])

frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)

frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)

frames = [ process_your_file(f) for f in files ]
result = pd.concat(frames)