Introducción al módulo de colecciones de Python

Introducción

Las colecciones en Python son contenedores que se utilizan para almacenar colecciones de datos, por ejemplo, lista, dictar, establecer, tupla etc. Estas son colecciones integradas. Se han desarrollado varios módulos que proporcionan estructuras de datos adicionales para almacenar colecciones de datos. Uno de esos módulos es Python módulo de colecciones.

Python módulo de colecciones se introdujo para mejorar las funcionalidades de los contenedores de recogida integrados. El módulo de colecciones de Python se introdujo por primera vez en su versión 2.4. Este tutorial se basa en su última versión estable (versión 3.7).

Módulo de colecciones

En este tutorial, analizaremos 6 de las estructuras de datos más utilizadas del módulo de colecciones de Python. Son los siguientes:

• Mostrador
• defaultdict
• OrderedDict
• deque
• ChainMap
• namedtuple ()

El contador

Mostrador es una subclase del objeto diccionario. los Counter() La función en el módulo de colecciones toma un iterable o un mapeo como argumento y devuelve un Diccionario. En este diccionario, una clave es un elemento en el iterable o el mapeo y el valor es el número de veces que ese elemento existe en el iterable o el mapeo.

Tienes que importar el Counter clase antes de poder crear una counter ejemplo.

from collections import Counter

Crear objetos de contador

Hay varias formas de crear counter objetos. La forma más sencilla es utilizar Counter() funcionar sin argumentos.

cnt = Counter()

Puede pasar una (lista) iterable a Counter() función para crear un counter objeto.

list = [1,2,3,4,1,2,6,7,3,8,1]
Counter(list)

Finalmente, el Counter() La función puede tomar un diccionario como argumento. En este diccionario, el valor de una clave debe ser el ‘recuento’ de esa clave.

Counter({1:3,2:4})

Puede acceder a cualquier artículo del contador con su clave como se muestra a continuación:

list = [1,2,3,4,1,2,6,7,3,8,1]
cnt = Counter(list)
print(cnt[1])

cuando imprime cnt[1], obtendrá la cuenta de 1.

Salida:

3

En los ejemplos anteriores, cnt es un objeto de Counter clase que es una subclase de dict. Entonces tiene todos los métodos de dict clase.

Aparte de eso, Counter tiene tres funciones adicionales:

• Elementos
• Más común([n])
• Sustraer([interable-or-mapping])

La función element ()

Puede obtener los elementos de un Counter objeto con elements() función. Devuelve una lista que contiene todos los elementos del Counter objeto.

Mira el siguiente ejemplo:

cnt = Counter({1:3,2:4})
print(list(cnt.elements()))

Salida:

[1, 1, 1, 2, 2, 2, 2]

Aquí, creamos un Counter objeto con un diccionario como argumento. En este objeto Contador, la cuenta de 1 es 3 y la cuenta de 2 es 4. La elements() la función se llama usando cnt objeto que devuelve un iterador que se pasa como argumento a la lista.

El iterador se repite 3 veces sobre 1 y devuelve tres ‘1’ y se repite cuatro veces sobre 2 devolviendo cuatro ‘2 a la lista. Finalmente, la lista se imprime utilizando el print función.

La función most_common ()

los Counter() La función devuelve un diccionario desordenado. Puede ordenarlo de acuerdo con el número de conteos en cada elemento usando most_common() función de la Counter objeto.

list = [1,2,3,4,1,2,6,7,3,8,1]
cnt = Counter(list)
print(cnt.most_common())

Salida:

[(1, 3), (2, 2), (3, 2), (4, 1), (6, 1), (7, 1), (8, 1)]

Puedes ver eso most_common La función devuelve una lista, que se ordena en función del recuento de elementos. 1 tiene una cuenta de tres, por lo tanto, es el primer elemento de la lista.

La función restar ()

los subtract() toma iterable (lista) o un mapeo (diccionario) como argumento y deduce el recuento de elementos usando ese argumento. Mira el siguiente ejemplo:

cnt = Counter({1:3,2:4})
deduct = {1:1, 2:2}
cnt.subtract(deduct)
print(cnt)

Salida:

Counter({1: 2, 2: 2})

Puedes notar que cnt objeto que creamos primero, tiene una cuenta de 3 para ‘1’ y cuenta de 4 para ‘2’. los deduct El diccionario tiene el valor ‘1’ para la clave ‘1’ y el valor ‘2’ para la clave ‘2’. los subtract() la función dedujo 1 conteo de la tecla ‘1’ y 2 conteos de la tecla ‘2’.

El defaultdict

los defaultdict funciona exactamente como un diccionario de Python, excepto que no arroja KeyError cuando intentas acceder a una clave inexistente.

En cambio, inicializa la clave con el elemento del tipo de datos que pasa como argumento en la creación de defaultdict. El tipo de datos se llama default_factory.

Importar defaultdict

