Сообщить об ошибке.

Метод .sort_values() и .sort_index() объектов Series/DataFrame в pandas

Сортировка Series/DataFrame по значениям или по индексу в pandas

Материал рассматривает как сортировать Series/DataFrame по значениям или по индексу (по возрастанию или убыванию) в модуле pandas, а именно методы сортировки .sort_values() и .sort_index() объектов Series/DataFrame.

Содержание:

  • DataFrame.sort_values() - сортирует DataFrame по возрастанию или убыванию по значениям вдоль любой оси;
  • Series.sort_values() - сортирует Series по возрастанию или убыванию по какому-либо критерию;
  • DataFrame.sort_index() - сортирует объект DataFrame по индексным меткам строк или столбцов;
  • Series.sort_index() - сортирует объект Series по индексным меткам строк.

DataFrame.sort_values(by, *, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None):

Метод DataFrame.sort_values() сортирует DataFrame по возрастанию или убыванию по значениям вдоль любой оси axis.

Принимаемые аргументы:

  • by - имя или список имен для сортировки.
    • Если axis имеет значение 0 или 'index', то by может содержать уровни индексов и/или метки столбцов.
    • Если axis имеет значение 1 или 'columns', то by может содержать уровни столбцов и/или метки индексов.
  • axis=0 - ось, подлежащая сортировке. Принимает значения: 0 ('index') или 1 ('columns')
  • ascending=True - сортировка по возрастанию и убыванию. Можно указать список для нескольких порядков сортировки. Если это список логических значений, то он должен совпадать с длиной by.
  • inplace=False - если значение True, то выполняет операцию на месте (не рекомендуется).
  • kind='quicksort' - алгоритм сортировки. Смотрите также numpy.sort() для получения дополнительной информации. Алгоритмы mergesort и stable являются единственными стабильными алгоритмами. Для DataFrames этот параметр применяется только при сортировке по одному столбцу или индексной метке. Принимает следующие строки: 'quicksort', 'mergesort', 'heapsort', 'stable'
  • na_position='last' - помещает NaN вначале если значение 'first' и помещает NaN в конце, если 'last'`.
  • ignore_index=False - если True, то результирующая ось будет помечена как 0, 1, ..., n - 1.
  • key=None - примените ключевую функцию к значениям перед сортировкой. Поведение похоже на аргумент key во встроенной функции sorted(), с той лишь разницей, что эта ключевая функция должна быть векторизована. Она должна ожидать Series и возвращать Series с той же формой, что и входные данные. Итоговый Series будет применен к каждому столбцу по отдельности.

Примеры использования DataFrame.sort_values():

>>> import pandas as pd
>>> import numpy as np
>>> df = pd.DataFrame({
...     'col1': ['A', 'A', 'B', np.nan, 'D', 'C'],
...     'col2': [2, 1, 9, 8, 7, 4],
...     'col3': [0, 1, 9, 4, 2, 3],
...     'col4': ['a', 'B', 'c', 'D', 'e', 'F']
... })
>>> df
#   col1  col2  col3 col4
# 0    A     2     0    a
# 1    A     1     1    B
# 2    B     9     9    c
# 3  NaN     8     4    D
# 4    D     7     2    e
# 5    C     4     3    F

Сортировать по col1:

>>> df.sort_values(by=['col1'])
#   col1  col2  col3 col4
# 0    A     2     0    a
# 1    A     1     1    B
# 2    B     9     9    c
# 5    C     4     3    F
# 4    D     7     2    e
# 3  NaN     8     4    D

Сортировка по нескольким столбцам

>>> df.sort_values(by=['col1', 'col2'])
#   col1  col2  col3 col4
# 1    A     1     1    B
# 0    A     2     0    a
# 2    B     9     9    c
# 5    C     4     3    F
# 4    D     7     2    e
# 3  NaN     8     4    D

Сортировать по убыванию

>>> df.sort_values(by='col1', ascending=False)
#   col1  col2  col3 col4
# 4    D     7     2    e
# 5    C     4     3    F
# 2    B     9     9    c
# 0    A     2     0    a
# 1    A     1     1    B
# 3  NaN     8     4    D

Приоритет в NA

>>> df.sort_values(by='col1', ascending=False, na_position='first')
#   col1  col2  col3 col4
# 3  NaN     8     4    D
# 4    D     7     2    e
# 5    C     4     3    F
# 2    B     9     9    c
# 0    A     2     0    a
# 1    A     1     1    B

Сортировка с помощью ключевой функции

>>> df.sort_values(by='col4', key=lambda col: col.str.lower())
#    col1  col2  col3 col4
# 0    A     2     0    a
# 1    A     1     1    B
# 2    B     9     9    c
# 3  NaN     8     4    D
# 4    D     7     2    e
# 5    C     4     3    F

Естественная сортировка с аргументом key при помощи дополнительного модуля natsort

>>> df = pd.DataFrame({
...    "time": ['0hr', '128hr', '72hr', '48hr', '96hr'],
...    "value": [10, 20, 30, 40, 50]
... })
>>> df
#     time  value
# 0    0hr     10
# 1  128hr     20
# 2   72hr     30
# 3   48hr     40
# 4   96hr     50

>>> from natsort import index_natsorted
>>> df.sort_values(
...     by="time",
...     key=lambda x: np.argsort(index_natsorted(df["time"]))
... )
#     time  value
# 0    0hr     10
# 3   48hr     40
# 2   72hr     30
# 4   96hr     50
# 1  128hr     20

Series.sort_values(*, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None):

Метод Series.sort_values() сортирует Series по возрастанию или убыванию по какому-либо критерию.

Принимаемые аргументы:

  • axis=0 - ось, подлежащая сортировке. Принимает значения: 0 ('index') или 1 ('columns')
  • ascending=True - сортировка по возрастанию и убыванию. Можно указать список для нескольких порядков сортировки. Если это список логических значений, то он должен совпадать с длиной by.
  • inplace=False - если значение True, то выполняет операцию на месте (не рекомендуется).
  • kind='quicksort' - алгоритм сортировки. Смотрите также numpy.sort() для получения дополнительной информации. Алгоритмы mergesort и stable являются единственными стабильными алгоритмами. Для DataFrames этот параметр применяется только при сортировке по одному столбцу или индексной метке. Принимает следующие строки: 'quicksort', 'mergesort', 'heapsort', 'stable'
  • na_position='last' - помещает NaN вначале если значение 'first' и помещает NaN в конце, если 'last'`.
  • ignore_index=False - если True, то результирующая ось будет помечена как 0, 1, ..., n - 1.
  • key=None - примените ключевую функцию к значениям перед сортировкой. Поведение похоже на аргумент key во встроенной функции sorted(), с той лишь разницей, что эта ключевая функция должна быть векторизована. Она должна ожидать Series и возвращать Series с той же формой, что и входные данные. Итоговый Series будет применен к каждому столбцу по отдельности.
Примеры использования Series.sort_values():
>>> import pandas as pd
>>> import numpy as np
>>> s = pd.Series([np.nan, 1, 3, 10, 5])
>>> s
# 0     NaN
# 1     1.0
# 2     3.0
# 3     10.0
# 4     5.0
# dtype: float64

Сортировка значений в порядке возрастания (поведение по умолчанию)

>>> s.sort_values(ascending=True)
# 1     1.0
# 2     3.0
# 4     5.0
# 3    10.0
# 0     NaN
# dtype: float64

Сортировка значений в порядке убывания

>>> s.sort_values(ascending=False)
# 3    10.0
# 4     5.0
# 2     3.0
# 1     1.0
# 0     NaN
# dtype: float64

Сортируйте значения, ставя NA на первое место

>>> s.sort_values(na_position='first')
# 0     NaN
# 1     1.0
# 2     3.0
# 4     5.0
# 3    10.0
# dtype: float64

Сортировка строк

>>> s = pd.Series(['z', 'b', 'd', 'a', 'c'])
>>> s
# 0    z
# 1    b
# 2    d
# 3    a
# 4    c
# dtype: object

>>> s.sort_values()
# 3    a
# 1    b
# 4    c
# 2    d
# 0    z
# dtype: object

Сортировка с помощью ключевой функции. Ключевой функции будет присвоен ряд значений, и она должна возвращать массив.

>>> s = pd.Series(['a', 'B', 'c', 'D', 'e'])
>>> s.sort_values()
# 1    B
# 3    D
# 0    a
# 2    c
# 4    e
# dtype: object

>>> s.sort_values(key=lambda x: x.str.lower())
# 0    a
# 1    B
# 2    c
# 3    D
# 4    e
# dtype: object

Здесь хорошо работают ufunc модуля NumPy. Например, можно отсортировать значения по np.sin

>>> s = pd.Series([-4, -2, 0, 2, 4])
>>> s.sort_values(key=np.sin)
# 1   -2
# 4    4
# 2    0
# 0   -4
# 3    2
# dtype: int64

Можно использовать более сложные пользовательские функции, если они ожидают последовательность и возвращают массив

>>> s.sort_values(key=lambda x: (np.tan(x.cumsum())))
# 0   -4
# 3    2
# 4    4
# 1   -2
# 2    0
# dtype: int64

DataFrame.sort_index(*, axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, ignore_index=False, key=None):

Метод DataFrame.sort_index() сортирует объект DataFrame по индексным меткам строк или столбцов (вдоль оси).

Возвращает новый DataFrame, отсортированный по метке, если аргумент inplace имеет значение False, в противном случае обновляет исходный DataFrame и возвращает None.

Принимаемые аргументы:

  • axis=0 - ось, по которой выполняется сортировка. Значение 0 или 'index' обозначает строки, а 1 'columns' - столбцы.
  • level=None - если не None, то выполняет сортировку по значениям в указанных уровнях индекса. Принимает: int или имя уровня или список целых чисел или список имен уровней.
  • ascending=True - сортировка по возрастанию и убыванию. Если индекс является MultiIndex, направление сортировки можно контролировать для каждого уровня отдельно.
  • inplace=False - если значение True, то выполняет операцию на месте (не рекомендуется).
  • kind='quicksort' - алгоритм сортировки. Смотрите также numpy.sort() для получения дополнительной информации. Алгоритмы mergesort и stable являются единственными стабильными алгоритмами. Для DataFrames этот параметр применяется только при сортировке по одному столбцу или индексной метке. Принимает следующие строки: 'quicksort', 'mergesort', 'heapsort', 'stable'
  • na_position='last' - помещает NaN вначале если значение 'first' и помещает NaN в конце, если 'last'. Не реализовано для [MultiIndex`]pandas.MultiIndex.
  • sort_remaining=True - если True и сортировка по уровню и индексу многоуровневая, то выполняет сортировку и по другим уровням (по порядку) после сортировки по указанному уровню.
  • ignore_index=False - если True, то результирующая ось будет помечена как 0, 1, ..., n - 1.
  • key=None - примените ключевую функцию к значениям перед сортировкой. Поведение похоже на аргумент key во встроенной функции sorted(), с той лишь разницей, что эта ключевая функция должна быть векторизована. Она должна ожидать индекс и возвращать индекс той же формы. Для многоиндексных входных данных ключ применяется для каждого уровня.
Примеры использования DataFrame.sort_index():
>>> import pandas as pd
>>> import numpy as np
>>> df = pd.DataFrame([1, 2, 3, 4, 5], index=[100, 29, 234, 1, 150],
...                   columns=['A'])
>>> df.sort_index()
#      A
# 1    4
# 29   2
# 100  1
# 150  5
# 234  3

По умолчанию сортируется по возрастанию, для сортировки по убыванию ascending=False

>>> df.sort_index(ascending=False)
#      A
# 234  3
# 150  5
# 100  1
# 29   2
# 1    4

Можно указать ключевую функцию, которая применяется к индексу перед сортировкой. Для MultiIndex она применяется к каждому уровню отдельно.

>>> df = pd.DataFrame({"a": [1, 2, 3, 4]}, index=['A', 'b', 'C', 'd'])
>>> df.sort_index(key=lambda x: x.str.lower())
#    a
# A  1
# b  2
# C  3
# d  4

Series.sort_index(*, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, ignore_index=False, key=None):

Метод Series.sort_index() сортирует объект Series по индексным меткам строк.

Возвращает новый DataFrame, отсортированный по метке, если аргумент inplace имеет значение False, в противном случае обновляет исходный DataFrame и возвращает None.

Принимаемые аргументы:

  • level=None - если не None, то выполняет сортировку по значениям в указанных уровнях индекса. Принимает: int или имя уровня или список целых чисел или список имен уровней.
  • ascending=True - сортировка по возрастанию и убыванию. Если индекс является MultiIndex, направление сортировки можно контролировать для каждого уровня отдельно.
  • inplace=False - если значение True, то выполняет операцию на месте (не рекомендуется).
  • kind='quicksort' - алгоритм сортировки. Смотрите также numpy.sort() для получения дополнительной информации. Алгоритмы mergesort и stable являются единственными стабильными алгоритмами. Для DataFrames этот параметр применяется только при сортировке по одному столбцу или индексной метке. Принимает следующие строки: 'quicksort', 'mergesort', 'heapsort', 'stable'
  • na_position='last' - помещает NaN вначале если значение 'first' и помещает NaN в конце, если 'last'. Не реализовано для [MultiIndex`]pandas.MultiIndex.
  • sort_remaining=True - если True и сортировка по уровню и индексу многоуровневая, то выполняет сортировку и по другим уровням (по порядку) после сортировки по указанному уровню.
  • ignore_index=False - если True, то результирующая ось будет помечена как 0, 1, ..., n - 1.
  • key=None - примените ключевую функцию к значениям перед сортировкой. Поведение похоже на аргумент key во встроенной функции sorted(), с той лишь разницей, что эта ключевая функция должна быть векторизована. Она должна ожидать индекс и возвращать индекс той же формы. Для многоиндексных входных данных ключ применяется для каждого уровня.
