排序

Pandas supports three kinds of sorting: sorting by index labels, sorting by column values, and sorting by a combination of both.

By Index

The Series.sort_index() and DataFrame.sort_index() methods are used to sort a pandas object by its index levels.

  1. In [307]: df = pd.DataFrame({'one' : pd.Series(np.random.randn(3), index=['a', 'b', 'c']),
  2.    .....:                    'two' : pd.Series(np.random.randn(4), index=['a', 'b', 'c', 'd']),
  3.    .....:                    'three' : pd.Series(np.random.randn(3), index=['b', 'c', 'd'])})
  4.    .....: 
  6. In [308]: unsorted_df = df.reindex(index=['a', 'd', 'c', 'b'],
  7.    .....:                          columns=['three', 'two', 'one'])
  8.    .....: 
  10. In [309]: unsorted_df
  11. Out[309]: 
  12.       three       two       one
  13. a       NaN  0.708543  0.036274
  14. d -0.540166  0.586626       NaN
  15. c  0.410238  1.121731  1.044630
  16. b -0.282532 -2.038777 -0.490032
  18. # DataFrame
  19. In [310]: unsorted_df.sort_index()
  20. Out[310]: 
  21.       three       two       one
  22. a       NaN  0.708543  0.036274
  23. b -0.282532 -2.038777 -0.490032
  24. c  0.410238  1.121731  1.044630
  25. d -0.540166  0.586626       NaN
  27. In [311]: unsorted_df.sort_index(ascending=False)
  28. Out[311]: 
  29.       three       two       one
  30. d -0.540166  0.586626       NaN
  31. c  0.410238  1.121731  1.044630
  32. b -0.282532 -2.038777 -0.490032
  33. a       NaN  0.708543  0.036274
  35. In [312]: unsorted_df.sort_index(axis=1)
  36. Out[312]: 
  37.         one     three       two
  38. a  0.036274       NaN  0.708543
  39. d       NaN -0.540166  0.586626
  40. c  1.044630  0.410238  1.121731
  41. b -0.490032 -0.282532 -2.038777
  43. # Series
  44. In [313]: unsorted_df['three'].sort_index()
  45. Out[313]: 
  46. a         NaN
  47. b   -0.282532
  48. c    0.410238
  49. d   -0.540166
  50. Name: three, dtype: float64

By Values

The Series.sort_values() method is used to sort a Series by its values. The DataFrame.sort_values() method is used to sort a DataFrame by its column or row values. The optional by parameter to DataFrame.sort_values() may used to specify one or more columns to use to determine the sorted order.

  1. In [314]: df1 = pd.DataFrame({'one':[2,1,1,1],'two':[1,3,2,4],'three':[5,4,3,2]})
  3. In [315]: df1.sort_values(by='two')
  4. Out[315]: 
  5.    one  two  three
  6. 0    2    1      5
  7. 2    1    2      3
  8. 1    1    3      4
  9. 3    1    4      2

The by parameter can take a list of column names, e.g.:

  1. In [316]: df1[['one', 'two', 'three']].sort_values(by=['one','two'])
  2. Out[316]: 
  3.    one  two  three
  4. 2    1    2      3
  5. 1    1    3      4
  6. 3    1    4      2
  7. 0    2    1      5

These methods have special treatment of NA values via the na_position argument:

  1. In [317]: s[2] = np.nan
  3. In [318]: s.sort_values()
  4. Out[318]: 
  5. 0       A
  6. 3    Aaba
  7. 1       B
  8. 4    Baca
  9. 6    CABA
  10. 8     cat
  11. 7     dog
  12. 2     NaN
  13. 5     NaN
  14. dtype: object
  16. In [319]: s.sort_values(na_position='first')
  17. Out[319]: 
  18. 2     NaN
  19. 5     NaN
  20. 0       A
  21. 3    Aaba
  22. 1       B
  23. 4    Baca
  24. 6    CABA
  25. 8     cat
  26. 7     dog
  27. dtype: object

By Indexes and Values

New in version 0.23.0.

Strings passed as the by parameter to DataFrame.sort_values() may refer to either columns or index level names.

  1. # Build MultiIndex
  2. In [320]: idx = pd.MultiIndex.from_tuples([('a', 1), ('a', 2), ('a', 2),
  3.    .....:                                 ('b', 2), ('b', 1), ('b', 1)])
  4.    .....: 
  6. In [321]: idx.names = ['first', 'second']
  8. # Build DataFrame
  9. In [322]: df_multi = pd.DataFrame({'A': np.arange(6, 0, -1)},
  10.    .....:                         index=idx)
  11.    .....: 
  13. In [323]: df_multi
  14. Out[323]: 
  15.               A
  16. first second   
  17. a     1       6
  18.       2       5
  19.       2       4
  20. b     2       3
  21.       1       2
  22.       1       1

