❮ Phương pháp ngẫu nhiên
Thí dụ
Trả về số ngẫu nhiên giữa 0. 0 và 1. 0
nhập ngẫu nhiên
in [ngẫu nhiên. ngẫu nhiên[]]
Tự mình thử »Định nghĩa và cách sử dụng
Phương thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370682 trả về một số thực ngẫu nhiên trong khoảng từ 0 đến 1
cú pháp
Giá trị tham số
Không có tham số
❮ Phương pháp ngẫu nhiên
Xác định dữ liệu [i. e. cung cấp siêu dữ liệu] bằng cách sử dụng các chỉ báo đã biết, quan trọng đối với phân tích, trực quan hóa và hiển thị bảng điều khiển tương tác
Cho phép căn chỉnh dữ liệu tự động và rõ ràng
Cho phép nhận và cài đặt trực quan các tập hợp con của tập dữ liệu
Trong phần này, chúng ta sẽ tập trung vào điểm cuối cùng. cụ thể là cách cắt, xúc xắc và nói chung là lấy và đặt các tập con của các đối tượng gấu trúc. Trọng tâm chính sẽ là Sê-ri và DataFrame vì chúng đã nhận được nhiều sự chú ý phát triển hơn trong lĩnh vực này
Ghi chú
Toán tử lập chỉ mục Python và NumPy
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642 và toán tử thuộc tính
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370643 cung cấp quyền truy cập nhanh chóng và dễ dàng vào cấu trúc dữ liệu gấu trúc trong nhiều trường hợp sử dụng. Điều này làm cho công việc tương tác trở nên trực quan, vì có rất ít điều mới để tìm hiểu nếu bạn đã biết cách xử lý từ điển Python và mảng NumPy. Tuy nhiên, vì loại dữ liệu được truy cập không được biết trước nên việc sử dụng trực tiếp các toán tử tiêu chuẩn có một số giới hạn tối ưu hóa. Đối với mã sản xuất, chúng tôi khuyên bạn nên tận dụng các phương pháp truy cập dữ liệu gấu trúc được tối ưu hóa trong chương này
Cảnh báo
Việc một bản sao hoặc một tham chiếu được trả lại cho thao tác cài đặt có thể phụ thuộc vào ngữ cảnh. Điều này đôi khi được gọi là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370644 và nên tránh. Xem Trả lại lượt xem so với bản sao .
Xem MultiIndex / Lập chỉ mục nâng cao để biết tài liệu lập chỉ mục nâng cao hơn cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370645.
Xem sách dạy nấu ăn để biết một số chiến lược nâng cao.
Các lựa chọn khác nhau để lập chỉ mục#
Lựa chọn đối tượng đã có một số bổ sung do người dùng yêu cầu để hỗ trợ lập chỉ mục dựa trên vị trí rõ ràng hơn. gấu trúc hiện hỗ trợ ba loại lập chỉ mục đa trục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
46 chủ yếu dựa trên nhãn, nhưng cũng có thể được sử dụng với mảng boolean.In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
46 sẽ tăngIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
48 khi không tìm thấy vật phẩm. Đầu vào được phép làMột nhãn duy nhất, e. g.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
49 hoặcIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
50 [Lưu ý rằngIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
49 được hiểu là nhãn của chỉ mục. Việc sử dụng này không phải là một vị trí số nguyên dọc theo chỉ mục. ]Danh sách hoặc mảng nhãn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
52Một đối tượng lát có nhãn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
53 [Lưu ý rằng trái với các lát Python thông thường, cả điểm bắt đầu và điểm dừng đều được bao gồm, khi có mặt trong chỉ mục. Xem Cắt lát có nhãn và Điểm cuối bao gồm . ]Một mảng boolean [mọi giá trị
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
54 sẽ được coi làIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
55]Một hàm
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
56 với một đối số [Sê-ri gọi hoặc DataFrame] và trả về đầu ra hợp lệ để lập chỉ mục [một trong những điều trên]
Xem thêm tại Lựa chọn theo Nhãn .
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
57 chủ yếu dựa trên vị trí số nguyên [từIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
58 đếnIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
59 của trục], nhưng cũng có thể được sử dụng với mảng boolean.In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
57 sẽ tăngIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
61 nếu bộ chỉ mục được yêu cầu nằm ngoài giới hạn, ngoại trừ bộ chỉ mục lát cắt cho phép lập chỉ mục ngoài giới hạn. [điều này phù hợp với ngữ nghĩa lát Python/NumPy]. Đầu vào được phép làMột số nguyên e. g.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
49Một danh sách hoặc mảng các số nguyên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
63Một đối tượng lát cắt với ints
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
64Một mảng boolean [mọi giá trị
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
54 sẽ được coi làIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
55]Một hàm
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
56 với một đối số [Sê-ri gọi hoặc DataFrame] và trả về đầu ra hợp lệ để lập chỉ mục [một trong những điều trên]
Xem thêm tại Lựa chọn theo vị trí , Lập chỉ mục nâng cao . Advanced Hierarchical.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
46,In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
57, và cả việc lập chỉ mụcIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
42 có thể chấp nhận mộtIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
56 làm chỉ mục. Xem thêm tại Lựa chọn theo khả năng gọi .
Nhận các giá trị từ một đối tượng với lựa chọn nhiều trục sử dụng ký hiệu sau [sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646 làm ví dụ, nhưng những điều sau đây cũng áp dụng cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370657]. Bất kỳ bộ truy cập trục nào cũng có thể là lát cắt rỗng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370674. Các trục nằm ngoài thông số kỹ thuật được giả định là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370674, e. g.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370676 tương đương với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370677
Loại đối tượng
Người lập chỉ mục
Loạt
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370678
Khung dữ liệu
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370679
Khái niệm cơ bản #
Như đã đề cập khi giới thiệu cấu trúc dữ liệu trong phần cuối , chức năng lập chỉ mục chính với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642 [a. k. a.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370681 dành cho những người quen thuộc với việc triển khai hành vi lớp trong Python] đang chọn ra các lát có chiều thấp hơn. Bảng sau đây hiển thị các giá trị kiểu trả về khi lập chỉ mục đối tượng pandas với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642.
Loại đối tượng
Lựa chọn
Loại giá trị trả về
Loạt
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370683
giá trị vô hướng
Khung dữ liệu
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370684
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685 tương ứng với colname
Ở đây chúng tôi xây dựng một tập dữ liệu chuỗi thời gian đơn giản để sử dụng để minh họa chức năng lập chỉ mục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837064
Ghi chú
Không có chức năng lập chỉ mục nào là chuỗi thời gian cụ thể trừ khi được nêu cụ thể
Do đó, như trên, chúng tôi có chỉ mục cơ bản nhất bằng cách sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
Bạn có thể chuyển danh sách các cột tới
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642 để chọn các cột theo thứ tự đó. Nếu một cột không được chứa trong DataFrame, một ngoại lệ sẽ được đưa ra. Nhiều cột cũng có thể được đặt theo cách này
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837068
Bạn có thể thấy điều này hữu ích khi áp dụng biến đổi [tại chỗ] cho một tập hợp con của các cột
Cảnh báo
gấu trúc căn chỉnh tất cả các TRỤC khi đặt
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689 từ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370657
Điều này sẽ không sửa đổi
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370692 vì căn chỉnh cột trước khi gán giá trị
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837064
Cách chính xác để hoán đổi giá trị cột là sử dụng giá trị thô
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837065
Quyền truy cập thuộc tính #
Bạn có thể truy cập trực tiếp vào chỉ mục trên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685 hoặc cột trên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689 dưới dạng thuộc tính
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837068
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837069
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837060
Cảnh báo
Bạn chỉ có thể sử dụng quyền truy cập này nếu phần tử chỉ mục là mã định danh Python hợp lệ, e. g.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
95 không được phép. Xem tại đây để được giải thích về số nhận dạng hợp lệThuộc tính sẽ không khả dụng nếu nó xung đột với tên phương thức hiện có, e. g.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
96 không được phép, nhưngIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
97 thì có thểTương tự, thuộc tính sẽ không khả dụng nếu xung đột với bất kỳ danh sách nào sau đây. ________ 098, ________ 099, ________ 4800, ________ 4801
Trong bất kỳ trường hợp nào, lập chỉ mục tiêu chuẩn sẽ vẫn hoạt động, e. g.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
802,In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
97 vàIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
804 sẽ truy cập phần tử hoặc cột tương ứng
Nếu bạn đang sử dụng môi trường IPython, bạn cũng có thể sử dụng tính năng hoàn thành tab để xem các thuộc tính có thể truy cập này
Bạn cũng có thể gán một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706805 cho một hàng của một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837063
Bạn có thể sử dụng quyền truy cập thuộc tính để sửa đổi phần tử hiện có của Sê-ri hoặc cột của DataFrame, nhưng hãy cẩn thận; . trong 0. 21. 0 trở lên, điều này sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706807
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837065
Phạm vi cắt #
Cách mạnh mẽ và nhất quán nhất để cắt các phạm vi dọc theo các trục tùy ý được mô tả trong phần Lựa chọn theo vị trí nêu chi tiết phương pháp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370657. Hiện tại, chúng tôi giải thích ngữ nghĩa của việc cắt bằng cách sử dụng toán tử
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642.
Với Sê-ri, cú pháp hoạt động chính xác như với ndarray, trả về một phần giá trị và nhãn tương ứng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837060
Lưu ý rằng cài đặt cũng hoạt động
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837061
Với DataFrame, cắt bên trong
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642 cắt các hàng. Điều này được cung cấp phần lớn như một sự thuận tiện vì đây là một hoạt động phổ biến.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837062
Lựa chọn theo nhãn#
Cảnh báo
Việc một bản sao hoặc một tham chiếu được trả lại cho thao tác cài đặt có thể phụ thuộc vào ngữ cảnh. Điều này đôi khi được gọi là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370644 và nên tránh. Xem Trả lại lượt xem so với bản sao .
Cảnh báo
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646 nghiêm ngặt khi bạn trình bày các slicer không tương thích [hoặc có thể chuyển đổi] với loại chỉ mục. Ví dụ: sử dụng số nguyên trongIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706813. Những điều này sẽ tăng mộtIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706814
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837063
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837064
Chuỗi thích trong cắt lát có thể được chuyển đổi thành loại chỉ mục và dẫn đến cắt tự nhiên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837065
Cảnh báo
Thay đổi trong phiên bản 1. 0. 0
gấu trúc sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370648 nếu lập chỉ mục với danh sách có nhãn bị thiếu. Xem giống như danh sách Sử dụng loc với các phím bị thiếu trong danh sách không được dùng nữa .
gấu trúc cung cấp một bộ phương pháp để lập chỉ mục hoàn toàn dựa trên nhãn. Đây là một giao thức dựa trên sự bao gồm nghiêm ngặt. Mọi nhãn được yêu cầu phải có trong chỉ mục, nếu không sẽ bị đánh dấu
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370648. Khi cắt, cả giới hạn bắt đầu VÀ giới hạn dừng đều được bao gồm, nếu có trong chỉ mục. Số nguyên là nhãn hợp lệ, nhưng chúng đề cập đến nhãn chứ không phải vị trí
Thuộc tính
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646 là phương thức truy cập chính. Sau đây là các đầu vào hợp lệ
Một nhãn duy nhất, e. g.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
49 hoặcIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
50 [Lưu ý rằngIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
49 được hiểu là nhãn của chỉ mục. Việc sử dụng này không phải là một vị trí số nguyên dọc theo chỉ mục. ]Danh sách hoặc mảng nhãn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
52Một đối tượng lát có nhãn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
53 [Lưu ý rằng trái với các lát Python thông thường, cả điểm bắt đầu và điểm dừng đều được bao gồm, khi có mặt trong chỉ mục. Xem Cắt lát có nhãn .một mảng boolean
A
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
56, xem Lựa chọn theo khả năng gọi .
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837066
Lưu ý rằng cài đặt cũng hoạt động
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837067
Với một khung dữ liệu
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837068
Truy cập qua các lát nhãn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.67368970808837069
Để lấy mặt cắt bằng nhãn [tương đương với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706824]
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370680
Để nhận các giá trị với một mảng boolean
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370681
Các giá trị NA trong một mảng boolean lan truyền dưới dạng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370655
Thay đổi trong phiên bản 1. 0. 2
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370682
Để nhận được một giá trị rõ ràng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370683
Cắt lát có nhãn#
Khi sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646 với các lát cắt, nếu cả nhãn bắt đầu và nhãn dừng đều có trong chỉ mục, thì các phần tử nằm giữa hai nhãn [bao gồm cả chúng] sẽ được trả về
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370684
Nếu ít nhất một trong hai yếu tố không có, nhưng chỉ mục được sắp xếp và có thể được so sánh với các nhãn bắt đầu và kết thúc, thì việc cắt lát sẽ vẫn hoạt động như mong đợi, bằng cách chọn các nhãn xếp hạng giữa hai yếu tố này.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685
Tuy nhiên, nếu ít nhất một trong hai không có và chỉ mục không được sắp xếp, thì sẽ xảy ra lỗi [vì làm khác sẽ tốn kém về mặt tính toán, cũng như có khả năng không rõ ràng đối với các chỉ mục loại hỗn hợp]. Chẳng hạn, trong ví dụ trên,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706827 sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370648
Để biết lý do đằng sau hành vi này, hãy xem Điểm cuối bao gồm .
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370686
Ngoài ra, nếu chỉ mục có các nhãn trùng lặp và nhãn bắt đầu hoặc nhãn dừng bị trùng lặp thì sẽ xảy ra lỗi. Chẳng hạn, trong ví dụ trên,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706829 sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370648
Để biết thêm thông tin về nhãn trùng lặp, hãy xem Nhãn trùng lặp .
Lựa chọn theo vị trí#
Cảnh báo
Việc một bản sao hoặc một tham chiếu được trả lại cho thao tác cài đặt có thể phụ thuộc vào ngữ cảnh. Điều này đôi khi được gọi là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370644 và nên tránh. Xem Trả lại lượt xem so với bản sao .
gấu trúc cung cấp một bộ phương pháp để có được chỉ mục dựa trên số nguyên thuần túy. Ngữ nghĩa theo sát Python và NumPy slicer. Đây là lập chỉ mục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706832. Khi cắt, bao gồm giới hạn bắt đầu, trong khi giới hạn trên bị loại trừ. Cố gắng sử dụng một số không phải là số nguyên, ngay cả một nhãn hợp lệ cũng sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370661
Thuộc tính
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370657 là phương thức truy cập chính. Sau đây là các đầu vào hợp lệ
Một số nguyên e. g.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
49Một danh sách hoặc mảng các số nguyên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
63Một đối tượng lát cắt với ints
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
64một mảng boolean
A
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
56, xem Lựa chọn theo khả năng gọi .
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370687
Lưu ý rằng cài đặt cũng hoạt động
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370688
Với một khung dữ liệu
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689
Chọn thông qua cắt số nguyên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370640
Chọn qua danh sách số nguyên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370641
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370643
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370644
Để lấy mặt cắt bằng cách sử dụng vị trí số nguyên [tương đương với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706839]
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370645
Các chỉ mục lát cắt nằm ngoài phạm vi được xử lý một cách duyên dáng giống như trong Python/NumPy
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646
Lưu ý rằng việc sử dụng các lát vượt quá giới hạn có thể dẫn đến một trục trống [e. g. một DataFrame trống được trả về]
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370647
Một người lập chỉ mục nằm ngoài giới hạn sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370661. Một danh sách các bộ chỉ mục trong đó bất kỳ phần tử nào nằm ngoài giới hạn sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370661
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370648
Lựa chọn theo callable#
Lập chỉ mục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370657 và cả
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642 có thể chấp nhận một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370656 làm chỉ mục.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370656 phải là một hàm có một đối số [Sê-ri đang gọi hoặc Khung dữ liệu] trả về đầu ra hợp lệ để lập chỉ mục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370649
Bạn có thể sử dụng lập chỉ mục có thể gọi được trong
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370650
Sử dụng các phương thức/bộ chỉ mục này, bạn có thể xâu chuỗi các thao tác chọn dữ liệu mà không cần sử dụng biến tạm thời
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370651
Kết hợp lập chỉ mục dựa trên vị trí và nhãn #
Nếu bạn muốn lấy phần tử thứ 0 và thứ 2 từ chỉ mục trong cột 'A', bạn có thể làm
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370652
Điều này cũng có thể được thể hiện bằng cách sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370657, bằng cách nhận rõ ràng các vị trí trên bộ chỉ mục và sử dụng chỉ mục vị trí để chọn những thứ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370653
Để có nhiều người lập chỉ mục, sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706849
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370654
Tính năng lập chỉ mục với danh sách thiếu nhãn không được dùng nữa#
Cảnh báo
Thay đổi trong phiên bản 1. 0. 0
Sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646 hoặc
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642 với danh sách có một hoặc nhiều nhãn bị thiếu sẽ không lập chỉ mục lại nữa, có lợi cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706852
Trong các phiên bản trước, việc sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706853 sẽ hoạt động miễn là tìm thấy ít nhất 1 trong số các khóa [nếu không, nó sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370648]. Hành vi này đã được thay đổi và hiện sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370648 nếu ít nhất một nhãn bị thiếu. Phương án thay thế được đề xuất là sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706856
Ví dụ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370655
Lựa chọn với tất cả các khóa được tìm thấy không thay đổi
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370656
hành vi trước đây
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370657
hành vi hiện tại
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370658
Lập chỉ mục lại#
Cách thành ngữ để đạt được việc chọn các phần tử có khả năng không tìm thấy là thông qua
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706856. Xem thêm phần về lập chỉ mục lại .
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370659
Ngoài ra, nếu bạn chỉ muốn chọn các khóa hợp lệ, cách sau đây là thành ngữ và hiệu quả;
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370680
Có một chỉ mục trùng lặp sẽ tăng lên cho một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706856
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370681
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370682
Nói chung, bạn có thể giao các nhãn mong muốn với trục hiện tại, sau đó lập chỉ mục lại
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370683
Tuy nhiên, điều này vẫn sẽ tăng lên nếu chỉ mục kết quả của bạn bị trùng lặp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370684
Chọn mẫu ngẫu nhiên#
Lựa chọn ngẫu nhiên các hàng hoặc cột từ Sê-ri hoặc Khung dữ liệu bằng phương pháp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706859. Phương thức này sẽ lấy mẫu các hàng theo mặc định và chấp nhận một số hàng/cột cụ thể để trả về hoặc một phần nhỏ các hàng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685
Theo mặc định,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706860 sẽ trả về mỗi hàng nhiều nhất một lần, nhưng người ta cũng có thể lấy mẫu thay thế bằng tùy chọn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706861
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370686
Theo mặc định, mỗi hàng có xác suất được chọn như nhau, nhưng nếu bạn muốn các hàng có xác suất khác nhau, bạn có thể chuyển trọng số lấy mẫu của hàm
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706860 thành
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706863. Các trọng số này có thể là một danh sách, một mảng NumPy hoặc một Sê-ri, nhưng chúng phải có cùng độ dài với đối tượng bạn đang lấy mẫu. Các giá trị bị thiếu sẽ được coi là trọng số bằng 0 và các giá trị inf không được phép. Nếu tổng các trọng số không bằng 1, chúng sẽ được chuẩn hóa lại bằng cách chia tất cả các trọng số cho tổng các trọng số. Ví dụ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370687
Khi được áp dụng cho Khung dữ liệu, bạn có thể sử dụng một cột của Khung dữ liệu làm trọng số lấy mẫu [miễn là bạn đang lấy mẫu hàng chứ không phải cột] bằng cách chuyển tên của cột dưới dạng chuỗi
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370688
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706860 cũng cho phép người dùng lấy mẫu cột thay vì hàng bằng cách sử dụng đối số
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706865
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689
Cuối cùng, người ta cũng có thể đặt hạt giống cho trình tạo số ngẫu nhiên của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706860 bằng cách sử dụng đối số
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706867, đối số này sẽ chấp nhận một số nguyên [làm hạt giống] hoặc đối tượng NumPy RandomState
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370690
Cài đặt với phóng to #
Các hoạt động của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706868 có thể thực hiện phóng to khi đặt khóa không tồn tại cho trục đó
Trong trường hợp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685, đây thực sự là một hoạt động nối thêm
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370691
Có thể phóng to một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689 trên một trong hai trục thông qua
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370692
Điều này giống như một hoạt động của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706872 trên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370693
Nhận và cài đặt giá trị vô hướng nhanh #
Vì lập chỉ mục với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370642 phải xử lý nhiều trường hợp [truy cập nhãn đơn, cắt, lập chỉ mục boolean, v.v. ], nó có một chút chi phí hoạt động để tìm ra những gì bạn đang yêu cầu. Nếu bạn chỉ muốn truy cập một giá trị vô hướng, cách nhanh nhất là sử dụng các phương thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706875 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706876, được triển khai trên tất cả các cấu trúc dữ liệu
Tương tự như
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706877,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706875 cung cấp tra cứu vô hướng dựa trên nhãn, trong khi đó,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706876 cung cấp tra cứu dựa trên số nguyên tương tự như
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706880
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370694
Bạn cũng có thể đặt bằng cách sử dụng cùng các bộ chỉ mục này
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370695
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706875 có thể phóng to đối tượng tại chỗ như trên nếu thiếu bộ chỉ mục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370696
Lập chỉ mục Boolean#
Một hoạt động phổ biến khác là sử dụng các vectơ boolean để lọc dữ liệu. Các nhà khai thác là.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706882 cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706883,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706884 cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706885 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706886 cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706887. Chúng phải được nhóm lại bằng cách sử dụng dấu ngoặc đơn, vì theo mặc định, Python sẽ đánh giá một biểu thức chẳng hạn như
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706888 là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706889, trong khi thứ tự đánh giá mong muốn là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706890
Sử dụng một vectơ boolean để lập chỉ mục Sê-ri hoạt động chính xác như trong NumPy ndarray
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370697
Bạn có thể chọn các hàng từ DataFrame bằng cách sử dụng vectơ boolean có cùng độ dài với chỉ mục của DataFrame [ví dụ: thứ gì đó có nguồn gốc từ một trong các cột của DataFrame]
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370698
Khả năng hiểu danh sách và phương pháp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706891 của Sê-ri cũng có thể được sử dụng để tạo ra các tiêu chí phức tạp hơn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370699
Với các phương pháp lựa chọn Lựa chọn theo nhãn , Lựa chọn theo vị trí, and Advanced Indexing you may select along more than one axis using boolean vectors combined with other indexing expressions.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370600
Cảnh báo
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706880 hỗ trợ hai loại lập chỉ mục boolean. Nếu bộ chỉ mục là boolean
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685, lỗi sẽ xuất hiện. Chẳng hạn, trong ví dụ sau,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706894 là được. Bộ chỉ mục boolean là một mảng. Nhưng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706895 sẽ tăng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706896
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370601
Lập chỉ mục với isin#
Xem xét phương thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706897 của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685, phương thức này trả về một vectơ boolean đúng ở bất kỳ nơi nào các phần tử
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685 tồn tại trong danh sách đã truyền. Điều này cho phép bạn chọn các hàng có một hoặc nhiều cột có giá trị bạn muốn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370602
Phương pháp tương tự có sẵn cho các đối tượng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706400 và hữu ích cho các trường hợp khi bạn không biết thực tế nhãn nào đang tìm kiếm có mặt
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370603
Ngoài ra,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370645 cho phép chọn cấp độ riêng để sử dụng trong kiểm tra thành viên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370604
DataFrame cũng có phương thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706897. Khi gọi
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706403, hãy chuyển một tập hợp các giá trị dưới dạng mảng hoặc chính tả. Nếu các giá trị là một mảng, thì
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706403 trả về một DataFrame gồm các booleans có cùng hình dạng với DataFrame ban đầu, với True ở bất kỳ đâu phần tử nằm trong chuỗi giá trị
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370605
Thông thường, bạn sẽ muốn khớp các giá trị nhất định với các cột nhất định. Chỉ cần tạo các giá trị là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706805 trong đó khóa là cột và giá trị là danh sách các mục bạn muốn kiểm tra
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370606
Để trả về DataFrame của booleans trong đó các giá trị không có trong DataFrame gốc, hãy sử dụng toán tử
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706886
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370607
Kết hợp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706403 của DataFrame với các phương pháp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706408 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706409 để nhanh chóng chọn các tập hợp con dữ liệu của bạn đáp ứng một tiêu chí nhất định. Để chọn một hàng trong đó mỗi cột đáp ứng tiêu chí riêng của nó
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370608
Phương pháp In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
410 và Mặt nạ#
Việc chọn các giá trị từ Sê-ri bằng vectơ boolean thường trả về một tập hợp con của dữ liệu. Để đảm bảo rằng đầu ra lựa chọn có cùng hình dạng với dữ liệu gốc, bạn có thể sử dụng phương pháp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706411 trong
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689
Để chỉ trả lại các hàng đã chọn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370609
Để trả về một Sê-ri có hình dạng giống như ban đầu
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370630
Việc chọn các giá trị từ DataFrame với tiêu chí boolean hiện cũng giữ nguyên hình dạng dữ liệu đầu vào.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706411 được sử dụng dưới mui xe khi triển khai. Đoạn mã dưới đây tương đương với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706415
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370631
Ngoài ra,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706411 lấy một đối số tùy chọn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706417 để thay thế các giá trị có điều kiện là Sai, trong bản sao được trả về
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370632
Bạn có thể muốn đặt giá trị dựa trên một số tiêu chí boolean. Điều này có thể được thực hiện bằng trực giác như vậy
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370633
Theo mặc định,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706411 trả về một bản sao dữ liệu đã sửa đổi. Có tham số tùy chọn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706419 để có thể chỉnh sửa dữ liệu gốc mà không cần tạo bản sao
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370634
Ghi chú
Chữ ký cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706420 khác với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706421. Khoảng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706422 tương đương với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706423
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370635
căn chỉnh
Hơn nữa,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706411 căn chỉnh điều kiện boolean đầu vào [ndarray hoặc DataFrame], sao cho có thể chọn một phần với cài đặt. Điều này tương tự với cài đặt từng phần qua
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646 [nhưng trên nội dung thay vì nhãn trục]
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370636
Where cũng có thể chấp nhận các tham số
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706865 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706427 để căn chỉnh đầu vào khi thực hiện
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706411
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370637
Điều này tương đương với [nhưng nhanh hơn] như sau
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370638
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706411 có thể chấp nhận một điều kiện có thể gọi được và các đối số
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706417. Hàm phải có một đối số [Sê-ri đang gọi hoặc Khung dữ liệu] và trả về đầu ra hợp lệ dưới dạng điều kiện và đối số
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706417
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370639
Mặt nạ#
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706432 là phép toán boolean nghịch đảo của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706411
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370650
Cài đặt phóng to có điều kiện bằng cách sử dụng In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
434#
Một thay thế cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706410 là sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706421. Kết hợp với việc đặt cột mới, bạn có thể sử dụng nó để phóng to DataFrame nơi các giá trị được xác định có điều kiện
Hãy xem xét bạn có hai lựa chọn để chọn trong DataFrame sau. Và bạn muốn đặt màu cột mới thành 'xanh lục' khi cột thứ hai có chữ 'Z'. Bạn có thể làm như sau
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370651
Nếu bạn có nhiều điều kiện, bạn có thể sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706437 để đạt được điều đó. Giả sử tương ứng với ba điều kiện có ba lựa chọn màu sắc, với màu thứ tư là màu dự phòng, bạn có thể thực hiện như sau
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370652
Phương thức In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
438#
Các đối tượng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689 có một phương thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706438 cho phép lựa chọn bằng một biểu thức
Bạn có thể lấy giá trị của khung nơi cột ________ 5441 có giá trị nằm giữa giá trị của cột ________ 5442 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706443. Ví dụ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370653
Thực hiện tương tự nhưng quay lại chỉ mục được đặt tên nếu không có cột nào có tên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706442
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370654
Thay vào đó, nếu bạn không muốn hoặc không thể đặt tên cho chỉ mục của mình, bạn có thể sử dụng tên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370698 trong biểu thức truy vấn của mình
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370655
Ghi chú
Nếu tên chỉ mục của bạn trùng với tên cột, tên cột sẽ được ưu tiên. Ví dụ,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370656
Bạn vẫn có thể sử dụng chỉ mục trong biểu thức truy vấn bằng cách sử dụng mã định danh đặc biệt 'chỉ mục'
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370657
Nếu vì lý do nào đó bạn có một cột có tên là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370698, thì bạn cũng có thể gọi chỉ mục là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706447, nhưng tại thời điểm này, bạn nên xem xét đổi tên các cột của mình thành một cái gì đó ít mơ hồ hơn
In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
45 In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
438 Cú pháp#
Bạn cũng có thể sử dụng các mức của một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689 với một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370645 như thể chúng là các cột trong khung
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370658
Nếu các cấp độ của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370645 không được đặt tên, bạn có thể tham khảo chúng bằng các tên đặc biệt
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370659
Quy ước là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706447, có nghĩa là “chỉ số cấp 0” cho cấp 0 của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370698
In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
438 Trường hợp sử dụng#
Trường hợp sử dụng cho
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706438 là khi bạn có một bộ sưu tập các đối tượng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689 có chung một tập hợp con các tên cột [hoặc cấp chỉ mục/tên]. Bạn có thể chuyển cùng một truy vấn cho cả hai khung mà không phải chỉ định khung nào bạn muốn truy vấn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370600
________ 5438 So sánh cú pháp giữa Python và pandas#
Cú pháp đầy đủ giống như numpy
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370601
Đẹp hơn một chút bằng cách bỏ dấu ngoặc đơn [toán tử so sánh liên kết chặt chẽ hơn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706884 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706882]
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370602
Sử dụng tiếng Anh thay vì ký hiệu
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370603
Khá gần với cách bạn có thể viết nó trên giấy
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370604
Toán tử In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
461 và In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
462#
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706438 cũng hỗ trợ sử dụng đặc biệt các toán tử so sánh
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706461 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706462 của Python, cung cấp một cú pháp ngắn gọn để gọi phương thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706403 của một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370685 hoặc
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370605
Bạn có thể kết hợp điều này với các biểu thức khác cho các truy vấn rất ngắn gọn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370606
Ghi chú
Lưu ý rằng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706461 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706462 được đánh giá bằng Python, vì
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706471 không có thao tác tương đương với thao tác này. Tuy nhiên, chỉ bản thân biểu thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706461/
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706462 được đánh giá trong vanilla Python. Ví dụ, trong biểu thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370607
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706474 được đánh giá bởi
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706471 và sau đó hoạt động
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706461 được đánh giá bằng Python thuần túy. Nói chung, bất kỳ hoạt động nào có thể được đánh giá bằng cách sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706471 sẽ được
Công dụng đặc biệt của toán tử In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
478 với các đối tượng In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
479#
So sánh một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706479 giá trị với một cột bằng cách sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706478/
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706482 hoạt động tương tự như
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706461/
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706462
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370608
Toán tử Boolean#
Bạn có thể phủ định các biểu thức boolean bằng từ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706887 hoặc toán tử
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706886
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370609
Tất nhiên, các biểu thức cũng có thể phức tạp tùy ý
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370610
Hiệu suất của In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
438#
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706488 sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706471 nhanh hơn một chút so với Python cho các khung hình lớn
Ghi chú
Bạn sẽ chỉ thấy những lợi ích về hiệu suất khi sử dụng công cụ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706471 với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706488 nếu khung của bạn có hơn khoảng 200.000 hàng
Biểu đồ này được tạo bằng cách sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370689 với 3 cột, mỗi cột chứa các giá trị dấu phẩy động được tạo bằng cách sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706493
Dữ liệu trùng lặp #
Nếu bạn muốn xác định và xóa các hàng trùng lặp trong DataFrame, có hai phương pháp sẽ hữu ích.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706494 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706495. Mỗi cái lấy làm đối số mà các cột sẽ sử dụng để xác định các hàng trùng lặp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
494 trả về một vectơ boolean có độ dài là số hàng và cho biết liệu một hàng có bị trùng lặp hay khôngIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
495 xóa các hàng trùng lặp
Theo mặc định, hàng được quan sát đầu tiên của tập hợp trùng lặp được coi là duy nhất, nhưng mỗi phương thức có tham số
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706498 để chỉ định các mục tiêu cần lưu giữ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
499 [mặc định]. đánh dấu/xóa các bản sao ngoại trừ lần xuất hiện đầu tiênIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
500. đánh dấu/xóa các bản sao ngoại trừ lần xuất hiện cuối cùngIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
501. đánh dấu/thả tất cả các bản sao
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370611
Ngoài ra, bạn có thể chuyển danh sách các cột để xác định các bản sao
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370612
Để loại bỏ các bản sao theo giá trị chỉ mục, hãy sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706502 rồi thực hiện cắt. Cùng một bộ tùy chọn có sẵn cho tham số
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706498
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370613
Phương thức In [4]: s = df['A']
In [5]: s[dates[5]]
Out[5]: -0.6736897080883706
504 giống từ điển#
Mỗi Sê-ri hoặc Khung dữ liệu đều có phương thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706505 có thể trả về giá trị mặc định
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370614
Tra cứu giá trị theo nhãn chỉ mục/cột#
Đôi khi bạn muốn trích xuất một tập hợp các giá trị được cung cấp một chuỗi nhãn hàng và nhãn cột, điều này có thể đạt được bằng cách lập chỉ mục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706506 và NumPy. Ví dụ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370615
Trước đây, điều này có thể đạt được bằng phương pháp chuyên dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706507 không được dùng trong phiên bản 1. 2. 0
đối tượng chỉ mục #
Lớp pandas
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706400 và các lớp con của nó có thể được xem như là thực thi một bộ nhiều tập có thứ tự. Bản sao được cho phép. Tuy nhiên, nếu bạn cố gắng chuyển đổi một đối tượng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706400 với các mục nhập trùng lặp thành một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706510, một ngoại lệ sẽ được đưa ra
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706400 cũng cung cấp cơ sở hạ tầng cần thiết để tra cứu, căn chỉnh dữ liệu và lập chỉ mục lại. Cách dễ nhất để tạo trực tiếp một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706400 là chuyển một chuỗi
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706479 hoặc chuỗi khác tới
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706400
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370616
Bạn cũng có thể chuyển một
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706515 để lưu trữ trong chỉ mục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370617
Tên, nếu được đặt, sẽ được hiển thị trong màn hình bảng điều khiển
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370618
Đang đặt siêu dữ liệu#
Các chỉ mục "hầu như không thay đổi", nhưng có thể đặt và thay đổi thuộc tính
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706515 của chúng. Bạn có thể sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706517,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706518 để đặt trực tiếp các thuộc tính này và chúng mặc định trả về một bản sao
Xem Lập chỉ mục nâng cao để biết cách sử dụng Đa chỉ mục.
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370619
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706518,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706520 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706521 cũng có một đối số tùy chọn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706427
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370620
Đặt thao tác trên các đối tượng Chỉ mục#
Hai hoạt động chính là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706523 và
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706524. Sự khác biệt được cung cấp thông qua phương pháp
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706525
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370621
Cũng có sẵn là phép toán
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706526, trả về các phần tử xuất hiện trong
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706527 hoặc
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706528, nhưng không xuất hiện trong cả hai. Điều này tương đương với Chỉ mục được tạo bởi
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706529, với các bản sao bị loại bỏ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370622
Ghi chú
Chỉ mục kết quả từ một hoạt động thiết lập sẽ được sắp xếp theo thứ tự tăng dần
Khi thực hiện
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706530 giữa các chỉ mục có các kiểu khác nhau, các chỉ mục phải được chuyển thành một kiểu chung. Thông thường, mặc dù không phải lúc nào cũng vậy, đây là đối tượng dtype. Ngoại lệ là khi thực hiện phép hợp giữa dữ liệu số nguyên và số float. Trong trường hợp này, các giá trị nguyên được chuyển thành float
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370623
Giá trị bị mất#
Quan trọng
Mặc dù
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706400 có thể chứa các giá trị bị thiếu [
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706532], nên tránh sử dụng nếu bạn không muốn có bất kỳ kết quả không mong muốn nào. Ví dụ: một số thao tác loại trừ hoàn toàn các giá trị bị thiếu
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706533 điền vào các giá trị còn thiếu với giá trị vô hướng được chỉ định
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370624
Đặt/đặt lại chỉ mục#
Đôi khi, bạn sẽ tải hoặc tạo tập dữ liệu vào DataFrame và muốn thêm chỉ mục sau khi bạn đã thực hiện xong. Có một vài cách khác nhau
Đặt chỉ mục #
DataFrame có phương thức
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706534 lấy tên cột [đối với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706400 thông thường] hoặc danh sách tên cột [đối với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370645]. Để tạo một DataFrame mới, được lập chỉ mục lại
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370625
Tùy chọn từ khóa
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706872 cho phép bạn giữ lại chỉ mục hiện có và nối các cột đã cho vào MultiIndex
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370626
Các tùy chọn khác trong
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706538 cho phép bạn không bỏ cột chỉ mục hoặc thêm chỉ mục tại chỗ [không tạo đối tượng mới]
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370627
Đặt lại chỉ mục #
Để thuận tiện, có một chức năng mới trên DataFrame được gọi là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706539 để chuyển các giá trị chỉ mục vào các cột của DataFrame và đặt một chỉ mục số nguyên đơn giản. Đây là hoạt động nghịch đảo của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706534
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370628
Đầu ra giống với bảng SQL hoặc mảng bản ghi hơn. Tên của các cột bắt nguồn từ chỉ mục là tên được lưu trữ trong thuộc tính
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706541
Bạn có thể sử dụng từ khóa
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706427 để chỉ xóa một phần của chỉ mục
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370629
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706543 lấy một tham số tùy chọn
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706544, nếu đúng thì chỉ cần loại bỏ chỉ mục, thay vì đặt các giá trị chỉ mục vào các cột của DataFrame
Thêm một chỉ mục đặc biệt #
Nếu bạn tự tạo một chỉ mục, bạn có thể chỉ định chỉ mục đó cho trường
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370698
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370630
Trả lại chế độ xem so với bản sao#
Khi đặt giá trị trong đối tượng gấu trúc, phải cẩn thận để tránh cái được gọi là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706546. Đây là một ví dụ
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370631
So sánh hai phương thức truy cập này
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370632
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370633
Cả hai đều mang lại kết quả như nhau, vậy bạn nên sử dụng cái nào?
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706549 chọn cấp độ đầu tiên của các cột và trả về một Khung dữ liệu được lập chỉ mục đơn lẻ. Sau đó, một thao tác Python khác
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706550 chọn chuỗi được lập chỉ mục bởi
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706551. Điều này được biểu thị bằng biến
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706552 vì gấu trúc xem các hoạt động này là các sự kiện riêng biệt. e. g. các cuộc gọi riêng biệt đến
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370681, vì vậy nó phải coi chúng là các hoạt động tuyến tính, chúng xảy ra lần lượt
Tương phản điều này với
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706554 chuyển một bộ dữ liệu lồng nhau của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706555 cho một cuộc gọi duy nhất tới
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370681. Điều này cho phép gấu trúc giải quyết vấn đề này như một thực thể duy nhất. Hơn nữa, thứ tự hoạt động này có thể nhanh hơn đáng kể và cho phép một người lập chỉ mục cho cả hai trục nếu muốn
Tại sao chuyển nhượng không thành công khi sử dụng lập chỉ mục theo chuỗi?#
Vấn đề trong phần trước chỉ là vấn đề về hiệu suất. Chuyện gì xảy ra với cảnh báo
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706557?
Nhưng hóa ra việc gán cho sản phẩm của việc lập chỉ mục theo chuỗi vốn có những kết quả không thể đoán trước. Để thấy điều này, hãy nghĩ về cách trình thông dịch Python thực thi đoạn mã này
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370634
Nhưng mã này được xử lý khác nhau
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370635
Thấy rằng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370681 trong đó? . Đó là điều mà
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706557 đang cảnh báo bạn
Ghi chú
Bạn có thể tự hỏi liệu chúng ta có nên quan tâm đến tài sản
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706877 trong ví dụ đầu tiên hay không. Nhưng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706563 được đảm bảo chính là
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706560 với hành vi lập chỉ mục được sửa đổi, vì vậy,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706565 /
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706566 hoạt động trực tiếp trên
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706560. Tất nhiên,
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706568 có thể là một chế độ xem hoặc bản sao của
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706560
Đôi khi, một cảnh báo
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706557 sẽ xuất hiện vào những thời điểm không có chuỗi lập chỉ mục rõ ràng đang diễn ra. Đây là những lỗi mà
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706557 được thiết kế để bắt. gấu trúc có thể đang cố cảnh báo bạn rằng bạn đã làm điều này
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370636
Rất tiếc
Thứ tự đánh giá quan trọng #
Khi bạn sử dụng lập chỉ mục theo chuỗi, thứ tự và loại thao tác lập chỉ mục sẽ xác định một phần xem kết quả là một lát cắt vào đối tượng ban đầu hay một bản sao của lát cắt đó
gấu trúc có
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706572 vì việc gán cho một bản sao của một lát cắt thường không cố ý, nhưng một lỗi gây ra bởi việc lập chỉ mục theo chuỗi trả về một bản sao trong đó một lát cắt được mong đợi
Nếu bạn muốn gấu trúc ít nhiều tin tưởng hơn về việc gán cho biểu thức lập chỉ mục theo chuỗi, bạn có thể đặt tùy chọn option
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706573 thành một .
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
574, mặc định, có nghĩa là mộtIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
572 được inIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
576 có nghĩa là gấu trúc sẽ gây ra mộtIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
577 mà bạn phải đối phóIn [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706
578 sẽ chặn hoàn toàn các cảnh báo
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370637
Tuy nhiên, điều này đang hoạt động trên một bản sao và sẽ không hoạt động
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370638
Một nhiệm vụ chuỗi cũng có thể cắt xén trong cài đặt trong khung dtype hỗn hợp
Ghi chú
Các quy tắc cài đặt này áp dụng cho tất cả
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706579
Sau đây là phương thức truy cập được khuyến nghị sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370646 cho nhiều mục [sử dụng
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.6736897080883706581] và một mục duy nhất sử dụng chỉ mục cố định
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370639
Những điều sau đây đôi khi có thể hoạt động, nhưng nó không được đảm bảo và do đó nên tránh
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370640
Cuối cùng, ví dụ tiếp theo hoàn toàn không hoạt động và vì vậy nên tránh
In [4]: s = df['A'] In [5]: s[dates[5]] Out[5]: -0.673689708088370641
Cảnh báo
Các cảnh báo/ngoại lệ về nhiệm vụ được xâu chuỗi nhằm mục đích thông báo cho người dùng về một nhiệm vụ có thể không hợp lệ. Có thể có dương tính giả;