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

Список - это некоторая упорядоченная последовательность разделённых запятой объектов, ограниченная квадратными скобками. Список является изменяемой коллекцией данных любых типов объединённой общим именем. В Питоне третьей версии списки определяются классом 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__']
>>> 

Характерные для списков операции и методы заслуживают отдельного внимания, их обзор и описание следуют ниже.

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

Метод 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
>>> 

Метод 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
>>> 

Метод copy возвращает копию исходного списка - новый список.

>>> sample
[[1, 2, 3], 'hello', True]
>>> new_sample = sample.copy()
>>> new_sample
[[1, 2, 3], 'hello', True]
>>> new_sample is sample
False
>>> 

Метод count принимает в качестве аргумента некоторое значение и возвращает целое число, которое характеризует количество найденных элементов указанного значения в исходном списке.

>>> sample
[1, 'some', [], 1, 'some', 1]
>>> sample.count(1)
3
>>> sample.count('some')
2
>>> sample.count([])
1
>>> sample.count('hello')
0
>>> 

Метод 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
>>> 

Метод 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
>>> 

Метод 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']
>>> 

Метод 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
>>> 

Метод 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
>>> 

Метод 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']
>>> 

Следует иметь ввиду, что этот метод изменяет исходный список на месте.

Метод 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']
>>> 

Со списками можно производить целый ряд логических операций. Списки, в которых имеется хотя бы один элемент, возвращают булево значение 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
>>> 

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

>>> x = [2, 4]
>>> y = [8, 9]
>>> z = x + y
>>> x
[2, 4]
>>> y
[8, 9]
>>> z
[2, 4, 8, 9]
>>> 

Для списков доступна операция умножения на целое число. Результатом такой операции будет новый список, в котором все элементы исходного списка будут повторены 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']
>>> 

В связи с тем, что список - изменяемый объект, доступ к элементам списка по индексам предоставляет достаточно интересные возможности.

Любой элемент списка можно изменить на месте.

>>> 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
>>> 

Хочется обратить внимание на одну из функций модуля 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']
>>>