Python kiểm tra boolean sai

gấu trúc cung cấp nhiều phương tiện khác nhau để dễ dàng kết hợp Sê-ri hoặc Khung dữ liệu với nhiều loại logic thiết lập khác nhau cho các chỉ mục và chức năng đại số quan hệ trong trường hợp hoạt động kiểu nối/hợp nhất

Nội dung chính Show

Nối các đối tượng #
Đặt logic trên các trục khác#
Bỏ qua các chỉ mục trên trục nối #
Kết nối với ndims hỗn hợp #
Kết nối nhiều hơn với các phím nhóm #
Nối các hàng vào DataFrame#
DataFrame kiểu cơ sở dữ liệu hoặc nối/hợp nhất sê-ri có tên #
Sơ lược về các phương pháp hợp nhất (đại số quan hệ)#
Đang kiểm tra các khóa trùng lặp#
Chỉ số hợp nhất #
Hợp nhất dtypes#
Tham gia vào chỉ số #
Tham gia các cột chính trên một chỉ mục #
Tham gia một Chỉ mục duy nhất vào MultiIndex#
Tham gia với hai MultiIndexes#
Hợp nhất trên sự kết hợp của các cột và cấp độ chỉ mục#
Cột giá trị chồng chéo #
Tham gia nhiều DataFrames#
Hợp nhất các giá trị với nhau trong các cột Sê-ri hoặc Khung dữ liệu#
Hợp nhất thân thiện với dòng thời gian#
Hợp nhất dữ liệu có thứ tự #
Sáp nhập asof#
So sánh đối tượng#

Ngoài ra pandas còn cung cấp tiện ích so sánh 2 Series hoặc DataFrame và tóm tắt sự khác biệt của chúng

Nối các đối tượng #

Hàm

19 (trong không gian tên gấu trúc chính) thực hiện tất cả các công việc nặng nhọc khi thực hiện các thao tác nối dọc theo một trục trong khi thực hiện logic thiết lập tùy chọn (liên kết hoặc giao nhau) của các chỉ mục (nếu có) trên các trục khác. Lưu ý rằng tôi nói “nếu có” bởi vì chỉ có một trục nối duy nhất có thể có cho Sê-ri

Trước khi đi sâu vào tất cả các chi tiết của

20 và những gì nó có thể làm, đây là một ví dụ đơn giản

In    ...:     {    ...:     ...:     ...:     ...:     ...:     ...:     ...: )    ...: 

In [2]:    ...:     {    ...:     ...:     ...:     ...:     ...:     ...:     ...: )    ...: 

In [3]:    ...:     {    ...:     ...:     ...:     ...:     ...:     ...:     ...: )    ...: 

In [4]:

In [5]:

[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], 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], 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], frames = [df1, df2, df3] result = pd.concat(frames)

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

21,

22 lấy một danh sách hoặc lệnh của các đối tượng được nhập đồng nhất và nối chúng với một số cách xử lý có thể định cấu hình “phải làm gì với các trục khác”

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

23. một chuỗi hoặc ánh xạ của các đối tượng Sê-ri hoặc DataFrame. Nếu một lệnh chính tả được thông qua, các khóa được sắp xếp sẽ được sử dụng làm đối số
24, 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). Mọi đối tượng Không có sẽ bị loại bỏ một cách im lặng trừ khi tất cả chúng đều là Không, trong trường hợp đó, ValueError sẽ được nâng lên
25. {0, 1, …}, mặc định 0. Trục để nối dọc
26. {‘bên trong’, ‘bên ngoài’}, ‘bên ngoài’ mặc định. Cách xử lý các chỉ mục trên (các) trục khác. Bên ngoài cho liên minh và bên trong cho giao lộ
27. 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 gắn nhãn 0, …, n - 1. Điều này hữu ích nếu bạn đang nối các đối tượng mà trục nối không có thông tin lập chỉ mục có ý nghĩa. Lưu ý rằng các giá trị chỉ mục trên các trục khác vẫn được tôn trọng trong phép nối
24. trình tự, mặc định Không có. Xây dựng chỉ mục phân cấp bằng cách sử dụng các khóa đã truyền làm cấp ngoài cùng. Nếu vượt qua nhiều cấp độ, nên chứa các bộ dữ liệu
29. danh sách các trình tự, mặc định Không có. Các mức cụ thể (giá trị duy nhất) để sử dụng để xây dựng MultiIndex. Nếu không, chúng sẽ được suy ra từ các phím
30. danh sách, mặc định Không có. Tên cho các mức trong chỉ mục phân cấp kết quả
31. boolean, mặc định Sai. Kiểm tra xem trục nối mới có trùng lặp không. Điều này có thể rất tốn kém so với việc nối dữ liệu thực tế
32. boolean, mặc định Đúng. Nếu Sai, không sao chép dữ liệu không cần thiết

Không có một chút ngữ cảnh, nhiều lập luận trong số này không có nhiều ý nghĩa. 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 DataFrame được chia nhỏ. Chúng ta có thể làm điều này bằng cách sử dụng đối số

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ỉ mục của đối tượng kết quả có chỉ mục phân cấp . Điều này có nghĩa là bây giờ chúng ta có thể chọn ra từng đoạn theo 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)

Không khó để thấy điều này có thể rất hữu ích như thế nào. Chi tiết hơn về chức năng này dưới đây

Ghi chú

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

19 (và do đó

35) tạo một bản sao đầy đủ của dữ liệu và việc liên tục sử dụng lại chức năng này có thể tạo ra hiệu suất đáng kể. Nếu bạn cần sử dụng thao tác trên một số bộ dữ liệu, hãy sử dụng cách hiểu danh sách

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)

Ghi chú

Khi nối các Khung dữ liệu với các trục được đặt tên, gấu trúc sẽ cố gắng giữ nguyê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 yếu tố đầ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 này cũng đúng với

36, nhưng logic được áp dụng riêng theo từng cấp độ

Đặ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

37 mặc định

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à đ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

41 không có chỉ mục có ý nghĩa, bạn có thể nối thêm chúng và bỏ qua thực tế là chúng có thể có các chỉ mục chồng chéo. Để làm điều này, hãy sử dụng đối số

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

43 và

41.

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

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

Ghi chú

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

43 với một

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

50. Để nối một số đối tượng gấu trúc tùy ý (

41 hoặc

43), hãy sử dụng

Nếu

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

Vượt qua

55 sẽ loại bỏ tất cả các tham chiếu tên

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ố

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

41 mới dựa trên

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

41 kế thừa tên của cha mẹ

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

Thông qua đối số

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

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

20 trong trường hợp đó, các phím chính tả sẽ được sử dụng cho đối số

24 (trừ khi các phím 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,
)

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

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ố

Đ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

41, bạn có thể chuyển đổi hàng đó thành một

41 và sử dụng

Bạn nên sử dụng

27 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 duy trì chỉ mục, bạn nên xây dựng một DataFrame được lập chỉ mục phù hợp và nối thêm hoặc nối các đối tượng đó

DataFrame kiểu cơ sở dữ liệu hoặc nối/hợp nhất sê-ri có tên #

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

70 trong R). Lý do cho điều này là do thiết kế thuật toán cẩn thận và bố cục bên trong của dữ liệu trong

Xem sách dạy nấu ăn để biết một số chiến lược nâng cao.

Người dùng quen thuộc với SQL nhưng mới sử dụng pandas có thể quan tâm đến so sánh với SQL .

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

72, làm điểm vào cho tất cả các thao tác nối cơ sở dữ liệu tiêu chuẩn giữa các đối tượng

41 hoặc tên là

75. Một DataFrame hoặc đối tượng Sê-ri có tên
76. Một DataFrame khác hoặc đối tượng Sê-ri có tên
77. Tên cấp độ cột hoặc chỉ mục để tham gia. Phải được tìm thấy trong cả đối tượng DataFrame và/hoặc Chuỗi bên trái và bên phải. Nếu không được thông qua và
78 và
79 là
80, giao điểm của các cột trong Khung dữ liệu và/hoặc Chuỗi sẽ được suy ra là khóa tham gia
81. Các 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
82. Các cột hoặc cấp chỉ mục từ Khung dữ liệu 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
78. Nếu
84, hãy sử dụng chỉ mục (nhãn hàng) từ DataFrame hoặc Sê-ri bên trái làm (các) khóa tham gia của nó. Trong trường hợp Khung dữ liệu hoặc Sê-ri có Đa chỉ mục (phân cấp), số cấp phải khớp với số lượng khóa tham gia từ Sê-ri hoặc Khung dữ liệu bên phải
79. Cách sử dụng tương tự như
78 cho DataFrame hoặc Sê-ri phù hợp
87. Một trong số
88,
89,
90,
91,
92. Mặc định là
93. Xem bên dưới để biết thêm mô tả chi tiết về từng phương pháp
94. Sắp xếp DataFrame kết quả theo các phím tham gia theo thứ tự từ điển. Mặc định là
84, đặt thành
80 sẽ cải thiện đáng kể hiệu suất trong nhiều trường hợp
97. Một bộ hậu tố chuỗi để áp dụng cho các cột chồng chéo. Mặc định là
98
32. Luôn sao chép dữ liệu (mặc định là
84) từ DataFrame đã truyền hoặc các đối tượng Sê-ri có tên, ngay cả khi không cần lập chỉ mục lại. Không thể tránh được trong nhiều trường hợp nhưng có thể cải thiện hiệu suất/sử dụng bộ nhớ. Các trường hợp sao chép có thể tránh được hơi bệnh lý nhưng tùy chọn này vẫn đượ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,
)

01. Thêm một cột vào DataFrame đầu ra có tên là

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

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

02 là loại Phân loại và nhận giá trị là

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

04 đối với các quan sát có khóa hợp nhất chỉ xuất hiện trong

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

06 đối với các quan sát có khóa hợp nhất chỉ xuất hiện trong

89 Khung dữ liệu hoặc Sê-ri và

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

08 nếu khóa hợp nhất của quan sát được tìm thấy trong cả hai

```
pd.concat(
    objs,
    axis=0,
    join="outer",
    ignore_index=False,
    keys=None,
    levels=None,
    names=None,
    verify_integrity=False,
    copy=True,
)
```
09. chuỗi, mặc định Không có. Nếu được chỉ định, kiểm tra xem hợp nhất có thuộc loại được chỉ định không
- “one_to_one” hoặc “1. 1”. kiểm tra xem các khóa hợp nhất có phải là duy nhất trong cả bộ dữ liệu bên trái và bên phải không
- “one_to_many” hoặc “1. m”. kiểm tra xem các khóa hợp nhất có phải là duy nhất trong tập dữ liệu bên trái không
- “many_to_one” hoặc “m. 1”. kiểm tra xem các khóa hợp nhất có phải là duy nhất trong tập dữ liệu bên phải không
- “many_to_many” hoặc “m. m”. được phép, nhưng không dẫn đến kiểm tra

Ghi chú

Hỗ trợ chỉ định các mức chỉ mục dưới dạng tham số

77,

81 và

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

43 đã được thêm vào trong phiên bản 0. 24. 0

Kiểu trả về sẽ giống như

75. Nếu

75 là một

41 hoặc có tên là

43 và

76 là một phân lớp của

41, kiểu trả về 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,
)

21 là một hàm trong không gian tên pandas và nó cũng có sẵn dưới dạng phương thức đối tượng

72, với cách gọi

41 được coi là đối tượng bên trái trong liên kết

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

25 có liên quan, sử dụng nội bộ

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

21 cho liên kết chỉ mục trên chỉ mục (theo mặc định) và (các) cột trên chỉ mục. Nếu bạn chỉ tham gia theo chỉ mục, bạn có thể sử dụng

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

27 để tiết kiệm thời gian nhập liệu

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

41 đã truyền sẽ bị loại bỏ

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 một tổ hợp phím xuất hiện nhiều lần trong cả hai bảng, thì bảng kết quả sẽ có tích Descartes 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

Đâ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

75 và

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

34 theo mặc định

Đối số

87 của

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

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

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

37. Dưới đây là tóm tắt về các tùy chọn

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

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

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

49 trước khi hợp nhất, như 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

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

09 để tự động kiểm tra xem có trùng lặp không mong muốn trong các khóa hợp nhất của họ hay không. Tính duy nhất của khóa được kiểm tra trước các hoạt động hợp nhất và do đó sẽ bảo vệ chống tràn bộ nhớ. Kiểm tra tính duy nhất của khóa cũng là một cách hay để đảm bảo cấu trúc dữ liệu người dùng như mong đợi

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

51 ở bên phải

41. Vì đây không phải là hợp nhất một đối một – như được chỉ định trong đối số

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

09 – một ngoại lệ sẽ được đưa ra

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

41 bên phải nhưng muốn đảm bảo không có bản sao nào trong DataFrame bên trái, 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,
)

55 để thay thế, điều này sẽ không gây ra ngoại lệ

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 #

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

01. Nếu

84, một cột kiểu Phân loại có tên là

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

02 sẽ được thêm vào đối tượng đầu ra nhận các giá trị

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

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

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

Chỉ hợp nhất khóa trong khung

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

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

01 cũng sẽ chấp nhận các đối số chuỗi, trong trường hợp đó, hàm chỉ báo sẽ sử dụng giá trị của chuỗi đã truyền làm tên cho cột chỉ báo

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 dtypes#

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

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)

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

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)

Việc hợp nhất sẽ giữ nguyên

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

67 dtypes của việc hợp nhất. Xem thêm phần về danh mục .

khung bên trái

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)

khung bên phải

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)

Kết quả hợp 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)

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 ________ 667 dtypes giống nhau có thể khá hiệu quả so với hợp nhất ________ 669 dtype

Tham gia vào chỉ số #

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

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

71 có khả năng được lập chỉ mục khác nhau thành một kết quả duy nhất

41. Đây là một ví dụ rất cơ bả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)

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)

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

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

21 cùng với các đối số bổ sung hướng dẫn nó sử dụng các chỉ mục

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)

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

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