Sort by ‘second’ (index) and ‘A’ (column)

  1. In [324]: df_multi.sort_values(by=['second', 'A'])
  2. Out[324]: 
  3.               A
  4. first second   
  5. b     1       1
  6.       1       2
  7. a     1       6
  8. b     2       3
  9. a     2       4
  10.       2       5

Note: If a string matches both a column name and an index level name then a warning is issued and the column takes precedence. This will result in an ambiguity error in a future version.

searchsorted

Series has the searchsorted() method, which works similarly to numpy.ndarray.searchsorted().

  1. In [325]: ser = pd.Series([1, 2, 3])
  3. In [326]: ser.searchsorted([0, 3])
  4. Out[326]: array([0, 2])
  6. In [327]: ser.searchsorted([0, 4])
  7. Out[327]: array([0, 3])
  9. In [328]: ser.searchsorted([1, 3], side='right')
  10. Out[328]: array([1, 3])
  12. In [329]: ser.searchsorted([1, 3], side='left')
  13. Out[329]: array([0, 2])
  15. In [330]: ser = pd.Series([3, 1, 2])
  17. In [331]: ser.searchsorted([0, 3], sorter=np.argsort(ser))
  18. Out[331]: array([0, 2])

smallest / largest values

Series has the nsmallest() and nlargest() methods which return the smallest or largest n values. For a large Series this can be much faster than sorting the entire Series and calling head(n) on the result.

  1. In [332]: s = pd.Series(np.random.permutation(10))
  3. In [333]: s
  4. Out[333]: 
  5. 0    8
  6. 1    2
  7. 2    9
  8. 3    5
  9. 4    6
  10. 5    0
  11. 6    1
  12. 7    7
  13. 8    4
  14. 9    3
  15. dtype: int64
  17. In [334]: s.sort_values()
  18. Out[334]: 
  19. 5    0
  20. 6    1
  21. 1    2
  22. 9    3
  23. 8    4
  24. 3    5
  25. 4    6
  26. 7    7
  27. 0    8
  28. 2    9
  29. dtype: int64
  31. In [335]: s.nsmallest(3)
  32. Out[335]: 
  33. 5    0
  34. 6    1
  35. 1    2
  36. dtype: int64
  38. In [336]: s.nlargest(3)
  39. Out[336]: 
  40. 2    9
  41. 0    8
  42. 7    7
  43. dtype: int64

DataFrame also has the nlargest and nsmallest methods.

  1. In [337]: df = pd.DataFrame({'a': [-2, -1, 1, 10, 8, 11, -1],
  2.    .....:                    'b': list('abdceff'),
  3.    .....:                    'c': [1.0, 2.0, 4.0, 3.2, np.nan, 3.0, 4.0]})
  4.    .....: 
  6. In [338]: df.nlargest(3, 'a')
  7. Out[338]: 
  8.     a  b    c
  9. 5  11  f  3.0
  10. 3  10  c  3.2
  11. 4   8  e  NaN
  13. In [339]: df.nlargest(5, ['a', 'c'])
  14. Out[339]: 
  15.     a  b    c
  16. 6  -1  f  4.0
  17. 5  11  f  3.0
  18. 3  10  c  3.2
  19. 4   8  e  NaN
  20. 2   1  d  4.0
  22. In [340]: df.nsmallest(3, 'a')
  23. Out[340]: 
  24.    a  b    c
  25. 0 -2  a  1.0
  26. 1 -1  b  2.0
  27. 6 -1  f  4.0
  29. In [341]: df.nsmallest(5, ['a', 'c'])
  30. Out[341]: 
  31.    a  b    c
  32. 0 -2  a  1.0
  33. 2  1  d  4.0
  34. 4  8  e  NaN
  35. 1 -1  b  2.0
  36. 6 -1  f  4.0

Sorting by a multi-index column

You must be explicit about sorting when the column is a multi-index, and fully specify all levels to by.

  1. In [342]: df1.columns = pd.MultiIndex.from_tuples([('a','one'),('a','two'),('b','three')])
  3. In [343]: df1.sort_values(by=('a','two'))
  4. Out[343]: 
  5.     a         b
  6.   one two three
  7. 0   2   1     5
  8. 2   1   2     3
  9. 1   1   3     4
  10. 3   1   4     2