Curso Intermedio de Python N03 Conjuntos

Cordiales Saludos

Conjuntos

Un conjunto es una colección de elementos los cuales se pueden modificar, estos elementos no manejan ningún orden (están desordenados) y no acepta duplicados. Los elementos los agrupamos dentro de { } al momento de declararlos o crearlos.

Declaración o Creación de conjuntos

>>> colores = {'azul','rojo', 'amarillo'}
>>> colores
{'amarillo', 'azul', 'rojo'}

type( ), dir( )

>>> type(colores)
<class 'set'>

>>> dir(colores)
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__init_subclass__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
>>>

Otras formas de declarar o crear conjuntos

Conjunto a partir de una lista

>>> conjunto_lista = set([1,2,3,4,5,])
>>> conjunto_lista
{1, 2, 3, 4, 5}
>>> type(conjunto_lista)
<class 'set'>

Conjunto a partir de una tupla

>>> conjunto_tupla = set((100,200,300,400))
>>> conjunto_tupla
{200, 100, 400, 300}

Conjunto a partir de un string

>>> cadena_texto = set('Rafael')
>>> cadena_texto
{'f', 'l', 'e', 'a', 'R'}
>>> type(cadena_texto)
<class 'set'>

Creando un Conjunto vacio

>>> conjunto_vacio = set()
>>> conjunto_vacio
set()
>>> type(conjunto_vacio)
<class 'set'>
>>> 

Conjunto a partir de un rango

>>> conj_rango = set(range(5))
>>> conj_rango
{0, 1, 2, 3, 4}
>>> type(conj_rango)
<class 'set'>
>>> 

Métodos

.add : Agregar Elementos a un conjunto

Teniendo el conjunto: conj_rango, previamente creado le vamos a agregar un nuevo elemento. En este caso el número 100, para esta operación utilizamos el método .add.

>>> conj_rango
{0, 1, 2, 3, 4}
>>> conj_rango.add(100)
>>> conj_rango
{0, 1, 2, 3, 4, 100}
>>> 

.update : Agregar Elementos Iterables

Update lo utilizaremos para agregar más de un elemento, es decir varios elementos con una sola operación.

Actualización del conjunto con lista

>>> lista = [5,6,7,8]
>>> conj_rango.update(lista)
>>> conj_rango
{0, 1, 2, 3, 4, 100, 5, 6, 7, 8}

Actuializacion del conjunto con tupla

>>> tupla = (9,10,11)
>>> conj_rango.update(tupla)
>>> conj_rango
{0, 1, 2, 3, 4, 100, 5, 6, 7, 8, 9, 10, 11}

Actualización del conjunto con range

>>> rango = range(12,15)
>>> conj_rango.update(rango)
>>> conj_rango
{0, 1, 2, 3, 4, 100, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}

.discard(): Permite eliminar un elemento.

PRIMER CASO. Si el elemento existe. En este caso eliminaremos el número 100, Al existir en el conjunto lo elimina automáticamente.

conj_rango
{0, 1, 2, 3, 4, 100, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
>>> conj_rango.discard(100)
>>> conj_rango
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}

SEGUNDO CASO. Si el elemento no existe. En este caso eliminaremos el número 20 con la instrucción: conj_rango.discard(20). Al realizar el proceso como no existe el número 20, no realiza la eliminación y no da error.

>>> conj_rango
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
>>> conj_rango.discard(20)
>>> conj_rango
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}

.remove(): Elimina un elemento del conjunto

PRIMER CASO. Si el elemento existe lo elimina automáticamente. En este caso eliminaremos el número 0, existente en: conj_rango

>>> conj_rango
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
>>> conj_rango.remove(0)
>>> conj_rango
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}

SEGUNDO CASO. Si el elemento no existe. En este caso eliminaremos el número 15 con la instrucción: conj_rango.remove(15). Al realizar el proceso como el número 15 no existe en el conjunto python nos lanza un error de tipo KeyError.

>>> conj_rango
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
>>> conj_rango.remove(15)
Traceback (most recent call last):
  File "", line 1, in <module>
KeyError: 15

.pop(): Elimina un elemento de forma aleatoria. En este caso al ejecutar: conj_rango.pop() se eliminó el elemento: 1 (De forma aleatoria)

>>> conj_rango
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
>>> conj_rango.pop()
1
>>> conj_rango
{2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}

.clear(): Permite eliminar todos los elementos del conjunto.

>>> conj_rango
{2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14}
>>> conj_rango.clear()
>>> conj_rango
set()
>>> 

Queda pendiente para la próxima publicación: Operaciones con conjuntos.

Para revisar las publicaciones anteriores del Curso Intermedio de Python entra al siguiente link: https://siraquino.github.io/pythoncumanes/intermediopython.html

Profundizando en python

Podemos Ejecutar líneas de códigos directamente desde nuestra terminal:

rafael@HP:~$ 
rafael@HP:~$ python3 -c 'print("Mensaje Python")'
Mensaje Python
rafael@HP:~$ 
rafael@HP:~$ 

Ejercicio:

Ejecutar desde la terminal una instrucción de python donde se muestre el Zen de Python. Se debe redireccionar la salida del Zen de Python a un archivo de texto denominado zen.txt y mostrarlo con el comando cat.

Respuesta:

rafael@HP:~$ python3 -c 'import this' > zen.txt; cat zen.txt

rafael@HP:~$ 
rafael@HP:~$ python3 -c 'import this' > zen.txt; cat zen.txt
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
rafael@HP:~$ 
rafael@HP:~$ 

Este ejercicio lo coloqué en mi Twitter. Aquí lo muestro.

https://twitter.com/Rafa_elaquino/status/1635672136110026754?s=20

- Rafa_elaquino

Invitación

Te invito a que sigas mi curso de linux. En este curso Intermedio de Python trabajaremos con este sistema operativo.
Link: https://siraquino.github.io/pythoncumanes/linux.html

Recurso para aprender Python

Curso Gratis de Programación
Curso de Programación Básica

Mi Twitter
Mi facebook