Примеры использования Series.sort_values():
>>> import pandas as pd
>>> import numpy as np
>>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, 4])
>>> s.sort_index()
# 1    c
# 2    b
# 3    a
# 4    d
# dtype: object

Сортировка по убыванию

>>> s.sort_index(ascending=False)
# 4    d
# 3    a
# 2    b
# 1    c
# dtype: object

По умолчанию NaN помещаются в конец, используя na_position, можно разместить их в начале

>>> s = pd.Series(['a', 'b', 'c', 'd'], index=[3, 2, 1, np.nan])
>>> s.sort_index(na_position='first')
# NaN     d
#  1.0    c
#  2.0    b
#  3.0    a
# dtype: object

Уровень индекса для сортировки

>>> arrays = [np.array(['qux', 'qux', 'foo', 'foo',
...                     'baz', 'baz', 'bar', 'bar']),
...           np.array(['two', 'one', 'two', 'one',
...                     'two', 'one', 'two', 'one'])]

>>> s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], index=arrays)
>>> s.sort_index(level=1)
# bar  one    8
# baz  one    6
# foo  one    4
# qux  one    2
# bar  two    7
# baz  two    5
# foo  two    3
# qux  two    1
# dtype: int64

Не сортирует по оставшимся уровням при сортировке по уровням

>>> s.sort_index(level=1, sort_remaining=False)
# qux  one    2
# foo  one    4
# baz  one    6
# bar  one    8
# qux  two    1
# foo  two    3
# baz  two    5
# bar  two    7
# dtype: int64

Применение ключевой функции перед сортировкой

>>> s = pd.Series([1, 2, 3, 4], index=['A', 'b', 'C', 'd'])
>>> s.sort_index(key=lambda x : x.str.lower())
# A    1
# b    2
# C    3
# d    4
# dtype: int64