Primero, tienes que importar defaultdict de collections módulo antes de usarlo:

from collections import defaultdict

Crear un defaultdict

Puedes crear un defaultdict con el defaultdict() constructor. Tienes que especificar un tipo de datos como argumento. Verifique el siguiente código:

nums = defaultdict(int)
nums['one'] = 1
nums['two'] = 2
print(nums['three'])

Salida:

0

En este ejemplo, int se pasa como el default_factory. Observa que solo pasas intno int(). A continuación, se definen los valores para las dos claves, a saber, ‘uno’ y ‘dos’, pero en la siguiente línea intentamos acceder a una clave que aún no se ha definido.

En un diccionario normal, esto forzará un KeyError. Pero defaultdict inicializar la nueva clave con default_factoryel valor predeterminado que es 0 para int. Por lo tanto, cuando se ejecute el programa, se imprimirá 0. Esta característica particular de inicializar claves inexistentes se puede aprovechar en varias situaciones.

Por ejemplo, supongamos que desea el recuento de cada nombre en una lista de nombres indicados como “Mike, John, Mike, Anna, Mike, John, John, Mike, Mike, Britney, Smith, Anna, Smith”.

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)

Salida:

defaultdict(<class 'int'>, {'Mike': 5, 'Britney': 1, 'John': 3, 'Smith': 2, 'Anna': 2})

Primero, creamos un defaultdict con int como default_factory. los names_list incluye un conjunto de nombres que se repiten varias veces. los split() La función devuelve una lista de la cadena dada. Rompe la cadena cada vez que se encuentra un espacio en blanco y devuelve palabras como elementos de la lista. En el bucle, cada elemento de la lista se agrega al defaultdict nombrado como count e inicializado a 0 basado en default_factory. Si se vuelve a encontrar el mismo elemento, a medida que continúa el ciclo, se incrementará el recuento de ese elemento.

El OrderedDict

OrderedDict es un diccionario donde las claves mantienen el orden en el que se insertan, lo que significa que si cambia el valor de una clave más tarde, no cambiará la posición de la clave.

Importar OrderedDict

Usar OrderedDict tienes que importarlo desde el módulo de colecciones.

from collections import OrderedDict

Crear un OrderedDict

Puede crear un objeto OrderedDict con OrderedDict() constructor. En el siguiente código, crea un OrderedDict sin ningún argumento. Después de eso, algunos elementos se insertan en él.

od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)

Salida:

OrderedDict([('a', 1), ('b', 2), ('c', 3)])

También puede acceder a cada elemento mediante un bucle. Eche un vistazo al siguiente código:

for key, value in od.items():
    print(key, value)

Salida:

a 1
b 2
c 3

El siguiente ejemplo es un caso de uso interesante de OrderedDict con Counter. Aquí, creamos un Counter de una lista e inserte el elemento en un OrderedDict basado en su recuento.

La letra que aparece con más frecuencia se insertará como la primera clave y la letra que aparece con menos frecuencia se insertará como la última clave.

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)

Salida:

a 4
c 3
b 2

El deque

los deque es una lista optimizada para insertar y eliminar elementos.

Importar la deque

Tienes que importar deque clase de collections módulo antes de usarlo.

from collections import deque

Creando un deque

Puedes crear una deque con deque() constructor. Tienes que pasar una lista como argumento.

list = ["a","b","c"]
deq = deque(list)
print(deq)

Salida:

deque(['a', 'b', 'c'])

Insertar elementos para deque

Puede insertar fácilmente un elemento en el deq que creamos en cualquiera de los extremos. Para agregar un elemento a la derecha de la deque, debes usar append() método.

Si desea agregar un elemento al inicio de la deque, debe usar appendleft() método.

deq.append("d")
deq.appendleft("e")
print(deq)deque

Salida:

deque(['e', 'a', 'b', 'c', 'd'])

Puedes notar que d se agrega al final de deq y e se agrega al inicio de la deq

Eliminar elementos de la deque

Eliminar elementos es similar a insertar elementos. Puede eliminar un elemento de la misma manera que inserta elementos. Para eliminar un elemento del extremo derecho, puede utilizar pop() función y para eliminar un elemento de la izquierda, puede utilizar popleft().

deq.pop()
deq.popleft()
print(deq)

Salida:

deque(['a', 'b', 'c'])

Puede observar que tanto el primer como el último elemento se eliminan del deq.

Limpiar una deque

Si desea eliminar todos los elementos de una deque, puede usar clear() función.

list = ["a","b","c"]
deq = deque(list)
print(deq)
print(deq.clear())

Salida:

deque(['a', 'b', 'c'])
None

Puedes ver en la salida, al principio hay una cola con tres elementos. Una vez que aplicamos clear() función, el deque se borra y ves none en la salida.

Contando elementos en un deque

Si desea encontrar el recuento de un elemento específico, use count(x) función. Debe especificar el elemento para el que necesita encontrar el recuento, como argumento.

