Всё о сортировке в python: исчерпывающий гайд

Таблица «методы списков»

Метод	Что делает
list.append(x)	Добавляет элемент в конец списка
list.extend(L)	Расширяет список list, добавляя в конец все элементы списка L
list.insert(i, x)	Вставляет на i-ый элемент значение x
list.remove(x)	Удаляет первый элемент в списке, имеющий значение x. ValueError, если такого элемента не существует
list.pop()	Удаляет i-ый элемент и возвращает его. Если индекс не указан, удаляется последний элемент
list.index(x, ])	Возвращает положение первого элемента со значением x (при этом поиск ведется от start до end)
list.count(x)	Возвращает количество элементов со значением x
list.sort()	Сортирует список на основе функции
list.reverse()	Разворачивает список
list.copy()	Поверхностная копия списка
list.clear()	Очищает список

Нужно отметить, что методы списков, в отличие от строковых методов, изменяют сам список, а потому результат выполнения не нужно записывать в эту переменную.

>>> l = 1, 2, 3, 5, 7
>>> l.sort()
>>> l

>>> l = l.sort()
>>> print(l)
None

И, напоследок, примеры работы со списками:

>>> a = 66.25, 333, 333, 1, 1234.5
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a

>>> a.index(333)
1
>>> a.remove(333)
>>> a

>>> a.reverse()
>>> a

>>> a.sort()
>>> a

Изредка, для увеличения производительности, списки заменяют гораздо менее гибкими массивами (хотя в таких случаях обычно используют сторонние библиотеки, например NumPy).

Предварительное использование key в функции сортировки

До сих пор нашими ключевыми функциями были простые считыватели атрибутов, но они также могут вычислять значения для сортировки. Давайте взглянем на еще один пример. На этот раз мы определим класс Snake:

У нашей змеи есть имя, toxicity (токсичность, мерило того, насколько токсичен её яд) и agression (представленная в виде числа от 0 до 1, которое указывает на вероятность того, что змея нападет).

Теперь предположим, что мы можем подсчитать, насколько опасная змея, основываясь на показателях токсичности и агрессивности, и можем отсортировать список змей по степени их опасности:

Змеи отсортированы в ожидаемом нами порядке (несмотря на то, что гремучая змея (rattlesnake) более ядовита, чем кобра (kingCobra), уровень агрессивности кобры делает её более опасной).

Начало работы с методами сортировки Pandas ↑

Напоминаем, что DataFrame — это структура данных с помеченными осями для строк и столбцов. Вы можете отсортировать DataFrame по значению строки или столбца, а также по индексу строки или столбца.

И строки, и столбцы имеют индексы, которые представляют собой числовые представления о том, где находятся данные в вашем DataFrame. Вы можете получать данные из определенных строк или столбцов, используя расположение индекса DataFrame. По умолчанию номера индексов начинаются с нуля. Вы также можете вручную назначить собственный индекс.

Подготовка набора данных   

В этом уроке будем работать с данными об экономии топлива, собранными Агентством по охране окружающей среды США (EPA) на транспортных средствах, выпущенных в период с 1984 по 2021 год. Набор данных EPA по экономии топлива великолепен, потому что он содержит много различных типов информации, которую вы можете отсортировать, включая текстовую и числовою информацию. Набор данных содержит всего восемьдесят три колонки.

Чтобы продолжить, вам понадобится установленная библиотека Python pandas. Код в этом руководстве был выполнен с использованием pandas 1.2.0 и Python 3.9.1.

Для анализа будем просматривать данные о MPG (миля на галлон) для транспортных средств по маркам, моделям, годам и другим характеристикам транспортных средств. Можно указать, какие столбцы следует читать в DataFrame. Для этого урока вам понадобится только часть доступных столбцов. Вот команды для чтения соответствующих столбцов набора данных по экономии топлива в DataFrame и для отображения первых пяти строк:

>>> import pandas as pd

>>> column_subset = 

>>> df = pd.read_csv(
...     "https://www.fueleconomy.gov/feg/epadata/vehicles.csv",
...     usecols=column_subset,
...     nrows=100
... )

>>> df.head()
   city08  cylinders fuelType  ...  mpgData            trany  year
0      19          4  Regular  ...        Y     Manual 5-spd  1985
1       9         12  Regular  ...        N     Manual 5-spd  1985
2      23          4  Regular  ...        Y     Manual 5-spd  1985
3      10          8  Regular  ...        N  Automatic 3-spd  1985
4      17          4  Premium  ...        N     Manual 5-spd  1993

Вызывая с URL-адресом набора данных, вы можете загрузить данные в DataFrame. Сокращение количества столбцов приводит к более быстрой загрузке и меньшему использованию памяти. Чтобы еще больше ограничить потребление памяти и быстро почувствовать данные, вы можете указать, сколько строк загружать, используя .

Знакомство с .sort_values()   

Для сортировки значений в DataFrame по любой оси (столбцы или строки) используем . Как правило, требуется отсортировать строки в DataFrame по значениям одного или нескольких столбцов:

На рисунке выше показаны результаты использования для сортировки строк DataFrame на основе значений в столбце . Это похоже на то, как вы сортируете данные в электронной таблице с помощью столбца.

Знакомство с .sort_index()   

используем для сортировки DataFrame по индексу строки или меткам столбцов. Отличие от заключается в том, что вы сортируете DataFrame на основе индекса строки или имени столбцов, а не значений в этих строках или столбцах:

Индекс строки DataFrame обведен синим на рисунке выше. Индекс не считается столбцом, и обычно у вас есть только один индекс строки. Индекс строки можно рассматривать как номера строк, которые начинаются с нуля.

Случайная сортировка

Ключи не обязаны иметь какую-либо связь с сортируемыми элементами (однако, это не самый продуктивный способ сортировать что-либо). Мы можем создать случайный порядок со следующим ключом:

Функция random() – это часть стандартной библиотеки random, которая выдает числа в случайном порядке от 0 до 1. Сортировка с использованием данного ключа выдает, кто бы мог подумать, случайный порядок:

В данной статье мы рассмотрели то, как Python создает отсортированные списки (и другие итерируемые) и то, насколько это просто. По умолчанию, функция sorted() возвращает список, содержимое которого упорядоченно в естественном порядке (что, в общем, именно то что мы ожидаем от чисел и строк). Желающие углубиться в то, как работает функция sorted() могут обратиться к документации Python.

Мы также научились определять наш собственный порядок сортировки, передавая функцию key функции sorted(). Наши ключевые функции могут возвращать любое значение, какое нам угодно, но зачастую нам, скорее всего, понадобится отсортировать атрибут, который принадлежит каждому элементу списка. Фактически, эта ситуация возникает настолько часто, что Python поместили функцию operator.getattr() в стандартную библиотеку, которая может генерировать ключевые функции этого типа для нас.

Использование методов сортировки для изменения фрейма данных ↑

Во всех примерах, которые вы видели до сих пор, и метод , и метод при вызове возвращали новые объекты DataFrame. По умолчанию в pandas эта сортировка не работает. В общем, это наиболее распространенный и предпочтительный способ анализа данных с помощью pandas, поскольку он создает новый DataFrame вместо изменения оригинала. Это позволяет вам сохранять состояние данных с момента их чтения из файла.

Однако вы можете изменить исходный DataFrame напрямую, указав необязательный параметр со значением . Большинство методов pandas включают параметр . Ниже вы увидите несколько примеров использования для сортировки DataFrame на месте.

Использование .sort_values() на месте   

Если в установлено значение , то исходный DataFrame будет изменён, а методы сортировки возвращают . Отсортируйте DataFrame по значениям столбца , как в самом первом примере, но с параметром , установленным в :

>>> df.sort_values("city08", inplace=True)

Обратите внимание, что вызов в этом случае не возвращает DataFrame. Вот как выглядит исходный df:

>>> df
    city08  cylinders fuelType  ...            trany  year mpgData_
99       9          8  Premium  ...  Automatic 4-spd  1993      NaN
1        9         12  Regular  ...     Manual 5-spd  1985      NaN
80       9          8  Regular  ...  Automatic 3-spd  1985      NaN
47       9          8  Regular  ...  Automatic 3-spd  1985      NaN
3       10          8  Regular  ...  Automatic 3-spd  1985      NaN
..     ...        ...      ...  ...              ...   ...      ...
9       23          4  Regular  ...  Automatic 4-spd  1993     True
8       23          4  Regular  ...     Manual 5-spd  1993     True
7       23          4  Regular  ...  Automatic 3-spd  1993     True
76      23          4  Regular  ...     Manual 5-spd  1993     True
2       23          4  Regular  ...     Manual 5-spd  1985     True

