Hợp nhất các tệp html
Trộn thư – trộn thư, là tính năng hữu ích trong Microsoft Word, tính năng này giúp bạn giảm thiểu thời gian khi làm hợp đồng lao động, phiếu lương, thư mời, thông báo, thư cảm ơn,… và có thể tham gia Show
Mặc dù rất hữu ích nhưng hình như rất nhiều độc giả còn chưa biết đến tính năng này. Vì thế hôm nay Webketoan sẽ hướng dẫn bạn cách sử dụng. Sau đây là hướng dẫn các bạn hợp tác lao động bằng cách hợp nhất thư Bước 1. Mở file Word, chọn tab Mailings -> Start Mail Merge -> Step by Step Mail Merge Wizard Bước 2. Xuất hiện Trộn thư ở phía bên phải Word, các bạn chọn Thư và chọn Tiếp theo. tài liệu bắt đầu Bước 3. Tiếp tục chọn Sử dụng tài liệu hiện tại và chọn Tiếp theo. Chọn người nhận Bước 4. Trong Chọn người nhận, các bạn chọn Sử dụng danh sách hiện có nếu danh sách có sẵn, các bạn có thể chọn Nhập danh sách mới để tạo danh sách mới. Sau đó nhấn Next. Viết thư của bạn Bước 5. Trong hộp thoại Select Data Source, các bạn chọn đến danh sách (file excel) có sẵn và nhấn Open Ví dụ file excel để tạo hợp đồng như sau. (đây chỉ là file excel minh họa, chưa đầy đủ) Sau đó nhấn chọn trang tính chứa thông tin Ví dụ trong file Excel sheet1 này là sheet chứa dữ liệu, ta chọn Sheet1. Sau đó nhấn OK Bước 6. Trong hộp thoại Người nhận trộn thư, các bạn chọn dữ liệu cần chèn bằng cách đánh dấu vào các ô vuông trước dữ liệu đó. Nếu chèn tất cả các bạn chọn đánh dấu vào ô vuông Nguồn dữ liệu. Bước 7. Chọn Tiếp theo. Viết thư của bạn Bước 8. Trong bước tiếp theo, bạn đặt con trỏ chuột vào vị trí cần chèn dữ liệu, sau đó nhấn vào Các mục khác Bước 9. Xuất hiện hộp thoại Insert Merge Field, các bạn chọn trường dữ liệu đúng với nội dung, sau đó nhấp chuột vào Insert để chèn. Bước 10. Chèn lần đến hết các trường dữ liệu vào mẫu Word có sẵn. Nhấn Tiếp theo. Xem trước thư của bạn 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 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ượngHàm (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 [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, 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, ) 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ố 24 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)7 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ó một. Đ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)9 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à (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 1 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 , nhưng logic được áp dụng riêng trên cơ sở từng cấp độ Đặt logic trên các trục khácKhi 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
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 5 Đây là điều tương tự với 38 8 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 1 Tương tự, chúng ta có thể lập chỉ mục trước khi nối 2 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ố 27 4 Kết nối với ndims hỗn hợpBạ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 43 6 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. Để nối một số đối tượng gấu trúc tùy ý ( 41 hoặc 43), hãy sử dụng 20 Nếu 43 không tên được thông qua, chúng sẽ được đánh số liên tiếp 8 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, )0 Kết nối nhiều hơn với các phím nhómMộ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, )2 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, )3 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, )4 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, )6 pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, )8 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 41 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)70 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ố 29 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)71 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)73 Đ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 DataFrameNế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 20 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)74 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ênpandas 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 41 Xem 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 gấu trúc cung cấp một chức năng duy nhất, 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à 43 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)76
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à 41 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 một phương thức đối tượng 41, với cách gọi 41 được ngầm coi là đối tượng bên trái trong liên kết Phương pháp 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 phép nối 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ể 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, )27 để tiết kiệm cho mình một số thao tác gõ 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
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 tổ hợp phím xuất hiện nhiều lần trong cả hai bảng, bảng kết quả sẽ có tích Đề các của dữ liệu được liên kết. Đây là một ví dụ rất cơ bản với một tổ hợp phím duy nhất In [1]: df1 = pd.DataFrame( ...: { ...: "A": ["A0", "A1", "A2", "A3"], ...: "B": ["B0", "B1", "B2", "B3"], ...: "C": ["C0", "C1", "C2", "C3"], ...: "D": ["D0", "D1", "D2", "D3"], ...: }, ...: index=[0, 1, 2, 3], ...: ) ...: In [2]: df2 = pd.DataFrame( ...: { ...: "A": ["A4", "A5", "A6", "A7"], ...: "B": ["B4", "B5", "B6", "B7"], ...: "C": ["C4", "C5", "C6", "C7"], ...: "D": ["D4", "D5", "D6", "D7"], ...: }, ...: index=[4, 5, 6, 7], ...: ) ...: In [3]: df3 = pd.DataFrame( ...: { ...: "A": ["A8", "A9", "A10", "A11"], ...: "B": ["B8", "B9", "B10", "B11"], ...: "C": ["C8", "C9", "C10", "C11"], ...: "D": ["D8", "D9", "D10", "D11"], ...: }, ...: index=[8, 9, 10, 11], ...: ) ...: In [4]: frames = [df1, df2, df3] In [5]: result = pd.concat(frames)77 Đâ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 lộ), vì theo 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, )34 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)79 Đố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ả 75 pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, )40 Chỉ sử dụng các phím từ khung bên trái 76 pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, )42 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, )43 pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, )44 Sử dụng liên kết các phím từ cả hai khung 93 pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, )46 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, )47 pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, )48 Tạo sản phẩm cartesian của các hàng của cả hai khung 1 3 5 7 9 Bạn có thể hợp nhất Sê-ri nhiều chỉ mục và Khung dữ liệu, nếu tên của Đa chỉ mục tương ứng với các cột từ Khung dữ liệu. Chuyển đổi Sê-ri thành Khung dữ liệu bằng cách sử dụng trước khi hợp nhất, như minh họa trong ví dụ sau In [1]: df1 = pd.DataFrame( ...: { ...: "A": ["A0", "A1", "A2", "A3"], ...: "B": ["B0", "B1", "B2", "B3"], ...: "C": ["C0", "C1", "C2", "C3"], ...: "D": ["D0", "D1", "D2", "D3"], ...: }, ...: index=[0, 1, 2, 3], ...: ) ...: In [2]: df2 = pd.DataFrame( ...: { ...: "A": ["A4", "A5", "A6", "A7"], ...: "B": ["B4", "B5", "B6", "B7"], ...: "C": ["C4", "C5", "C6", "C7"], ...: "D": ["D4", "D5", "D6", "D7"], ...: }, ...: index=[4, 5, 6, 7], ...: ) ...: In [3]: df3 = pd.DataFrame( ...: { ...: "A": ["A8", "A9", "A10", "A11"], ...: "B": ["B8", "B9", "B10", "B11"], ...: "C": ["C8", "C9", "C10", "C11"], ...: "D": ["D8", "D9", "D10", "D11"], ...: }, ...: index=[8, 9, 10, 11], ...: ) ...: In [4]: frames = [df1, df2, df3] In [5]: result = pd.concat(frames)91 Đâ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)92 Cảnh báo Tham gia/hợp nhất trên các khóa trùng lặp có thể gây ra khung trả về là phép nhân của kích thước hàng, điều này có thể dẫn đến tràn bộ nhớ. Người dùng có trách nhiệm quản lý các giá trị trùng lặp trong các khóa trước khi tham gia các Khung dữ liệu lớn Kiểm tra các khóa trùng lặpNgườ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)94 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)95 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)96 Chỉ số hợp nhấtchấ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ị
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)97 Đố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)98 Hợp nhất các loạiHợ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)99 Chúng tôi có thể bảo tồn các khóa tham gia 10 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 11 Việc hợp nhất sẽ bảo tồn pd.concat( objs, axis=0, join="outer", ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True, )67 dtypes của việc hợp nhất. Xem thêm phần về khung bên trái 12 khung bên phải 13 Kết quả hợp nhất 14 Ghi chú Các loại danh mục phải hoàn toàn giống nhau, nghĩa là cùng danh mục và thuộc tính được sắp xếp. Nếu không, kết quả sẽ ép buộc vào dtype của danh mục Ghi chú Hợp nhất ________ 567 dtypes giống nhau có thể khá hiệu quả so với hợp nhất ________ 569 dtype Tham gia vào chỉ mụclà 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 15 17 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, )34 19 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 51 53 Tham gia các cột chính trên một chỉ mụclấy một đối số 77 tùy chọn 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 55 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 56 58 Để tham gia trên nhiều khóa, DataFrame đã qua phải có một 36 0 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 1 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ư vậy 3 Như bạn có thể thấy, thao tác này loại bỏ bất kỳ hàng nào không khớp Tham gia một Chỉ mục duy nhất vào Đa chỉ mụcBạ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 5 Đ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 7 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 9 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 80 Hợp nhất trên sự kết hợp của các cột và cấp độ chỉ mụcCá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 82 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 lấpĐố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ả 84 86 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ự 88 Tham gia nhiều DataFramesMộ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 để nối chúng lại với nhau trên các chỉ mục của chúng 00 Hợp nhất các giá trị với nhau trong các cột Sê-ri hoặc Khung dữ liệuMộ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ụ 02 Đối với điều này, sử dụng phương pháp 03 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 thức liên quan, , thay đổi các giá trị không phải NA tại chỗ 05 Hợp nhất thân thiện với thời gianHợp nhất dữ liệu có thứ tựMột chức năng cho phép kết hợp chuỗi thời gian và dữ liệu được sắp xếp khác. Cụ thể, nó có một từ khóa In [1]: df1 = pd.DataFrame( ...: { ...: "A": ["A0", "A1", "A2", "A3"], ...: "B": ["B0", "B1", "B2", "B3"], ...: "C": ["C0", "C1", "C2", "C3"], ...: "D": ["D0", "D1", "D2", "D3"], ...: }, ...: index=[0, 1, 2, 3], ...: ) ...: In [2]: df2 = pd.DataFrame( ...: { ...: "A": ["A4", "A5", "A6", "A7"], ...: "B": ["B4", "B5", "B6", "B7"], ...: "C": ["C4", "C5", "C6", "C7"], ...: "D": ["D4", "D5", "D6", "D7"], ...: }, ...: index=[4, 5, 6, 7], ...: ) ...: In [3]: df3 = pd.DataFrame( ...: { ...: "A": ["A8", "A9", "A10", "A11"], ...: "B": ["B8", "B9", "B10", "B11"], ...: "C": ["C8", "C9", "C10", "C11"], ...: "D": ["D8", "D9", "D10", "D11"], ...: }, ...: index=[8, 9, 10, 11], ...: ) ...: In [4]: frames = [df1, df2, df3] In [5]: result = pd.concat(frames)705 tùy chọn để điền/nội suy dữ liệu bị thiếu 07 sáp nhậpA tương tự như phép nối trái có thứ tự ngoại trừ việc chúng tôi khớp với khóa gần nhất thay vì các khóa bằng nhau. Đối với mỗi hàng trong 75 41, chúng tôi chọn hàng cuối cùng trong 76 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 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)712 như nhau, ngoài khớp gần nhất trên khóa 77 Ví dụ; 08 09 Theo mặc định, chúng tôi đang sử dụng dấu ngoặc kép 10 Chúng tôi chỉ cập nhật trong vòng In [1]: df1 = pd.DataFrame( ...: { ...: "A": ["A0", "A1", "A2", "A3"], ...: "B": ["B0", "B1", "B2", "B3"], ...: "C": ["C0", "C1", "C2", "C3"], ...: "D": ["D0", "D1", "D2", "D3"], ...: }, ...: index=[0, 1, 2, 3], ...: ) ...: In [2]: df2 = pd.DataFrame( ...: { ...: "A": ["A4", "A5", "A6", "A7"], ...: "B": ["B4", "B5", "B6", "B7"], ...: "C": ["C4", "C5", "C6", "C7"], ...: "D": ["D4", "D5", "D6", "D7"], ...: }, ...: index=[4, 5, 6, 7], ...: ) ...: In [3]: df3 = pd.DataFrame( ...: { ...: "A": ["A8", "A9", "A10", "A11"], ...: "B": ["B8", "B9", "B10", "B11"], ...: "C": ["C8", "C9", "C10", "C11"], ...: "D": ["D8", "D9", "D10", "D11"], ...: }, ...: index=[8, 9, 10, 11], ...: ) ...: In [4]: frames = [df1, df2, df3] In [5]: result = pd.concat(frames)717 giữa thời gian báo giá và thời gian giao dịch 11 Chúng tôi chỉ tính trong vòng 17 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 đó 12 So sánh đối tượngCác phương thức và 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 trong 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 13 14 15 Theo mặc định, nếu hai giá trị tương ứng bằng nhau, chúng sẽ được hiển thị 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)722. 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 |