list = ["a","b","c"]
deq = deque(list)
print(deq.count("a"))

Salida:

1

En el ejemplo anterior, la cuenta de “a” es 1. Por lo tanto, se imprime “1”.

El ChainMap

ChainMap se utiliza para combinar varios diccionarios o mapeos. Devuelve una lista de diccionarios.

Importar mapa de cadena

Tienes que importar ChainMap desde el collections módulo antes de usarlo.

from collections import ChainMap

Crear un ChainMap

Para crear un mapa de cadena podemos usar ChainMap() constructor. Tenemos que pasar los diccionarios que vamos a combinar como un conjunto de argumentos.

dict1 = { 'a' : 1, 'b' : 2 }
dict2 = { 'c' : 3, 'b' : 4 }
chain_map = ChainMap(dict1, dict2)
print(chain_map.maps)

Salida:

[{'b': 2, 'a': 1}, {'c': 3, 'b': 4}]

Puede ver una lista de diccionarios como resultado. Puede acceder a los valores del mapa de cadena por nombre de clave.

print(chain_map['a'])

Salida:

1

‘1’ se imprime como el valor de la clave ‘a’ es 1. Otro punto importante es ChainMap actualiza sus valores cuando se actualizan sus diccionarios asociados. Por ejemplo, si cambia el valor de ‘c’ en dict2 a ‘5’, notará el cambio en ChainMap también.

dict2['c'] = 5
print(chain_map.maps)

Salida:

[{'a': 1, 'b': 2}, {'c': 5, 'b': 4}]

Obtención de claves y valores de ChainMap

Puede acceder a las claves de un ChainMap con keys() función. Del mismo modo, puede acceder a los valores de los elementos con values() función, como se muestra a continuación:

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

Salida:

['b', 'a', 'c']
[2, 1, 3]

Observe que el valor de la clave ‘b’ en la salida es el valor de la clave ‘b’ en dict1. Como regla general, cuando una clave aparece en más de un diccionario asociado, ChainMap toma el valor de esa clave del primer diccionario.

Agregar un nuevo diccionario a ChainMap

Si desea agregar un nuevo diccionario a un existente ChainMap, utilizar new_child() función. Crea una nueva ChainMap con el diccionario recién agregado.

dict3 = {'e' : 5, 'f' : 6}
new_chain_map = chain_map.new_child(dict3)
print(new_chain_map)

Salida:

ChainMap({'f': 6, 'e': 5}, {'a': 1, 'b': 2}, {'b': 4, 'c': 3})

Observe que se agrega un nuevo diccionario al comienzo de ChainMap lista.

El namedtuple ()

los namedtuple() devuelve una tupla con nombres para cada posición en la tupla. Uno de los mayores problemas con las tuplas ordinarias es que debe recordar el índice de cada campo de un objeto de tupla. Evidentemente, esto es difícil. los namedtuple se introdujo para resolver este problema.

Importar namedtuple

Antes de usar namedtuple, tienes que importarlo desde el collections módulo.

from collections import namedtuple

Crear una tupla con nombre

from collections import namedtuple

Student = namedtuple('Student', 'fname, lname, age')
s1 = Student('John', 'Clarke', '13')
print(s1.fname)

Salida:

Student(fname="John", lname="Clarke", age="13")

En este ejemplo, un namedtuple objeto Student ha sido declarado. Puede acceder a los campos de cualquier instancia de un Student class por el nombre del campo definido.

Crear una tupla con nombre usando la lista

los namedtuple() La función requiere que se le pase cada valor por separado. En su lugar, puede utilizar _make() para crear un namedtuple instancia con una lista. Verifique el siguiente código:

s2 = Student._make(['Adam','joe','18'])
print(s2)

Salida:

Student(fname="Adam", lname="joe", age="18")

Crear una nueva instancia con una instancia existente

los _asdict() La función se puede utilizar para crear una OrderedDict instancia de una instancia existente.

s2 = s1._asdict()
print(s2)

Salida:

OrderedDict([('fname', 'John'), ('lname', 'Clarke'), ('age', '13')])

Cambiar valores de campo con la función _replace ()

Para cambiar el valor de un campo de una instancia, el _replace() se utiliza la función. Recuérdalo, _replace() La función crea una nueva instancia. No cambia el valor de la instancia existente.

s2 = s1._replace(age="14")
print(s1)
print(s2)

Salida:

Student(fname="John", lname="Clarke", age="13")
Student(fname="John", lname="Clarke", age="14")

Conclusión

Con eso, concluimos nuestro tutorial sobre el módulo Colecciones. Hemos discutido todos los temas importantes en el módulo de colección. El módulo de colección de Python todavía necesita mejoras si lo comparamos con la biblioteca de colección de Java. Por lo tanto, podemos esperar muchos cambios en las próximas versiones.

Referencias

• Documentación del módulo de colección de Python