В объекте значения теперь отсортированы в порядке возрастания на основе столбца. Исходный DataFrame был изменен и изменения сохранены. Обычно, при анализе, рекомендуется избегать использования , поскольку изменения в DataFrame отменить нельзя.

Использование .sort_index() на месте   

В следующем примере показано, что также работает с .

Поскольку при чтении файла в DataFrame индекс был создан в возрастающем порядке, вы можете снова изменить свой объект , чтобы вернуть его в исходный порядок. Используйте с параметром , установленным в для изменнения DataFrame:

>>> df.sort_index(inplace=True)
>>> df
    city08  cylinders fuelType  ...            trany  year mpgData_
0       19          4  Regular  ...     Manual 5-spd  1985     True
1        9         12  Regular  ...     Manual 5-spd  1985      NaN
2       23          4  Regular  ...     Manual 5-spd  1985     True
3       10          8  Regular  ...  Automatic 3-spd  1985      NaN
4       17          4  Premium  ...     Manual 5-spd  1993      NaN
..     ...        ...      ...  ...              ...   ...      ...
95      17          6  Regular  ...  Automatic 3-spd  1993     True
96      17          6  Regular  ...  Automatic 4-spd  1993      NaN
97      15          6  Regular  ...  Automatic 4-spd  1993      NaN
98      15          6  Regular  ...     Manual 5-spd  1993      NaN
99       9          8  Premium  ...  Automatic 4-spd  1993      NaN

Теперь DataFrame снова был изменен с помощью . Поскольку у DataFrame все еще есть индекс по умолчанию, сортировка его в порядке возрастания возвращает данные в исходный порядок.

Если вы знакомы со встроенными функциями Python и , то параметр , доступный в методах сортировки pandas, может показаться очень похожим. Для получения дополнительной информации вы можете проверить, как использовать sorted() и sort() в Python.

Как работает Быстрая сортировка

Быстрая сортировка чаще всего не сможет разделить массив на равные части. Это потому, что весь процесс зависит от того, как мы выбираем опорный элемент. Нам нужно выбрать опору так, чтобы она была примерно больше половины элементов и, следовательно, примерно меньше, чем другая половина элементов. Каким бы интуитивным ни казался этот процесс, это очень сложно сделать.

Подумайте об этом на мгновение — как бы вы выбрали адекватную опору для вашего массива? В истории быстрой сортировки было представлено много идей о том, как выбрать центральную точку — случайный выбор элемента, который не работает из-за того, что «дорогой» выбор случайного элемента не гарантирует хорошего выбора центральной точки; выбор элемента из середины; выбор медианы первого, среднего и последнего элемента; и еще более сложные рекурсивные формулы.

Самый простой подход — просто выбрать первый (или последний) элемент. По иронии судьбы, это приводит к быстрой сортировке на уже отсортированных (или почти отсортированных) массивах.

Именно так большинство людей выбирают реализацию быстрой сортировки, и, так как это просто и этот способ выбора опоры является очень эффективной операцией, и это именно то, что мы будем делать.

Теперь, когда мы выбрали опорный элемент — что нам с ним делать? Опять же, есть несколько способов сделать само разбиение. У нас будет «указатель» на нашу опору, указатель на «меньшие» элементы и указатель на «более крупные» элементы.

Цель состоит в том, чтобы переместить элементы так, чтобы все элементы, меньшие, чем опора, находились слева от него, а все более крупные элементы были справа от него. Меньшие и большие элементы не обязательно будут отсортированы, мы просто хотим, чтобы они находились на правильной стороне оси. Затем мы рекурсивно проходим левую и правую сторону оси.

Рассмотрим пошагово то, что мы планируем сделать, это поможет проиллюстрировать весь процесс. Пусть у нас будет следующий список.

29 | 99 (low),27,41,66,28,44,78,87,19,31,76,58,88,83,97,12,21,44 (high)

Выберем первый элемент как опору 29), а указатель на меньшие элементы (называемый «low») будет следующим элементом, указатель на более крупные элементы (называемый «high») станем последний элемент в списке.

29 | 99 (low),27,41,66,28,44,78,87,19,31,76,58,88,83,97,12,21 (high),44

Мы двигаемся в сторону high то есть влево, пока не найдем значение, которое ниже нашего опорного элемента.

29 | 99 (low),27,41,66,28,44,78,87,19,31,76,58,88,83,97,12,21 (high),44

• Теперь, когда наш элемент high указывает на элемент 21, то есть на значение меньше чем опорное значение, мы хотим найти значение в начале массива, с которым мы можем поменять его местами. Нет смысла менять местами значение, которое меньше, чем опорное значение, поэтому, если low указывает на меньший элемент, мы пытаемся найти тот, который будет больше.
• Мы перемещаем переменную low вправо, пока не найдем элемент больше, чем опорное значение. К счастью, low уже имеет значение 89.
• Мы меняем местами low и high:

29 | 21 (low),27,41,66,28,44,78,87,19,31,76,58,88,83,97,12,99 (high),44

• Сразу после этого мы перемещает high влево и low вправо (поскольку 21 и 89 теперь на своих местах)
• Опять же, мы двигаемся high влево, пока не достигнем значения, меньшего, чем опорное значение, и мы сразу находим — 12
• Теперь мы ищем значение больше, чем опорное значение, двигая low вправо, и находим такое значение 41

Этот процесс продолжается до тех пор, пока указатели low и high наконец не встретятся в одном элементе:

29 | 21,27,12,19,28 (low/high),44,78,87,66,31,76,58,88,83,97,41,99,44

Мы больше не используем это опорное значение, поэтому остается только поменять опорную точку и high, и мы закончили с этим рекурсивным шагом:

28,21,27,12,19,29,44,78,87,66,31,76,58,88,83,97,41,99,44

Как видите, мы достигли того, что все значения, меньшие 29, теперь слева от 29, а все значения больше 29 справа.

Затем алгоритм делает то же самое для коллекции 28,21,27,12,19 (левая сторона) и 44,78,87,66,31,76,58,88,83,97,41,99,44 (правая сторона). И так далее.

Выполняет сортировку последовательности по возростанию/убыванию.

Параметры:

• — объект, поддерживающий итерирование
• — пользовательская функция, которая применяется к каждому элементу последовательности
• — порядок сортировки

Описание:

Функция вернет новый отсортированный t-list] из итерируемых элементов. Функция имеет два необязательных аргумента, которые должны быть указаны в качестве аргументов ключевых слов.

Аргумент принимает функцию, например . Переданная функция вычисляет результат для каждого элемента последовательности, который используется для сравнения элементов при сортировке. Значением по умолчанию является , т.е. сравнивать элементы напрямую (как есть).

Аргумент имеет логическое значение. Если установлено значение , то элементы списка сортируются в обратной последовательности (по убыванию).

Используйте для преобразования функции, использующей cmp (старый стиль) в использующую key (новый стиль).

Встроенная функция sorted() является гарантированно стабильной. Это означает, что когда несколько элементов последовательности имеют равные значения, их первоначальный порядок сохраняется. Такое поведение полезно при сортировке в несколько проходов.

Примеры различных способов сортировки последовательностей.

Сортировка слов в предложении без учета регистра:

line = 'This is a test string from Andrew'
x = sorted(line.split(), key=str.lower)
print(x)
# 

Сортировка сложных объектов с использованием индексов в качестве ключей :

student = 
    ('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
    

# Сортируем по возрасту student
x = sorted(student, key=lambda student student2])
print(x)
# 

Тот же метод работает для объектов с именованными атрибутами.

class Student
    def __init__(self, name, grade, age):
        self.name = name
        self.grade = grade
        self.age = age
    def __repr__(self):
        return repr((self.name, self.grade, self.age))

student = 
    Student('john', 'A', 15),
    Student('jane', 'B', 12),
    Student('dave', 'B', 10),
    

x = sorted(student, key=lambda student student.age)
print(x)
# 

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

student = 
    ('john', 'A', 15),
    ('jane', 'B', 12),
    ('dave', 'B', 10),
    

# Сортируем по убыванию возраста student
x = sorted(student, key=lambda i i2], reverse=True)
print(x)
# 

Стабильность сортировки и сложные сортировки:

data = 
x = sorted(data, key=lambda data data])
print(x)
# 

Обратите внимание, как две записи (‘blue’, 1), (‘blue’, 2) для синего цвета сохраняют свой первоначальный порядок. Это замечательное свойство позволяет создавать сложные сортировки за несколько проходов по нескольким ключам

Например, чтобы отсортировать данные учащиеся по возрастанию успеваемости, а затем по убыванию возраста. Успеваемость будет первым ключом, возраст вторым

Это замечательное свойство позволяет создавать сложные сортировки за несколько проходов по нескольким ключам. Например, чтобы отсортировать данные учащиеся по возрастанию успеваемости, а затем по убыванию возраста. Успеваемость будет первым ключом, возраст вторым.

student = 
    ('john', 15, 4.1),
    ('jane', 12, 4.9),
    ('dave', 10, 3.9),
    ('kate', 11, 4.1),
    

# По средней оценке
x = sorted(student, key=lambda num num2])
# По убыванию возраста
y = sorted(x, key=lambda age age1], reverse=True)
print(y)
# 

А еще, для сортировок по нескольким ключам, удобнее использовать модуль . Функции модуля допускают несколько уровней сортировки. Например, как в предыдущем примере успеваемость будет первым ключом, возраст вторым.Только сортировать будем все по возрастанию:

from operator import itemgetter

x = sorted(student, key=itemgetter(2,1))
print(x)
# 

sorted() With a key Argument

One of the most powerful components of is the keyword argument called . This argument expects a function to be passed to it, and that function will be used on each value in the list being sorted to determine the resulting order.

To demonstrate a basic example, let’s assume the requirement for ordering a specific list is the length of the strings in the list, shortest to longest. The function to return the length of a string, , will be used with the argument:

>>>

The resulting order is a list with a string order of shortest to longest. The length of each element in the list is determined by and then returned in ascending order.

Let’s return to the earlier example of sorting by first letter when the case is different. can be used to solve that problem by converting the entire string to lowercase:

>>>

The output values have not been converted to lowercase because does not manipulate the data in the original list. During sorting, the function passed to is being called on each element to determine sort order, but the original values will be in the output.

There are two main limitations when you’re using functions with the argument.

First, the number of required arguments in the function passed to must be one.

The example below shows the definition of an addition function that takes two arguments. When that function is used in on a list of numbers, it fails because it is missing a second argument. Each time is called during the sort, it is only receiving one element from the list at a time:

>>>

The second limitation is that the function used with must be able to handle all the values in the iterable. For example, you have a list of numbers represented as strings to be used in , and is going to attempt to convert them to numbers using . If a value in the iterable can’t be cast to an integer, then the function will fail:

>>>

Each numeric value as a can be converted to , but can’t. This causes a to be raised and explain that can’t be converted to because it is invalid.

The functionality is extremely powerful because almost any function, built-in or user-defined, can be used to manipulate the output order.

If the ordering requirement is to order an iterable by the last letter in each string (and if the letter is the same, then to use the next letter), then a function can be defined and then used in the sorting. The example below defines a function that reverses the string passed to it, and then that function is used as the argument for :

>>>

The slice syntax is used to reverse a string. Each element will have applied to it, and the sorting order will be based on the characters in the backwards word.

Instead of writing a standalone function, you can use a function defined in the argument.

A is an anonymous function that:

1. Must be defined inline
2. Doesn’t have a name
3. Can’t contain statements
4. Will execute just like a function

In the example below, the is defined as a with no name, the argument taken by the is , and is the operation that will be performed on the argument:

>>>

is called on each element and reverses the word. That reversed output is then used for sorting, but the original words are still returned.

If the requirement changes, and the order should be reversed as well, then the keyword can be used alongside the argument:

>>>

functions are also useful when you need to sort objects based on a property. If you have a group of students and need to sort them by their final grade, highest to lowest, then a can be used to get the property from the :

>>>

This example uses to produce classes with and attributes. The calls on each element and returns the value for .

is set to to make the ascending output flipped to be descending so that the highest grades are ordered first.

The possibilities are endless for how ordering can be done when you leverage both the and keyword arguments on . Code can be kept clean and short when you use a basic for a small function, or you can write a whole new function, import it, and use it in the key argument.

Odd and Ends

• For locale aware sorting, use locale.strxfrm() for a key function or locale.strcoll() for a comparison function.

• The reverse parameter still maintains sort stability (i.e. records with equal keys retain the original order). Interestingly, that effect can be simulated without the parameter by using the builtin reversed function twice:

  >>> data =
  >>> assert sorted(data, reverse=True) == list(reversed(sorted(reversed(data))))

• To create a standard sort order for a class, just add the appropriate rich comparison methods:

  >>> Student.__eq__ = lambda self, other: self.age == other.age
  >>> Student.__ne__ = lambda self, other: self.age != other.age
  >>> Student.__lt__ = lambda self, other: self.age >> Student.__le__ = lambda self, other: self.age >> Student.__gt__ = lambda self, other: self.age > other.age
  >>> Student.__ge__ = lambda self, other: self.age >= other.age
  >>> sorted(student_objects)

  For general purpose comparisons, the recommended approach is to define all six rich comparison operators. The functools.total_ordering class decorator makes this easy to implement.

• Key functions need not access data internal to objects being sorted. A key function can also access external resources. For instance, if the student grades are stored in a dictionary, they can be used to sort a separate list of student names:

  >>> students =
  >>> newgrades = {‘john’: ‘F’, ‘jane’:’A’, ‘dave’: ‘C’}
  >>> sorted(students, key=newgrades.__getitem__)

Python sort list by multiple sort criteria

The following example sorts a list of students by two sorting
criteria.

multiple_sort.py

#!/usr/bin/env python3

from typing import NamedTuple
from operator import attrgetter


def multi_sort(data, specs):

    for key, reverse in reversed(specs):
        data.sort(key=attrgetter(key), reverse=reverse)
    return data


class Student(NamedTuple):
    id: int
    name: str
    grade: str
    age: int


s1 = Student(1, 'Patrick', 'A', 21)
s2 = Student(2, 'Lucia', 'B', 19)
s3 = Student(3, 'Robert', 'C', 19)
s4 = Student(4, 'Monika', 'A', 22)
s5 = Student(5, 'Thomas', 'D', 20)
s6 = Student(6, 'Petra', 'B', 18)
s6 = Student(7, 'Sofia', 'A', 18)
s7 = Student(8, 'Harold', 'E', 22)
s8 = Student(9, 'Arnold', 'B', 23)

students = 

multi_sort(students, (('grade', False), ('age', True)))

for student in students:
    print(student)

First, the students are sorted by grades in ascending order, then
they are sorted by age in descending order.

def multi_sort(data, specs):

    for key, reverse in reversed(specs):
        data.sort(key=attrgetter(key), reverse=reverse)
    return data

The method applies all the sorting specs
on the list.

$ ./multi_sort.py 
Student(id=4, name='Monika', grade='A', age=22)
Student(id=1, name='Patrick', grade='A', age=21)
Student(id=7, name='Sofia', grade='A', age=18)
Student(id=9, name='Arnold', grade='B', age=23)
Student(id=2, name='Lucia', grade='B', age=19)
Student(id=3, name='Robert', grade='C', age=19)
Student(id=5, name='Thomas', grade='D', age=20)
Student(id=8, name='Harold', grade='E', age=22)

This is the output.

Работа с отсутствующими данными при сортировке в Pandas ↑

Часто данные реального мира имеют много недостатков. Хотя у pandas есть несколько методов, которые можно использовать для очистки данных перед сортировкой, иногда приятно увидеть, какие данные отсутствуют во время сортировки. Это можно сделать с помощью параметра .

Подмножество данных об экономии топлива, используемое в этом руководстве, не имеет пропущенных значений. Чтобы проиллюстрировать использование , сначала нужно создать некоторые недостающие данные. Следующий фрагмент кода создает новый столбец на основе существующего столбца , сопоставляя , где равно и , где это не так:

>>> df = df.map({"Y": True})
>>> df
    city08  cylinders fuelType  ...            trany  year mpgData_
0       19          4  Regular  ...     Manual 5-spd  1985     True
1        9         12  Regular  ...     Manual 5-spd  1985      NaN
2       23          4  Regular  ...     Manual 5-spd  1985     True
3       10          8  Regular  ...  Automatic 3-spd  1985      NaN
4       17          4  Premium  ...     Manual 5-spd  1993      NaN
..     ...        ...      ...  ...              ...   ...      ...
95      17          6  Regular  ...  Automatic 3-spd  1993     True
96      17          6  Regular  ...  Automatic 4-spd  1993      NaN
97      15          6  Regular  ...  Automatic 4-spd  1993      NaN
98      15          6  Regular  ...     Manual 5-spd  1993      NaN
99       9          8  Premium  ...  Automatic 4-spd  1993      NaN

Теперь у вас есть новый столбец с именем , который содержит значения и . В этом столбце вы увидите, какой эффект дает при использовании двух методов сортировки. Чтобы узнать больше об использовании , вы можете прочитать Pandas Project: Make Gradebook With Python & Pandas.

Значение параметра na_position в .sort_values()   

принимает параметр с именем , который помогает упорядочить недостающие данные в столбце, по которому выполняется сортировка. Если сортируется столбец с отсутствующими данными, то строки с отсутствующими значениями появятся в конце . Это происходит независимо от того, выполнятся ли сортировка по возрастанию или по убыванию.

Вот как выглядит DataFrame при сортировке по столбцу с отсутствующими данными:

>>> df.sort_values(by="mpgData_")
    city08  cylinders fuelType  ...            trany  year mpgData_
0       19          4  Regular  ...     Manual 5-spd  1985     True
55      18          6  Regular  ...  Automatic 4-spd  1993     True
56      18          6  Regular  ...  Automatic 4-spd  1993     True
57      16          6  Premium  ...     Manual 5-spd  1993     True
59      17          6  Regular  ...  Automatic 4-spd  1993     True
..     ...        ...      ...  ...              ...   ...      ...
94      18          6  Regular  ...  Automatic 4-spd  1993      NaN
96      17          6  Regular  ...  Automatic 4-spd  1993      NaN
97      15          6  Regular  ...  Automatic 4-spd  1993      NaN
98      15          6  Regular  ...     Manual 5-spd  1993      NaN
99       9          8  Premium  ...  Automatic 4-spd  1993      NaN

Чтобы изменить это поведение и чтобы недостающие данные сначала отображались в DataFrame, надо установить в значение . Параметр принимает только значения , которые являются значениями по умолчанию, или . Вот как использовать в :

>>> df.sort_values(
...     by="mpgData_",
...     na_position="first"
... )
    city08  cylinders fuelType  ...            trany  year mpgData_
1        9         12  Regular  ...     Manual 5-spd  1985      NaN
3       10          8  Regular  ...  Automatic 3-spd  1985      NaN
4       17          4  Premium  ...     Manual 5-spd  1993      NaN
5       21          4  Regular  ...  Automatic 3-spd  1993      NaN
11      18          4  Regular  ...  Automatic 4-spd  1993      NaN
..     ...        ...      ...  ...              ...   ...      ...
32      15          8  Premium  ...  Automatic 4-spd  1993     True
33      15          8  Premium  ...  Automatic 4-spd  1993     True
37      17          6  Regular  ...  Automatic 3-spd  1993     True
85      17          6  Regular  ...  Automatic 4-spd  1993     True
95      17          6  Regular  ...  Automatic 3-spd  1993     True

Теперь любые недостающие данные из столбцов, которые использовались для сортировки, будут отображаться в верхней части DataFrame. Это особенно полезно при начале анализа своих данные, когда нет уверенности в том, есть ли пропущенные значения.

Описание параметра na_position в .sort_index()   

также принимает . Обычно, DataFrame не имеет значений как часть индекса, поэтому этот параметр менее полезен в . Однако полезно знать, что если DataFrame действительно имеет в индексе строки или имени столбца, то можно быстро определить это с помощью и .

По умолчанию для этого параметра установлено значение , что помещает значения в конец отсортированного результата. Чтобы изменить это поведение и сначала сохранить недостающие данные в фрейме данных, установите для параметра значение .