Как сделать массив по возрастанию питон
Добавил пользователь Владимир З. Обновлено: 05.10.2024
Библиотека NumPy ( Numerical Python ) считается основной реализацией массивов Python. Она представляет высокопроизводительный, полнофункциональный тип n-мерного массива, который называется ndarray ( array ). Операции с array выполняются на два порядка быстрее, чем операции со списками. Многие популярные библиотеки data science, такие как pandas, SciPy, Keras и другие, построены на базе NumPy или зависят от нее.
1. Создание массива в Python
Создадим массив на основе списка. NumPy рекомендует импортировать модуль numpy под именем np , чтобы к его компонентам можно было обращаться с префиксом " np ".
>>> import numpy as np
>>> a = [2, 56, 46, 24, 12]
>>> numbers = np . array (a)
>>> type(numbers)
>>> numbers
array([ 2, 56, 46, 24, 12])
Мы взяли обыкновенный список с различными значениями и преобразовали его в массив с помощью модуля numpy . Модуль numpy предоставляет различные функции для создания массивов. Мы воспользовались функцией array , которая в аргументе получила список а. Проверив с помощью функции type() тип объекта мы получили 'numpy.ndarray.
Приведем пример создания массива на основе списка из трех строк и трех столбцов:
>>> b = [[5, 6, 10], [25, 64, 17], [14, 25, 14]]
>>> mas = np.array (b)
>>> mas
array([[ 5, 6, 10],
[25, 64, 17],
[14, 25, 14]])
NumPy автоматически форматирует array на основание количества их измерений и выравнивает столбцы в каждой строке.
Список так же можно передавать напрямую переменной:
>>> numbers = np.array ([ 1, 5, 47, 78])
>>> numbers
array([ 1, 5, 47, 78])
2. Атрибуты array
2.1. Определение типа элементов array
Для проверки типа элемента array можно воспользоваться атрибутом dtype :
>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> numbers_1
array([[ 5, 7, 45],
[14, 7, 9]])
>>> numbers_1. dtype
dtype('int32')
>>> numbers_2 = np.array ([[0.5, 0.7, 0.45], [0.14, 0.7, 0.9]])
>>> numbers_2
array([[0.5 , 0.7 , 0.45],
[0.14, 0.7 , 0.9 ]])
>>> numbers_2. dtype
dtype('float64')
В примере есть два массива numbers_1 и numbers_2 , с помощью dtype определяем их тип. Так как библиотека NumPy написана на языке C и в ней используется тип данных С. В результате мы получили, что первый массив принадлежит к типу dtype('int32') - целые числа , а второй к типу dtype('float64')- вещественные или числа с плавающей точкой.
2.2. Определение размерности array
Для определения размерности существует атрибут ndim , который содержит количество измерений array . Атрибут shape содержит кортеж, определяющий размерность array .
>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> numbers_1. ndim
2
>>> numbers_1. shape
(2, 3)
В примере numbers_1 состоит из двух строк и трех столбцов.
2.3. Определение количества и размера элементов
Количество элементов в массиве можно получить с помощью атрибута size.
>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> numbers_1. size
6
Количество байтов, необходимое для хранения элементов можно получить из атрибута itemsize .
>>> numbers_1. itemsize
4
Для компиляторов C с 32-разрядным int, размер равен 4. Если у вас 64-разрядный, у вас будет равен 8.
2.4. Перебор элементов array
Для перебора многомерной коллекции array можно воспользоваться циклом for:
>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> for row in numbers_1:
. for column in row:
. print(column, end=' ')
. print()
.
5 7 45
14 7 9
Если вы хотите получить все результаты в одно строку, можно воспользоваться атрибутом flat :
>>> for i in numbers_1. flat :
. print(i, end=' ')
.
5 7 45 14 7 9
3. Создание массивов в Python по диапазонам
NumPy представляет множество функций для создания массивов в заданном диапазоне. Разберем самые распространённые.
3.1. Создание диапазонов функцией arange
В библиотеке NumPy существует функция arange для создания целочисленных диапазонов, аналогичной встроенной функции range в Python.
>>> import numpy as np
>>> np. arange (7)
array([0, 1, 2, 3, 4, 5, 6])
>>> np. arange (5, 10)
array([5, 6, 7, 8, 9])
>>> np. arange (100, 10, -10)
array([100, 90, 80, 70, 60, 50, 40, 30, 20])
При создании коллекций array вы можете воспользоваться встроенной функции Python range, но рекомендуется использовать именно arange , так как она оптимизирована для array . Все свойства arange аналогичны функции range.
3.2. Создание диапазонов чисел с плавающей точкой функцией linspace
Для создания диапазонов чисел с плавающей точкой можно воспользоваться функцикй limspace библиотеки NumPy.
>>> import numpy as np
>>> np. linspace (1.0, 2.0, num=5)
array([1. , 1.25, 1.5 , 1.75, 2. ])
>>> np. linspace (1.0, 5.0, num=10)
array([1. , 1.44444444, 1.88888889, 2.33333333, 2.77777778, 3.22222222, 3.66666667, 4.11111111, 4.55555556, 5. ])
В функции linspace первые два аргумента определяют начальное и конечное значение диапазона. Важно: конечное значение включается в array . Ключевой аргумент num необязательный. Он задает количество равномерно распределенных генерируемых значений. По умолчанию num = 50 .
3.3. Изменение размерности array методом reshape
Методом reshape вы можете преобразовать одномерную коллекцию в многомерную. В примере создадим коллекцию array с помощью arange со значениями от 1 до 36 и с помощью метода reshape преобразуем ее в структуру из 6 строк и 6 столбцов.
>>> import numpy as np
>>> np.arange(1, 37). reshape (6, 6)
array([[ 1, 2, 3, 4, 5, 6],
[ 7, 8, 9, 10, 11, 12],
[13, 14, 15, 16, 17, 18],
[19, 20, 21, 22, 23, 24],
[25, 26, 27, 28, 29, 30],
[31, 32, 33, 34, 35, 36]])
>>> np.arange(1, 37). reshape (4, 9)
array([[ 1, 2, 3, 4, 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14, 15, 16, 17, 18],
[19, 20, 21, 22, 23, 24, 25, 26, 27],
[28, 29, 30, 31, 32, 33, 34, 35, 36]])
Во втором примере мы преобразовали в структуру 4 строк и 9 столбцов.
Размерность можно изменять для любой коллекции array , но при условии, что количество новой версии не будет отличаться от оригинала. Например, коллекцию из шести элементов, можно преобразовать в коллекцию 3*2 или 2*3. В нашем примере мы преобразовали коллекцию из 36 элементов в коллекцию 6*6 и 4*9. В случае неправильного преобразования, вы получите ошибку ValueError .
3.4. Заполнение array конкретными значениями. Функции zeros , ones , full
Функция zeros создает коллекцию содержащие 0. Первым аргументом должно быть целое число или кортеж целых чисел.
>>> import numpy as np
>>> np. zeros (7)
array([0., 0., 0., 0., 0., 0., 0.])
>>> np. zeros ((3, 3))
array([[0., 0., 0.],
[0., 0., 0.],
[0., 0., 0.]])
Функция ones создает коллекцию содержащие 1.
>>> import numpy as np
>>> np. ones ((3, 3))
array([[1., 1., 1.],
[1., 1., 1.],
[1., 1., 1.]])
По умолчанию функции zeros и ones создают коллекции array, содержащие значения float . Для изменения типа значения можно задать аргумент dtype :
>>> import numpy as np
>>> np. ones ((3, 3), dtype=int )
array([[1, 1, 1],
[1, 1, 1],
[1, 1, 1]])
>>> np. zeros ((3, 3), dtype=int )
array([[0, 0, 0],
[0, 0, 0],
[0, 0, 0]])
Функция full , возвращает элементы со значением и типом второго аргумента:
>>> import numpy as np
>>> np. full ((3, 4), 55)
array([[55, 55, 55, 55],
[55, 55, 55, 55],
[55, 55, 55, 55]])
>>> np. full ((2, 4), 21.2)
array([[21.2, 21.2, 21.2, 21.2],
[21.2, 21.2, 21.2, 21.2]])
3.5. Вывод больших коллекций array
При выводе больших коллекций array , NumPy исключает из вывода все строки и столбцы кроме первых трех и последних. Вместо исключенных данных проставляется знак многоточие.
>>> import numpy as np
>>> np.arange(1, 100001).reshape(100, 1000)
array([[ 1, 2, 3, . 998, 999, 1000],
[ 1001, 1002, 1003, . 1998, 1999, 2000],
[ 2001, 2002, 2003, . 2998, 2999, 3000],
.
[ 97001, 97002, 97003, . 97998, 97999, 98000],
[ 98001, 98002, 98003, . 98998, 98999, 99000],
[ 99001, 99002, 99003, . 99998, 99999, 100000]])
4. Операторы array
4.1. Арифметические операции c массивами в Python
Арифметические операции с array выполняются поэлементно, то есть применяются к каждому элементу массива. Пример, если мы умножаем массив на 3, то каждый элемент будет умножен на 3. Так же и с остальными арифметическими операциями.
>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> numbers_1 * 3
array([[ 15, 21, 135],
[ 42, 21, 27]])
>>> numbers_1 ** 3
array([[ 125, 343, 91125],
[ 2744, 343, 729]], dtype=int32)
>>> numbers_1
array([[ 5, 7, 45],
[14, 7, 9]])
Важно, что при арифметических операциях, возвращается новая коллекция array , исходный массив numbers_1 не изменяется.
А вот расширенное присваивание изменяет каждый элемент левого операнда:
>>> import numpy as np
>>> numbers_1 = np.array([[5, 7, 45], [14, 7, 9]])
>>> numbers_1 += 10
>>> numbers_1
array([[15, 17, 55],
[24, 17, 19]])
4.2. Арифметические операции между коллекциями array
С коллекциями array можно выполнять арифметические операции, если они имеют одинаковые размеры. Результатом будет новая коллекция array :
>>> import numpy as np
>>> numbers_1 = np.array ([[5, 7, 45], [14, 7, 9]])
>>> numbers_2 = np.array ([[8, 12, -35], [4, 12, 25]])
>>> numbers_1 * numbers_2
array([[ 40, 84, -1575],
[ 56, 84, 225]])
>>> numbers_1 - numbers_2
array([[ -3, -5, 80],
[ 10, -5, -16]])
4.3. Сравнение коллекция array
Коллекции array можно сравнивать как между собой, так и с отдельными значениями. Сравнение выполняется поэлементно.
>>> import numpy as np
>>> numbers_1 = np.array([2, 4, 6, 8, 10])
>>> numbers_2 = np.array([1, 5, 6, 7, 12])
>>> numbers_1 > numbers_2
array([ True, False, False, True, False])
>>> numbers_1 == numbers_2
array([False, False, True, False, False])
>>> numbers_1 >= 5
array([False, False, True, True, True])
В результате сравнений создаются коллекции array с логическими значениями ( True или False), каждое из которых означает результат сравнения каждого элемента.
5. Вычислительные методы NumPy
При помощи различных методов мы можем проводить арифметические операции внутри коллекций, вычислить сумму всех элементов или найти наибольше значение. Приведем пример основных методов:
>>> import numpy as np
>>> grades = np.array([[3, 4, 5, 4], [2, 5, 4, 5], [5, 5, 4, 5]])
>>> grades
array([[3, 4, 5, 4],
[2, 5, 4, 5],
[5, 5, 4, 5]])
>>> grades. min()
2
>>> grades. max()
5
>>> grades. sum()
51
>>> grades. mean()
4.25
>>> grades. std()
0.924211375534118
>>> grades. var()
0.8541666666666666
Метод min() и max() находит наименьшее и наибольшее значение. Метод sum() - вычисляет сумму всех элементов, mean() - математическое ожидание, std() - стандартное отклонение, var() - дисперсию.
Эти методы могут применяться к конкретным осям array. К примеру, нам нужно вычислить средний бал по предмету. Для это в метод добавляется аргумент axis , который позволяет проводить вычисление по строкам или столбцам.
>>> grades.mean( axis=0 )
array([3.33333333, 4.66666667, 4.33333333, 4.66666667])
>>> grades.mean( axis=1 )
array([4. , 4. , 4.75])
Если axis=0, выполняется вычисления по всем значениям строк внутри каждого столбца.
Если axis=1, выполняется вычисления со всеми значениями столбца внутри каждой отдельной строки.
6. Индексирование и сегментация массивов в Python
Для одномерных коллекций array применяются, операции сегментации и индексирования, описанные в разделе "Сегментация последовательностей в Python". Ниже разберем сегментацию с двумерными коллекциями array.
Выбор элемента двумерной коллекции array
Для выбора элемента двумерной коллекции array укажите кортеж с индексами строки и столбца элемента в квадратных скобках.
Выбор подмножества строк двумерной коллекции array
Для выбора одной строки укажите в квадратных скобках только один индекс:
>>> grades[ 2 ]
array([5, 5, 4, 5])
Для выбора нескольких строк используйте синтаксис сегмента:
>>> grades[ 1:3 ]
array([[2, 5, 4, 5],
[5, 5, 4, 5]])
Для выбора нескольких несмежных строк используйте список индексов строк:
>>> grades[[ 1, 3 ]]
array([[2, 5, 4, 5],
[5, 4, 5, 3]])
Выбор подмножества столбцов двумерной коллекции array
Для выбора подмножества столбцов следует указать кортеж, в котором указаны выбираемые строки и столбцы:
>>> grades[ :, 1 ]
array([4, 5, 5, 4])
Двоеточие указывает какие строки в столбце должны выбираться. В нашем случает " : " является сегментом и выбираются все строки. После запятой мы указали 1, значит выбрали столбец номер два.
Для выбора нескольких смежных столбцов используется синтаксис сегмента:
>>> grades[:, 1:3 ]
array([[4, 5],
[5, 4],
[5, 4],
[4, 5]])
Для выбора конкретных столбцов используйте список индексов этих строк:
>>> grades[:, [0, 2, 3] ]
array([[3, 5, 4],
[2, 4, 5],
[5, 4, 5],
[5, 5, 3]])
7. Глубокое копирование. Метод copy
В случае если вам необходимо создать новую коллекцию с аналогичными данными, можно воспользоваться методом copy . Метод copy коллекций array возвращает новый объект array с глубокой копией данных объекта исходной коллекции.
>>> import numpy as np
>>> numbers_1 = np.array([21, 25, 12, 1, 78])
>>> numbers_1
array([21, 25, 12, 1, 78])
>>> numbers_2 = numbers_1. copy()
>>> numbers_2
array([21, 25, 12, 1, 78])
В итоге мы получили новый массив numbers_2, с которым далее мы можем работать, не изменяя основной массив.
8. Изменение размеров и транспонирование массива в Python
В NumPy существует много возможностей для изменения размера массивов.
8.1. Метод resize
Метод resize изменяет размер исходной коллекции array:
>>> import numpy as np
>>> numbers = np.array([21, 25, 12, 1, 78, 77])
>>> numbers
array([21, 25, 12, 1, 78, 77])
>>> numbers. resize(3, 2)
>>> numbers
array([[21, 25],
[12, 1],
[78, 77]])
8.2. Методы flatten и ravel
- Метод flatten выполняет глубокое копирование данных исходной коллекции
>>> import numpy as np
>>> numbers = np.array([21, 25, 12, 1, 78])
>>> numbers_fl = numbers. flatten()
>>> numbers_fl
array([21, 25, 12, 1, 78])
Чтобы проверить что numbers и numbers_fl не используют общие данные изменим элемент numbers_fl и выведем оба массива:
>>> numbers_fl[ 0 ] = 77
>>> numbers_fl
array([ 77 , 25, 12, 1, 78])
>>> numbers
array([21, 25, 12, 1, 78])
Значение в numbers_fl изменилось, значит массивы уже не связаны между собой.
- метод ravel создает представление (поверхностную копию) исходной коллекции array, которое использует общие данные.
>>> numbers
array([21, 25, 12, 1, 78])
>>> numbers_ra = numbers. ravel()
>>> numbers_ra
array([21, 25, 12, 1, 78])
Чтобы проверить использование общих данных, изменим один элемент numbers_ra:
>>> numbers_ra[ 0 ] = 125
>>> numbers_ra
array([ 125 , 25, 12, 1, 78])
>>> numbers
array([ 125 , 25, 12, 1, 78])
В результате значения поменялись в обоих массивах.
8.3. Транспонирование строк и столбцов
С помощью атрибута T вы можете быстро транспонировать строки и столбцы маcсива, то есть сделать так чтобы строки стали столбцами, а столбцы строками.
>>> import numpy as np
>>> numbers = np.array([[45, 65, 48], [78, 45, 62]])
>>> numbers
array([[45, 65, 48],
[78, 45, 62]])
>>> numbers. T
array([[45, 78],
[65, 45],
[48, 62]])
Транспонирование не изменяет исходную коллекцию array.
8.4. Горизонтальное и вертикальное дополнение. Функции hstack и vstack
Добавление новых строк или столбцов, называется горизонтальным или вертикальным дополнением. Допустим у нас есть две коллекции array, и мы хотим объединить их в одну. Для этого можно воспользоваться функцией hstack() из библиотеки NumPy. Функцие hstack() передается кортеж с объединяемыми коллекциями:
>>> import numpy as np
>>> numbers_1 = np.array([21, 25, 12, 1, 78])
>>> numbers_2 = np.array([17, 54, 55, 24, 78])
>>> np. hstack (( numbers_1, numbers_2 ))
array([21, 25, 12, 1, 78, 17, 54, 55, 24, 78])
В случае если нам требуется объединить массивы добавлением, можно воспользоваться функцией vstack() :
>>> np. vstack (( numbers_1, numbers_2 ))
array([[21, 25, 12, 1, 78],
[17, 54, 55, 24, 78]])
Общей идиомой в программировании является сортировка списка. Python делает эту задачу очень простой благодаря встроенной функции sorted() которая принимает итерируемый тип и возвращает отсортированный список:
1. Стандартная сортировка
Обратите внимание на то, что функция sorted() возвращает список каждый раз, несмотря на то, какой тип был передан. В случае со словарями, она возвращает отсортированный список словарных ключей.
2. Сортировка сложных структур с использованием ключа
Это нормально работать с вещами, у которых по природе есть определенный порядок, вроде чисел или строк, но что делать с более сложными структурами? Здесь функция sorted() демонстрирует свое великолепие. Функция sorted() принимает ключ в качестве опционально названного параметра. Этот ключ должен быть, сам по себе, функцией, которая принимает один параметр, которая затем используется функцией sorted(), для определения значения в целях дальнейшей сортировки. Давайте взглянем на пример. Скажем, у нас есть класс Person с такими атрибутами как имя и возраст:
(Функция __repr__ является специальной функцией, которая используется для переопределения того, как объект будет представлен в интерпретаторе Python)
Причина, по которой я определил функцию – это выделение порядка сортировки. По умолчанию, представление определенных пользователем объектов выглядит примерно так: “ ”. Если оставить все как есть, то отличать различные экземпляры в будущих примерах будет несколько затруднительно для нас.
Давайте сделаем список людей:
Сама по себе функция sorted() не знает, что делать со списком людей:
Однако, мы можем указать функции sorted(), какой атрибут сортировать, указав используемый ключ. Давайте определим это в следующем примере:
Функция ключа должна принять один аргумент и выдать значение, на котором базируется сортировка. Функция sorted() должна вызвать функцию key в каждом элементе используемой итерируемой, и использовать значение выдачи при сортировке списка.
Обратите внимание на то, что мы передаем ссылку на саму функцию, не вызывая ее и передаем ссылку к её возвращаемому значению. Это очень важный момент. Помните, sorted() будет использовать функцию key, вызывая её в каждом элементе итерируемой.
Давайте взглянем на еще один код, на этот раз определяем возраст как значение для сортировки:
3. Обратная сортировка
Функция sorted() намного упрощает сортировку в обратном порядке. Функция принимает опциональный параметр под названием reverse, который действует по строгой логике.
4. Сортировка с использованием функции attrgetter
В этот раз, возвращаемый список отсортирован по возрасту, как мы и ожидали. Фактически, сортировка по определенному атрибуту объекта это простая задача Python, которую может выполнить стандартная библиотека, благодаря функции, которая может генерировать функции ключей для вас:
Результат вызова attrgetter() – это функция, схожая с предыдущими двумя, которые мы только что рассмотрели. Мы определяем имя атрибута для выборки, после чего attrgetter генерирует функцию, которая принимает объект и возвращает определенный атрибут из этого объекта.
Таким образом, attrgetter(name) возвращает функцию, которая ведет себя также как и определенная раннее нашей функцией byName_key():
Функция attrgetter(age) возвращает функцию, которая ведет себя также как и определенная раннее нашей функцией byAge_key():
5. Предварительное использование key в функции сортировки
До сих пор нашими ключевыми функциями были простые считыватели атрибутов, но они также могут вычислять значения для сортировки. Давайте взглянем на еще один пример. На этот раз мы определим класс Snake:
У нашей змеи есть имя, toxicity (токсичность, мерило того, насколько токсичен её яд) и agression (представленная в виде числа от 0 до 1, которое указывает на вероятность того, что змея нападет).
Надежный сайт по продвижению doctorsmm предлагает купить подписчиков на свой Телеграмм канал по очень выгодным и притягательным ценам от 51 рубля за сотню аккаунтов. Кроме того, Вы сможете подобрать наиболее оптимальную для Вашего сообщества скорость поступления, которая доходит до 1000 единиц в сутки.
Теперь предположим, что мы можем подсчитать, насколько опасная змея, основываясь на показателях токсичности и агрессивности, и можем отсортировать список змей по степени их опасности:
Змеи отсортированы в ожидаемом нами порядке (несмотря на то, что гремучая змея (rattlesnake) более ядовита, чем кобра (kingCobra), уровень агрессивности кобры делает её более опасной).
6. Случайная сортировка
Ключи не обязаны иметь какую-либо связь с сортируемыми элементами (однако, это не самый продуктивный способ сортировать что-либо). Мы можем создать случайный порядок со следующим ключом:
Функция random() – это часть стандартной библиотеки random, которая выдает числа в случайном порядке от 0 до 1. Сортировка с использованием данного ключа выдает, кто бы мог подумать, случайный порядок:
В данной статье мы рассмотрели то, как Python создает отсортированные списки (и другие итерируемые) и то, насколько это просто. По умолчанию, функция sorted() возвращает список, содержимое которого упорядоченно в естественном порядке (что, в общем, именно то что мы ожидаем от чисел и строк). Желающие углубиться в то, как работает функция sorted() могут обратиться к документации Python.
Если вы хотите узнать, как работать с Сортировать () Метод в ваших проектах Python, тогда эта статья для вас. Этот метод очень мощный, и вы можете настроить его, чтобы соответствовать вашим потребностям, поэтому давайте посмотрим, как он работает подробно.
- Как использовать этот метод и настроить его функциональность.
- Когда использовать его и когда не использовать его.
- Как называть это проходящими комбинациями аргументов.
- Как сортировать список в порядке возрастания и убывания.
- Как сравнить элементы списка на основе промежуточных значений.
- Как вы можете пройти функции лямбда к этому методу.
- Как этот метод сравнивается с отсортировано () функция.
- Почему Сортировать () Способ выполняет стабильное сортировка.
- Как процесс мутации работает за кулисами.
Вы готовы? Давайте начнем! ⭐.
🔹 Цель и использование случаев
С Сортировать () Способ, вы можете отсортировать список в либо:
Этот метод используется для сортировки списка на месте, что означает, что это Мутации Это или изменяет его непосредственно без создания дополнительных копий, поэтому помните:
Вы узнаете больше о мутации в этой статье (обещаю!), Но на данный момент очень важно, чтобы вы знали, что Сортировать () Метод изменяет список, поэтому его оригинальная версия потеряна.
Из-за этого вы должны использовать только этот метод, если:
- Вы хотите изменить (сортировать) список постоянно.
- Вам не нужно держать оригинальную версию списка.
Если это соответствует вашим потребностям, то .sort () Метод точно то, что вы ищете.
🔸 синтаксис и аргументы
Давайте посмотрим, как вы можете позвонить .sort () воспользоваться его полной властью.
Это самый простой вызов (без аргументов):
Если вы не передадите никаких аргументов, по умолчанию:
- Список будет отсортирован в порядке возрастания.
- Элементы списка будут сравниваться непосредственно с использованием их значений с оператор.
Пользовательские аргументы
Настроить, как Сортировать () Способ работает, вы можете пройти два дополнительных аргумента:
Давайте посмотрим, как они изменит поведение этого метода. Здесь у нас есть возможность позвонить с этими двумя аргументами:
Прежде чем объяснить, как они работают, я хотел бы объяснить то, что вы, вероятно, заметили на диаграмме выше – в вызове метода, имена параметров должны быть включены перед их соответствующими значениями, как это:
Это потому, что они только ключевые аргументы Отказ Если вы передаете их таможенное значение для них, их имена должны быть указаны в вызове метода, за которым следует равный знак = И их соответствующие значения, как это:
В противном случае, если вы попытаетесь пройти аргументы непосредственно, поскольку мы обычно делаем для позиционных параметров, вы увидите эту ошибку, потому что функция не будет знать, какой аргумент соответствует какому параметру:
Обеспечить регресс
Теперь, когда вы знаете, какие аргументы только ключевых слов, давайте начнем с Обратный Отказ
Значение Обратный может быть либо Правда или Ложь :
- Ложь означает, что список будет отсортирован в порядке возрастания.
- Правда означает, что список будет отсортирован в убывании (обратный) порядок.
💡 Совет: По умолчанию его значение – Ложь – Если вы не передадите никакие аргументы для этого параметра, список отсортирован в порядке возрастания.
Здесь у нас есть несколько примеров:
💡 Совет: Если элементы списка являются строки, они сортируются в алфавитном порядке.
💡 Совет: Обратите внимание, как список отсортирован в порядке убывания, если Обратный это Правда Отказ
Теперь, когда вы знаете, как работать с Обратный Параметр, давайте посмотрим ключ параметр.
Этот параметр немного более подробно, потому что он определяет, как элементы списка можно сравнить в процессе сортировки.
Значение ключ это либо:
- Нет , что означает, что элементы списка будут сравниваться напрямую. Например, в списке целых чисел сами целые числа могут быть использованы для сравнения.
- АФункция одного аргумента, который генерирует промежуточное значение для каждого элемента. Это промежуточное значение рассчитывается только один раз, и он используется для создания сравнений в течение всего процесса сортировки. Мы используем это, когда мы не хотим сравнивать элементы напрямую, например, когда мы хотим сравнить строки на основе их длины (промежуточное значение).
💡 Совет: По умолчанию значение ключ это Нет Таким образом, элементы сравниваются напрямую.
Допустим, мы хотим сортировать список строк на основе их длины, из кратчайшей строки до самой длинной строки. Мы можем пройти функцию Лен Как ценность ключ , как это:
💡 Совет: Обратите внимание, что мы передаем только имя функции ( Len ) без скобок, потому что мы не называем функцию. Это очень важно.
Обратите внимание на разницу между сравнением элементов непосредственно и сравнение их длины (см. Ниже). Использование значения по умолчанию ключ ( Нет ) бы отсортировали бы струны в алфавистых (слева), но теперь мы сортируем их на основе их длины (справа):
Что происходит за кулисами? Каждый элемент передан как аргумент для Лен () Функция, и значение, возвращаемое этим вызовом функции, используется для выполнения сравнений во время процесса сортировки:
Это приводит к списку с различными критериями сортировки: длина.
Здесь у нас есть еще один пример:
Согласно лексикографическому заказу, заглавные буквы приходят до строчных букв:
Чтобы избежать различения капитальных и строчных букв, мы можем пройти функцию str.low как ключ Отказ Это создаст строчную версию строк, которые будут использоваться для сравнения:
💡 Совет: Если бы мы использовали процесс сортировки по умолчанию, все строки, начатые с заглавной буквы, пришли бы до всех строк, которые начались с строчной буквы:
Вот пример с использованием объектно-ориентированного программирования (OOP):
Если у нас есть этот очень простой класс Python:
И мы создаем четыре экземпляра:
Мы можем сделать список, который ссылается на них:
Затем, если мы определим функцию, чтобы получить возраст Из этих случаев:
Мы можем отсортировать список, исходя из их возраста, передавая Get_age Функция аргумент:
Это финальная, отсортированная версия списка. Мы используем для петли для печати возраста экземпляров в том порядке, в котором они появляются в списке:
Именно то, что мы хотели – теперь список отсортирован в порядке возрастания в зависимости от возраста экземпляров.
💡 Совет: Вместо определения Get_age Функция, мы могли бы использовать функцию лямбда, чтобы получить возраст каждого экземпляра, как это:
Лямбда функции Небольшие и простые анонимные функции, что означает, что у них нет имени. Они очень полезны для этих сценариев, когда мы только хотим использовать их в определенные места в течение очень короткого периода времени.
Это основная структура функции лямбда, которую мы используем для сортировки списка:
Прохождение обоих аргументов
Потрясающие! Теперь вы знаете, чтобы настроить функциональность Сортировать () метод. Но вы можете взять свои навыки на совершенно новый уровень, сочетая эффект ключ и Обратный В том же методе вызов:
Это различные комбинации аргументов и их эффект:
Порядок аргументов только ключевых слов не имеет значения
Поскольку мы указываем имена аргументов, мы уже знаем, какое значение соответствует какому параметру, поэтому мы можем включить либо ключ или Обратный Сначала в списке и эффект будет точно таким же.
Так что этот метод вызова:
Если мы изменим порядок аргументов, мы получаем тот же результат:
🔹 возвращаемое значение
Теперь давайте немного поговорим о возвращенном значении этого метода. Сортировать () Метод возвращает Нет – Это делает не Верните отсортированную версию списка, как мы могли бы интуитивно ожидать.
По сути, это используется, чтобы напомнить нам, что мы изменяем исходный список в памяти, не генерируя новую копию списка.
Это пример возвращаемого значения Сортировать () :
Видеть? Нет был возвращен по телефону.
💡 Совет: Очень важно не путать Сортировать () Метод с отсортировано () Функция, которая является функцией, которая работает очень похожи, но не Измените исходный список. Вместо этого отсортировано () Создает и возвращает новую копию списка, уже отсортирован.
Это пример, который мы можем использовать для их сравнения:
Это очень важно, потому что их эффект очень отличается. Используя Сортировать () Метод, когда вы намереваетесь использовать отсортировано () Может ввести серьезные ошибки в вашу программу, потому что вы можете не осознавать, что список мутируется.
🔸 метод сортировки () выполняет стабильную сортировку
Теперь давайте немного поговорим о характеристиках сортировочного алгоритма, используемого Сортировать () Отказ
Этот метод выполняет стабильный сорт, потому что он работает с реализацией Timsort , очень эффективный и стабильный алгоритм сортировки.
Это означает, что если два элемента имеют одинаковое значение или промежуточное значение (ключ), они гарантированно остаются в том же порядке относительно друг друга.
Давайте посмотрим, что я имею в виду с этим. Пожалуйста, посмотрите на этот пример в течение нескольких мгновений:
Мы сравниваем элементы на основе их Длина Потому что мы прошли Лен Функция как аргумент для ключ Отказ
Мы видим, что есть три элемента с длиной 2: "BB" , "АА" и "CC" в этой последовательности.
Теперь обратите внимание, что эти три элемента находятся в одном относительном порядке в финальном отсортированном списке:
Это связано с тем, что алгоритм гарантированно будет стабильным, и у трех из них имели одинаковое промежуточное значение (ключ) во время процесса сортировки (их длина была 2, поэтому их ключ составлял 2).
Теперь вы знаете, как Сортировать () Метод работает, поэтому давайте погрузимся в мутацию и как это может повлиять на вашу программу.
🔹 Мутация и риски
Как и обещал, давайте посмотрим, как процесс мутации работает за кулисами:
Когда вы определяете список в Python, как это:
Вы можете получить доступ к идентификатору списка, используя ID () Функция, передавая список в качестве аргумента:
Когда ты Мутате Список, вы меняете его непосредственно в память. Вы можете спросить, почему это так рискованно?
Это рискованно, потому что это влияет на каждую единую строку кода, которая использует список после мутации, поэтому вы можете писать код для работы со списком, который полностью отличается от фактического списка, который существует в памяти после мутации.
Вот почему вы должны быть очень осторожны с методами, которые вызывают мутацию.
В частности, Сортировать () Метод Мутации список. Это пример своего эффекта:
Список был мутирован после звонка .sort () Отказ
Каждая отдельная строка кода, которая работает со списком А После того, как мутация произошла, будет использовать новую, отсортированную версию списка. Если это было не то, что вы предполагаете, вы не понимаете, что другие части вашей программы работают с новой версией списка.
Вот еще один пример рисков мутации в рамках функции:
Список А Это было передано как аргумент мутировал, даже если это не то, что вы предполагали, когда вы изначально написали функцию.
💡 Совет: Если функция мутирует аргумент, он должен быть четко указан, чтобы избежать внедрения ошибок в другие части вашей программы.
🔸 Сводка метода сортировки ()
- Сортировать () Метод позволяет сортировать список в порядке возрастания или убывания.
- Требуется два аргумента только ключевых слов: ключ и Обратный Отказ
- Обратный Определяет, отсортирован ли список в порядке возрастания или убывания.
- ключ Это функция, которая генерирует промежуточное значение для каждого элемента, и это значение используется для выполнения сравнений во время процесса сортировки.
- Сортировать () Метод мутирует список, вызывая постоянные изменения. Вы должны быть очень осторожны и использовать его только, если вам не нужна оригинальная версия списка.
Я действительно надеюсь, что вам понравилась моя статья и обнаружила, что это полезно. Теперь вы можете работать с Сортировать () Метод в ваших проектах Python. Проверьте мои онлайн-курсы Отказ Следуй за мной на Twitter Отказ ⭐️.
Основы
В Питоне нет структуры данных, полностью соответствующей массиву. Однако, есть списки, которые являются их надмножеством, то есть это те же массивы, но с расширенным функционалом. Эти структуры удобнее в использовании, но цена такого удобства, как всегда, производительность и потребляемые ресурсы. И массив, и список – это упорядоченные коллекции, но разница между ними заключается в том, что классический массив должен содержать элементы только одного типа, а список Python может содержать любые элементы.
Создание массива
Существует несколько способ создать массив. Ниже приведены примеры как это можно сделать.
Многомерный массив
Двухмерный массив в Python можно объявить следующим образом.
Операции с массивами
Давайте теперь рассмотрим операции, которые Пайтон позволяет выполнять над массивами.
Обход массива с использованием цикла for
Мы можем использовать цикл for для обхода элементов массива.
Здесь представлен подход, свойственный большинству языков программирования. В Python же есть свой, более удобный вариант.
Обход многомерного массива
Для того чтоб получить элементы многомерного массива придётся использовать вложенные циклы.
Добавление
Мы можем использовать функцию insert() для вставки элемента по указанному индексу. Элементы из указанного индекса сдвигаются вправо на одну позицию.
Определение размера
Используйте метод len() чтобы вернуть длину массива (число элементов массива).
Не стоит путать размер массива с его размерностью!
Поскольку индексация элементов начинается с нуля, длина массива всегда на единицу больше, чем индекс последнего элемента.
Небольшое пояснение: метод списка .index() возвращает индекс элемента, значение которого совпадает с тем, которое передали методу. Здесь мы передаём значение последнего элемента и, таким образом, получаем индекс последнего элемента. Будьте осторожны: если в списке есть повторяющиеся значения, этот приём не сработает!
Срез Python предоставляет особый способ создания массива из другого массива.
Функция pop
В Python удалить ненужные элементы из массива можно при помощи метода pop, аргументом которого является индекс ячейки. Как и в случае с добавлением нового элемента, метод необходимо вызвать через ранее созданный объект.
После выполнения данной операции содержимое массива сдвигается так, чтобы количество доступных ячеек памяти совпадало с текущим количеством элементов.
Методы массива
В Python есть набор встроенных методов, которые вы можете использовать при работе с list.
| Метод | Значение |
| append() | Добавляет элементы в конец списка |
| clear() | Удаляет все элементы в списке |
| copy() | Возвращает копию списка |
| count() | Возвращает число элементов с определенным значением |
| extend() | Добавляет элементы списка в конец текущего списка |
| index() | Возвращает индекс первого элемента с определенным значением |
| insert() | Добавляет элемент в определенную позицию |
| pop() | Удаляет элемент по индексу |
| remove() | Убирает элементы по значению |
| reverse() | Разворачивает порядок в списке |
| sort() | Сортирует список |
Модуль array
Если Вам всё-таки нужен именно классический массив, вы можете использовать встроенный модуль array. Он почти не отличается от структуры list, за исключением, пожалуй, объявления.
Вот небольшая демонстрация:
Читайте также: