De hecho, la colección de Python es un diccionario sin valor en su implementación interna, por lo que es muy similar a un diccionario. Como es muy similar a un diccionario, ¿qué más quieres ensamblar? ¿Cuál es el propósito principal de la colección?
Las colecciones se utilizan principalmente para probar si un objeto está en un conjunto de objetos, es decir, in una operación. Esta función puede ser realmente una lista, como 1 in [2,3,4,5] , pero la velocidad de uso de las listas es mucho menor que la colección, especialmente cuando el número de objetos en este montón es muy grande.
Debido a que la lista se almacena secuencialmente, su complejidad de tiempo de búsqueda es O(n) , y el conjunto se implementa mediante una tabla hash, y su complejidad de tiempo es O(1) .
Creación de colección (conjunto) de Python
Las colecciones se pueden crear con set() para crear una colección vacía, o una lista se puede convertir en una colección. Al igual que un diccionario, puede poner varios objetos separados por comas entre llaves:
In [1]: s = set()
In [2]: type(s)
Out[2]: set
In [3]: set([1,2,3,4,5])
Out[3]: {1, 2, 3, 4, 5}
In [4]: set([1,2,3,3,5])
Out[4]: {1, 2, 3, 5}
In [5]: s = {'a', 'd', 'e', 'c', 'b'}
In [6]: s2 = {1, 'a', True}
In [7]: s = {'a', 'a', 'a'}
In [8]: s
Out[8]: {'a'} # 字典里面的元素不能重复
Las claves del diccionario no pueden ser las mismas que los objetos mutables, las colecciones no pueden ser listas, colecciones o diccionarios:
In [9]: s = {'a', [1,2]}
------------------------
TypeError Traceback (most recent call last)
<ipython-input-9-0a9fe58d273d> in <module>
----> 1 s = {'a', [1,2]}
TypeError: unhashable type: 'list'
In [10]: s = {'a', {'a':1}}
---------------------------
TypeError Traceback (most recent call last)
<ipython-input-10-f0b724762652> in <module>
----> 1 s = {'a', {'a':1}}
TypeError: unhashable type: 'dict'
Acceso a la colección de Python (set)
Una colección no puede acceder a un elemento interno a través de un índice como una lista. Sólo puede acceder a todos los elementos mediante el desplazamiento, o acceder a la colección completa por nombre de variable:
In [13]: s = {'a', 'b', 'c'}
In [14]: s
Out[14]: {'a', 'b', 'c'}
In [15]: for x in s:
...: print(x)
...:
a
c
b
Colección de funciones incorporadas relacionadas
Python tiene funciones integradas que se pueden usar para manipular colecciones, que son:
- len ()
Devuelve la longitud de la colección, que es el número de elementos que contiene la colección. La longitud del conjunto vacío es 0
In [41]: len({'a', 'b'})
Out[41]: 2
In [42]: len(set())
Out[42]: 0
- any () y all ()
Similar a la operación de listas, tuplas.
Any (): Devuelve True si la colección tiene un elemento que es True;
All (): devuelve True solo si todos los elementos de la colección son True;
In [45]: any({'', 0, False})
Out[45]: False
In [46]: all({'', 0, False})
Out[46]: False
In [47]: all({'a', 0:, False})
Out[47]: False
In [48]: any({'a', 0:, False})
Out[48]: True
In [49]: any(set())
Out[49]: False
In [50]: all(set())
Out[50]: True
Al igual que el diccionario vacío, asume que todos los elementos son Verdaderos y all(set()) devuelve Verdadero.
- sorted ()
Al igual que la lista de acciones y la tupla, ordena todos los elementos de la colección.
In [51]: sorted({'a', 'c', 'b'})
Out[51]: ['a', 'b', 'c']
En operador
Al igual que las listas, tuplas, in utiliza para comprobar si un objeto está en una colección:
In [56]: 'a' in {'a', 'c', 'b'}
Out[56]: True
In [57]: '3' in {'a', 'c', 'b'}
Out[57]: False
In [58]: '3' not in {'a', 'c', 'b'}
Out[58]: True
Atraviesa la colección:
In [59]: for k in {'a', 'c', 'b'}:
...: print(key)
...:
a
c
b
Los métodos incorporados de la colección:
(1) add (x)
Añadir objeto x a la colección.
In [25]: s = {'a', 'b', 'c'}
In [26]: s.add(1)
In [27]: s
Out[27]: {1, 'a', 'b', 'c'}
(2) update ()
Añadir varios objetos a la colección.
In [28]: s.update([1,2,3])
In [29]: s
Out[29]: {1, 2, 3, 'a', 'b', 'c'}
In [30]: s.update(['x', 'y'], {7,8,0})
In [31]: s
Out[31]: {0, 1, 2, 3, 7, 8, 'a', 'b', 'c', 'x', 'y'}
(3) discard (x) y remove (x)
Ambos eliminan un elemento x de la colección. La diferencia es que si x no está en la colección, descartar () lo ignorará y remove () lanzará un error KeyError :
In [32]: s
Out[32]: {0, 1, 2, 3, 7, 8, 'a', 'b', 'c', 'x', 'y'}
In [33]: s.discard(0)
In [34]: s.remove(1)
In [35]: s
Out[35]: {2, 3, 7, 8, 'a', 'b', 'c', 'x', 'y'}
In [36]: s.discard('z')
In [37]: s.remove('z')
----------------------
KeyError Traceback (most recent call last)
<ipython-input-37-a9e7a977e50c> in <module>
----> 1 s.remove('z')
KeyError: 'z'
(4) pop ()
El pop () como el diccionario y el pop () de la lista eliminan un elemento y lo devuelven.Debido a que la colección no tiene el concepto de una clave y un índice, el pop () de la colección no toma argumentos.
(5) clear ()
Vaciar una colección
In [40]: s
Out[40]: {2, 3, 7, 8, 'a', 'b', 'c', 'x', 'y'}
In [41]: s.clear()
In [42]: s
Out[42]: set()
(6) copy ()
Al igual que la copia del diccionario (), devuelve una copia profunda de la colección.
In [44]: s = {'a', 'b', 'c'}
In [45]: s2 = s.copy()
In [46]: s2
Out[46]: {'a', 'b', 'c'}
In [47]: s.add(1)
In [48]: s
Out[48]: {1, 'a', 'b', 'c'}
In [49]: s2
Out[49]: {'a', 'b', 'c'}
(7) union ()
Encuentre la unión de dos o más colecciones, es decir, junte todos los elementos de estas colecciones para formar una nueva colección y regresar. No cambia la colección original.
In [51]: s1, s2, s3 = {1,2,3}, {4,5,6}, {6,7,8}
In [52]: s1.union(s2)
Out[52]: {1, 2, 3, 4, 5, 6}
In [53]: s1
Out[53]: {1, 2, 3}
In [54]: s1.union(s2, s3)
Out[54]: {1, 2, 3, 4, 5, 6, 7, 8}
(8) intersecion ()
Encuentre la intersección de dos o más colecciones, es decir, combine los elementos que comúnmente están contenidos en estas colecciones en una nueva colección y devuélvala. De nuevo no cambia la colección original.
In [55]: s1.intersection(s2)
Out[55]: set()
In [56]: s2.intersection(s3)
Out[56]: {6}
In [57]: s1.intersection(s2, s3)
Out[57]: set()
(10) difference ()
Encuentre la diferencia entre un conjunto S y otro conjunto, es decir, los elementos que solo están incluidos en el conjunto pero no en el conjunto se comparan para formar un nuevo conjunto y retorno, y no cambia el conjunto original. Equivalente a la resta del conjunto.
In [58]: s1.difference(s2)
Out[58]: {1, 2, 3} # Devuelve una colección de elementos que s1 contiene pero no en s2: s1 - s2
In [59]: s2.difference(s1)
Out[59]: {4, 5, 6} # S2 contiene, s1 no contiene: s2 - s1
In [60]: s2.difference(s3)
Out[60]: {4, 5} # S2 contiene, s3 no contiene: s2 - s3
In [61]: s2.difference(s3, s1)
Out[61]: {4, 5} # S2 contiene, s3, s1 no contiene: s2 - s3 - s1
(11) symmetric_difference ()
Encuentre el conjunto de elementos en los dos conjuntos, excepto la intersección, es decir, junte los elementos que no están incluidos en los dos conjuntos para formar un nuevo conjunto y regrese.
In [63]: s1, s2, s3
Out[63]: ({1, 2, 3}, {4, 5, 6}, {6, 7, 8})
In [64]: s1.symmetric_difference(s2)
Out[64]: {1, 2, 3, 4, 5, 6}
In [65]: s2.symmetric_difference(s3)
Out[65]: {4, 5, 7, 8}
(12) intersection_update ()
Una nueva colección se obtiene como con la intersección (), pero este método cambia el objeto que la llamó.
In [74]: s1, s2, s3 = {1,2,3}, {4,5,6}, {6,7,8}
In [75]: s1.intersection(s2)
Out[75]: set()
In [76]: s1
Out[76]: {1, 2, 3}
In [77]: s1.intersection_update(s2)
In [78]: s1
Out[78]: set()
(13) diferencia_update ()
Obtenga la nueva colección como con la diferencia () y cambie la colección que llama al método con la nueva colección.
In [79]: s1, s2, s3 = {1,2,3}, {4,5,6}, {6,7,8}
In [80]: s1.difference_update(s2)
In [81]: s1
Out[81]: {1, 2, 3}
(14) symmetric_difference_update ()
Obtenga la nueva colección como de costumbre con symmetric_difference () y cambie la colección que llama al método con la nueva colección.
In [83]: s1, s2 = {1,2,3}, {4,5,6}
In [84]: s1.symmetric_difference_update(s2)
In [85]: s1
Out[85]: {1, 2, 3, 4, 5, 6}
(15) isdisjoint ()
Devuelve True si no hay intersecciones entre las dos colecciones.
In [87]: s1, s2 = {1,2,3}, {4,5,6}
In [88]: s1.isdisjoint(s2)
Out[88]: True
(16) issubset ()
Determina si una colección es un subconjunto de otra colección, es decir, todos sus elementos están contenidos en otra colección.
In [89]: {1,2}.issubset({1,2,3})
Out[89]: True
In [90]: {1,2}.issubset({1,2})
Out[90]: True
In [91]: {1,2}.issubset({1,5,6})
Out[91]: False
(17) issuperset ()
Determina si una colección es un superconjunto de otra colección, es decir, contiene todos los elementos de otra colección.
In [93]: {1,2}.issuperset({1,2})
Out[93]: True
In [94]: {1,2}.issuperset({1,2,3})
Out[94]: False
In [95]: {1,2}.issuperset({1})
Out[95]: True
Frozenset
Como su nombre lo indica, es una colección de productos congelados, es decir, una colección inmutable. Las colecciones no se pueden usar como claves para los diccionarios, pero los frozensets sí.
In [100]: fs1 = frozenset()
In [101]: fs1
Out[101]: frozenset()
In [102]: fs2 = frozenset([1,2,3])
In [103]: fs2
Out[103]: frozenset({1, 2, 3})
In [104]: {fs2:3}
Out[104]: {frozenset({1, 2, 3}): 3}
Resumen
Una colección es un diccionario sin valor, pero también tiene su propia personalidad.
Practica
- Familiarizado con las distintas operaciones de la colección.
- Piensa en qué colecciones puedes asociarte en tu vida diaria.
留言
張貼留言