Categorías
Python

Su guía para el código fuente CPython

 

Tabla de Contenidos

  • Definición de un tamaño fijo
  • Set y afiliación
  • operativo en un SetOperators vs. MethodsAvailable Operadores y Métodos
  • Operadores vs Métodos
  • operadores disponibles y métodos
  • la modificación de un SetAugmented Operadores de asignación y métodos MethodsOther Establece para la modificación de los operadores y métodos de asignación
  • Aumentada
  • Otros métodos para modificar Establece
  • congelado conjuntos
  • Conclusión
    Operadores

  • vs Métodos
  • operadores disponibles y Métodos
  • Aumentada Operadores de asignación y métodos
  • Otros los métodos para modificar Establece

Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: Conjuntos en Python

Quizás Recuerda haber aprendiendo sobre establece y teoría de conjuntos en algún momento de su educación matemática. Tal vez incluso recuerda los diagramas de Venn:

Si esto no suena, no se preocupe! Este tutorial todavía debe ser fácilmente accesible para usted.

En matemáticas, una definición rigurosa de un conjunto pueden ser abstracto y difícil de entender. Prácticamente, sin embargo, un conjunto se puede considerar simplemente como una colección bien definida de objetos distintos, típicamente llamados elementos o miembros .

agrupar objetos en un conjunto puede ser útil en la programación, así, y Python proporciona un tipo incorporado conjunto para hacerlo. Los sistemas se distinguen de otros tipos de objetos por parte de las operaciones singulares que se pueden realizar en ellos.

Esto es lo que aprenderá en este tutorial: Usted verá cómo definir fijar objetos en Python y descubrir las operaciones que apoyan. Al igual que con los tutoriales anteriores sobre listas y diccionarios, cuando haya terminado con este tutorial, usted debe tener una buena idea de cuando un establece es una opción apropiada. También aprenderá acerca congelada establece s, que son similares a conjunto s salvo por un detalle importante.

Tome el Cuestionario: Prueba sus conocimientos con nuestro cuestionario interactivo “Conjuntos Python”. Al finalizar, recibirá una puntuación para que pueda controlar su progreso en el aprendizaje a través del tiempo:

Contesta la trivia »

definir un conjunto

de Python tipo incorporado conjunto tiene las siguientes características: Conjuntos

  • no están ordenados.
  • conjunto de elementos son únicos. No se permiten elementos duplicados.
  • A se fijó pueden ser modificados, pero los elementos contenidos en el conjunto debe ser de un tipo inmutable. Véase la

Vamos a repasar lo que todos los medios, y cómo se puede trabajar con conjuntos en Python.

Un conjunto se puede crear de dos formas. En primer lugar, se puede definir un conjunto con la función incorporada en el conjunto ():

x = set()

En este caso, el argumento es un iterable de nuevo, por el momento, piensan lista o tupla que genera la lista de objetos para ser incluido en el conjunto. Esto es análogo a la argumento dado al método lista .extend ():

>>> x = set(['foo', 'bar', 'baz', 'foo', 'qux'])
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = set(('foo', 'bar', 'baz', 'foo', 'qux'))
>>> x
{'qux', 'foo', 'bar', 'baz'}

Strings también son iterable, por lo que una cadena se puede pasar a set () también. Ya ha visto que la lista (s) genera una lista de los caracteres de la cadena s. Del mismo modo, conjunto (s) genera un conjunto de los personajes de s:

>>> s = 'quux'

>>> list(s)
['q', 'u', 'u', 'x']
>>> set(s)
{'x', 'u', 'q'}

se puede ver que los conjuntos resultantes no tienen orden: el orden original, tal como se especifica en la definición, no necesariamente se conserva. Además, los valores duplicados solamente se representan en el conjunto de una vez, al igual que con la cadena ‘foo’ en los dos primeros ejemplos y la letra ‘u’ en el tercero.

Alternativamente, un conjunto se puede definir con las llaves ({}):

x = {, , ..., }

Cuando un conjunto se define de esta manera, cada uno se convierte en un elemento distintivo del conjunto, incluso si se trata de un iterable. Este comportamiento es similar a la del método de la lista .Append ().

Por lo tanto, los conjuntos mostrados anteriormente también se pueden definir de esta manera:

>>> x = {'foo', 'bar', 'baz', 'foo', 'qux'}
>>> x
{'qux', 'foo', 'bar', 'baz'}

>>> x = {'q', 'u', 'u', 'x'}
>>> x
{'x', 'q', 'u'}

Para recapitular:

  • El argumento a set () es un iterable. Se genera una lista de elementos que se coloca en el conjunto.
  • los objetos entre llaves se colocan en el conjunto intacta, incluso si son iterable.

Observe la diferencia entre estas dos definiciones de conjuntos:

>>> {'foo'}
{'foo'}

>>> set('foo')
{'o', 'f'}

Un conjunto puede estar vacío. Sin embargo, recordemos que interpreta Python vacían las llaves ({}) como un diccionario vacío, por lo que la única manera de definir un conjunto vacío es con la función set ():

>>> x = set()
>>> type(x)

>>> x
set()

>>> x = {}
>>> type(x)

un conjunto vacío es Falsy en contexto booleano:

>>> x = set()
>>> bool(x)
False
>>> x or 1
1
>>> x and 1
set()

se podría pensar que los conjuntos más intuitiva contendrían objetos-por ejemplo, números o incluso apellidos similares:

>>> s1 = {2, 4, 6, 8, 10}
>>> s2 = {'Smith', 'McArthur', 'Wilson', 'Johansson'}

Python no requiere esto, sin embargo. Los elementos de un conjunto pueden ser objetos de diferentes tipos:

>>> x = {42, 'foo', 3.14159, None}
>>> x
{None, 'foo', 42, 3.14159}

no se olvide que los elementos de ajuste deben ser inmutables. Por ejemplo, una tupla puede incluirse en un conjunto:

>>> x = {42, 'foo', (1, 2, 3), 3.14159}
>>> x
{42, 'foo', 3.14159, (1, 2, 3)}

Pero las listas y diccionarios son mutables, por lo que no pueden ser elementos obligatorios: Tamaño

>>> a = [1, 2, 3]
>>> {a}
Traceback (most recent call last):
File "", line 1, in
{a}
TypeError: unhashable type: 'list'

>>> d = {'a': 1, 'b': 2}
>>> {d}
Traceback (most recent call last):
File "", line 1, in
{d}
TypeError: unhashable type: 'dict'

Set y afiliación

El len () devuelve la función del número de elementos en un conjunto, y la entrada y no en los operadores se puede utilizar para comprobar la pertenencia:

>>> x = {'foo', 'bar', 'baz'}

>>> len(x)
3

>>> 'bar' in x
True
>>> 'qux' in x
False

operativo en un conjunto

Muchas de las operaciones que se pueden utilizar para otros tipos de datos compuesta de Python no tienen sentido para los conjuntos. Por ejemplo, los conjuntos no pueden ser indexados o en rodajas. Sin embargo, Python ofrece toda una serie de operaciones en el set objetos que generalmente imitan las operaciones que se definen para conjuntos matemáticos.

Operadores vs Métodos

La mayoría, aunque no todo, las operaciones establecidas en Python se puede realizar de dos maneras diferentes: por el operador o por el método. Vamos a echar un vistazo a cómo funcionan estos operadores y métodos, utilizando unión de conjuntos como ejemplo.

Dados dos conjuntos, X1 y X2, la unión de X1 y X2 es un conjunto que consta de todos los elementos, ya sea en conjunto.

en cuenta estos dos conjuntos:

x1 = {'foo', 'bar', 'baz'}
x2 = {'baz', 'qux', 'quux'}

La unión de X1 y X2 es { ‘foo’, ‘valor’, ‘baz’, ‘QUX’, ‘quux’}.

Nota: en cuenta que el elemento ‘baz’, que aparece tanto en X1 y X2, aparece sólo una vez en la unión. Conjuntos nunca contienen valores duplicados.

En Python, aparato de unión se puede realizar con el | operador:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 | x2
{'baz', 'quux', 'qux', 'bar', 'foo'}

Set unión también se puede obtener con el método .union (). El método se invoca en uno de los conjuntos, y el otro se pasa como argumento:

>>> x1.union(x2)
{'baz', 'quux', 'qux', 'bar', 'foo'}

La forma en que se utilizan en los ejemplos anteriores, el operador y el método se comportan de forma idéntica. Pero hay una diferencia sutil entre ellos. Cuando se utiliza el | operador, ambos operadores deben ser conjuntos. El método .union (), por el contrario, se llevará a cualquier iterable como argumento, lo convierten en un conjunto, y luego realizar la unión.

Observe la diferencia entre estas dos afirmaciones:

>>> x1 | ('baz', 'qux', 'quux')
Traceback (most recent call last):
File "", line 1, in
x1 | ('baz', 'qux', 'quux')
TypeError: unsupported operand type(s) for |: 'set' and 'tuple'

>>> x1.union(('baz', 'qux', 'quux'))
{'baz', 'quux', 'qux', 'bar', 'foo'}

Tanto intenta resolver la unión de x1 y la tupla ( ‘baz’, ‘QUX’, ‘quux’). Esta falla con el | operador pero tiene éxito con el método .union ().

operadores disponibles y Métodos

A continuación se muestra una lista de las operaciones de conjuntos disponibles en Python. Algunos se llevan a cabo por el operador, algunos por el método, y algunos por ambos. El principio descrito anteriormente es aplicable en general: donde se espera un conjunto, los métodos normalmente aceptará cualquier iterable como un argumento, pero los operadores requieren conjuntos reales como operandos.

x1.union (x2 [, … x3])

x1 | x2 [| x3 …]

Calcular la unión de dos o más conjuntos. x1.union

(x2) y x1 | x2 tanto la rentabilidad como el conjunto de todos los elementos, ya sea en x1 o x2:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.union(x2)
{'foo', 'qux', 'quux', 'baz', 'bar'}

>>> x1 | x2
{'foo', 'qux', 'quux', 'baz', 'bar'}

más de dos conjuntos pueden especificarse ya sea con el operador o el método:

>>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}

>>> a.union(b, c, d)
{1, 2, 3, 4, 5, 6, 7}

>>> a | b | c | d
{1, 2, 3, 4, 5, 6, 7}

El conjunto resultante contiene todos los elementos que están presentes en cualquiera de los conjuntos especificados . x1.intersection

(x2 [, … x3])

X1 y X2 [& x3 …]

calcular la intersección de dos o más conjuntos.

x1.intersection (x2) y X1 y X2 devuelven el conjunto de elementos comunes a ambos X1 y X2:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.intersection(x2)
{'baz'}

>>> x1 & x2
{'baz'}

Se pueden especificar varios conjuntos con el método de intersección y el operador, al igual que se puede con unión de conjuntos:

>>> a = {1, 2, 3, 4}
>>> b = {2, 3, 4, 5}
>>> c = {3, 4, 5, 6}
>>> d = {4, 5, 6, 7}

>>> a.intersection(b, c, d)
{4}

>>> a & b & c & d
{4}

El conjunto resultante contiene sólo elementos que están presentes en todos los conjuntos especificados.

x1.difference (x2 [, … x3])

x1 – x2 [- x3 …]

Calcular la diferencia entre dos o más conjuntos.

x1.difference (x2) y x1 – x2 devuelven el conjunto de todos los elementos que están en x1, pero no en x2:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.difference(x2)
{'foo', 'bar'}

>>> x1 - x2
{'foo', 'bar'}

Otra forma de pensar de esto es que x1.difference (x2) y x1 – x2 retorno el conjunto que resultados cuando ningún elemento en x2 se eliminan o se restan de x1.

Una vez más, se puede especificar más de dos conjuntos:

>>> a = {1, 2, 3, 30, 300}
>>> b = {10, 20, 30, 40}
>>> c = {100, 200, 300, 400}

>>> a.difference(b, c)
{1, 2, 3}

>>> a - b - c
{1, 2, 3}

Cuando se especifican varios conjuntos, la operación se realiza de izquierda a derecha. En el ejemplo anterior, a – b se calcula primero, lo que resulta en {1, 2, 3, 300}. Entonces c se resta de ese conjunto, dejando {1, 2, 3}:

x1.symmetric_difference (x2)

x1 ^ x2 [^ x3 …]

Calcular la diferencia simétrica entre series.

x1.symmetric_difference (x2) y x1 x2 ^ devuelven el conjunto de todos los elementos de cualquiera de X1 o X2, pero no ambos:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.symmetric_difference(x2)
{'foo', 'qux', 'quux', 'bar'}

>>> x1 ^ x2
{'foo', 'qux', 'quux', 'bar'}

El operador ^ también permite que más de dos conjuntos:

>>> a = {1, 2, 3, 4, 5}
>>> b = {10, 2, 3, 4, 50}
>>> c = {1, 50, 100}

>>> a ^ b ^ c
{100, 5, 10}

Como con el operador de diferencia , cuando se especifican varios conjuntos, la operación se realiza de izquierda a derecha.

Curiosamente, aunque el operador ^ permite múltiples conjuntos, el método .symmetric_difference () sin que:

>>> a = {1, 2, 3, 4, 5}
>>> b = {10, 2, 3, 4, 50}
>>> c = {1, 50, 100}

>>> a.symmetric_difference(b, c)
Traceback (most recent call last):
File "", line 1, in
a.symmetric_difference(b, c)
TypeError: symmetric_difference() takes exactly one argument (2 given)

x1.isdisjoint (x2)

determina si dos conjuntos tienen ningún elemento en común.

x1.isdisjoint (x2) devuelve verdadero si X1 y X2 no tienen elementos en común:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'baz', 'qux', 'quux'}

>>> x1.isdisjoint(x2)
False

>>> x2 - {'baz'}
{'quux', 'qux'}
>>> x1.isdisjoint(x2 - {'baz'})
True

Si x1.isdisjoint (x2) es verdadera, entonces X1 y X2 es el conjunto vacío:

>>> x1 = {1, 3, 5}
>>> x2 = {2, 4, 6}

>>> x1.isdisjoint(x2)
True
>>> x1 & x2
set()

Nota: No hay operador que corresponde al método .isdisjoint ().

x1.issubset (x2)

x1 <= x2

Determinar si un conjunto es un subconjunto de la otra.

En la teoría de conjuntos, un conjunto x1 se considera un subconjunto de otro conjunto x2 si todos los elementos de x1 está en x2.

x1.issubset (x2) y x1

>>> x1 = {'foo', 'bar', 'baz'}
>>> x1.issubset({'foo', 'bar', 'baz', 'qux', 'quux'})
True

>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 <= x2 False

Un conjunto es considerado como un subconjunto de sí mismo:

>>> x = {1, 2, 3, 4, 5}
>>> x.issubset(x)
True
>>> x <= x True

Parece extraño, tal vez. Pero se ajusta a la definición, todos los elementos de x está en x.

x1

Determina si un conjunto es un subconjunto propio de la otra.

un subconjunto propio es el mismo como un subconjunto, excepto que los conjuntos no pueden ser idénticos. Un x1 conjunto se considera un subconjunto propio de otro conjunto x2 si todos los elementos de x1 está en x2 y x1 y x2 no son iguales.

x1

>>> x1 = {'foo', 'bar'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 < x2 True >>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 < x2 False

Mientras que un conjunto se considera un subconjunto de sí mismo, no es un subconjunto propio de sí mismo:

>>> x = {1, 2, 3, 4, 5}
>>> x <= x True >>> x < x False

Nota: El operador

x1.issuperset (x2)

x1 > = x2

Determinar si un conjunto es un superconjunto de la otra.

un superconjunto es el reverso de un subconjunto. Un x1 conjunto se considera un superconjunto de otro conjunto x2 x1 si contiene todos los elementos de x2. x1.issuperset

(x2) y x1 x2 = Retorno > True si x1 es un superconjunto de x2:

>>> x1 = {'foo', 'bar', 'baz'}

>>> x1.issuperset({'foo', 'bar'})
True

>>> x2 = {'baz', 'qux', 'quux'}
>>> x1 >= x2
False

Ya se ha visto que un conjunto se considera un subconjunto de sí mismo. Un conjunto también se considera un superconjunto de sí mismo:

>>> x = {1, 2, 3, 4, 5}
>>> x.issuperset(x)
True
>>> x >= x
True

x1 x2 >

Determina si un juego es un superconjunto adecuada de la otra.

un superconjunto adecuada es el mismo que un superconjunto, excepto que los conjuntos no pueden ser idénticos. Un x1 conjunto se considera un superconjunto adecuada de otro conjunto x2 x1 si contiene todos los elementos de X2 y X1 y X2 no son iguales.

x1 > x2 devuelve True si x1 es un superconjunto adecuada de x2:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar'}
>>> x1 > x2
True

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'bar', 'baz'}
>>> x1 > x2
False

Un conjunto no es un superconjunto adecuada de sí mismo:

>>> x = {1, 2, 3, 4, 5}
>>> x > x
False

Nota: Operador El > es la única manera de probar si un conjunto es una superconjunto adecuada. No existe un método correspondiente.

Modificación de un Conjunto

Aunque los elementos contenidos en un conjunto debe ser de tipo inmutable, conjuntos mismos pueden ser modificados. Al igual que las operaciones anteriores, hay una mezcla de los operadores y métodos que se pueden utilizar para cambiar el contenido de un conjunto.

Aumentada Operadores de asignación y Métodos

Cada uno de la unión, intersección, diferencia, y los operadores diferencia simétrica anotados arriba una forma de asignación aumentada que puede ser utilizado para modificar un conjunto. Para cada uno, existe un método correspondiente también. x1.update