25 nhận một đối số tùy chọn

77 có thể là một cột hoặc nhiều tên cột, xác định rằng

41 đã qua sẽ được căn chỉnh trên cột đó trong

41. Hai lệnh gọi hàm này hoàn toàn tương đươ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)

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

41 đã được lập chỉ mục bằng khóa nối), sử dụng

26 có thể thuận tiện hơn. Đây là một ví dụ đơn giả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)

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)

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

27 là thực hiện nối trái (về cơ bản là thao tác “VLOOKUP”, dành cho người dùng Excel), thao tác này chỉ sử dụng các khóa được tìm thấy trong DataFrame đang gọi. Các kiểu nối khác, ví dụ như nối bên trong, có thể được thực hiện dễ dàng

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 MultiIndex#

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

41 được lập chỉ mục đơn lẻ với cấp độ của một

41 được lập chỉ mục nhiều. Cấp độ sẽ khớp với tên của chỉ mục của khung được lập chỉ mục đơn lẻ so với tên cấp độ của khung MultiIndexed

Đ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ố

77,

81 và

82 có thể đề cập đến tên cột hoặc tên cấp chỉ mục. Điều này cho phép hợp nhất các phiên bản

41 trên tổ hợp các cấp chỉ mục và cột mà không cần đặt lại chỉ mục

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

36, các cấp độ bổ sung sẽ bị loại bỏ khỏi kết quả hợp nhất. Để duy trì các cấp độ đó, hãy sử dụng

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

90 trên các tên cấp độ đó để di chuyển các cấp độ đó sang các cột trước khi thực hiện hợp nhất

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 chéo #

Đối số hợp nhất

97 lấy một bộ danh sách các chuỗi để nối vào các tên cột chồng chéo trong các

41 đầu vào để phân biệt các cột kết quả

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

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

94 và

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

95 hoạt động tương tự

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

71 cũng có thể được chuyển đến

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

25 để nối chúng lại với nhau trên các chỉ mục của chúng

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

43 hoặc

41 được lập chỉ mục giống nhau (hoặc được lập chỉ mục tương tự) và muốn “chắp vá” các giá trị trong một đối tượng từ các giá trị để khớp chỉ mục trong đối tượng kia. Đây là một ví dụ

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

800

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

41 nếu chúng bị thiếu trong bên trái

41. Một phương pháp liên quan,

803, thay đổi các giá trị không phải NA tại chỗ

Hợp nhất thân thiện với dòng thời gian#

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

Hàm

804 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

805 tùy chọn để điền/nội suy dữ liệu bị thiếu

Sáp nhập asof#

Một

806 tương tự như nối trái theo 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

41, chúng tôi chọn hàng cuối cùng trong

41 có phím

77 nhỏ hơn phím bên trái. Cả hai DataFrames phải được sắp xếp theo khóa

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

812 như nhau, ngoài khớp gần nhất trên khóa

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 1817 giữa thời gian báo giá và thời gian giao dịch

Chúng tôi chỉ cập nhật trong vòng 18 giờ 18 phút giữa thời điểm báo giá và thời gian giao dịch và chúng tôi loại trừ các trận đấu chính xác đúng thời điểm. Lưu ý rằng mặc dù chúng tôi loại trừ các đối sánh chính xác (của các trích dẫn), nhưng các trích dẫn trước đó sẽ lan truyền đến thời điểm đó

So sánh đối tượng#

Các phương pháp

819 và

819 cho phép bạn so sánh hai DataFrame hoặc Sê-ri tương ứng và tóm tắt sự khác biệt của chúng

Tính năng này đã được thêm vào V1. 1. 0 .

Ví dụ: bạn có thể muốn so sánh hai

41 và xếp các điểm khác biệt của chúng cạnh nhau

Theo mặc định, nếu hai giá trị tương ứng bằng nhau, chúng sẽ được hiển thị là

822. Hơn nữa, nếu tất cả các giá trị trong toàn bộ một hàng/cột, thì hàng/cột đó sẽ bị loại khỏi kết quả. Sự khác biệt còn lại sẽ được căn chỉnh trên các cột

programming python

Python kiểm tra boolean sai

Nối các đối tượng #

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

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

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

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

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

DataFrame kiểu cơ sở dữ liệu hoặc nối/hợp nhất sê-ri có tên #

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

Đang kiểm tra các khóa trùng lặp#

Chỉ số hợp nhất #

Hợp nhất dtypes#

Tham gia vào chỉ số #

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

Tham gia một Chỉ mục duy nhất vào MultiIndex#

Tham gia với hai MultiIndexes#

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

Cột giá trị chồng chéo #

Tham gia nhiều DataFrames#

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

Hợp nhất thân thiện với dòng thời gian#

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

Sáp nhập asof#

So sánh đối tượng#

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội