Conjuntos en Python

miércoles, 25 de junio de 2008

Como en Python todo es un objeto, los conjuntos no son la excepcion. A traves de métodos, podremos operar entre conjuntos.

Todo lo que esté con el símbolo indica que no es necesario leerlo, pero puede resultar interesante para aquellos que no saben en que consiste cada operacion.

Declaración
Primero, ¿como declaramos un conjunto?
En python, cualquier objeto iterable lo podemos "transformar" en un conjunto.

>>> T = (1,2,3,4,5,5)
>>> conjuntoT = set(T) #Con set() definimos el conjunto
>>> conjuntoT
set([1, 2, 3, 4, 5])

>>> L = [1,2,3,4,5,5]
>>> conjuntoL = set(L)
>>> conjuntoL
set([1, 2, 3, 4, 5])

>>> C = 'Hola Mundo'
>>> conjuntoC = set(C)
>>> conjuntoC
set(['a', ' ', 'd', 'H', 'M', 'l', 'o', 'n', 'u'])

Por definicion de la teoría de conjuntos los elementos perteneciente a un conjunto no se re repiten, fijense en los dos primeros casos en T y L se repite el 5 y en conjuntoT y conjuntoL, solo hay un 5. Lo mismo pasa en el tercer ejemplo.


Unión

>>> A = set([1,2,3,4,5])
>>> B = set([3,4,5,6,7])
>>> A|B
set([1, 2, 3, 4, 5, 6, 7])

Definicion: Dado un conjuto A y un conjuto B cualquiera. La unión de conjuntos A y B (se denota A∪B)consiste en un nuevo conjunto el cual contiene todos los elementos A y B.

Tambien podría haberse hecho A.union(B)

Interseccion

>>> A = set([1,2,3,4,5])
>>> B = set([3,4,5,6,7])
>>> A&B
set([3, 4, 5])

Definicion: Dado un conjuto A y un conjuto B cualquiera. La intersección de conjuntos A y B (se denota A ∩ B) consiste en un nuevo conjunto el cual contiene todos los elementos que tengan en común A y B.

Tambien podría haberse hecho A.intersection(B)

Diferencia

>>> A = set([1,2,3,4,5])
>>> B = set([3,4,5,6,7])
>>> A-B
set([1, 2])

Definicion: Dado un conjuto A y un conjuto B cualquiera. La diferencia entre un conjuntos A y B (se denota A-B) consiste en un nuevo conjunto el cual contiene todos los elementos de A y que no pertenezcan a B.

Tambien podría haberse hecho A.difference(B)


Diferencia Simétrica

>>> A = set([1,2,3,4,5])
>>> B = set([3,4,5,6,7])
>>> A^B
set([1, 2, 6, 7, 8])

Definición: Dado un conjuto A y un conjuto B cualquiera. La diferencia simétrica de conjuntos A y B (se denota A Δ B) consiste en un nuevo conjunto el cual contiene todos los elementos de A y B que no tengan en comun.

Tambien podría haberse hecho A.symmetric_difference(B)

¿Es subconjunto?

>>> B = set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> A = set([1,2,3,4,5])
>>> A.issubset(B)
True
>>> B.issubset(A)
False

Definición: Un conjuto A es subconjunto de B cuando todos los elementos de A tambien pertenecen a B.


¿Es superconjunto?

>>> B = set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> A = set([1,2,3,4,5])
>>> B.issuperset(A)
True
>>> A.issuperset(B)
False

Definición: Un conjunto B es superconjunto de A si y solo si A es subconjunto de B


Pertenencia

>>> A = set([1,2,3,4,5])
>>> 1 in A
True
>>> 1 not in A
False
>>> 10 in A
False
>>> 10 not in A
True

Definición: Matemáticamente no tiene una definición, pero podemos decir que es un termino que usamos para saber si un elemento está o no dentro de un conjunto.


Las operaciones las hicimos entre dos conjuntos, pero podemos operar con la cantidad de conjuntos que querramos.
Hasta acá las operaciones definidas por la teoría conjuntista, pero tambien existen otras en Python para hacer mas fácil la programación.

Agregar un elemento al conjunto

>>> A = set([1,2,3,4,5])
>>> A.add(0)
>>> A
set([0, 1, 2, 3, 4, 5])

Quitar un elemento al conjunto

>>> A = set([0,1,2,3,4,5])
>>> A.discard(2)
>>> A
set([0, 1, 3, 4, 5])

Quitar todos los elementos de un conjunto

>>> A = set([0,1,2,3,4,5])
>>> A.clear()
>>> A
set([])

Copiar un conjunto

>>> B = A #acá decimos que B es igual a A, por lo que cualquier cambio en A tambien se producirá en B y viceversa
>>> B
set([1, 2, 3, 4, 5])
>>> A
set([1, 2, 3, 4, 5])
>>> B.add(987)
>>> B
set([1, 2, 3, 4, 5, 987])
>>> A
set([1, 2, 3, 4, 5, 987])

Probablemente no querramos que pase eso, para resolver este problema existe el método .copy()
-----------------------------------------------

>>> A = set([1,2,3,4,5])
>>> B=A.copy()
>>> B
set([1, 2, 3, 4, 5])
>>> A
set([1, 2, 3, 4, 5])
>>> B.add(987)
>>> B
set([1, 2, 3, 4, 5, 987])
>>> A
set([1, 2, 3, 4, 5])

.update
A.intersection_update(B) equivale a hacer A = A & B o A &= B

A.defference_update(B) equivale a hacer A = A -B o A -= B

A.symmetric_difference_update(B) equivale a hacer A = A ^B o A^=B

A.update(B) equivale a hacer A = A | B o A |= B