En este tutorial, aprenderá los conceptos básicos de Conjuntos de Python y los diversos métodos de conjuntos que puede usar para modificar conjuntos de Python.
Los conjuntos son una de las estructuras de datos integradas en Python. Cuando necesite trabajar con una colección de elementos que no se repiten, utilizará el conjunto como la estructura de datos de acceso.
En las siguientes secciones, repasaremos los conceptos básicos de los conjuntos de python y los métodos de conjunto que puede usar para trabajar con ellos. Luego aprenderemos cómo realizar operaciones de conjuntos comunes en Python.
Vamos a empezar!
Basics of Python Sets
En Python, un conjunto es una colección desordenada de elementos que no se repiten. Esto significa que todos los elementos de un conjunto deben ser distinto.
Puede agregar y eliminar elementos de un conjunto; por lo tanto, el conjunto es un colección mutable. Puede contener elementos de diferentes tipos de datos. Sin embargo, los elementos individuales de un conjunto deben ser mezclable.
En Python, se dice que un objeto es hashable si su valor hash nunca cambia. La mayoría de los objetos inmutables como cadenas de pitón, tuplas y diccionarios son hash.
Aprenderemos a crear conjuntos en detalle. Por ahora, considere los siguientes dos conjuntos:
py_set = {0,1,2,(2,3,4),'Cool!'}
py_set = {0,1,2,[2,3,4],'Oops!'}
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-40-2d3716c7fe01> in <module>()
----> 1 py_set = {0,1,2,[2,3,4],'Oops!'}
TypeError: unhashable type: 'list'El primer conjunto contiene tres números, una tupla y una cadena. La inicialización del conjunto se ejecuta sin errores. Mientras que el segundo conjunto contiene una lista en lugar de una tupla. Una lista es una colección mutable, no se puede codificar y la inicialización arroja un TypeError.
📑 Poniéndolo todo junto, podemos definir un conjunto de Python como un mudable colección de distinto y mezclable elementos.
How to Create a Python Set
Comenzaremos aprendiendo cómo crear un conjunto en Python.
#1. Uso de inicialización explícita
Puede crear un conjunto en Python especificando los elementos del conjunto, separados por comas (,) y encerrado entre un par de llaves {}.
py_set1 = {'Python','C','C++','JavaScript'}
type(py_set1)
# Output
setSi has trabajado con Listas de Python antes, lo sabes [] inicializa una lista vacía. Aunque un conjunto de Python está encerrado entre un par de llaves {}, Que no puede usa un par {} para inicializar un conjunto. Esto es porque {} it inicializa un Diccionario de Python y no un conjunto de Python.
py_set2 = {}
type(py_set2)
# Output
dictPuede volver a llamar al type() función para verificar que py_set es un diccionario (dict).
#2. Usando la función set()
Si desea inicializar un conjunto vacío y luego agregarle elementos, puede hacerlo usando el set() función.
py_set3 = set()
type(py_set3)
# Output
set#3. Conversión de otros iterables en un conjunto
Otra forma de crear conjuntos es convertir otros iterables, como listas y tuplas, en conjuntos, usando set(iterable).
py_list = ['Python','C','C++','JavaScript','C']
py_set4 = set(py_list)
print(py_set4)
# {'C++', 'C', 'JavaScript', 'Python'} # repeating element 'C' removed
type(py_set4)
# setEn el ejemplo anterior, py_list contiene 'C' dos veces. Pero en py_set4, 'C' aparece solo una vez, ya que el conjunto es una colección de elementos distintos. Esta técnica de fundición en el conjunto se utiliza a menudo para eliminar duplicados de las listas de Python.
How to Add Elements to a Python Set
Comencemos por crear un conjunto vacío. py_set y trabaje con él durante el resto de este tutorial.
py_set = set()
len(py_set) # returns the length of a set
# Output
0#1. Usando el método .add()
Para agregar elementos a un conjunto, puede usar el
.add()método.set.add(element)añade elemento al conjunto.
Para mayor claridad, agregaremos elementos al conjunto de Python e imprimiremos el conjunto en cada paso.
▶️ Agreguemos la cadena 'Python' como un elemento para py_set.
py_set.add('Python')
print(py_set)
# Output
{'Python'}A continuación, añadiremos otro elemento.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}Es importante comprender que el .add() El método solo agrega un elemento al conjunto si aún no está presente. Si el conjunto ya contiene el elemento que desea agregar, la operación de agregar no tiene efecto.
Para verificar esto, intentemos agregar 'C++' a py_set.
py_set.add('C++')
print(py_set)
# Output
{'Python', 'C++'}El conjunto contiene 'C++', por lo que la operación de agregar no tiene efecto.
▶️ Agreguemos algunos elementos más al conjunto.
py_set.add('C')
print(py_set)
py_set.add('JavaScript')
print(py_set)
py_set.add('Rust')
print(py_set)
# Output
{'Python', 'C++', 'C'}
{'JavaScript', 'Python', 'C++', 'C'}
{'Rust', 'JavaScript', 'Python', 'C++', 'C'}
#2. Usando el método .update()
Hasta ahora, hemos visto cómo agregar elementos al conjunto existente, un elemento a la vez.
¿Qué sucede si desea agregar más de un elemento a una secuencia de elementos?
Puede hacerlo utilizando el
.update()método con la sintaxis:set.update(collection)para agregar elementos encollectiona un conjunto loscollectionpuede ser una lista, una tupla, un diccionario, etc.
py_set.update(['Julia','Ruby','Scala','Java'])
print(py_set)
# Output
{'C', 'C++', 'Java', 'JavaScript', 'Julia', 'Python', 'Ruby', 'Rust', 'Scala'}Este método es útil cuando desea agregar una colección de elementos a un conjunto sin crear otro objeto en la memoria.
En la siguiente sección, aprenderemos cómo eliminar elementos de un conjunto.
Remove Elements from a Python Set
Consideremos el siguiente conjunto (py_set antes de la operación de actualización).
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}#1. Usando el método .pop()
set.pop() elimina un elemento aleatoriamente del conjunto y lo devuelve. Llamemos al método pop en py_set y mira lo que devuelve.
py_set.pop()
# Output
'Rust'Esta vez, la llamada a .pop() El método devolvió la cadena 'Rust'.
Nota:: Porque el .pop() método devuelve un elemento al azar, cuando ejecuta el código en su extremo, también podría obtener otro elemento.
Cuando examinamos el conjunto, 'Rust' ya no está presente en el conjunto.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++', 'C'}#2. Uso de los métodos .remove() y descarte()
En la práctica, es posible que desee eliminar elementos específicos del conjunto. Para ello, puede utilizar el .remove() y .discard() métodos.
set.remove(element) elimina elementos del conjunto.
py_set.remove('C')
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}Si intentamos eliminar un elemento que no está presente en el conjunto, nos encontraremos con un KeyError.
py_set.remove('Scala')
# Output
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
<ipython-input-58-a1abab3a8892> in <module>()
----> 1 py_set.remove('Scala')
KeyError: 'Scala'Echemos un vistazo a py_set de nuevo Ahora tenemos tres elementos.
print(py_set)
# Output
{'JavaScript', 'Python', 'C++'}con la sintaxis set.discard(element), la .discard() El método también elimina elementos del conjunto.
py_set.discard('C++')
print(py_set)
# Output
{'JavaScript', 'Python'}Sin embargo, se diferencia del .remove() método en que lo hace no levantar un KeyError cuando intentamos eliminar un elemento que no está presente.
Si tratamos de eliminar 'Scala' (que no existe) de la lista usando el .discard() método, no vemos ningún error.
py_set.discard('Scala') #no error!
print(py_set)
# Output
{'JavaScript', 'Python'}Access Elements of a Python Set
Hasta ahora, hemos aprendido cómo agregar y quitar elementos de los conjuntos de Python. Sin embargo, aún no hemos visto cómo acceder a elementos individuales en un conjunto.
Como un conjunto es una colección desordenada, no es indexable. Por lo tanto, si intenta acceder a los elementos de un conjunto utilizando el índice, se encontrará con un error, como se muestra.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
print(py_set[0])
# Output
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-27-0329274f4580> in <module>()
----> 1 print(py_set[0])
TypeError: 'set' object is not subscriptableEntonces, ¿cómo se accede a los elementos de un conjunto?
Hay dos formas comunes de hacer esto:
- Recorra el conjunto y acceda a cada elemento
- Comprobar si un elemento en particular es miembro del conjunto
▶️ Recorra el set y acceda a los elementos usando un for lazo.
for elt in py_set:
print(elt)
# Output
C++
JavaScript
Python
Rust
CEn la práctica, puede querer verificar si un elemento dado está presente en el conjunto usando el in operador.
Nota:: elementos
inplanificadas devolucionesTruesi el elemento está presente en el conjunto; de lo contrario vuelveFalse.
En este ejemplo, py_set contiene 'C++' y no contiene 'Julia' y el in el operador regresa True y False, respectivamente.
'C++' in py_set
# True
'Julia' in py_set
# FalseFind the Length of a Python Set
Como se vio anteriormente, puede usar el len() función para obtener el número de elementos presentes en un conjunto.
py_set = {'C++', 'JavaScript', 'Python', 'Rust', 'C'}
len(py_set)
# Output: 5How to Clear a Python Set
Para borrar un conjunto eliminando todos los elementos, puede usar el .clear() método.
Llamemos al .clear() método en py_set.
py_set.clear()Si intenta imprimirlo, obtendrá set() – indicando que el conjunto está vacío. También puede llamar al len() para verificar que la longitud del conjunto es cero.
print(py_set)
# set()
print(len(py_set))
# 0Hasta ahora, hemos aprendido cómo realizar funciones básicas CRUD operaciones en conjuntos de Python:
- Crea: Utilizando
set()función, conversión de tipos e inicialización - Lee: Acceder a elementos del conjunto mediante bucles y
inoperador para pruebas de pertenencia - Noticias: Agregar, eliminar elementos de conjuntos y actualizar conjuntos
- Borrar: borre un conjunto eliminando todos los elementos de él
Common Set Operations, Explained with Python Code
Los conjuntos de Python también nos permiten realizar las operaciones básicas de conjuntos. Aprenderemos sobre ellos en esta sección.
#1. Unión de Conjuntos
En la teoría de conjuntos, la unión de dos conjuntos es el conjunto de todos los elementos en al menos uno de los dos conjuntos. Si hay dos conjuntos, A y B, entonces la unión contiene elementos que están presentes solo en A, solo en B, y los elementos presentes tanto en A como en B.
Para encontrar la unión de conjuntos, puedes usar el | operador o el .union() el método con la sintaxis: setA.union(setB).
setA = {1,3,5,7,9}
setB = {2,4,6,8,9}
print(setA | setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}
setA.union(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}La unión de conjuntos es una operación conmutativa; entonces AUB es lo mismo que BU A. Verifiquemos esto intercambiando las posiciones de setA y setB en el capítulo respecto a la .union() llamada al método.
setB.union(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8, 9}#2. Intersección de Conjuntos
Otra operación conjunta de conjuntos es esta intersección de dos conjuntos, A y B. La operación de intersección de conjuntos devuelve un conjunto que contiene todos los elementos presentes tanto en A como en B.
Para calcular la intersección, puede usar el & operador o el .intersection() método, como se explica en el fragmento de código a continuación.
print(setA & setB)
# Output
{9}
setA.intersection(setB)
# Output
{9}En este ejemplo, el elemento 9 está presente tanto en setA como en setB; por lo que el conjunto de intersección contiene solo este elemento.
Al igual que la unión de conjuntos, la intersección de conjuntos también es una operación conmutativa.
setB.intersection(setA)
# Output
{9}#3. Establecer diferencia
Dados dos conjuntos cualesquiera, la unión y la intersección nos ayudan a encontrar los elementos presentes en ambos y al menos en uno de los conjuntos, respectivamente. Por otra parte, establecer diferencia nos ayuda a encontrar los elementos presentes en un conjunto pero no en el otro.
–
setA.difference(setB)da el conjunto de elementos que están presentes sólo ensetAy no ensetB.–
setB.difference(setA)da el conjunto de elementos que están presentes sólo ensetBy no ensetA.
print(setA - setB)
print(setB - setA)
# Output
{1, 3, 5, 7}
{8, 2, 4, 6}Claramente, A\B no es lo mismo que B\A, por lo que la diferencia de conjuntos no es una operación conmutativa.
setA.difference(setB)
# {1, 3, 5, 7}
setB.difference(setA)
# {2, 4, 6, 8}#4. Diferencia de conjuntos simétricos
Aunque la establecer intersección nos da elementos presentes en ambas conjuntos, el diferencia de conjuntos simétricos devuelve el conjunto de elementos presentes en exactamente uno de los conjuntos.
Considere el siguiente ejemplo.
setA = {1,3,5,7,10,12}
setB = {2,4,6,8,10,12}Para calcular el conjunto de diferencias simétricas, puede usar el ^ operador o el .symmetric_difference() método.
print(setA ^ setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}Los elementos 10 y 12 están presentes en ambos setA y setB. Por lo tanto, no están presentes en el conjunto de diferencias simétricas.
setA.symmetric_difference(setB)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}Como la operación de diferencia de conjuntos simétrica recopila todos los elementos que aparecen exactamente en uno de los dos conjuntos, el conjunto resultante es el mismo independientemente del orden en que se recopilan los elementos. Por lo tanto, una diferencia de conjunto simétrica es una operación conmutativa.
setB.symmetric_difference(setA)
# Output
{1, 2, 3, 4, 5, 6, 7, 8}#5. Subconjuntos y Superconjuntos
En la teoría de conjuntos, los subconjuntos y superconjuntos ayudan a comprender la relación entre dos conjuntos.
Dados dos conjuntos A y B, el conjunto B es un subconjunto del conjunto A si todos los elementos del conjunto B también están presentes en el conjunto A. Y el conjunto A es el superconjunto del conjunto B.
Considere el ejemplo de dos conjuntos: languages y languages_extended.
languages = {'Python', 'JavaScript','C','C++'}
languages_extended = {'Python', 'JavaScript','C','C++','Rust','Go','Scala'}En Python, puede usar el .issubset() método para comprobar si un conjunto dado es un subconjunto de otro conjunto.
setA.issubset(setB)devolucionesTrueifsetAes un subconjunto desetB; de lo contrario, vuelveFalse.
En este ejemplo, languages es un subconjunto de languages_extended.
languages.issubset(languages_extended)
# Output
TrueDel mismo modo, puede usar el .issuperset() método para verificar si un conjunto dado es un superconjunto de otro conjunto.
setA.issuperset(setB)devolucionesTrueifsetAes un superconjunto desetB; de lo contrario, vuelveFalse.
languages_extended.issuperset(languages)
# Output
TrueAs languages_extended es un superconjunto de idiomas, languages_extended.issuperset(languages) devoluciones True, como se ve arriba.
Conclusión
Espero que este tutorial lo haya ayudado a comprender el funcionamiento de los conjuntos de Python, los métodos establecidos para las operaciones CRUD y las operaciones comunes de conjuntos. Como siguiente paso, puede intentar usarlos en su Proyectos de Python.
Puedes consultar otros en profundidad Guías de Python. ¡Feliz aprendizaje!