(x2 [, ... x3])

x1 | x2 = [| x3 ...]

Modificar un conjunto de unión.

x1.update (x2) y x1 | x2 = x1 añadir a cualquier elemento en x2 x1 que no tiene ya:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}

>>> x1 |= x2
>>> x1
{'qux', 'foo', 'bar', 'baz'}

>>> x1.update(['corge', 'garply'])
>>> x1
{'qux', 'corge', 'garply', 'foo', 'bar', 'baz'}

x1.intersection_update (x2 [, ... x3])

x1 y x2 = [ y X3 ...]

Modificar un conjunto de intersección.

x1.intersection_update (x2) y x1 y x2 = x1 actualización, reteniendo sólo los elementos encontrados tanto en X1 y X2:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}

>>> x1 &= x2
>>> x1
{'foo', 'baz'}

>>> x1.intersection_update(['baz', 'qux'])
>>> x1
{'baz'}

x1.difference_update (x2 [, ... x3])

x1 - x2 = [| x3 ...]

Modificar un conjunto por diferencia.

x1.difference_update (x2) y x1 - x2 = actualización x1, elementos de eliminación encuentran en x2:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}

>>> x1 -= x2
>>> x1
{'bar'}

>>> x1.difference_update(['foo', 'bar', 'qux'])
>>> x1
set()

x1.symmetric_difference_update (x2)

x1 ^ = x2

Modificar un conjunto por diferencia simétrica.

x1.symmetric_difference_update (x2) y x1 ^ = actualización x2 x1, elementos de retención encontraron en cualquiera de X1 o X2, pero no ambos:

>>> x1 = {'foo', 'bar', 'baz'}
>>> x2 = {'foo', 'baz', 'qux'}
>>>
>>> x1 ^= x2
>>> x1
{'bar', 'qux'}
>>>
>>> x1.symmetric_difference_update(['qux', 'corge'])
>>> x1
{'bar', 'corge'}

Otros métodos para modificar Establece

Aparte de los operadores aumentada por encima de, Python soporta varios adicional métodos que modifican conjuntos.

x.add ()

añade un elemento a un conjunto.

x.add () añade , que debe ser un único objeto inmutable, para x:

>>> x = {'foo', 'bar', 'baz'}

>>> x.add('qux')
>>> x
{'bar', 'baz', 'foo', 'qux'}

x.remove ()

elimina un elemento de un conjunto.

x.remove () Elimina de x. Python plantea una excepción si no está en x:

>>> x = {'foo', 'bar', 'baz'}

>>> x.remove('baz')
>>> x
{'bar', 'foo'}

>>> x.remove('qux')
Traceback (most recent call last):
File "", line 1, in
x.remove('qux')
KeyError: 'qux'

x.discard ()

elimina un elemento de un conjunto.

x.discard () también elimina de x. Sin embargo, si no está en x, este método no hace nada en silencio en lugar de lanzar una excepción:

>>> x = {'foo', 'bar', 'baz'}

>>> x.discard('baz')
>>> x
{'bar', 'foo'}

>>> x.discard('qux')
>>> x
{'bar', 'foo'}

x.pop ()

Elimina un elemento de azar de un conjunto. x.pop () elimina y vuelve

un elemento elegido arbitrariamente a partir de x. Si x es vacía, x.pop () lanza una excepción:

>>> x = {'foo', 'bar', 'baz'}

>>> x.pop()
'bar'
>>> x
{'baz', 'foo'}

>>> x.pop()
'baz'
>>> x
{'foo'}

>>> x.pop()
'foo'
>>> x
set()

>>> x.pop()
Traceback (most recent call last):
File "", line 1, in
x.pop()
KeyError: 'pop from an empty set'

x.clear ()

Borra un conjunto.

x.clear () quita todos los elementos de x:

>>> x = {'foo', 'bar', 'baz'}
>>> x
{'foo', 'bar', 'baz'}
>>>
>>> x.clear()
>>> x
set()

Frozen Establece

Python proporciona otro tipo incorporado llamado un frozenset , que es en todos los aspectos exactamente como un conjunto, excepto que una frozenset es inmutable. Se pueden realizar operaciones en un frozenset no modificar:

>>> x = frozenset(['foo', 'bar', 'baz'])
>>> x
frozenset({'foo', 'baz', 'bar'})

>>> len(x)
3

>>> x & {'baz', 'qux', 'quux'}
frozenset({'baz'})

Pero los métodos que intentan modificar un frozenset fallan:

>>> x = frozenset(['foo', 'bar', 'baz'])

>>> x.add('qux')
Traceback (most recent call last):
File "", line 1, in
x.add('qux')
AttributeError: 'frozenset' object has no attribute 'add'

>>> x.pop()
Traceback (most recent call last):
File "", line 1, in
x.pop()
AttributeError: 'frozenset' object has no attribute 'pop'

>>> x.clear()
Traceback (most recent call last):
File "", line 1, in
x.clear()
AttributeError: 'frozenset' object has no attribute 'clear'

>>> x
frozenset({'foo', 'bar', 'baz'})

inmersión profunda: Frozensets y asignación Aumentada

Desde un frozenset es inmutable, se podría pensar que puede' t ser el blanco de un operador de asignación aumentada. Pero observe:

>>> f = frozenset(['foo', 'bar', 'baz'])
>>> s = {'baz', 'qux', 'quux'}

>>> f &= s
>>> f
frozenset({'baz'})

Lo que da?

Python no lleva a cabo las tareas aumentada en frozensets en su lugar. La sentencia x = y s es efectivamente equivalente a x = x y s. No está modificando el original x. Se reasignación de x para un nuevo objeto, y el objeto X referenciado originalmente se ha ido.

Usted puede verificar esto con la función Identificación del ():

>>> f = frozenset(['foo', 'bar', 'baz'])
>>> id(f)
56992872
>>> s = {'baz', 'qux', 'quux'}

>>> f &= s
>>> f
frozenset({'baz'})
>>> id(f)
56992152

f tiene un identificador entero diferente después de la asignación aumentada. Se ha reasignado, sin modificar en su lugar.

Algunos objetos en Python son modificados en su lugar cuando están en el blanco de un operador de asignación aumentada. Pero frozensets no lo son.

Frozensets son útiles en situaciones en las que desee utilizar un conjunto, pero se necesita un objeto inmutable. Por ejemplo, no se puede definir un conjunto cuyos elementos son también conjuntos, ya que los elementos de ajuste deben ser inmutables:

>>> x1 = set(['foo'])
>>> x2 = set(['bar'])
>>> x3 = set(['baz'])
>>> x = {x1, x2, x3}
Traceback (most recent call last):
File "", line 1, in
x = {x1, x2, x3}
TypeError: unhashable type: 'set'

Si realmente se siente obligado a definir un conjunto de conjuntos (hey, podría suceder), puede hacerlo si los elementos son frozensets, porque son inmutables:

>>> x1 = frozenset(['foo'])
>>> x2 = frozenset(['bar'])
>>> x3 = frozenset(['baz'])
>>> x = {x1, x2, x3}
>>> x
{frozenset({'bar'}), frozenset({'baz'}), frozenset({'foo'})}

del mismo modo, recuerdan desde el tutorial anterior en los diccionarios de que una clave de diccionario debe ser inmutable. No se puede utilizar la incorporada en el tipo de conjunto como una clave de diccionario:

>>> x = {1, 2, 3}
>>> y = {'a', 'b', 'c'}
>>>
>>> d = {x: 'foo', y: 'bar'}
Traceback (most recent call last):
File "", line 1, in
d = {x: 'foo', y: 'bar'}
TypeError: unhashable type: 'set'

Si ves que necesitas para su uso como conjuntos de claves de diccionario, puede utilizar frozensets:

>>> x = frozenset({1, 2, 3})
>>> y = frozenset({'a', 'b', 'c'})
>>>
>>> d = {x: 'foo', y: 'bar'}
>>> d
{frozenset({1, 2, 3}): 'foo', frozenset({'c', 'a', 'b'}): 'bar'}

Conclusión

En este tutorial, ha aprendido a definir establece objetos en Python, y se convirtió en familiarizarse con las funciones, operadores y métodos que se pueden utilizar para trabajar con establece s.

Ahora debe ser cómodo con los tipos de datos incorporados en Python básicos que presta.

A continuación, comenzará a explorar cómo el código que funciona en esos objetos está organizado y estructurado en un programa Python.

Tome el Cuestionario: Prueba sus conocimientos con nuestro cuestionario interactivo “Conjuntos Python”. Al finalizar, recibirá una puntuación para que pueda controlar su progreso en el aprendizaje a través del tiempo:

Contesta la trivia »

Mira ahora Este tutorial tiene un vídeo relacionado curso creado por el equipo del Real Python. Mira que junto con el tutorial escrito para profundizar su comprensión: Conjuntos en Python

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *