按位置选择

Warning

Whether a copy or a reference is returned for a setting operation, may depend on the context. This is sometimes called chained assignment and should be avoided. See Returning a View versus Copy.

Pandas provides a suite of methods in order to get purely integer based indexing. The semantics follow closely Python and NumPy slicing. These are 0-based indexing. When slicing, the start bounds is included, while the upper bound is excluded. Trying to use a non-integer, even a valid label will raise an IndexError.

The .iloc attribute is the primary access method. The following are valid inputs:

  • An integer e.g. 5.
  • A list or array of integers [4, 3, 0].
  • A slice object with ints 1:7.
  • A boolean array.
  • A callable, see Selection By Callable.
  1. In [60]: s1 = pd.Series(np.random.randn(5), index=list(range(0,10,2)))
  3. In [61]: s1
  4. Out[61]: 
  5. 0    0.695775
  6. 2    0.341734
  7. 4    0.959726
  8. 6   -1.110336
  9. 8   -0.619976
  10. dtype: float64
  12. In [62]: s1.iloc[:3]
  13. Out[62]: 
  14. 0    0.695775
  15. 2    0.341734
  16. 4    0.959726
  17. dtype: float64
  19. In [63]: s1.iloc[3]
  20. Out[63]: -1.1103361028911669

Note that setting works as well:

  1. In [64]: s1.iloc[:3] = 0
  3. In [65]: s1
  4. Out[65]: 
  5. 0    0.000000
  6. 2    0.000000
  7. 4    0.000000
  8. 6   -1.110336
  9. 8   -0.619976
  10. dtype: float64

With a DataFrame:

  1. In [66]: df1 = pd.DataFrame(np.random.randn(6,4),
  2.    ....:                    index=list(range(0,12,2)),
  3.    ....:                    columns=list(range(0,8,2)))
  4.    ....: 
  6. In [67]: df1
  7. Out[67]: 
  8.            0         2         4         6
  9. 0   0.149748 -0.732339  0.687738  0.176444
  10. 2   0.403310 -0.154951  0.301624 -2.179861
  11. 4  -1.369849 -0.954208  1.462696 -1.743161
  12. 6  -0.826591 -0.345352  1.314232  0.690579
  13. 8   0.995761  2.396780  0.014871  3.357427
  14. 10 -0.317441 -1.236269  0.896171 -0.487602

Select via integer slicing:

  1. In [68]: df1.iloc[:3]
  2. Out[68]: 
  3.           0         2         4         6
  4. 0  0.149748 -0.732339  0.687738  0.176444
  5. 2  0.403310 -0.154951  0.301624 -2.179861
  6. 4 -1.369849 -0.954208  1.462696 -1.743161
  8. In [69]: df1.iloc[1:5, 2:4]
  9. Out[69]: 
  10.           4         6
  11. 2  0.301624 -2.179861
  12. 4  1.462696 -1.743161
  13. 6  1.314232  0.690579
  14. 8  0.014871  3.357427

Select via integer list:

  1. In [70]: df1.iloc[[1, 3, 5], [1, 3]]
  2. Out[70]: 
  3.            2         6
  4. 2  -0.154951 -2.179861
  5. 6  -0.345352  0.690579
  6. 10 -1.236269 -0.487602
  1. In [71]: df1.iloc[1:3, :]
  2. Out[71]: 
  3.           0         2         4         6
  4. 2  0.403310 -0.154951  0.301624 -2.179861
  5. 4 -1.369849 -0.954208  1.462696 -1.743161
  1. In [72]: df1.iloc[:, 1:3]
  2. Out[72]: 
  3.            2         4
  4. 0  -0.732339  0.687738
  5. 2  -0.154951  0.301624
  6. 4  -0.954208  1.462696
  7. 6  -0.345352  1.314232
  8. 8   2.396780  0.014871
  9. 10 -1.236269  0.896171
  1. # this is also equivalent to ``df1.iat[1,1]``
  2. In [73]: df1.iloc[1, 1]
  3. Out[73]: -0.15495077442490321

For getting a cross section using an integer position (equiv to df.xs(1)):

  1. In [74]: df1.iloc[1]
  2. Out[74]: 
  3. 0    0.403310
  4. 2   -0.154951
  5. 4    0.301624
  6. 6   -2.179861
  7. Name: 2, dtype: float64

Out of range slice indexes are handled gracefully just as in Python/Numpy.

  1. # these are allowed in python/numpy.
  2. In [75]: x = list('abcdef')
  4. In [76]: x
  5. Out[76]: ['a', 'b', 'c', 'd', 'e', 'f']
  7. In [77]: x[4:10]
  8. Out[77]: ['e', 'f']
  10. In [78]: x[8:10]
  11. Out[78]: []
  13. In [79]: s = pd.Series(x)
  15. In [80]: s
  16. Out[80]: 
  17. 0    a
  18. 1    b
  19. 2    c
  20. 3    d
  21. 4    e
  22. 5    f
  23. dtype: object
  25. In [81]: s.iloc[4:10]
  26. Out[81]: 
  27. 4    e
  28. 5    f
  29. dtype: object
  31. In [82]: s.iloc[8:10]
  32. Out[82]: Series([], dtype: object)

Note that using slices that go out of bounds can result in an empty axis (e.g. an empty DataFrame being returned).

  1. In [83]: dfl = pd.DataFrame(np.random.randn(5,2), columns=list('AB'))
  3. In [84]: dfl
  4. Out[84]: 
  5.           A         B
  6. 0 -0.082240 -2.182937
  7. 1  0.380396  0.084844
  8. 2  0.432390  1.519970
  9. 3 -0.493662  0.600178
  10. 4  0.274230  0.132885
  12. In [85]: dfl.iloc[:, 2:3]
  13. Out[85]: 
  14. Empty DataFrame
  15. Columns: []
  16. Index: [0, 1, 2, 3, 4]
  18. In [86]: dfl.iloc[:, 1:3]
  19. Out[86]: 
  20.           B
  21. 0 -2.182937
  22. 1  0.084844
  23. 2  1.519970
  24. 3  0.600178
  25. 4  0.132885
  27. In [87]: dfl.iloc[4:6]
  28. Out[87]: 
  29.          A         B
  30. 4  0.27423  0.132885

A single indexer that is out of bounds will raise an IndexError. A list of indexers where any element is out of bounds will raise an IndexError.

  1. dfl.iloc[[4, 5, 6]]
  2. IndexError: positional indexers are out-of-bounds
  4. dfl.iloc[:, 4]
  5. IndexError: single positional indexer is out-of-bounds