Introducción al módulo collections

Para abstraer un poquito:

>>> from collections import namedtuple

>>> Point = namedtuple('Point', ['x', 'y'])  # Define namedtuple
>>> p = Point(10, y=20)  # Creating an object
>>> p
Point(x=10, y=20)
>>> p.x + p.y
30
>>> p[0] + p[1]  # Accessing the values in normal way
30
>>> x, y = p     # Unpacking the tuple
>>> x
10
>>> y
20

Me costo entender este concepto. Creo que seria más entendible si siguiran enseñando como en los videos.
Les dejo mi aporte a lo que entendi(no es todo) pero si me sirvio de mucho lo saque de otra página.
Saludos.

- :link: [collections — Container datatypes](https://docs.python.org/3/library/collections.html)

El módulo collections nos brinda un conjunto de objetos primitivos que nos permiten extender el comportamiento de las built-in collections que poseé Python y nos otorga estructuras de datos adicionales. Por ejemplo, si queremos extender el comportamiento de un diccionario, podemos extender la clase UserDict; para el caso de una lista, extendemos UserList; y para el caso de strings, utilizamos UserString.

1. `namedtuple()` factory function for creating tuple subclasses with named fields
2. `deque` list-like container with fast appends and pops on either end
3. `ChainMap` dict-like class for creating a single view of multiple mappings
4. `Counter` dict subclass for counting hashable objects
5. `OrderedDict` dict subclass that remembers the order entries were added
6. `defaultdict` dict subclass that calls a factory function to supply missing values
7. `UserDict` wrapper around dictionary objects for easier dict subclassing
8. `UserList` wrapper around list objects for easier list subclassing
9. `UserString` wrapper around string objects for easier string subclassing


##### Counter
```python
from collections import Counter

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

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

Counter tiene tres funciones adicionales.

1. Elements
2. Most_common([n])
3. Subtract([interable-or-mapping])

elements()

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

most_common()

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

subtract

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

Crear diccionarios con el constructor defaultdict()

from collections import defaultdict

nums = defaultdict(int)
nums['one'] = 1
# -
print(nums)
# Output:
defaultdict(<class 'int'>, {'one': 1, 'two': 2})
# -
print(nums['two'])
# Output:
2

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)
# Output:
defaultdict(<class 'int'>, {'Mike': 5, 'Britney': 1, 'John': 3, 'Smith': 2, 'Anna': 2})

Ordenar diccionario(s)

from collections import OrderedDict

od = OrderedDict()
od['a'] = 1
od['b'] = 2
od['c'] = 3
print(od)
# Output:
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

for key, value in od.items():
    print(key, value)
# Output
a 1
b 2
c 3

from collections import deque

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

deq.append("d")
deq.appendleft("e")
print(deq)deque
# Output
deque(['e', 'a', 'b', 'c', 'd'])

deq.pop()
deq.popleft()
print(deq)
# Output
deque(['a', 'b', 'c'])

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

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

from collections import ChainMap

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

dict2['c'] = 5
print(chain_map.maps)
# Output
[{'a': 1, 'b': 2}, {'c': 5, 'b': 4}]

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()))
# Output
['b', 'a', 'c']
[2, 1, 3]

dict3 = {'e' : 5, 'f' : 6}
new_chain_map = chain_map.new_child(dict3)
print(new_chain_map)
# Output
ChainMap({'f': 6, 'e': 5}, {'a': 1, 'b': 2}, {'b': 4, 'c': 3})

from collections import namedtuple

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

Creando namedtuple usando una lista

s2 = Student._make(['Adam','joe','18'])
print(s2)
# Output
Student(fname='Adam', lname='joe', age='18')

Creando una nueva instancia usando una instancia existente

s2 = s1._asdict()
print(s2)
# Output
OrderedDict([('fname', 'John'), ('lname', 'Clarke'), ('age', '13')])

Cambiando valores con la funcion _replace()

s2 = s1._replace(age='14')
print(s1)
print(s2)
# Output
Student(fname='John', lname='Clarke', age='13')
Student(fname='John', lname='Clarke', age='14')

No me parece de lo más adecuado que estando viendo programación estructurada con python y se ponga de trancazo una explicación y código orientado a objetos, esto puede causar mucha confusión al momento de leerlo y más a los programadores que apenas están aprendiendo

No me gustó, . deberían hacer un video, sería más explicativo…

Este post me ayudo a entender el tema:
Módulo Collections

Esto hubiera estado mejor en un vídeo, y no solo un texto, la metodología que usan esta dejando mucho que desear. Meten un texto a modo de introducción y vienen clases algo que no han abordado anteriormente Mal!

Muy interesante. Cada vez me gusta más Python

Counter me pareció muy interesante, funciona genial para hacer estadística pues en tres simples pasos podemos organizar la información de los datos y crear un diccionario para guardar el valor y la moda:

>>>from collections import Counter
>>>a = [1, 2, 3, 2, 3, 4, 5, 6, 7, 3, 2, 3, 4, 3, 5, 6, 3, 2, 1, 4]
>>>dict(Counter(a))
{1: 2, 2: 4, 3: 6, 4: 3, 5: 2, 6: 2, 7: 1}

No entiendo algo, y es ese parámetro self. 😦 ¿Alguien me puede explicar por favor?

https://docs.python.org/3/library/collections.html?highlight=collections#collections.namedtuple

Esto no queda bien claro, me perdí, y creo que es bastante avanzado, para lo que venimos aquí a aprender a programar, se me esta siendo muy difícil el curso… porque aveces el profe aplica varios temas avanzados, alguien me ayuda con este modulo?

No entiendo nada, qué es todo eso ?

Alguien que aclare por favor el primer ejemplo.
Por que a las funciones se les pasa como parametro
(self, password)?
no deberia ser:
(self, self['password'])??
porque “password” y “key” son keys del diccionario que se la pasa como parametro a la clase al crear my_secret_dict? Y para acceder a ellas hay que usar el ['password']?

Creo que falto más explicación para esta parte, hubiera preferido vídeos o una sección completa de este tema. Les recomiendo que entiendan POO antes de meterse a este tema.

El módulo collections en Python es un módulo integrado que proporciona varias clases de colecciones adicionales, como contadores, ordenadores, defaultdicts,UserDict, namedtuple
, etc. (Voy a dejar ejemplos como respuesta a este aporte) Estas clases de colecciones son similares a las clases de colecciones integradas, como listas, diccionarios, conjuntos, etc. pero tienen algunas características adicionales que las hacen más útiles en algunos casos específicos. Por ejemplo, un contador es una clase de colección que se utiliza para contar la frecuencia de elementos en una lista, mientras que un defaultdict es un diccionario que proporciona un valor predeterminado para una clave no existente.
.
En esta clase básicamente estamos utilizando un modulo decollections y estamos importando la clase UserDict.

Lo podemos importar así:

from collections import UserDict

En este ejemplo, utilizamos la clase UserDict para crear nuestra propia clase de diccionario llamada SecretDict. La clase SecretDict hereda los métodos y atributos de UserDict, lo que significa que tiene las mismas funciones que un diccionario normal de python:

class SecretDict(collections.UserDict):

Los UserDict son útiles para cuando se quieren crear diccionarios personalizados con funciones adicionales o para sobreescribir métodos existentes.
.
En este ejemplo sobreescribimos el modo getitem(), que es un método mágico en Python, que cuando se utiliza en una clase, permite a sus instancias utilizar los operadores [] (indexador). Digamos que x es una instancia de esta clase, entonces x[i] es aproximadamente equivalente a tipo(x).getitem(x, i).
.
El código en realidad no hace nada ni esta completo, es solo un ejemplo de como sobrescribir un método con esa clase.
.
Les dejo más ejemplos de collections en las respuestas, pero les recomiendo que estudien por ustedes el tema.

Esta página es muy explicativa. Python Collections

No entiendo a que te refieres con ''Comportamiento de un diccionario"

Buenísimo. Sólo un poco complejo al comienzo. Espero ir aclarando mis dudas en el camino.

Es un poco dificil de entender el concepto, pero aca les dejo algo que me sirvio muchisimo

Me gustó mucho el Counter … por acá les dejo algunas de las cosas que ví en el help(collections.Counter):

• Saber cuales son los N elementos que más apariciones tiene en la lista con el método most_common()
• Establecer un elemento en cero pero que se mantenga en la lista de elementos (asignación a cero)

import collections

my_string = 'abracadabra'

c = collections.Counter(my_string)

print(c.most_common(3)) #returned [('a', 5), ('r', 2), ('b', 2), ('c', 1), ('d', 1)]

print(c['b']) #returned 2
c['b'] = 0 #remove all 'b' but keep the element. Returned nothing
print(c)

ojala todas las ayudas fueran como las de collections 🐍🐧

Exijo que esto lo extiendan a una clase con video please

Recomiendo esta lectura para las namedtuple.

#collections: Counter, namedtuple, default, deque
from collections import Counter
#Counter: is a container that stores the elementes as dictionary Keys in their counts as dictionary values. 
#We can see the dictionaries with all the different characters as keys an their count as values
a="aaaaabbbbccc"
my_counter=Counter(a)
print(my_counter)

from collections import namedtuple
#namedtuple('Class Name', string que son todos los different elementos separadaos por comas)
Point=namedtuple('Point','x,y,z')
pt=Point(1,-3,2)
print(pt.x,pt.y,pt.z)

from collections import defaultdict
d=defaultdict(dict)
#Valor por defecto si no encuentra el item en la lista
d['a']=1
d['b']=2
print(d['c'])

from collections import deque
#Deck is a double ended queue
d=deque()
d.append(1)
d.append(2)

d.appendleft(3)
#remove the last element
d.popleft()
print(d)
#extender
d.extendleft([4,5,6])
print(d)

d.rotate(-1)
print(d)

En conclusión, el módulo collections es una gran fuente de utilerías que nos permiten escribir código más “pythonico” y más eficiente.

Documentación oficial de collections

Me encantan este tipo de clases son muy ricas en contenido y para aportar en ello quiero compartirles este enlance donde habla un poco mas sobre el modulo collections.

• https://docs.python.org/3/library/collections.html

Me parece muy bueno esta libreria ya que es bastane util para ciertos tipos de tareas

Genial!!

Existe alguna clase referente a este tema, despues de este punto?

David, podrias explicar mas a detalle etae tema por favor, habemos varios que no hemos entendido el tema.

Gracias,

Interesante modulo, a ponerlos en practica

Esté modulo solo sirve para diccionarios?

I’ll have to try it

excelente, Pythonico

Excelente!