Tìm chỉ số của phần tử trong Chuỗi gấu trúc

Tôi biết đây là một câu hỏi rất cơ bản nhưng vì một số lý do tôi không thể tìm thấy câu trả lời. Làm cách nào tôi có thể lấy chỉ mục của một số phần tử nhất định của Sê-ri trong gấu trúc trăn? (lần đầu tiên xuất hiện sẽ đủ)

Tức là tôi muốn một cái gì đó như:

import pandas as pd
myseries = pd.Series([1,4,0,7,5], index=[0,1,2,3,4])
print myseries.find(7) # should output 3

Chắc chắn, có thể định nghĩa một phương thức như vậy với một vòng lặp:

def find(s, el):
    for i in s.index:
        if s[i] == el: 
            return i
    return None

print find(myseries, 7)

nhưng tôi cho rằng nên có một cách tốt hơn. Lanhung?

>>> myseries[myseries == 7]
3    7
dtype: int64
>>> myseries[myseries == 7].index[0]
3

Mặc dù tôi thừa nhận rằng nên có một cách tốt hơn để làm điều đó, nhưng điều này ít nhất tránh được việc lặp và lặp qua đối tượng và di chuyển nó đến cấp độ C.

Chuyển đổi sang một Chỉ mục, bạn có thể sử dụng get_loc

In [1]: myseries = pd.Series([1,4,0,7,5], index=[0,1,2,3,4])

In [3]: Index(myseries).get_loc(7)
Out[3]: 3

In [4]: Index(myseries).get_loc(10)
KeyError: 10

Xử lý trùng lặp

In [5]: Index([1,1,2,2,3,4]).get_loc(2)
Out[5]: slice(2, 4, None)

Sẽ trả về một mảng boolean nếu trả về không liền kề

In [6]: Index([1,1,2,1,3,2,4]).get_loc(2)
Out[6]: array([False, False,  True, False, False,  True, False], dtype=bool)

Sử dụng một hashtable trong nội bộ, rất nhanh

In [7]: s = Series(randint(0,10,10000))

In [9]: %timeit s[s == 5]
1000 loops, best of 3: 203 µs per loop

In [12]: i = Index(s)

In [13]: %timeit i.get_loc(5)
1000 loops, best of 3: 226 µs per loop

Như Viktor chỉ ra, có một chi phí tạo một lần để tạo một chỉ mục (nó phát sinh khi bạn thực sự làm gì đó với chỉ mục, ví dụ is_unique:)

In [2]: s = Series(randint(0,10,10000))

In [3]: %timeit Index(s)
100000 loops, best of 3: 9.6 µs per loop

In [4]: %timeit Index(s).is_unique
10000 loops, best of 3: 140 µs per loop

In [92]: (myseries==7).argmax()
Out[92]: 3

Điều này hoạt động nếu bạn biết 7 là có trước. Bạn có thể kiểm tra điều này với (myseries == 7) .any ()

Một cách tiếp cận khác (rất giống với câu trả lời đầu tiên) cũng chiếm nhiều 7 (hoặc không có) là

In [122]: myseries = pd.Series([1,7,0,7,5], index=['a','b','c','d','e'])
In [123]: list(myseries[myseries==7].index)
Out[123]: ['b', 'd']

Tôi ấn tượng với tất cả các câu trả lời ở đây. Đây không phải là một câu trả lời mới, chỉ là một nỗ lực để tóm tắt thời gian của tất cả các phương pháp này. Tôi đã xem xét trường hợp của một chuỗi có 25 phần tử và giả sử trường hợp chung trong đó chỉ mục có thể chứa bất kỳ giá trị nào và bạn muốn giá trị chỉ mục tương ứng với giá trị tìm kiếm nằm ở cuối của chuỗi.

Dưới đây là các bài kiểm tra tốc độ trên MacBook Pro 2013 trong Python 3.7 với phiên bản Pandas 0.25.3.

In [1]: import pandas as pd                                                

In [2]: import numpy as np                                                 

In [3]: data = [406400, 203200, 101600,  76100,  50800,  25400,  19050,  12700, 
   ...:          9500,   6700,   4750,   3350,   2360,   1700,   1180,    850, 
   ...:           600,    425,    300,    212,    150,    106,     75,     53, 
   ...:            38]                                                                               

In [4]: myseries = pd.Series(data, index=range(1,26))                                                

In [5]: myseries[21]                                                                                 
Out[5]: 150

In [7]: %timeit myseries[myseries == 150].index[0]                                                   
416 µs ± 5.05 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [8]: %timeit myseries[myseries == 150].first_valid_index()                                        
585 µs ± 32.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [9]: %timeit myseries.where(myseries == 150).first_valid_index()                                  
652 µs ± 23.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

In [10]: %timeit myseries.index[np.where(myseries == 150)[0][0]]                                     
195 µs ± 1.18 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [11]: %timeit pd.Series(myseries.index, index=myseries)[150]                 
178 µs ± 9.35 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [12]: %timeit myseries.index[pd.Index(myseries).get_loc(150)]                                    
77.4 µs ± 1.41 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

In [13]: %timeit myseries.index[list(myseries).index(150)]
12.7 µs ± 42.5 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [14]: %timeit myseries.index[myseries.tolist().index(150)]                   
9.46 µs ± 19.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Câu trả lời của @ Jeff dường như là nhanh nhất - mặc dù nó không xử lý các bản sao.

Sửa chữa : Xin lỗi, tôi đã bỏ lỡ một, giải pháp của @Alex Spangher sử dụng phương pháp chỉ mục danh sách là nhanh nhất.

Cập nhật : Đã thêm câu trả lời của @ EliadL.

Hi vọng điêu nay co ich.

Thật ngạc nhiên khi một hoạt động đơn giản như vậy đòi hỏi các giải pháp phức tạp như vậy và nhiều người rất chậm. Hơn nửa mili giây trong một số trường hợp để tìm giá trị trong chuỗi 25.

Một cách khác để làm điều này, mặc dù không thỏa mãn là:

s = pd.Series([1,3,0,7,5],index=[0,1,2,3,4])

list(s).index(7)

trả về: 3

Về kiểm tra thời gian bằng cách sử dụng bộ dữ liệu hiện tại tôi đang làm việc (coi đó là ngẫu nhiên):

[64]:    %timeit pd.Index(article_reference_df.asset_id).get_loc('100000003003614')
10000 loops, best of 3: 60.1 µs per loop

In [66]: %timeit article_reference_df.asset_id[article_reference_df.asset_id == '100000003003614'].index[0]
1000 loops, best of 3: 255 µs per loop


In [65]: %timeit list(article_reference_df.asset_id).index('100000003003614')
100000 loops, best of 3: 14.5 µs per loop

Nếu bạn sử dụng numpy, bạn có thể nhận được một loạt các phần tử mà giá trị của bạn được tìm thấy:

import numpy as np
import pandas as pd
myseries = pd.Series([1,4,0,7,5], index=[0,1,2,3,4])
np.where(myseries == 7)

Điều này trả về một bộ phần tử chứa một mảng các phần tử trong đó 7 là giá trị trong myseries:

(array([3], dtype=int64),)

bạn có thể sử dụng Series.idxmax ()

>>> import pandas as pd
>>> myseries = pd.Series([1,4,0,7,5], index=[0,1,2,3,4])
>>> myseries.idxmax()
3
>>> 

Một cách khác để làm điều đó chưa được đề cập đến là phương pháp khoan dung:

myseries.tolist().index(7)

sẽ trả về chỉ mục chính xác, giả sử giá trị tồn tại trong Sê-ri.

Thông thường giá trị của bạn xảy ra ở nhiều chỉ số:

>>> myseries = pd.Series([0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1])
>>> myseries.index[myseries == 1]
Int64Index([3, 4, 5, 6, 10, 11], dtype='int64')

Đây là cách tiếp cận tự nhiên và có thể mở rộng nhất mà tôi có thể tìm thấy:

>>> myindex = pd.Series(myseries.index, index=myseries)

>>> myindex[7]
3

>>> myindex[[7, 5, 7]]
7    3
5    4
7    3
dtype: int64