Python3-списки и их методы
newbie
Опубликован: | 2018-09-21T05:29:01.672166Z |
Отредактирован: | 2018-09-21T05:25:58.324187Z |
Список - ещё один из наиболее часто используемых типов данных в программах написанных на Python3. В этом обзоре рассмотрим характерные особенности и методы работы с данными этого типа, а так же детально на примерах разберём возможное использование всех имеющихся в арсенале этого типа объектов методов.
1. Общие сведения
Продолжаем разбираться со встроенными типами данных Питона. На этот раз речь пойдёт о списках, их создании, изменении и других предусмотренных этим диалектом процедурах.
Список - это некоторая упорядоченная последовательность разделённых запятой объектов, ограниченная квадратными скобками. Список является изменяемой коллекцией данных любых типов объединённой общим именем. В Питоне третьей версии списки определяются классом list
модуля стандартной библиотеки builtins
.
Создать список можно несколькими различными способами. Можно создать список посредством вызова соответствующего класса. Созданный таким способом список будет пустым.
>>> x = list() >>> x [] >>>
Аналогичный результат будет получен, если имени переменной присвоить специальное значение []
.
>>> x = [] >>> x [] >>>
Список можно создать из любой другой последовательности, например из строки.
>>> s = 'Hello, World!' >>> x = list(s) >>> x ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'] >>>
Из последовательности список можно создать ещё и посредством специального выражения - list comprehension.
>>> s = 'Hello, World!' >>> x = [i for i in s] >>> x ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'] >>>
Списки полученные этими двумя методами из одной и той же последовательности буду эквивалентны, при этом размеры этих объектов в байтах будут отличаться.
>>> import sys >>> s = 'Hello, World!' >>> x = list(s) >>> y = [i for i in s] >>> x ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'] >>> y ['H', 'e', 'l', 'l', 'o', ',', ' ', 'W', 'o', 'r', 'l', 'd', '!'] >>> sys.getsizeof(x) 224 >>> sys.getsizeof(y) 192 >>>
Список можно создать выражением, в котором явным образом будут перечислены все элементы создаваемого списка.
>>> x = [1, 3, 5, 7] >>> x [1, 3, 5, 7] >>>
Технически, список - это набор ссылок на объекты, хранящиеся в пространстве имён, поэтому список может содержать любые определяемые диалектом объекты: любые экземпляры любого из встроенных типов данных, классы, функции, анонимные функции, экземпляры классов etc.
>>> s 'Hello, World!' >>> x [1, 3, 5, 7] >>> class A: pass ... >>> a = A() >>> y = [s, x, A, a, None, sorted] >>> y ['Hello, World!', [1, 3, 5, 7], <class '__main__.A'>, <__main__.A object at 0x7f2f3dc67320>, None, <built-in function sorted>] >>>
Список в Питоне имеет ряд очень важных характерных особенностей, а именно:
- список имеет длину;
- список - это упорядоченная последовательность;
- список - это изменяемый объект (mutable object);
- список - это итерируемый объект.
Рассмотрим эти особенности в деталях.
Список имеет длину. Длина списка выражается целым числом и отражает количество элементов в списке. Длину списка можно найти при помощи встроенной функции len
из модуля builtins
стандартной библиотеки.
>>> x = [1, 2, 3, 4, 5] >>> len(x) 5 >>>
Следует обратить внимание, что пустой список тоже имеет длину.
>>> empty = [] >>> len(empty) 0 >>>
Основное отличие пустого списка заключается в возвращаемом булевой операцией с этим списком значении.
>>> x [1, 2, 3, 4, 5] >>> empty [] >>> bool(x) True >>> bool(empty) False >>>
Список - это упорядоченная последовательность. Каждый элемент списка, находясь на своём месте, имеет числовой индекс, посредством которого к этому элементу списка можно получить доступ.
>>> x = ['a', 'b', 'c', 'd', 'e', 'f'] >>> x[0] 'a' >>> x[1] 'b' >>> x[5] 'f' >>> len(x) 6 >>>
Индексы элементов начинают отсчёт с нуля, с левой стороны списка, индекс каждого последующего элемента на единицу больше индекса предыдущего элемента. Индекс последнего элемента в списке на единицу меньше длины списка. Последним считается крайний правый элемент списка.
Индексы могут принимать отрицательные значения, в этом случае отсчёт ведётся с правой стороны, с конца списка, с минус единицы, и наименьший индекс в этом случае будет равен длине списка умноженной на минус единицу.
>>> x ['a', 'b', 'c', 'd', 'e', 'f'] >>> x[-1] 'f' >>> x[-2] 'e' >>> x[-6] 'a' >>> len(x) 6 >>>
Важное замечание: попытка получить доступ по индексу к несуществующему элементу сгенерирует соответствующее исключение.
>>> x ['a', 'b', 'c', 'd', 'e', 'f'] >>> x[7] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range >>>
Оперируя индексами списка можно получить срез списка. Срез списка - это фрагмент исходного списка, который в свою очередь тоже является списком. Срез списка включает элемент указанный первым индексом в срезе, все элементы следующие за ним до элемента указанного вторым индексом в срезе, и не включает элемент указанный вторым индексом в срезе.
>>> x ['a', 'b', 'c', 'd', 'e', 'f'] >>> x[1:4] ['b', 'c', 'd'] >>>
Индексы в срезе могут быть опущены.
>>> x ['a', 'b', 'c', 'd', 'e', 'f'] >>> x[:3] ['a', 'b', 'c'] >>> x[2:] ['c', 'd', 'e', 'f'] >>>
Кроме того, для среза может быть указан интервал.
>>> x ['a', 'b', 'c', 'd', 'e', 'f'] >>> x[::2] ['a', 'c', 'e'] >>> x[::3] ['a', 'd'] >>>
При помощи среза можно получить список инвертированный относительно исходного списка.
>>> x ['a', 'b', 'c', 'd', 'e', 'f'] >>> x[::-1] ['f', 'e', 'd', 'c', 'b', 'a'] >>>
Список - это изменяемый объект (mutable object). На практике это означает, что список можно изменить на месте любым из предусмотренных для этого способов.
>>> sample ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'] >>> sample[0] = 'A' >>> sample ['A', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'] >>>
Изменяемость списка также означает, что копирование списка не следует осуществлять операцией присваивания значения, потому что в этом случае полученная копия будет тем же самым объектом, просто у исходного списка появится ещё одна ссылка в пространстве имён.
>>> sample ['A', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k'] >>> new_sample = sample >>> new_sample is sample True >>> sample[-1] = 'K' >>> new_sample ['A', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'K'] >>>
Копирование списков следует осуществлять иными способами. Первый способ копирования списков - это вызов list
.
>>> sample ['A', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'K'] >>> new_sample = list(sample) >>> new_sample is sample False >>> sample[3] = 'D' >>> sample ['A', 'b', 'c', 'D', 'e', 'f', 'g', 'h', 'i', 'j', 'K'] >>> new_sample ['A', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'K'] >>>
Скопировать исходный список можно посредством среза.
>>> sample ['A', 'b', 'c', 'D', 'e', 'f', 'g', 'h', 'i', 'j', 'K'] >>> new_sample = sample[:] >>> new_sample == sample True >>> new_sample is sample False >>>
Ещё один вариант копирования исходного списка предоставляет метод copy
.
>>> sample ['A', 'b', 'c', 'D', 'e', 'f', 'g', 'h', 'i', 'j', 'K'] >>> new_sample = sample.copy() >>> new_sample == sample True >>> new_sample is sample False >>>
Вернемся к характерным особенностям списков. Список - это итерируемый объект. Любой список поддерживает протокол итерации.
>>> new_sample ['A', 'b', 'c', 'D', 'e', 'f', 'g', 'h', 'i', 'j', 'K'] >>> for each in new_sample: ... print(each.lower(), end=' ') ... a b c d e f g h i j k >>>
Важное замечание: при итерации списков в цикле for
не следует изменять итерируемый список в теле цикла, так как это может привести к непредсказуемым последствиям и стать причиной ошибки. Типичный пример, как делать не надо - попытка удаления из исходного списка трёх элементов по известным индексам (0, 3, 10)
приведёт к плачевному результату.
>>> new_sample ['A', 'b', 'c', 'D', 'e', 'f', 'g', 'h', 'i', 'j', 'K'] >>> for step, item in enumerate(new_sample): ... if step in (0, 3, 10): ... del new_sample[step] ... >>> new_sample ['b', 'c', 'D', 'f', 'g', 'h', 'i', 'j', 'K'] >>>
Класс list
определяет обширный набор операций и методов, что позволяет сравнительно просто и без затрат производить со списками достаточно сложные манипуляции. Доступные спискам методы можно увидеть при помощи встроенной функции dir
.
>>> dir(list)[::-1] ['sort', 'reverse', 'remove', 'pop', 'insert', 'index', 'extend', 'count', 'copy', 'clear', 'append', '__subclasshook__', '__str__', '__sizeof__', '__setitem__', '__setattr__', '__rmul__', '__reversed__', '__repr__', '__reduce_ex__', '__reduce__', '__new__', '__ne__', '__mul__', '__lt__', '__len__', '__le__', '__iter__', '__init__', '__imul__', '__iadd__', '__hash__', '__gt__', '__getitem__', '__getattribute__', '__ge__', '__format__', '__eq__', '__doc__', '__dir__', '__delitem__', '__delattr__', '__contains__', '__class__', '__add__'] >>>
Характерные для списков операции и методы заслуживают отдельного внимания, их обзор и описание следуют ниже.
Резюмируя, хочу отметить, что списки очень широко используются при программировании на Питоне, этот встроенный тип данных значительно упрощает реализацию многих задач и поэтому важно понимать назначение списков, их свойства и функции, уметь с ними работать и знать, где и как можно получить о них справочную информацию.
2. Методы: append
Метод append
принимает в качестве аргумента любой объект и добавляет его в конец списка.
>>> sample = [] >>> id(sample) 139987173744520 >>> sample.append('string') >>> sample.append([1, 2, 3]) >>> sample.append(None) >>> sample ['string', [1, 2, 3], None] >>>
Следует иметь ввиду, что метод append
изменяет исходный список на месте и возвращает None
.
>>> result = sample.append(124) >>> result is None True >>> sample ['string', [1, 2, 3], None, 124] >>> id(sample) 139987173744520 >>>
3. Методы: clear
Метод clear
удаляет из исходного списка все элементы. Подобно методу append
, метод clear
изменяет исходный список на месте и возвращает None
.
>>> id(sample) 139987173744520 >>> sample ['string', [1, 2, 3], None, 124] >>> result = sample.clear() >>> sample [] >>> result is None True >>> id(sample) 139987173744520 >>>
4. Методы: copy
Метод copy
возвращает копию исходного списка - новый список.
>>> sample [[1, 2, 3], 'hello', True] >>> new_sample = sample.copy() >>> new_sample [[1, 2, 3], 'hello', True] >>> new_sample is sample False >>>
5. Методы: count
Метод count
принимает в качестве аргумента некоторое значение и возвращает целое число, которое характеризует количество найденных элементов указанного значения в исходном списке.
>>> sample [1, 'some', [], 1, 'some', 1] >>> sample.count(1) 3 >>> sample.count('some') 2 >>> sample.count([]) 1 >>> sample.count('hello') 0 >>>
6. Методы: extend
Метод extend
принимает в качестве аргумента любую последовательность (итерируемый объект) и добавляет в конец исходного списка все элементы из заданной последовательности.
>>> sample ['a', 'b', 'c'] >>> sample.extend(range(3)) >>> sample ['a', 'b', 'c', 0, 1, 2] >>>
Следует иметь ввиду, что метод extend
изменяет исходный список на месте и возвращает None
.
>>> sample ['a', 'b', 'c', 0, 1, 2] >>> id(sample) 139987173756104 >>> result = sample.extend([10, 20]) >>> result is None True >>> sample ['a', 'b', 'c', 0, 1, 2, 10, 20] >>> id(sample) 139987173756104 >>>
7. Методы: index
Метод index
принимает в качестве аргумента некоторое значение и возвращает первый индекс этого значения, найденного в исходном списке.
>>> sample = ['ab', 'cd', 'mv', 'lc', 'cd', 'ab'] >>> sample.index('ab') 0 >>> sample.index('cd') 1 >>>
Если заданного значения в исходном списке не обнаружено, будет сгенерировано соответствующее исключение.
>>> sample ['ab', 'cd', 'mv', 'lc', 'cd', 'ab'] >>> sample.index('rs') Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: 'rs' is not in list >>>
Опционально могут быть заданы индексы начала и конца фрагмента списка, в котором осуществляется поиск.
>>> sample ['ab', 'cd', 'mv', 'lc', 'cd', 'ab'] >>> sample.index('cd', 2) 4 >>>
Индексы начала и конца фрагмента списка в этом случае интерпретируются подобно срезу.
>>> sample ['ab', 'cd', 'mv', 'lc', 'cd', 'ab'] >>> sample.index('cd', 2, 4) Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: 'cd' is not in list >>>
8. Методы: insert
Метод insert
принимает в качестве аргументов индекс и объект и добавляет указанный объект в исходный список перед элементом с указанным индексом.
>>> sample = ['a', 'b'] >>> sample.insert(0, 'c') >>> sample ['c', 'a', 'b'] >>>
Если у исходного списка нет указанного индекса, указанный объект добавляется в конец списка.
>>> sample ['c', 'a', 'b'] >>> sample.insert(3, 'w') >>> sample ['c', 'a', 'b', 'w'] >>>
Следует иметь ввиду, что метод insert
изменяет исходный список на месте и возвращает None
.
>>> sample ['c', 'a', 'b', 'w'] >>> result = sample.insert(1, 'u') >>> result is None True >>> sample ['c', 'u', 'a', 'b', 'w'] >>>
9. Методы: pop
Метод pop
принимает в качестве аргумента индекс, возвращает объект, находящийся по указанному индексу в исходном списке, и удаляет этот объект из исходного списка.
>>> sample ['c', 'u', 'a', 'b', 'w'] >>> value = sample.pop(1) >>> value 'u' >>> sample ['c', 'a', 'b', 'w'] >>>
Если индекс не задан, то метод pop
возвращает последний в исходном списке объект и удаляет его из исходного списка.
>>> sample ['c', 'a', 'b', 'w'] >>> value = sample.pop() >>> value 'w' >>> sample ['c', 'a', 'b'] >>>
Если исходный список пустой, или указанного индекса у исходного списка нет, то будет сгенерировано соответствующее исключение.
>>> sample ['c', 'a', 'b'] >>> sample.pop(3) Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: pop index out of range >>> empty = [] >>> empty.pop(0) Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: pop from empty list >>>
10. Методы: remove
Метод remove
принимает в качестве аргумента некоторое значение и удаляет из исходного списка первый элемент с указанным значением.
>>> sample = ['a', 'b', 'c', 'b', 'c'] >>> sample.remove('b') >>> sample ['a', 'c', 'b', 'c'] >>>
Следует иметь ввиду, что метод remove
изменяет исходный список на месте и возвращает None
.
>>> sample ['a', 'c', 'b', 'c'] >>> result = sample.remove('a') >>> result is None True >>> sample ['c', 'b', 'c'] >>>
Если исходный список не имеет элемента с указанным значением, то будет сгенерировано соответствующее исключение.
>>> sample ['c', 'b', 'c'] >>> sample.remove('a') Traceback (most recent call last): File "<stdin>", line 1, in <module> ValueError: list.remove(x): x not in list >>>
11. Методы: reverse
Метод reverse
выполняет инверсию исходного списка и возвращает None
.
>>> sample ['l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a'] >>> result = sample.reverse() >>> result is None True >>> sample ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l'] >>>
Следует иметь ввиду, что этот метод изменяет исходный список на месте.
12. Методы: sort
Метод sort
сортирует исходный список на месте используя только <
сравнения.
>>> sample ['e', 'A', 'c', 'I', 'k', 'B', 'd', 'H', 'g', 'L', 'j', 'F'] >>> sample.sort() >>> sample ['A', 'B', 'F', 'H', 'I', 'L', 'c', 'd', 'e', 'g', 'j', 'k'] >>>
Этот метод принимает два аргумента: key
и reverse
. По умолчанию key
имеет значение None
, а reverse
имеет значение False
. Аргумент key
может быть функцией одного аргумента, при помощи которой будет вычислен ключ сравнения для каждого элемента исходного списка, сортировка исходного списка производится на основе этого значения.
>>> sample ['e', 'A', 'c', 'I', 'k', 'B', 'd', 'H', 'g', 'L', 'j', 'F'] >>> sample.sort(key=str.lower) >>> sample ['A', 'B', 'c', 'd', 'e', 'F', 'g', 'H', 'I', 'j', 'k', 'L'] >>>
При помощи аргумента reverse
сортировку можно произвести в обратном порядке.
>>> sample ['e', 'A', 'c', 'I', 'k', 'B', 'd', 'H', 'g', 'L', 'j', 'F'] >>> sample.sort(key=str.lower, reverse=True) >>> sample ['L', 'k', 'j', 'I', 'H', 'g', 'F', 'e', 'd', 'c', 'B', 'A'] >>>
Следует иметь ввиду, что не каждый список может быть отсортирован.
>>> sample = [1, 'a', 'b', 3.5, ['some']] >>> sample.sort() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unorderable types: str() < int() >>>
Также следует иметь ввиду, что метод sort
изменяет исходный список на месте, а исключение будет сгенерировано, только когда возникнет ошибка, при этом исходный список уже не будет в исходном состоянии.
>>> sample = ['f', 'e', 'g', 1, 'a'] >>> sample.sort() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unorderable types: int() < str() >>> sample ['e', 'f', 'g', 1, 'a'] >>>
13. Логические операции со списками
Со списками можно производить целый ряд логических операций. Списки, в которых имеется хотя бы один элемент, возвращают булево значение True
, пустые списки возвращают булево значение False
.
>>> empty = [] >>> bool(empty) False >>> sample ['a', 'B', 'c', 'D', 'e', 'F', 'g', 'H', 'i', 'J', 'k', 'L'] >>> bool(sample) True >>>
Список позволяет определить членство некоторого значения в этом списке.
>>> sample ['a', 'B', 'c', 'D', 'e', 'F', 'g', 'H', 'i', 'J', 'k', 'L'] >>> 'a' in sample True >>> 'A' in sample False >>>
Возможна проверка эквивалентности двух списков.
>>> master ['a', 'B', 'c', 'D', 'e', 'F', 'g', 'H', 'i', 'J', 'k', 'L'] >>> sample ['a', 'B', 'c', 'D', 'e', 'F', 'g', 'H', 'i', 'J', 'k', 'L'] >>> sample == master True
Списки, содержащие однотипные значения, можно сравнивать на больше-меньше.
>>> sample ['B', 'D', 'F', 'H', 'J', 'L', 'a', 'c', 'e', 'g', 'i', 'k'] >>> master ['a', 'B', 'c', 'D', 'e', 'F', 'g', 'H', 'i', 'J', 'k', 'L'] >>> sample < master True >>>
Если элементы списков имеют значения разных типов, то такое сравнение будет невозможно.
>>> one = ['ab', 'cd'] >>> two = [1.24, 3.15] >>> one > two Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: unorderable types: str() > float() >>>
Кроме того, для списков доступны булевы операции посредством встроенных функций all
и any
из модуля builtins
стандартной библиотеки. Функция all
возвращает True
, если все элементы списка возвращают True
, или если список пустой.
>>> all([1, 2, 3, 4]) True >>> all([0, 1, 2, 3, 4]) False >>> all([]) True >>>
Функция any
возвращает True
, если любой, хотя бы один из элементов списка возвращает True
. Если список пустой, функция any
возвращает False
.
>>> any([0, 1, 0]) True >>> any([0, 0, 0]) False >>> any([]) False >>>
14. Сложение списков
Списки, являясь последовательностями, допускают конкатенацию посредством операции сложения. Результатом конкатенации будет новый список, при этом списки, участвующие в этой операции, не изменяются.
>>> x = [2, 4] >>> y = [8, 9] >>> z = x + y >>> x [2, 4] >>> y [8, 9] >>> z [2, 4, 8, 9] >>>
15. Умножение списка на целое число
Для списков доступна операция умножения на целое число. Результатом такой операции будет новый список, в котором все элементы исходного списка будут повторены n-ое количество раз, при этом исходный список не изменяется.
>>> sample = ['a', 'b'] >>> sample * 4 ['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b'] >>> sample ['a', 'b'] >>>
При умножении списков, содержащих в себе другие списки или любые другие изменяемые объекты (mutable objects), следует учитывать, как при этом копируются изменяемые объекты.
>>> sample = [[]] * 3 >>> sample [[], [], []] >>> sample[0].append(3) >>> sample [[3], [3], [3]] >>>
Чтобы избежать сюрпризов, изменяемые объекты лучше повторять другими способами.
>>> sample = [[] for _ in range(3)] >>> sample [[], [], []] >>> sample[0].append(3) >>> sample[1].append(1) >>> sample[2].append('hello!') >>> sample [[3], [1], ['hello!']] >>>
В случае, когда исходный список содержит только неизменяемые объекты, повторение полностью оправдано.
>>> sample = ['some'] >>> sample = sample * 5 >>> sample ['some', 'some', 'some', 'some', 'some'] >>>
16. Доступ по индексам
В связи с тем, что список - изменяемый объект, доступ к элементам списка по индексам предоставляет достаточно интересные возможности.
Любой элемент списка можно изменить на месте.
>>> sample = ['a', 'b', 'c'] >>> sample[1] = sample[1].capitalize() >>> sample ['a', 'B', 'c'] >>>
Можно изменить группу следующих один за другим элементов списка.
>>> sample = ['a', 'b', 'c', 'd', 'e', 'f'] >>> sample[1:4] = ['bc', 'cd', 'de'] >>> sample ['a', 'bc', 'cd', 'de', 'e', 'f'] >>>
Элементы списка можно удалять ссылкой на индекс элемента в списке.
>>> sample ['a', 'bc', 'cd', 'de', 'e', 'f'] >>> del sample[0] >>> sample ['bc', 'cd', 'de', 'e', 'f'] >>>
Совершенно аналогично можно удалять группу следующих друг за другом элементов списка.
>>> sample = ['bc', 'cd', 'de', 'e', 'f'] >>> del sample[3:] >>> sample ['bc', 'cd', 'de'] >>>
Группу следующих друг за другом элементов можно удалять ещё одним способом.
>>> sample = ['bc', 'cd', 'de', 'e', 'f'] >>> sample[3:] = [] >>> sample ['bc', 'cd', 'de'] >>>
Если элементы исходного списка в свою очередь являются списками, то можно получить доступ и к элементам этих списков.
>>> sample = [[1, 3, 5], [3, 4, 7], [5, 7, 8]] >>> sample[0][0] 1 >>> sample[1][-1] 7 >>> sample[-1][2] 8 >>>
17. Другие операции со списками
Хочется обратить внимание на одну из функций модуля random
стандартной библиотеки - shuffle
. При помощи этой функции список можно отсортировать случайным образом.
>>> import random >>> master ['a', 'B', 'c', 'D', 'e', 'F', 'g', 'H', 'i', 'J', 'k', 'L'] >>> random.shuffle(master) >>> master ['L', 'D', 'a', 'k', 'i', 'H', 'F', 'B', 'g', 'e', 'c', 'J'] >>> random.shuffle(master) >>> master ['L', 'e', 'B', 'g', 'k', 'D', 'a', 'F', 'i', 'H', 'J', 'c'] >>>
Следует иметь ввиду, что random.shuffle
изменяет исходный список на месте и возвращает None
.
Встроенная функция sorted
модуля builtins
стандартной библиотеки позволяет получить отсортированную копию исходного списка. Действия и аргументы функции sorted
очень похожи на действия и аргументы метода sort
, отличие лишь в том, что функция sorted
возвращает новый список, а исходный список остаётся в прежнем состоянии.
>>> master ['L', 'e', 'B', 'g', 'k', 'D', 'a', 'F', 'i', 'H', 'J', 'c'] >>> new = sorted(master, key=str.lower, reverse=True) >>> new ['L', 'k', 'J', 'i', 'H', 'g', 'F', 'e', 'D', 'c', 'B', 'a'] >>> master ['L', 'e', 'B', 'g', 'k', 'D', 'a', 'F', 'i', 'H', 'J', 'c'] >>>