Автор оригинала: Guest Contributor.
Вступление
Коллекции в Python-это контейнеры, которые используются для хранения коллекций данных, например, list, dict, set, tuple и т. Д. Это встроенные коллекции. Было разработано несколько модулей, которые предоставляют дополнительные структуры данных для хранения коллекций данных. Одним из таких модулей является модуль Python collections .
Python collections module был введен для улучшения функциональных возможностей встроенных контейнеров коллекций. Модуль Python collections был впервые представлен в версии 2.4. Этот учебник основан на его последнем стабильном выпуске (версия 3.7).
Модуль Коллекций
В этом уроке мы обсудим 6 наиболее часто используемых структур данных из модуля Python collections. Они заключаются в следующем:
- Счетчик
- defaultdict
- Приказано
- дек
- Цепная карта
- namedtuple()
Счетчик
Counter – это подкласс объекта dictionary. Функция Counter() в модуле collections принимает в качестве аргумента итерацию или отображение и возвращает словарь. В этом словаре ключ-это элемент в итерируемом или отображении, а значение-это количество раз, когда этот элемент существует в итерируемом или отображении.
Вы должны импортировать класс Counter , прежде чем сможете создать экземпляр counter .
from collections import Counter
Создание объектов Счетчика
Существует несколько способов создания объектов counter . Самый простой способ-использовать функцию Counter() без каких-либо аргументов.
cnt = Counter()
Вы можете передать итерацию (список) функции Counter() для создания объекта counter .
list = [1,2,3,4,1,2,6,7,3,8,1] Counter(list)
Наконец, функция Counter() может принимать словарь в качестве аргумента. В этом словаре значение ключа должно быть “количеством” этого ключа.
Counter({1:3,2:4})
Вы можете получить доступ к любому элементу счетчика с помощью его ключа, как показано ниже:
list = [1,2,3,4,1,2,6,7,3,8,1] cnt = Counter(list) print(cnt[1])
когда вы печатаете cnt[1] , вы получите счет 1.
Выход:
3
В приведенных выше примерах cnt является объектом класса Counter , который является подклассом dict . Таким образом, он имеет все методы класса dict .
Кроме того, Счетчик имеет три дополнительные функции:
- Элементы
- Most_common([n])
- Вычитание([интегрируемое-или-отображение])
Функция element()
Вы можете получить элементы объекта Counter с помощью функции elements () . Он возвращает список, содержащий все элементы в объекте Counter .
Посмотрите на следующий пример:
cnt = Counter({1:3,2:4})
print(list(cnt.elements()))
Выход:
[1, 1, 1, 2, 2, 2, 2]
Здесь мы создаем объект Counter со словарем в качестве аргумента. В этом объекте счетчика количество 1 равно 3, а количество 2 равно 4. Функция elements() вызывается с помощью объекта cnt , который возвращает итератор, передаваемый в качестве аргумента списку.
Итератор повторяется 3 раза над 1, возвращая три ‘1, и повторяется четыре раза над 2, возвращая четыре ‘2 в список. Наконец, список печатается с помощью функции print .
Функция most_common()
Функция Counter() возвращает неупорядоченный словарь. Вы можете отсортировать его по количеству отсчетов в каждом элементе, используя функцию most_common() объекта Counter .
list = [1,2,3,4,1,2,6,7,3,8,1] cnt = Counter(list) print(cnt.most_common())
Выход:
[(1, 3), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1)]
Вы можете видеть, что функция most_common возвращает список, который сортируется на основе количества элементов. 1 имеет счет три, поэтому он является первым элементом списка.
Функция subtract()
Функция subtract() принимает в качестве аргумента итерацию (список) или отображение (словарь) и вычитает количество элементов с помощью этого аргумента. Проверьте следующий пример:
cnt = Counter({1:3,2:4})
deduct = {1:1, 2:2}
cnt.subtract(deduct)
print(cnt)
Выход:
Counter({1: 2, 2: 2})
Вы можете заметить, что cnt объект, который мы сначала создали, имеет количество 3 для “1” и количество 4 для “2”. Словарь deduct имеет значение “1” для ключа “1” и значение ” 2 “для ключа “2”. Функция subtract() вычла 1 отсчет из ключа “1” и 2 отсчета из ключа “2”.
Дефолт
defaultdict работает точно так же, как словарь python, за исключением того, что он не выдает KeyError при попытке доступа к несуществующему ключу.
Вместо этого он инициализирует ключ элементом типа данных, который вы передаете в качестве аргумента при создании defaultdict . Тип данных называется default_factory .
Импорт defaultdict
Во-первых, вы должны импортировать defaultdict из collections модуля перед его использованием:
from collections import defaultdict
Создайте defaultdict
Вы можете создать defaultdict с помощью конструктора defaultdict () . Вы должны указать тип данных в качестве аргумента. Проверьте следующий код:
nums = defaultdict(int) nums['one'] = 1 nums['two'] = 2 print(nums['three'])
Выход:
0
В этом примере int передается как default_factory . Обратите внимание , что вы передаете только int , а не int() . Далее значения определяются для двух ключей, а именно “один” и “два”, но в следующей строке мы пытаемся получить доступ к ключу, который еще не был определен.
В обычном словаре это вызовет KeyError . Но defaultdict инициализируйте новый ключ с помощью значения по умолчанию default_factory , которое равно 0 для int . Следовательно, когда программа будет выполнена, и 0 будет напечатано. Эта особенность инициализации несуществующих ключей может быть использована в различных ситуациях.
Например, предположим, что вы хотите, чтобы количество каждого имени в списке имен было указано как “Майк, Джон, Майк и, Майк, Джон, Джон, Майк, Майк, Бритни, Смит, Анна, Смит”.
from collections import defaultdict
count = defaultdict(int)
names_list = "Mike John Mike Anna Mike John John Mike Mike Britney Smith Anna Smith".split()
for names in names_list:
count[names] +=1
print(count)
Выход:
defaultdict(, {'Mike': 5, 'Britney': 1, 'John': 3, 'Smith': 2, 'Anna': 2})
Сначала мы создаем defaultdict с int as default_factory . Список names_list включает в себя набор имен, которые повторяются несколько раз. Функция split() возвращает список из заданной строки. Он разрывает строку всякий раз, когда встречается пробел, и возвращает слова как элементы списка. В цикле каждый элемент списка добавляется в defaultdict с именем count и инициализируется в 0 на основе default_factory . Если тот же самый элемент встречается снова, то по мере продолжения цикла количество этого элемента будет увеличиваться.
Орденский указ
OrderedDict – это словарь, в котором ключи сохраняют порядок, в котором они вставляются, что означает, что если вы измените значение ключа позже, это не изменит положение ключа.
Импорт OrderedDict
Чтобы использовать OrderedDict , вы должны импортировать его из модуля collections.
from collections import OrderedDict
Создайте OrderedDict
Вы можете создать объект OrderedDict с помощью конструктора OrderedDict () . В следующем коде Вы создаете OrderedDict без каких-либо аргументов. После этого в него вставляются какие-то предметы.
od = OrderedDict() od['a'] = 1 od['b'] = 2 od['c'] = 3 print(od)
Выход:
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
Вы также можете получить доступ к каждому элементу с помощью цикла. Взгляните на следующий код:
for key, value in od.items():
print(key, value)
Выход:
a 1 b 2 c 3
Следующий пример представляет собой интересный пример использования OrderedDict с Counter . Здесь мы создаем Счетчик из списка и вставляем элемент в OrderedDict на основе их количества.
Наиболее часто встречающаяся буква будет вставлена в качестве первого ключа, а наименее часто встречающаяся буква будет вставлена в качестве последнего ключа.
list = ["a","c","c","a","b","a","a","b","c"]
cnt = Counter(list)
od = OrderedDict(cnt.most_common())
for key, value in od.items():
print(key, value)
Выход:
a 4 c 3 b 2
Дек
deque – это список, оптимизированный для вставки и удаления элементов.
Импорт дека
Вы должны импортировать deque class из collections module перед его использованием.
from collections import deque
Создание дека
Вы можете создать deque с помощью конструктора deque () . Вы должны передать список в качестве аргумента.
list = ["a","b","c"] deq = deque(list) print(deq)
Выход:
deque(['a', 'b', 'c'])
Вставка элементов в deque
Вы можете легко вставить элемент в deq , который мы создали на любом из концов. Чтобы добавить элемент справа от дека, вы должны использовать метод append () .
Если вы хотите добавить элемент в начало deque, вы должны использовать метод appendleft () .
deq.append("d")
deq.appendleft("e")
print(deq)deque
Выход:
deque(['e', 'a', 'b', 'c', 'd'])
Вы можете заметить, что d добавляется в конце deq, а e добавляется в начало deq
Удаление элементов из дека
Удаление элементов аналогично вставке элементов. Вы можете удалить элемент аналогично тому, как вы вставляете элементы. Чтобы удалить элемент справа, вы можете использовать функцию pop () , а чтобы удалить элемент слева, вы можете использовать функцию popleft() .
deq.pop() deq.popleft() print(deq)
Выход:
deque(['a', 'b', 'c'])
Вы можете заметить, что и первый, и последний элементы удалены из deq .
Очистка дека
Если вы хотите удалить все элементы из deque, вы можете использовать функцию clear () .
list = ["a","b","c"] deq = deque(list) print(deq) print(deq.clear())
Выход:
deque(['a', 'b', 'c']) None
Вы можете видеть на выходе, что сначала есть очередь с тремя элементами. Как только мы применили функцию clear () , deque очищается, и вы видите none в выводе.
Подсчет элементов в деке
Если вы хотите найти количество определенного элемента, используйте функцию count(x) . Вы должны указать элемент, для которого вам нужно найти счетчик, в качестве аргумента.
list = ["a","b","c"]
deq = deque(list)
print(deq.count("a"))
Выход:
1
В приведенном выше примере число “а” равно 1. Следовательно, печатается “1”.
Цепная карта
Цепная карта используется для объединения нескольких словарей или отображений. Он возвращает список словарей.
Импорт chainmap
Вы должны импортировать ChainMap из модуля collections перед его использованием.
from collections import ChainMap
Создайте цепную карту
Чтобы создать цепную карту, мы можем использовать конструктор Chain Map () . Мы должны передать словари, которые мы собираемся объединить в качестве набора аргументов.
dict1 = { 'a' : 1, 'b' : 2 }
dict2 = { 'c' : 3, 'b' : 4 }
chain_map = ChainMap(dict1, dict2)
print(chain_map.maps)
Выход:
[{'b': 2, 'a': 1}, {'c': 3, 'b': 4}]
В качестве выходных данных вы можете увидеть список словарей. Вы можете получить доступ к значениям карты цепочки по имени ключа.
print(chain_map['a'])
Выход:
1
“1” печатается так, как значение ключа ” а ” равно 1. Еще один важный момент заключается в том, что ChainMap обновляет свои значения при обновлении связанных с ним словарей. Например, если вы измените значение ‘c’ в dict2 на ‘5’, вы также заметите изменение в Chain Map .
dict2['c'] = 5 print(chain_map.maps)
Выход:
[{'a': 1, 'b': 2}, {'c': 5, 'b': 4}]
Получение ключей и значений из Карты цепочек
Вы можете получить доступ к ключам Chain Map с помощью функции keys () . Аналогично, вы можете получить доступ к значениям элементов с помощью функции values () , как показано ниже:
dict1 = { 'a' : 1, 'b' : 2 }
dict2 = { 'c' : 3, 'b' : 4 }
chain_map = ChainMap(dict1, dict2)
print (list(chain_map.keys()))
print (list(chain_map.values()))
Выход:
['b', 'a', 'c'] [2, 1, 3]
Обратите внимание, что значение ключа ” b “в выводе является значением ключа” b ” в dict1 . Как правило, когда один ключ появляется в нескольких связанных словарях, ChainMap берет значение этого ключа из первого словаря.
Добавление нового словаря в Цепную карту
Если вы хотите добавить новый словарь к существующей Цепной карте , используйте функцию new_child () . Он создает новую Цепную карту с недавно добавленным словарем.
dict3 = {'e' : 5, 'f' : 6}
new_chain_map = chain_map.new_child(dict3)
print(new_chain_map)
Выход:
ChainMap({'f': 6, 'e': 5}, {'a': 1, 'b': 2}, {'b': 4, 'c': 3})
Обратите внимание, что новый словарь добавляется в начало списка Chain Map .
Именованная группа()
Функция namedtuple() возвращает кортеж с именами для каждой позиции в кортеже. Одна из самых больших проблем с обычными кортежами заключается в том, что вы должны помнить индекс каждого поля объекта кортежа. Это, очевидно, трудно. Для решения этой проблемы был введен namedtuple .
Импорт namedtuple
Перед использованием namedtuple вы должны импортировать его из модуля collections .
from collections import namedtuple
Создайте namedtuple
from collections import namedtuple
Student = namedtuple('Student', 'fname, lname, age')
s1 = Student('John', 'Clarke', '13')
print(s1.fname)
Выход:
Student(fname='John', lname='Clarke', age='13')
В этом примере был объявлен объект namedtuple object Student . Вы можете получить доступ к полям любого экземпляра класса Student по определенному имени поля.
Создание namedtuple с помощью списка
Функция namedtuple() требует, чтобы каждое значение передавалось ей отдельно. Вместо этого вы можете использовать _make() для создания экземпляра namedtuple со списком. Проверьте следующий код:
s2 = Student._make(['Adam','joe','18']) print(s2)
Выход:
Student(fname='Adam', lname='joe', age='18')
Создайте Новый Экземпляр С Помощью Существующего Экземпляра
Функция _addict() может быть использована для создания экземпляра OrderedDict из существующего экземпляра.
s2 = s1._asdict() print(s2)
Выход:
OrderedDict([('fname', 'John'), ('lname', 'Clarke'), ('age', '13')])
Изменение значений полей с помощью функции _replace()
Для изменения значения поля экземпляра используется функция _replace () . Помните, что функция _replace() создает новый экземпляр. Это не меняет значения существующего экземпляра.
s2 = s1._replace(age='14') print(s1) print(s2)
Выход:
Student(fname='John', lname='Clarke', age='13') Student(fname='John', lname='Clarke', age='14')
Вывод
На этом мы завершаем наш учебник по модулю коллекций. Мы обсудили все важные темы в модуле сбора. Модуль коллекции Python все еще нуждается в улучшениях, если мы сравним его с коллекционной библиотекой Java. Поэтому мы можем ожидать много изменений в будущих версиях.