Вступление
Коллекции в Python - это контейнеры, которые используются для хранения коллекций данных, например list, dict, set, tuple и т. Д. Это встроенные коллекции. Было разработано несколько модулей, которые предоставляют дополнительные структуры данных для хранения коллекций данных. Одним из таких модулей является модуль коллекций Python.
Модуль коллекций Python был представлен для улучшения функциональности встроенных контейнеров коллекции. Модуль коллекций Python был впервые представлен в версии 2.4. Это руководство основано на его последней стабильной версии (версия 3.7).
Модуль Коллекции
В этом руководстве мы обсудим 6 наиболее часто используемых структур данных из модуля коллекций Python. Вот они:
Счетчик
Counter - это подкласс объекта словаря. Функция Counter() в модуле
коллекций принимает в качестве аргумента итерацию или отображение и
возвращает словарь. В этом словаре ключ - это элемент в итерируемом
объекте или отображении, а значение - это количество раз, которое
элемент существует в итерируемом объекте или отображении.
Перед созданием экземпляра 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
Кроме того, Counter имеет три дополнительных функции:
- Элементы
- Most_common ([n])
- Вычесть ([interable-or-mapping])
Функция element ()
Вы можете получить элементы Counter с помощью функции elements() .
Он возвращает список, содержащий все элементы объекта Counter
Взгляните на следующий пример:
cnt = Counter({1:3,2:4})
print(list(cnt.elements()))
Выход:
[1, 1, 1, 2, 2, 2, 2]
Здесь мы создаем Counter со словарем в качестве аргумента. В этом
объекте 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
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(<class 'int'>, {'Mike': 5, 'Britney': 1, 'John': 3, 'Smith': 2, 'Anna': 2})
Сначала мы создаем defaultdict с int как default_factory . В
names_list входит набор имен, которые повторяются несколько раз.
Функция split() возвращает список из заданной строки. Он разбивает
строку всякий раз, когда встречается пробел, и возвращает слова как
элементы списка. В цикле каждый элемент в списке добавляется к
defaultdict именем count и инициализируется значением 0 на основе
default_factory . Если тот же элемент встречается снова, по мере
продолжения цикла, счетчик этого элемента будет увеличиваться.
OrderedDict
OrderedDict - это словарь, в котором ключи сохраняют порядок, в
котором они вставляются, что означает, что если вы измените значение
ключа позже, он не изменит положение ключа.
Импортировать OrderedDict
Чтобы использовать OrderedDict вам необходимо импортировать его из
модуля коллекций.
from collections import 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 . Здесь мы создаем 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
collections
from collections import deque
Создание двухсторонней очереди
Вы можете создать двухстороннюю очередь с конструктором deque() . Вы
должны передать список в качестве аргумента.
list = ["a","b","c"]
deq = deque(list)
print(deq)
Выход:
deque(['a', 'b', 'c'])
Вставка элементов в deque
Вы можете легко вставить элемент в deq мы создали на любом из концов.
Чтобы добавить элемент справа от двухсторонней очереди, вы должны
использовать метод append()
Если вы хотите добавить элемент в начало 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
.
Очистка двухсторонней очереди
Если вы хотите удалить все элементы из двухсторонней очереди, вы можете
использовать функцию clear()
list = ["a","b","c"]
deq = deque(list)
print(deq)
print(deq.clear())
Выход:
deque(['a', 'b', 'c'])
None
Как видно на выходе, сначала идет очередь из трех элементов. Как только
мы применили clear() , двухсторонняя очередь очищается, и вы не видите
none на выходе.
Подсчет элементов в двухсторонней очереди
Если вы хотите узнать количество определенного элемента, используйте
функцию count(x) Вы должны указать элемент, для которого вам нужно
найти счетчик, в качестве аргумента.
list = ["a","b","c"]
deq = deque(list)
print(deq.count("a"))
Выход:
1
В приведенном выше примере количество «а» равно 1. Следовательно, напечатано «1».
Цепная карта
ChainMap используется для объединения нескольких словарей или
отображений. Возвращает список словарей.
Импортировать карту цепочки
Перед использованием необходимо импортировать ChainMap из
collections
from collections import ChainMap
Создать ChainMap
Для создания карты цепи мы можем использовать конструктор ChainMap() .
Мы должны передать словари, которые мы собираемся объединить, в качестве
набора аргументов.
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» печатается, поскольку значение ключа «a» равно 1. Другой важный
момент - ChainMap обновляет свои значения при обновлении связанных с
ней словарей. Например, если вы измените значение «c» в dict2 на «5»,
вы также заметите изменение в ChainMap .
dict2['c'] = 5
print(chain_map.maps)
Выход:
[{'a': 1, 'b': 2}, {'c': 5, 'b': 4}]
Получение ключей и значений из ChainMap
Вы можете получить доступ к клавишам ChainMap с 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 берет значение этого ключа из
первого словаря.
Добавление нового словаря в ChainMap
Если вы хотите добавить новый словарь к существующей ChainMap ,
используйте new_child() . Он создает новую ChainMap с недавно
добавленным словарем.
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})
Обратите внимание, что новый словарь добавлен в начало списка ChainMap
Именованный кортеж ()
namedtuple() возвращает кортеж с именами для каждой позиции в кортеже.
Одна из самых больших проблем с обычными кортежами заключается в том,
что вы должны помнить индекс каждого поля объекта кортежа. Очевидно, это
сложно. Для решения этой проблемы был введен namedtuple
Импортировать namedtuple
Перед использованием namedtuple необходимо импортировать его из модуля
collections
from collections import 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 объект Student . Вы можете получить доступ
к полям любого экземпляра Student по заданному имени поля.
Создание именованного кортежа с помощью списка
Функция namedtuple() требует, чтобы каждое значение передавалось ей
отдельно. Вместо этого вы можете использовать _make() для создания
namedtuple со списком. Проверьте следующий код:
s2 = Student._make(['Adam','joe','18'])
print(s2)
Выход:
Student(fname='Adam', lname='joe', age='18')
Создайте новый экземпляр, используя существующий экземпляр
_asdict() можно использовать для создания 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 Collection. Поэтому в следующих версиях можно ожидать много изменений.