Operaciones con conjuntos

Operaciones set

• union(set): Realiza la operacion “union” entre dos conjuntos. La unión entre dos conjuntos es sumar los elementos de estos sin repetir elementos. Esta operación tambien se puede realizar con el signo “|”: set_a | set_b.
• intersection(set): Realiza la operacion “intersection” entre dos conjuntos. La intersección entre dos conjuntos es tomar unicamente los elementos en común de los conjutnos. Esta operación tambien se puede realizar con el signo “&”: set_a & set_b.
• difference(set): Realiza la operacion “difference” entre dos conjuntos. La diferencia entre dos conjuntos es restar los elementos del segundo conjunto al primero. Esta operación tambien se puede realizar con el signo “-”: set_a - set_b.
• symmetric_difference(set): Realiza la operacion “symmetric_difference” entre dos conjuntos. La diferencia simetrica entre dos conjutnos consta de restar todos los elementos de ambos exceptuando el elemento en común. Esta operación tambien se puede realizar con el signo “^”: set_a ^ set_b.

NOTA: No se pueden realizar operaciones con otras colecciones de datos, solo se puede únicamente entre conjuntos.

Operaciones con conjunto

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

# unión de los elementos
set_c = set_a.union(set_b)
print(set_c) # {'col', 'mex', 'bol', 'pe'}
print(set_a | set_b)  # {'col', 'mex', 'bol', 'pe'}

# obtener los elementos en común
set_c = set_a.intersection(set_b)
print(set_c) # {'bol'}
print(set_a & set_b)  # {'bol'}

# dejamos sólo los elementos de A
set_c = set_a.difference(set_b)
print(set_c)  # {'col', 'mex'}
print(set_a - set_b)  # {'col', 'mex'}

# es hacer una unión, sin los elementos en común
set_c = set_a.symmetric_difference(set_b)
print(set_c) # {'col', 'mex', 'pe'}
print(set_a ^ set_b) # {'col', 'mex', 'pe'}

Vengo del curso básico con Visual Studio Code y Cmder, me parece muy bueno Replit y además se puede conectar con Github, hacer commits y push.

Para poder sacar el signo de intercalacion ^ ponemos en el teclado Alt gr seguido de su teclado que esta a lado de la *“Ñ”

El signo de intercalación me salió con ‘Alt + 94’ = ^

en mi caso lo comprimi xD

set_a = {“col”,“per”,‘bol’}
set_b = {“can”,“usa”,“col”}
set_union = set_a | set_b
set_intersetion = set_a & set_b
set_difference = set_a - set_b
set_symmetric_difference = set_a ^ set_b
print(set_union)
print(set_intersetion)
print(set_difference)
print(set_symmetric_difference)

Debo decir que le tenia cierta incomodidad al curso, pero, el profe es de 10! lo explica perfecto

Fuente

Otra manera de hacer una diferencia simétrica sin hacer uso del método symmetric_difference o el operador ^ seria la siguiente:

# the symmetric difference between two sets is equal to union of them minus their intersection

# number one -> doing first an union method minus their intersection
symmetric_dif = (set_a.union(set_b) - (set_a & set_b))
print(symmetric_dif)

En Python, se pueden realizar varias operaciones entre los Sets (conjuntos), como:

1. Unión: para combinar los elementos de tres Sets en un único Set. Esta operación se puede realizar utilizando el método union() o el operador |.
2. Intersección: para encontrar los elementos que están presentes en los tres Sets. Esta operación se puede realizar utilizando el método intersection() o el operador &.
3. Diferencia: para encontrar los elementos que están en un Set pero no en los otros dos. Esta operación se puede realizar utilizando el método difference() o el operador -.
4. Simetría de diferencia: para encontrar los elementos que están en un Set o en otro, pero no en ambos. Esta operación se puede realizar utilizando el método symmetric_difference() o el operador ^.

Para hacer el signo de intercalación ( ^ ), también se puede hacer según el código ASCII con las teclas Alt + 94.

Hay que tener en cuenta que la operación de diferencia no es conmutativa, el resultado **si **depende del orden de los términos.

( set_A - set_B ) es diferente de ( set_B - set_A )

#union: Realiza la operacion “union” entre dos conjuntos. La unión entre dos conjuntos es sumar los elementos de estos sin repetir elementos. Esta operación tambien se puede realizar con el signo “|”: set_a | set_b.

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

# intersection: La intersección entre dos conjuntos es tomar unicamente los elementos en común de los conjutnos.

set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

#difference(set): Realiza la operacion “difference” entre dos conjuntos. La diferencia entre dos conjuntos es restar los elementos del segundo conjunto al primero. Esta operación tambien se puede realizar con el signo “-”: set_a - set_b.

set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

# symmetric_difference(set): Realiza la operacion “symmetric_difference” entre dos conjuntos. La diferencia simetrica entre dos conjutnos consta de restar todos los elementos de ambos exceptuando el elemento en común. Esta operación tambien se puede realizar con el signo “^”: set_a ^ set_b.

set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

gracias al aporte de un alumno puedo hacerlo con los codigos de la clases

Buenisimo! las ideas quedan plasmadas de forma clara

Funciones en los SET(conjuntos)

# add(elemento): Agrega el elemento especificado al conjunto. Por ejemplo:
set_countries = {'bolivia', 'colombia', 'argentina'}
set_countries.add('peru')
print(set_countries) # {'argentina', 'colombia', 'bolivia', 'peru'}

# clear(): Elimina todos los elementos del conjunto. Por ejemplo:
set_countries = {'bolivia', 'colombia', 'argentina'}
set_countries.clear()
print(set_countries) # set()

# copy(): Devuelve una copia superficial del conjunto. Por ejemplo:
set_countries = {'bolivia', 'colombia', 'argentina'}
set_countries_copy = set_countries.copy()
print(set_countries_copy) # {'argentina', 'colombia', 'bolivia'}

# difference(*otros): Devuelve un nuevo conjunto con los elementos del conjunto original que no están en otros. Por ejemplo:
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
diff = set1.difference(set2)
print(diff) # {1, 2}

# difference_update(*otros): Elimina del conjunto original todos los elementos que están en otros. Por ejemplo:
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set1.difference_update(set2)
print(set1) # {1, 2}

# symmetric_difference(otro): Devuelve un nuevo conjunto con los elementos que están en el conjunto o en otro, pero no en ambos. Por ejemplo:
set1 = {1, 2, 3}
set2 = {2, 3, 4}
sym_diff = set1.symmetric_difference(set2)
print(sym_diff) # {1, 4}


# discard(elemento): Elimina el elemento especificado del conjunto si está presente. Por ejemplo:
set_countries = {'bolivia', 'colombia', 'argentina'}
set_countries.discard('bolivia')
print(set_countries) # {'argentina', 'colombia'}

# intersection(*otros): Devuelve un nuevo conjunto con los elementos comunes a todos los conjuntos. Por ejemplo:
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
inter = set1.intersection(set2)
print(inter) # {3, 4}

# intersection_update(*otros): Actualiza el conjunto original conservando solo los elementos que están en otros. Por ejemplo:
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}
set1.intersection_update(set2)
print(set1) # {3, 4}

# isdisjoint(otro): Devuelve True si el conjunto no tiene elementos en común con otro. Por ejemplo:
set1 = {1, 2}
set2 = {3, 4}
result = set1.isdisjoint(set2)
print(result) # True

# issubset(otro): Devuelve True si todos los elementos del conjunto están en otro. Por ejemplo:
set1 = {1, 2}
set2 = {0, 1, 2, 3}
result = set1.issubset(set2)

Notas de clase

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

#Unión entre los dos conjuntos
set_c = set_a.union(set_b)
print(set_c)

#La unión también se puede hacer así
print(set_a | set_b)

#Intersección entre los dos conjuntos
set_d = set_a.intersection(set_b)
print(set_d)

#La intersección también se puede hacer así
print(set_a & set_b)

#Diferencia entre dos conjuntos
set_e = set_a.difference(set_b)
print(set_e)

#La diferencia también se puede hacer así
print(set_a - set_b)

#Diferencia simétrica entre dos conjuntos
set_f = set_a.symmetric_difference(set_b)
print(set_f)

#La diferencia simétrica también se puede hacer así
print(set_a ^ set_b)

Otras operaciones que suelen usarse son

# Verificar la inclusión
es_subconjunto = set_a <= set_b
print(es_subconjunto)  # Imprime False

# Verificar la igualdad
son_iguales = set_a == set_b
print(son_iguales)  # Imprime False```

Benditos diagramas de Venn, ahora veo que mis clases de probabilidad y estadística en la uni no fueron en vano.

Profesor el símbolo de intercalación que menciona se llama en conjuntos asi pero en matematicatica básica es para representar exponenciales ^.

Ejemplo 5 ^ 2 = 25

Operaciones de conjuntos

<#union
set_a = {'green', 'white', 'purple'}
set_b = {'black', 'purple'}

set_c = set_a.union(set_b)
print(set_c)

#unirlos con operadores matemáticos, el resultado es el mismmo solo hay una diferencia en la sintaxis
print(set_a | set_b)

#intersection
set_c = set_a.intersection(set_b)
print(set_c)
#segunda manera
print(set_a & set_b)

#difference
set_c = set_a.difference(set_b)
print(set_c)
#segunda manera
print(set_a - set_b)

#symmetric difference - hacer una union sin los elementos en común
set_c = set_a.symmetric_difference(set_b)
print(set_c)> 

Los conjuntos en Python admiten una variedad de operaciones que son comunes en la teoría de conjuntos y son muy útiles en la programación. Aquí están algunas de las operaciones más comunes que puedes realizar con conjuntos en Python:

1. Unión de conjuntos: La unión de dos conjuntos crea un nuevo conjunto que contiene todos los elementos presentes en ambos conjuntos.

   pythonCopy code
   conjunto1 = {1, 2, 3}
   conjunto2 = {3, 4, 5}
   
   union = conjunto1 | conjunto2  # También puedes usar conjunto1.union(conjunto2)
   
   

   Después de esto, union contendrá {1, 2, 3, 4, 5}.

2. Intersección de conjuntos: La intersección de dos conjuntos crea un nuevo conjunto que contiene solo los elementos que están presentes en ambos conjuntos.

   pythonCopy code
   conjunto1 = {1, 2, 3}
   conjunto2 = {3, 4, 5}
   
   interseccion = conjunto1 & conjunto2  # También puedes usar conjunto1.intersection(conjunto2)
   
   

   Después de esto, interseccion contendrá {3}.

3. Diferencia de conjuntos: La diferencia entre dos conjuntos crea un nuevo conjunto que contiene los elementos presentes en el primer conjunto pero no en el segundo.

   pythonCopy code
   conjunto1 = {1, 2, 3}
   conjunto2 = {3, 4, 5}
   
   diferencia = conjunto1 - conjunto2  # También puedes usar conjunto1.difference(conjunto2)
   
   

   Después de esto, diferencia contendrá {1, 2}.

4. Diferencia simétrica: La diferencia simétrica entre dos conjuntos crea un nuevo conjunto que contiene los elementos que están en uno de los conjuntos, pero no en ambos.

   pythonCopy code
   conjunto1 = {1, 2, 3}
   conjunto2 = {3, 4, 5}
   
   diferencia_simetrica = conjunto1 ^ conjunto2  # También puedes usar conjunto1.symmetric_difference(conjunto2)
   
   

   Después de esto, diferencia_simetrica contendrá {1, 2, 4, 5}.

5. Comprobación de pertenencia: Puedes verificar si un elemento está presente en un conjunto utilizando el operador in.

   pythonCopy code
   conjunto = {1, 2, 3}
   
   pertenece = 2 in conjunto  # Devuelve True si 2 está en el conjunto, de lo contrario, False
   
   

Estas son algunas de las operaciones más comunes que puedes realizar con conjuntos en Python. Los conjuntos son muy útiles para realizar operaciones de conjuntos de manera eficiente y para manejar colecciones de elementos únicos.

No mms curso bilingue

• .union() ó | : Sumar los dos conjuntos sin repetir elementos
• .intersection() ó &: Seleccionamos los elementos que comparten los dos conjuntos
• .difference() ó - : Resta de conjuntos
• .symmetric_difference() ó ^ : Hacemos una union de elementos pero quitando los elementos que se repiten

Aquí mis apuntes, espero les sirvan! (Estoy intentado usar más el inglés que sé en mis apuntes para acostumbrarme, perdón por los posibles fallos)

# OPERACIONES DE CONJUNTOS

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

# Así pues, 1º UNIMOS los sets creando 'set_c' y usando '.union'
set_c = set_a.union(set_b)
print(set_c) # {'pe', 'bol', 'col', 'mex'}
print(set_a | set_b) # We can use | (alt gr+1) instead of '.union'

# En INTERSECTION, it will show ONLY the elements in common
set_c = set_a.intersection(set_b)
print(set_c) # {'bol'}
print(set_a & set_b) # We can use '&' instead of '.intersection()'

# DIFFERENCE, remove the elements of B en el set A
set_c = set_a.difference(set_b)
print(set_c) # {'col', 'mex'}
print(set_a- set_b) # Too we can subtact (restar) directly

# DIFERENCIA SIMETRICA, remove the elements in common, and show the rest
set_c = set_a.symmetric_difference(set_b)
print(set_c) # {'col', 'pe', 'mex'}
print(set_a ^ set_b) # we can use the sig of intercalación instead of el método

Operaciones con conjuntos

Las operaciones entre conjuntos son operaciones que se realizan entre dos o más conjuntos para crear un nuevo conjunto basado en la relación entre los conjuntos originales. Python proporciona una serie de operadores y métodos que te permiten realizar varias operaciones entre conjuntos.

Aquí están algunas de las operaciones más comunes:

Unión

La unión de dos conjuntos devuelve un nuevo conjunto que contiene todos los elementos que están en al menos uno de los conjuntos originales. Puedes realizar una unión utilizando el operador | o el método union().

conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}

union = conjunto1 | conjunto2  # Usando el operador |

union = conjunto1.union(conjunto2)  # Usando el método union()

Después de la unión, union contendrá {1, 2, 3, 4, 5}.

Intersección

La intersección de dos conjuntos devuelve un nuevo conjunto que contiene todos los elementos que están en ambos conjuntos originales. Puedes realizar una intersección utilizando el operador & o el método intersection().

conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}

interseccion = conjunto1 & conjunto2  # Usando el operador &

interseccion = conjunto1.intersection(conjunto2)  # Usando el método intersection()

Después de la intersección, interseccion contendrá {3}.

Diferencia

La diferencia entre dos conjuntos devuelve un nuevo conjunto que contiene todos los elementos que están en el primer conjunto pero no en el segundo. Puedes realizar una diferencia utilizando el operador - o el método difference().

conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}

diferencia = conjunto1 - conjunto2  # Usando el operador -

diferencia = conjunto1.difference(conjunto2)  # Usando el método difference()

Después de la diferencia, diferencia contendrá {1, 2}.

Diferencia simétrica

La diferencia simétrica entre dos conjuntos devuelve un nuevo conjunto que contiene todos los elementos que están en uno de los conjuntos pero no en ambos. Puedes realizar una diferencia simétrica utilizando el operador ^ o el método symmetric_difference().

conjunto1 = {1, 2, 3}
conjunto2 = {3, 4, 5}

diferencia_simetrica = conjunto1 ^ conjunto2  # Usando el operador ^

diferencia_simetrica = conjunto1.symmetric_difference(conjunto2)  # Usando el método symmetric_difference()

Después de la diferencia simétrica, diferencia_simetrica contendrá {1, 2, 4, 5}.

union: “|”: set_a | set_b.
intersection: “&”: set_a & set_b.
difference: “-”: set_a - set_b.
symmetric_difference: “^”: set_a ^ set_b.

este sintaxis me funciono les comparto
set_c = set_a | set_b
print(set_c)

Operaciones con conjuntos, mis apuntes

#Operaciones entre conjuntos:
#UNION: unifica +2 sets
set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

print('-'*10)
print('--Operadores de Conjunto--')
print('-'*10)
#Forma 1: Metodo Union
set_union = set_a.union(set_b)
print('Forma 1 con union: ', set_union)
#Forma 2: con un operador (|)
print('Forma 2 con |: ', set_a | set_b)
print('-' * 10)
#INTERSECTION: Elementos en común
set_intersection = set_a.intersection(set_b)
#Forma 1: Metodo Intersection
print('Forma 1 con intersection: ', set_intersection)
#Forma 2: con un operador (&)
print('Forma 2 con &: ', set_a & set_b)
print('-'*10)

#DIFFERENCE: Muestra los elementos del 1er conjunto removiendo la interseccion y set_b
set_difference = set_a.difference(set_b)
#Forma 1: Metodo difference
print('Forma 1 con difference: ', set_difference)
#Forma 2: con un operador (-)
print('Forma 2 con -: ', set_a - set_b)
print('-'*10)

#SYMMETRIC DIFFERENCE: Muestra los elementos externos removiendo los datos en común.
set_sym_difference = set_a.symmetric_difference(set_b) 
#Forma 1: Metodo difference
print('Forma 1 con symmetric difference: ', set_sym_difference)
#Forma 2: con un operador (^) intercalacion
print('Forma 2 con ^: ', set_a ^ set_b)

# definir 2 conjuntos a y b
set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

# unir a y b con el método unión
set_c = set_a.union(set_b)
print(set_c)                      # => {'col', 'pe', 'mex', 'bol'}

# unir a y b con el operador |
print(set_a | set_b)              # => {'col', 'pe', 'mex', 'bol'}

# interseccipon entre a y b usando el método intersection
set_c = set_a.intersection(set_b)
print(set_c)                      # => {'bol'}

# interdección de a y b usando el operador &
print(set_a & set_b)              # => {'bol'}

# restar a de b usando el método difference
set_c = set_a.difference(set_b)
print(set_c)                      # => {'col', 'mex'}

# restar a de b usando el operador -
print(set_a - set_b)               # => {'col', 'mex'}

# diferrenca simetrica de a y b con el método symmetric_difference
set_c = set_a.symmetric_difference(set_b)
print(set_c)                       # => {'col', 'pe', 'mex'}

# diferencia simétrica de a y b con el operador ^
print(set_a ^ set_b)               # => {'col', 'pe', 'mex'}

Dejo mi aporte de lo que escribí en clase:

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

# Puedes tomar 2 (o más) conjuntos y unirlos?

set_c = set_a.union(set_b)
# y más facil?
print(set_a | set_b)

##############################

# Bueno, ahora quiero intersecarlos
set_c = set_a.intersection(set_b)
# Y más facil?
print(set_a & set_b)

##############################

# Ahora diferenciarlos
set_c = set_a.difference(set_b)
# Y más facil?
print(set_a - set_b)
##############################

# Ahora diferenciarlos simetricamente
set_c = set_a.symmetric_difference(set_b)

# Y más facil?

print(set_a ^ set_b)

# Esto si que es impresionante

#union
#se unen los elementos de los dos conjuntos

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

set_c = set_a.union(set_b)
print(set_c)

#con operaciones

print(set_a | set_b) 

#intersection
#tiene en cuentalos elementos en comun para hacerla union

set_c= set_a.intersection(set_b)

print(set_c)

#con operaciones

print(set_a & set_b)

#difference
#dejarlos elementos del primer conjunto, removiendo los del segundo.

set_c = set_a.difference(set_b)
print(set_c)

#con operaciones

print(set_a - set_b)

#Symmetric Difference
#Hacer una union sin los elementos en comun 

set_c = set_a.symmetric_difference(set_b)
print(set_c)

#con operaciones

print(set_a ^ set_b)

Depende la necesidad de usar los operadores o la functions

update(*others)
set |= other

Estos son solo algunos ejemplos de las operaciones que puedes realizar con conjuntos en Python. La clase set también proporciona otros métodos y operadores útiles, como issubset(), issuperset(), etc. Puedes consultar la documentación oficial de Python para obtener más información sobre los métodos y operadores disponibles: https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset

#Unir dos conjuntos
Conjunto_A = {“Colombia”,“Venezuela”,“Ecuador”,“Chile”}
Conjunto_B = {“Peru”,“Chile”}

Conjunto_Resultado = Conjunto_A.union(Conjunto_B)
print(Conjunto_Resultado)
print(Conjunto_A | Conjunto_B )

#Interseccion conjunto

Conjunto_Resultado=Conjunto_A.intersection(Conjunto_B)
print(Conjunto_Resultado)
print(Conjunto_A & Conjunto_B)

#Diferencia conjunto Resta del conjunto A-B quitando el elmento de B en A

Conjunto_Resultado=Conjunto_A.difference(Conjunto_B)
print(Conjunto_Resultado)
print(Conjunto_A-Conjunto_B)

#Diferencia simetrica sin tener en cuenta los elementos repetidos de los dos conjuntos
Conjunto_Resultado = Conjunto_A.symmetric_difference(Conjunto_B)
print(Conjunto_Resultado)
print(Conjunto_A ^ Conjunto_B)

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}
# union
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

# Intersection
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

# Difference
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

# Symmetric Difference
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

Operaciones de conjuntos

En Python, los conjuntos (sets) tienen soporte integrado para una variedad de operaciones de conjuntos. A continuación se presentan algunas de las operaciones de conjuntos más comunes en Python:

Unión de conjuntos

La unión de dos conjuntos se realiza utilizando el operador | o la función union(). El resultado es un nuevo conjunto que contiene todos los elementos presentes en ambos conjuntos, sin duplicados.

a = {1, 2, 3}
b = {3, 4, 5}
union_ab = a | b
print(union_ab)  # Salida: {1, 2, 3, 4, 5}

# También se puede utilizar la función union()
union_ab = a.union(b)
print(union_ab)  # Salida: {1, 2, 3, 4, 5}

Intersección de conjuntos

La intersección de dos conjuntos se realiza utilizando el operador & o la función intersection(). El resultado es un nuevo conjunto que contiene sólo los elementos que están presentes en ambos conjuntos.

a = {1, 2, 3}
b = {3, 4, 5}
interseccion_ab = a & b
print(interseccion_ab)  # Salida: {3}

# También se puede utilizar la función intersection()
interseccion_ab = a.intersection(b)
print(interseccion_ab)  # Salida: {3}

Diferencia de conjuntos

La diferencia de dos conjuntos se realiza utilizando el operador - o la función difference(). El resultado es un nuevo conjunto que contiene sólo los elementos que están presentes en el primer conjunto pero no en el segundo.

a = {1, 2, 3}
b = {3, 4, 5}
diferencia_ab = a - b
print(diferencia_ab)  # Salida: {1, 2}

# También se puede utilizar la función difference()
diferencia_ab = a.difference(b)
print(diferencia_ab)  # Salida: {1, 2}

Diferencia simétrica de conjuntos

La diferencia simétrica de dos conjuntos se realiza utilizando el operador ^ o la función symmetric_difference(). El resultado es un nuevo conjunto que contiene sólo los elementos que están presentes en uno de los conjuntos pero no en ambos.

a = {1, 2, 3}
b = {3, 4, 5}
diferencia_simetrica_ab = a ^ b
print(diferencia_simetrica_ab)  # Salida: {1, 2, 4, 5}

# También se puede utilizar la función symmetric_difference()
diferencia_simetrica_ab = a.symmetric_difference(b)
print(diferencia_simetrica_ab)  # Salida: {1, 2, 4, 5}

Estas son solo algunas de las operaciones de conjuntos disponibles en Python. También hay otras operaciones como issubset(), issuperset(), copy(), entre otras.

# declaramos los conjuntos 
set_a = {"col", "mex", "bol"}
set_b = {"pe", "bol"}
print("El conjunto A es: ", set_a)
print("El conjunto B es: ", set_b)

# union 
# forma 1
set_c = set_a.union(set_b)
print("Forma 1, unión ", set_c)
# forma 2
set_d = set_a | set_b
print("Forma 2, unión: ", set_d)

#interseccion 
# forma 1
set_c = set_a.intersection(set_b)
print ("Forma 1, intersección:  ", set_c)
# forma 2
set_d = set_a & set_b
print("Forma 2, interesección:  ", set_d)

# diferencia
set_c = set_a.difference(set_b)
print("Forma 1, diferencia:  ", set_c)
set_d = set_a - set_b
print("Forma 2, diferencia:  ", set_d)

# diferencia simetrica 
# forma 1
set_c = set_a.symmetric_difference(set_b)
print("Forma 1, diferencia simetria: ", set_c)
set_d = set_a ^ set_b
print("Forma 2, diferencia simetria: ", set_d)

Para poder sacar el signo de intercalación ^ ponemos en el teclado Alt gr seguido de su teclado que esta a lado de la “Ñ”

DATO EXTRA
https://elcodigoascii.com.ar/codigos-ascii/intercalacion-acento-circunflejo-codigo-ascii-94.html

Operaciones con Conjuntos

#conjuntos a y b
set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

#union
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

#intersection
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

#difference
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

#symetric difference
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

# UNIÓN

# Unir el conjunto A y B
set_c = set_a.union(set_b)
print(set_c)

# Otra forma de unir conjuntos
print(set_a | set_b)

# INTERSECIÓN

# Intersección del conjunto A y B
set_c = set_a.intersection(set_b)
print(set_c)

# DIFERENCIA

# Diferencia del conjunto A y B
set_c = set_a.difference(set_b)
print(set_c)

# Otra forma usando operadores
print(set_a - set_b)

# DIFERENCIA SIMÉTRICA

# Diferencia simétrica de los conjuntos A y B
set_c = set_a.symmetric_difference(set_b)
print(set_c)

# Otra forma con operadores
print(set_a ^ set_b)

Las operaciones con conjuntos son un conjunto de operaciones matemáticas que se pueden realizar en conjuntos. En Python, los conjuntos tienen incorporados métodos para realizar estas operaciones de manera eficiente.

Aca les dejo ejercicios para que practiquen:
¡Claro! A continuación, te proporcionaré algunos conjuntos base que puedes usar para los ejercicios:

Conjunto A = {1, 2, 3, 4, 5}
Conjunto B = {4, 5, 6, 7, 8}
Conjunto C = {3, 6, 9, 12}
Conjunto D = {1, 3, 5, 7}

Ahora sí, aquí te dejo los ejercicios:

Nivel fácil:

Dado el conjunto A, imprimir su longitud (número de elementos).
Dados los conjuntos A y B, imprimir la unión y la intersección.
Dado el conjunto B, imprimir los elementos en orden inverso.
Nivel intermedio:

Dados los conjuntos A y B, imprimir los elementos que están en A pero no en B.
Dados los conjuntos A y C, imprimir los elementos que están en A y en C, pero no en B.
Dados los conjuntos B y D, imprimir los elementos que están en ambos conjuntos y que son impares.
Nivel avanzado:

Dados los conjuntos A, B y C, imprimir los elementos que están en al menos dos conjuntos.
Dados los conjuntos A, B y C, imprimir los elementos que están en exactamente dos conjuntos.
Dados los conjuntos A, B y C, imprimir los elementos que están en A o B, pero no en C.

set_a = {'col','mex','bol'}
set_b = {'pe', 'bol'}

#union
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

#intesrsection
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

#difference
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

#symmetric difference
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

HOLA!!! Aqui les dejo mi codigo espero ayude!

jumpline = '-' * 25

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}
print('SET A => ',set_a) # {'col', 'mex', 'bol'}
print('SET B => ',set_b) # {'pe', 'bol'}
print(jumpline)

# Puedo unir dos sets con .union()
set_c = set_a.union(set_b)
print(set_c) # {'col', 'pe', 'mex', 'bol'}

# Tambien puedo unir dos sets con |
print(set_a | set_b) # {'col', 'pe', 'mex', 'bol'}
print(jumpline)

# Puedo interceptar los elementos en comun con .intersection()
set_d = set_a.intersection(set_b)
print(set_d) # {'bol'}

# Igualmente el singno & hace la funcion de intersection
print(set_a & set_b) # {'bol'}
print(jumpline)

# El metodo de operacion .difference() me retorna los elementos del set a que no esten en el set b
set_e = set_a.difference(set_b)
print(set_e) # {'col', 'mex'}

# Tambien puedo hacer la diferencia con el signo -
print(set_a - set_b)  # {'col', 'mex'}
print(jumpline)

# El metodo Symmetric Difference nos retorna una union sin los elementos en comun
set_f = set_a.symmetric_difference(set_b)
print(set_f) # {'col', 'pe', 'mex'}

# Tambien puedo tener el Symmetric Difference con el signo ^
print(set_a ^ set_b) # {'col', 'pe', 'mex'}

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

# .union genera una union entre los conjuntos para que no se repitan datos, hace un conjunto mas grande
# .union (es un metodo) ; |(es un operador) no cambia en nada
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

# .intersection muestra los elementos que tienen en comun los dos conjuntos (individualmente)

# .intersection(metodo) y (operador) &
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

# .diffrence muestra los elementos que no estan en ambos conjuntos, se le restan los elementos de a - b pero solo muestra el conjunto a
# .difference(metodo) y (operador) -
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

# .symmetric_difference quita los valores que son iguales en ambos conjuntos pero genera un conjunto con los elementos del conjunto a y b 
# .symmetric_difference(metodo) y (operador) ^

set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)```

Excelente para enseñar a los niños

set_a = {“colombia”, “mexico”, “bolivia”}
set_b = {“peru”, “bolivia”}

#unir conjuntos sin que se repitan los elementos
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

#mantiene los elementos que estan en ambos conjuntos
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

#eliminar del conjunto a todos los elementos del conjunto b
set_c = set_a.difference(set_c)
print(set_c)
print(set_a - set_b)

#mantiene solo los elementos que estan en ambos conjuntos
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

## set entre conjuntos 
set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}
# unen los dos conjuntos
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

# da los elementos comunes entre los dos
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

# da los elementos que existan solo en el conjunto set_a
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

# da los elementos que NO son comunes
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

Estuve esperando que la simplificación de la unión fuese con el + (de la misma forma que con las listas), aunque su actualización para reemplazar el operador | por el +, daría para todo un debate, ya que de alguna forma la unión una especie de dualidad con la intersección (ya que se representa con el símbolo &).

Y de forma curiosa los operadores | y &, en otros lenguajes de programación reemplazan los and y or que se usan en python.

El atajo de teclado para la operación de Diferencia Simétrica es también llamado “Intercalación, o Acento Circunflejo”, y es:
ALT + 94

Vale la pena recordar que dado que set() no permite registros duplicados

Creí que no habría operador para diferencia simétrica, así que pausé el video e intenté hacerlo por mi cuenta. Me salió esto Jajaja

print((set_a - set_b) | (set_b - set_a))

#Operaciones con conjuntos
set_a={"col","mex","bol"}
set_b={"pe","bol"}

#Union
set_c=set_a.union(set_b)
print(set_c)
print(set_a | set_b)

#Interseccion
set_d=set_a.intersection(set_b)
print(set_d)
print(set_a & set_b)

#Diferencia
set_e=set_a.difference(set_b)
print(set_e)
print(set_a - set_b)

#Diferencia simetrica
set_f=set_a.symmetric_difference(set_b)
print(set_f)
print(set_a ^ set_b)

set_a = {'col', 'mx', 'bol'}
set_b = {'pe', 'col'}

#Unir conjuntos por método y operador
set_c = set_a.union(set_b)
set_c = set_a | set_b

#Intersección por método y operador
set_c = set_a.intersection(set_b)
set_c = set_a % set_b

#Diferencia por método y operador
set_c = set_a.difference(set_c)
set_c = set_a - set_b

#Diferencia simétrica
set_c = set_a.symmetric_difference(set_b)
set_c = set_a ^ set_b

Operador de intercalación (Teclado: Español Latinoamérica)

Para todos los que usan la distribución de teclado: Español (Latinoamérica) la combinación de teclas para escribir el operador de intercalación es: AltGR + [{^

Creo que nunca vi esto en ningun curso, cool.

El signo de intercalación o de potencia se puede escribir utilizando el código ASCII de la siguiente manera: ALT 94 (tecla ALT oprimida todo el tiempo y typeamos 94)

^

Y tenemos nuestro signo de intercalación.

Espero les sea de ayuda.

TIP: Para sacar el ^ en Mac (teclado latinoamericano), hay que darle a la tecla alt (option) y el ^ está al lado de la Ñ:

Saludos. 😄

Los métodos de conjuntos! 😄
https://www.w3schools.com/python/python_sets_methods.asp

set_a = {“col”,“mex”,“bol”}
set_b = {“pe”,“bol”}
set_c = set_a.union(set_b)
#UNION CON | o .union
print(set_c)
print(type(set_c))
print(len(set_c))
print(set_a | set_b)

#INTERSECCION >>>.intersection<<<
set_d = set_a.intersection(set_b)
print(set_d)
print(type(set_d))
print(len(set_d))
print(set_a & set_b)
#Diferencia
set_e = set_a.difference(set_b)
print(set_e)
print(type(set_e))
print(len(set_e))
print(set_a - set_b)

#Diferencia simetrica
set_f = set_a.symmetric_difference(set_b)
print(set_f)
print(set_a ^ set_b)

set_a={'col','mex','bol'}
set_b = {'pe','bol'}

# Union
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

# Inersection
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

# Difference
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

# Symmetric Difference
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

Espero que con este programa puedan ver como funciona

set_a = set()
set_b = set()
set_c = set()

def agregar():
    respuesta = 0
    while respuesta == 0:
        
        menuset = """
        1.set a
        2.set b"""
        print(menuset)
        opc= int(input("seleccione una opcion"))

        if opc==1:
            repe=0
            while repe ==0:
                a =input('escriba un pais')
                set_a.add(a)
                repe = int(input("0 pare ingresar otro pais"))

        if opc == 2:
            repe = 0
            while repe==0:
                
                b = input('escriba un pais')
                set_b.add(b)
                repe = int(input("0 para ingresar otro pais"))
        respuesta = input("oprima 0 para continuar o otra tecla para salir"  )

def mostrar():
    respuesta = 0
    while respuesta == 0:
        print(set_a)
        print(set_b)
        respuesta = input("oprima 0 para continuar o otra tecla para salir")

def unir():
    respuesta = 0
    while respuesta == 0:
        set_c = set_a.union(set_b)
        print(set_c)
        respuesta = input("oprima 0 para continuar o otra tecla para salir")

def interseccion():
    respuesta = 0
    while respuesta == 0:
        set_c = set_a.intersection(set_b)
        print(set_c)
        respuesta = input("oprima 0 para continuar o otra tecla para salir")

def diferenciasimetrica():
    respuesta = 0
    while respuesta == 0:
        # diferencia simetrica
        set_c = set_a.symmetric_difference(set_b)
        print(set_c)
        respuesta = input("oprima 0 para continuar o otra tecla para salir")

def diferencia():
    respuesta = 0
    while respuesta == 0:
        # operacion de diferencia
        set_c = set_a.difference(set_b)
        print(set_c)
        respuesta = input("oprima 0 para continuar o otra tecla para salir")

def eliminar():
    respuesta = 0
    while respuesta == 0:
        c= input("Que pais quiere eliminar")
        set_c.remove(c)
        respuesta = input("oprima 0 para continuar o otra tecla para salir")


if __name__  == "__main__":
    respuesta = 0
    while respuesta == 0:
        menu ="""
        1.agregar elementos
        2.mostrar elementos
        3.unir los set
        4.hacer interseccion en a y b
        5.diferencia simetrica
        6.diferencia
        7.eliminar"""

        print(menu)
        opc = int(input("Seleccione una opcion valida"))

        if opc == 1:
            agregar();

        elif opc == 2:
            mostrar();

        elif opc == 3:
            unir();

        elif opc == 4:
            interseccion();

        elif opc == 5:
            diferenciasimetrica();

        elif opc == 6:
            diferencia();

        elif opc == 7:
            eliminar();

        else:
            print("opcion no valida")
            respuesta = int(input("oprima 0 para volver al menu"))

""" set operations """
set_a = {2, 3, 5, 7}
print("set_a =", set_a)

set_b = {5, 11, 13}
print("set_b =", set_b)

# union
print("-" * 35)
set_c = set_a.union(set_b)
print("set_c = set_a.union(set_b) =", set_c)
set_c = set_a | set_b
print("set_c = set_a | set_ b =", set_c)

# intersection
print("-" * 35)
set_d = set_a.intersection(set_b)
print("set_d = set_a.intersection(set_b) =", set_d)
set_d = set_a & set_b
print("set_d = set_a & set_b =", set_d)

# difference
print("-" * 35)
set_e = set_a.difference(set_b)
print("set_e = set_a.difference(set_b) =", set_e)
set_e = set_a - set_b
print("set_e = set_a - set_b =", set_e)

print("-" * 15)
set_e = set_b.difference(set_a)
print("set_e = set_b.difference(set_a) =", set_e)
set_e = set_b - set_a
print("set_e = set_b - set_a =", set_e)

# symetric difference
print("-" * 35)
set_f = set_a.symmetric_difference(set_b)
print("set_f = set_a.symetric_difference(set_b) =", set_f)
set_f = set_a ^ set_b
print("set_f = set_a ^ set_b =", set_f)

Minuto 7:18 Para sacar el signo de intercalación ^ aprieten alt + 94

.
El teclado en español se me hacia demasiado incomodo porque siempre tenia que estar googleando caracteres, hasta que me di cuanta que la distribución de un teclado ANSI tiene todos los caracteres que se usan mientras programo, así que decidí cambiar el idioma del teclado a ingles (estados unidos).
.
.

.
.
Y como en su momento compre el teclado mas barato que encontré, la solución económica fue imprimir los caracteres ANSI y pegárselo con celoven (cinta adhesiva) y así quedo:
.
.

.
.
Puede que para este 31 de diciembre solo pueda desear un Feliz ano nuevo pero en mi opinión y si me lo preguntan el cambio valió la pena.

#----------- Operaciones con Sets--------------------

set_a = {'colombia','mexico', 'bolivia'}
set_b = {'peru', 'colombia'}

#Union --> union(), |
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)
--> {'colombia', 'peru', 'mexico', 'bolivia'}
		{'colombia', 'peru', 'mexico', 'bolivia'}

#Interseccion --> intersection(), &
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)
--> {'colombia'}
		{'colombia'}

#Diferencia --> difference(), -
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)
--> {'mexico', 'bolivia'}
		{'mexico', 'bolivia'}

#Diferencia Simetrica --> symmetric_difference, ^
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)
--> {'mexico', 'bolivia', 'peru'}
		{'mexico', 'bolivia', 'peru'}

Mis anotaciones 7w7

# Operacon entre conjuntos

set_a = {'col', 'mex', 'bol'}
set_b= {'pe', 'bol'}

## Union de conjuntos (union)
set_c = set_a.union(set_b)
print(set_c)

# Union con caracter " | "
print(set_a | set_b)

## Interseccion
set_c = set_a.intersection(set_b)
print(set_c)

# Interseccion con caracter ' & '
print(set_a & set_b)

## Diferencia
set_c = set_a.difference(set_b)
print(set_c)

# Diferencia con caracter ' - '
print(set_a - set_b)

## diferencia simetrica
set_c = set_a.symmetric_difference(set_b)
print(set_c)

# Diferencia simetrica caracter ' ^ '
print(set_a ^ set_b)

Resumen funciones de conjuntos

Funciones de actualización de conjuntos:

• .add(elemt) – Añadimos un elemt al conjunto
• .remove(elemt) – Elimina elemt SI ESTA PRESENTE, de lo contrario, eleva una excepción de tipo KeyError.
• .discard(elemt) – Elimina elemt si esta presente, no eleva excepción alguna.
• .pop() – Elimina y devuelve un elemento arbitrario de setA. KeyError si el conjunto esta vacío.
• .clear() – Elimina todos los elementos de setA
• .update(*elemt) – añade los elementos de un iterador al conjunto. |= para concatenar
• setA.difference_update(*elemt) – elimina los elementos encontrados en el iterador elem, que estén en setA
• setA.symmetric_difference_update(setB) – actualiza setA manteniendo solo los elementos encontrados en setA o en setB pero que no esten en ambos.

Operadores para Conjuntos

Nos ayudan a realizar comprobaciones sobre conjuntos, el tamaño, si un elemento pertenece o no, entre otros.

• len(setA) – número de elementos que tiene el conjunto

• elemt in setA – True si el elemt está presente False en caso contrario

• elemt not in setA – True si el elemt no está presente False en caso contrario.

• setA.isdisjoint(setB) – True si no existen elementos en común entre los dos conjuntos. No hay elementos en su intersección.

• setA.issubset(setB) – True si todos los de setA estan en setB. -----> setA <= setB — setA < setB

• setA.issuperset(setB) – True si todos los elementos de de setB estan en setA. ----> setA >= setB — setA > setB

Operaciones con conjuntos

• Unión – une dos conjuntos - set_a.union(set_b). ------ Alternativa set_a | set_b
• Intersección – toma los elementos en común de los conjuntos intersectados. set_a.intersection(set_b) ---- Alternativa set_a & set_b
• Diferencia – toma los elementos de A que no esten en B. set_a.difference(set_b) — Alternativa set_a - set_b (signo menos -)
• Diferencia simétrica – Un nuevo conjunto sin los valores que se intersectaron entre A y B. set_a.symmetric_difference(set_b). — Alternativa set_a ^ set_b

def run():
    set_a = {"col", "mex", "bol"}
    set_b = set(["pe", "bol"])

    # La union de dos conjuntos es un nuevo conjunto con los datos del primero y el segundo conjunto sin duplicar.
    set_c = set_a.union(set_b)
    print(set_c)
    print(set_a | set_b)

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # La intersección solo imprime los elementos que tienen en comun una sola vez, sin duplicar.
    set_c = set_a.intersection(set_b)
    print(set_c)
    print(set_a & set_b)

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # La diferencia de conjunto lo que hará sera quitar los elementos de "b" a "a" inclutyendo los que tienen en común.
    set_c = set_a.difference(set_b)
    print(set_c)
    print(set_a - set_b)

    #---------------------------------------------------------------------------------------------------------------------------------------------#

    # La diferencia simetrica entre dos conjuntos es la union de los conjuntos sin su intersección.
    set_c = set_a.symmetric_difference(set_b)
    print(set_c)
    print(set_a ^ set_b)

if __name__ == "__main__":
    run()

signo de intercalación lo sacan con alt + 94 ^

• set_c= set_a.union(set_b) : Une set_a y set_b en set_c

or set_c= (set_a | set_b)

ser_c= ser_a.intersection(set_b): Interseccion.

or set_c=(set_a & set_b)

• A-B=Todo de A menos de B.

set_c= set_a.difference(set_b)

or
set_c= (set_a - set_b)

• Diferencia Simetrica

set_c= se_a.symmetric_difference(set_b)

or

set_c=(set_a ^ set_b)

set_a = {'col','mex','bol'}
set_b = {'pe','bol'}

set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

Operaciones con conjuntos

set_a = {'col', 'mex', 'bol'}
set_b = {'pe', 'bol'}

# Union
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b) 

# Interseccion
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

# Diferencia
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

#Diferencia simetrica
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

perdonen este curso lo actualizaron o pusieron hace poco?, creo que yo ya lo habia hecho y aprobado, pero me aparece como si no lo ubiera visto ni aprobado

Hermoso como todo python:

set_a = {'uru', 'par', 'ecu','bras'}
set_b = {'bol', 'col','chil', 'bras'}

#join
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

#interseccion
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

#difference
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

#symetric difference
set_c = set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)

Me acorde de Full Outer Exclusive

Hola de nuevo! Dejo mi paso a paso de esta clase:

#Se definen los conjuntos:
set_a= {"col","mex","bol"}
set_b= {"pe","bol"}

#Unión entre conjuntos:
set_c = set_a.union(set_b)
print(set_c)
print(set_a | set_b)

#Intersección de conjuntos (valor en común):
set_c = set_a.intersection(set_b)
print(set_c)
print(set_a & set_b)

#Resta de conjuntos.
set_c = set_a.difference(set_b)
print(set_c)
print(set_a - set_b)

#Diferencia simétrica. Retira el(los) elemento(s) en común.
set_c =set_a.symmetric_difference(set_b)
print(set_c)
print(set_a ^ set_b)