对多索引进行排序

For MultiIndex-ed objects to be indexed and sliced effectively, they need to be sorted. As with any index, you can use sort_index.

  1. In [88]: import random; random.shuffle(tuples)
  3. In [89]: s = pd.Series(np.random.randn(8), index=pd.MultiIndex.from_tuples(tuples))
  5. In [90]: s
  6. Out[90]: 
  7. baz  one    0.206053
  8. foo  two   -0.251905
  9.      one   -2.213588
  10. baz  two    1.063327
  11. qux  two    1.266143
  12. bar  two    0.299368
  13.      one   -0.863838
  14. qux  one    0.408204
  15. dtype: float64
  17. In [91]: s.sort_index()
  18. Out[91]: 
  19. bar  one   -0.863838
  20.      two    0.299368
  21. baz  one    0.206053
  22.      two    1.063327
  23. foo  one   -2.213588
  24.      two   -0.251905
  25. qux  one    0.408204
  26.      two    1.266143
  27. dtype: float64
  29. In [92]: s.sort_index(level=0)
  30. Out[92]: 
  31. bar  one   -0.863838
  32.      two    0.299368
  33. baz  one    0.206053
  34.      two    1.063327
  35. foo  one   -2.213588
  36.      two   -0.251905
  37. qux  one    0.408204
  38.      two    1.266143
  39. dtype: float64
  41. In [93]: s.sort_index(level=1)
  42. Out[93]: 
  43. bar  one   -0.863838
  44. baz  one    0.206053
  45. foo  one   -2.213588
  46. qux  one    0.408204
  47. bar  two    0.299368
  48. baz  two    1.063327
  49. foo  two   -0.251905
  50. qux  two    1.266143
  51. dtype: float64

You may also pass a level name to sort_index if the MultiIndex levels are named.

  1. In [94]: s.index.set_names(['L1', 'L2'], inplace=True)
  3. In [95]: s.sort_index(level='L1')
  4. Out[95]: 
  5. L1   L2 
  6. bar  one   -0.863838
  7.      two    0.299368
  8. baz  one    0.206053
  9.      two    1.063327
  10. foo  one   -2.213588
  11.      two   -0.251905
  12. qux  one    0.408204
  13.      two    1.266143
  14. dtype: float64
  16. In [96]: s.sort_index(level='L2')
  17. Out[96]: 
  18. L1   L2 
  19. bar  one   -0.863838
  20. baz  one    0.206053
  21. foo  one   -2.213588
  22. qux  one    0.408204
  23. bar  two    0.299368
  24. baz  two    1.063327
  25. foo  two   -0.251905
  26. qux  two    1.266143
  27. dtype: float64

On higher dimensional objects, you can sort any of the other axes by level if they have a MultiIndex:

  1. In [97]: df.T.sort_index(level=1, axis=1)
  2. Out[97]: 
  3.         one      zero       one      zero
  4.           x         x         y         y
  5. 0  0.600178  2.410179  1.519970  0.132885
  6. 1  0.274230  1.450520 -0.493662 -0.023688

Indexing will work even if the data are not sorted, but will be rather inefficient (and show a PerformanceWarning). It will also return a copy of the data rather than a view:

  1. In [98]: dfm = pd.DataFrame({'jim': [0, 0, 1, 1],
  2.    ....:                     'joe': ['x', 'x', 'z', 'y'],
  3.    ....:                     'jolie': np.random.rand(4)})
  4.    ....: 
  6. In [99]: dfm = dfm.set_index(['jim', 'joe'])
  8. In [100]: dfm
  9. Out[100]: 
  10.             jolie
  11. jim joe          
  12. 0   x    0.490671
  13.     x    0.120248
  14. 1   z    0.537020
  15.     y    0.110968
  16. In [4]: dfm.loc[(1, 'z')]
  1. PerformanceWarning: indexing past lexsort depth may impact performance.
  3. Out[4]:
  4.            jolie
  5. jim joe
  6. 1   z    0.64094

Furthermore if you try to index something that is not fully lexsorted, this can raise:

  1. In [5]: dfm.loc[(0,'y'):(1, 'z')]
  2. UnsortedIndexError: 'Key length (2) was greater than MultiIndex lexsort depth (1)'

The is_lexsorted() method on an Index show if the index is sorted, and the lexsort_depth property returns the sort depth:

  1. In [101]: dfm.index.is_lexsorted()
  2. Out[101]: False
  4. In [102]: dfm.index.lexsort_depth
  5. Out[102]: 1
  1. In [103]: dfm = dfm.sort_index()
  3. In [104]: dfm
  4. Out[104]: 
  5.             jolie
  6. jim joe          
  7. 0   x    0.490671
  8.     x    0.120248
  9. 1   y    0.110968
  10.     z    0.537020
  12. In [105]: dfm.index.is_lexsorted()
  13. Out[105]: True
  15. In [106]: dfm.index.lexsort_depth
  16. Out[106]: 2

And now selection works as expected.

  1. In [107]: dfm.loc[(0,'y'):(1, 'z')]
  2. Out[107]: 
  3.             jolie
  4. jim joe          
  5. 1   y    0.110968
  6.     z    0.537020