索引对象

The pandas Index class and its subclasses can be viewed as implementing an ordered multiset. Duplicates are allowed. However, if you try to convert an Index object with duplicate entries into a set, an exception will be raised.

Index also provides the infrastructure necessary for lookups, data alignment, and reindexing. The easiest way to create an Index directly is to pass a list or other sequence to Index:

  1. In [289]: index = pd.Index(['e', 'd', 'a', 'b'])
  3. In [290]: index
  4. Out[290]: Index(['e', 'd', 'a', 'b'], dtype='object')
  6. In [291]: 'd' in index
  7. Out[291]: True

You can also pass a name to be stored in the index:

  1. In [292]: index = pd.Index(['e', 'd', 'a', 'b'], name='something')
  3. In [293]: index.name
  4. Out[293]: 'something'

The name, if set, will be shown in the console display:

  1. In [294]: index = pd.Index(list(range(5)), name='rows')
  3. In [295]: columns = pd.Index(['A', 'B', 'C'], name='cols')
  5. In [296]: df = pd.DataFrame(np.random.randn(5, 3), index=index, columns=columns)
  7. In [297]: df
  8. Out[297]: 
  9. cols         A         B         C
  10. rows                              
  11. 0     1.295989  0.185778  0.436259
  12. 1     0.678101  0.311369 -0.528378
  13. 2    -0.674808 -1.103529 -0.656157
  14. 3     1.889957  2.076651 -1.102192
  15. 4    -1.211795 -0.791746  0.634724
  17. In [298]: df['A']
  18. Out[298]: 
  19. rows
  20. 0    1.295989
  21. 1    0.678101
  22. 2   -0.674808
  23. 3    1.889957
  24. 4   -1.211795
  25. Name: A, dtype: float64

Setting metadata

Indexes are “mostly immutable”, but it is possible to set and change their metadata, like the index name (or, for MultiIndex, levels and labels).

You can use the rename, set_names, set_levels, and set_labels to set these attributes directly. They default to returning a copy; however, you can specify inplace=True to have the data change in place.

See Advanced Indexing for usage of MultiIndexes.

  1. In [299]: ind = pd.Index([1, 2, 3])
  3. In [300]: ind.rename("apple")
  4. Out[300]: Int64Index([1, 2, 3], dtype='int64', name='apple')
  6. In [301]: ind
  7. Out[301]: Int64Index([1, 2, 3], dtype='int64')
  9. In [302]: ind.set_names(["apple"], inplace=True)
  11. In [303]: ind.name = "bob"
  13. In [304]: ind
  14. Out[304]: Int64Index([1, 2, 3], dtype='int64', name='bob')

set_names, set_levels, and set_labels also take an optional level` argument

  1. In [305]: index = pd.MultiIndex.from_product([range(3), ['one', 'two']], names=['first', 'second'])
  3. In [306]: index
  4. Out[306]: 
  5. MultiIndex(levels=[[0, 1, 2], ['one', 'two']],
  6.            labels=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
  7.            names=['first', 'second'])
  9. In [307]: index.levels[1]
  10. Out[307]: Index(['one', 'two'], dtype='object', name='second')
  12. In [308]: index.set_levels(["a", "b"], level=1)
  13. Out[308]: 
  14. MultiIndex(levels=[[0, 1, 2], ['a', 'b']],
  15.            labels=[[0, 0, 1, 1, 2, 2], [0, 1, 0, 1, 0, 1]],
  16.            names=['first', 'second'])

Set operations on Index objects

The two main operations are union (|) and intersection (&). These can be directly called as instance methods or used via overloaded operators. Difference is provided via the .difference() method.

  1. In [309]: a = pd.Index(['c', 'b', 'a'])
  3. In [310]: b = pd.Index(['c', 'e', 'd'])
  5. In [311]: a | b
  6. Out[311]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
  8. In [312]: a & b
  9. Out[312]: Index(['c'], dtype='object')
  11. In [313]: a.difference(b)
  12. Out[313]: Index(['a', 'b'], dtype='object')

Also available is the symmetric_difference (^) operation, which returns elements that appear in either idx1 or idx2, but not in both. This is equivalent to the Index created by idx1.difference(idx2).union(idx2.difference(idx1)), with duplicates dropped.

  1. In [314]: idx1 = pd.Index([1, 2, 3, 4])
  3. In [315]: idx2 = pd.Index([2, 3, 4, 5])
  5. In [316]: idx1.symmetric_difference(idx2)
  6. Out[316]: Int64Index([1, 5], dtype='int64')
  8. In [317]: idx1 ^ idx2
  9. Out[317]: Int64Index([1, 5], dtype='int64')

Note: The resulting index from a set operation will be sorted in ascending order.

Missing values

Important: Even though Index can hold missing values (NaN), it should be avoided if you do not want any unexpected results. For example, some operations exclude missing values implicitly.

Index.fillna fills missing values with specified scalar value.

  1. In [318]: idx1 = pd.Index([1, np.nan, 3, 4])
  3. In [319]: idx1
  4. Out[319]: Float64Index([1.0, nan, 3.0, 4.0], dtype='float64')
  6. In [320]: idx1.fillna(2)
  7. Out[320]: Float64Index([1.0, 2.0, 3.0, 4.0], dtype='float64')
  9. In [321]: idx2 = pd.DatetimeIndex([pd.Timestamp('2011-01-01'), pd.NaT, pd.Timestamp('2011-01-03')])
  11. In [322]: idx2
  12. Out[322]: DatetimeIndex(['2011-01-01', 'NaT', '2011-01-03'], dtype='datetime64[ns]', freq=None)
  14. In [323]: idx2.fillna(pd.Timestamp('2011-01-02'))
  15. Out[323]: DatetimeIndex(['2011-01-01', '2011-01-02', '2011-01-03'], dtype='datetime64[ns]', freq=None)