Introducci贸n

1

El Zen de Python

Conjuntos

2

Sets

3

Modificando conjuntos

4

Operaciones con conjuntos

5

Playgrounds: Elimina elementos duplicados usando conjuntos

Comprehensions

6

List Comprehension

7

Dictionary Comprehension

8

Dictionary Comprehension: condition

9

Playgrounds: Crea una lista usando List Comprehension

10

Lists vs. Tuples vs. Sets

Funciones

11

Funciones

12

Funciones: return

13

Par谩metros por defecto y m煤ltiples returns

14

El scope

15

Refactor game

16

Playgrounds: Tienda de Tecnolog铆a

17

Funciones an贸nimas: lambda

18

Higher order function: una funci贸n dentro de otra funci贸n

19

Map

20

Map con diccionarios

21

Reto: map con inmutabilidad

22

Playgrounds: Multiplica todos los elementos por dos

23

Filter

24

Playgrounds: Retorna solo palabras de 4 letras y m谩s

25

Reduce

M贸dulos

26

M贸dulos

27

Mis propios m贸dulos

28

M贸dulos como scripts: __name__ y __main__

29

Paquetes

30

Playgrounds: Calcular la suma de todas las compras

Manipulaci贸n de archivos y errores

31

Iterables

32

Errores en Python

33

Manejo de excepciones

34

Playgrounds: Captura la excepci贸n: ZeroDivisionError

35

Leer un archivo de texto

36

Escribir en un archivo

37

Leer un CSV

38

Playgrounds: Lee un CSV para calcular el total de gastos

Gr谩ficas en Python

39

Creando una gr谩fica

40

Reto: graficando la poblaci贸n de un pa铆s

41

Reto: graficando la poblaci贸n mundial

Pr贸ximos pasos

42

隆Conoce otros proyectos de este curso!

43

Reconoce tu proceso y certif铆cate

44

Toma el Curso de PIP y Entornos Virtuales con Python

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Operaciones con conjuntos

4/44
Recursos

Aportes 83

Preguntas 9

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Operaciones set

  • union(set): Realiza la operacion 鈥渦nion鈥 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 鈥渋ntersection鈥 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 鈥渄ifference鈥 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 鈥渟ymmetric_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 鈥楢lt + 94鈥 = ^

en mi caso lo comprimi xD

set_a = {鈥渃ol鈥,鈥減er鈥,鈥榖ol鈥檥
set_b = {鈥渃an鈥,鈥渦sa鈥,鈥渃ol鈥潁
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

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)
Me encanta la pizarra donde se explican las operaciones de los conjuntos.

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 鈥渦nion鈥 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 鈥渄ifference鈥 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 鈥渟ymmetric_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 = {鈥淐olombia鈥,鈥淰enezuela鈥,鈥淓cuador鈥,鈥淐hile鈥潁
Conjunto_B = {鈥淧eru鈥,鈥淐hile鈥潁

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 = {鈥渃olombia鈥, 鈥渕exico鈥, 鈥渂olivia鈥潁
set_b = {鈥減eru鈥, 鈥渂olivia鈥潁

#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 鈥淚ntercalaci贸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. 馃槃

set_a = {鈥渃ol鈥,鈥渕ex鈥,鈥渂ol鈥潁
set_b = {鈥減e鈥,鈥渂ol鈥潁
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)