Tutorial de Estructuras de Datos en Python

Las estructuras de datos son una forma de organizar y almacenar datos para poder acceder a ellos y trabajar con ellos de forma eficaz. Definen la relación entre los datos y las operaciones que pueden realizarse con ellos. Hay muchos tipos distintos de estructuras de datos definidas que facilitan tanto a los científicos de datos como a los ingenieros informáticos concentrarse en la imagen principal de la resolución de problemas de mayor envergadura, en lugar de perderse en los detalles de la descripción y el acceso a los datos.

En este tutorial, conocerás las distintas estructuras de datos de Python y verás cómo se implementan:

• Tipos de datos abstractos y estructuras de datos
• Estructuras de datos primitivas
  • Enteros
  • Flotador
  • Cuerdas
  • Booleano
• Estructuras de datos no primitivas
  • Matrices
  • Listas
  • Tuplas
  • Diccionario
  • Establece
  • Archivos

En el curso gratuito Introducción a Python para la Ciencia de Datos de DataCamp, puedes aprender más sobre el uso de Python específicamente en el contexto de la ciencia de datos. El curso ofrece una introducción a los conceptos básicos de Python. Con él, descubrirás métodos, funciones y el paquete NumPy.

Tipos de datos abstractos y estructuras de datos

Como has leído en la introducción, las estructuras de datos te ayudan a centrarte en el panorama general en lugar de perderte en los detalles. Esto se conoce como abstracción de datos.

Ahora bien, las estructuras de datos son en realidad una implementación de los Tipos de Datos Abstractos o TDA. Esta implementación requiere una visión física de los datos, utilizando una serie de construcciones de programación y tipos de datos básicos.

En general, las estructuras de datos pueden dividirse en dos categorías en informática: estructuras de datos primitivas y no primitivas. Las primeras son las formas más sencillas de representar datos, mientras que las segundas son más avanzadas: contienen estructuras de datos primitivas dentro de estructuras de datos más complejas con fines especiales.

Estructuras de datos primitivas

Son las estructuras de datos más primitivas o básicas. Son los bloques de construcción para la manipulación de datos y contienen valores puros y simples de datos. Python tiene cuatro tipos de variables primitivas:

• Enteros
• Flotador
• Cuerdas
• Booleano

En las próximas secciones, aprenderás más sobre ellos.

Enteros

Puedes utilizar un número entero para representar datos numéricos y, más concretamente, números enteros desde el infinito negativo hasta el infinito, como 4, 5 o -1.

Flotador

"Float" significa "número de coma flotante". Puedes utilizarlo para números racionales, que suelen terminar con una cifra decimal, como 1,11 o 3,14.

Echa un vistazo al siguiente DataCamp Light Chunk y ¡prueba algunas de las operaciones con enteros y flotantes!

Ten en cuenta que en Python no tienes que indicar explícitamente el tipo de la variable o de tus datos. Esto se debe a que es un lenguaje tipado dinámicamente. Los lenguajes tipados dinámicamente son aquellos en los que el tipo de datos que puede almacenar un objeto es mutable.

Cadena

Las cadenas son colecciones de alfabetos, palabras u otros caracteres. En Python, puedes crear cadenas encerrando una secuencia de caracteres dentro de un par de comillas simples o dobles. Por ejemplo 'cake', "cookie", etc.

También puedes aplicar las operaciones + sobre dos o más cadenas para concatenarlas, como en el ejemplo siguiente:

x = 'Cake'
y = 'Cookie'
x + ' & ' + y

'Cake & Cookie'

Aquí tienes otras operaciones básicas que puedes realizar con cadenas; Por ejemplo, puedes utilizar * para repetir una cadena un determinado número de veces:

# Repeat
x * 2

'CakeCake'

También puedes trocear cadenas, lo que significa que seleccionas partes de cadenas:

# Range Slicing
z1 = x[2:] 

print(z1)

# Slicing
z2 = y[0] + y[1] 

print(z2)

ke
Co

Ten en cuenta que las cadenas también pueden ser caracteres alfanuméricos, pero que la operación + se sigue utilizando para concatenar cadenas.

x = '4'
y = '2'

x + y

'42'

Python tiene muchos métodos incorporados o funciones de ayuda para manipular cadenas. Sustituir una subcadena, poner en mayúsculas determinadas palabras de un párrafo, encontrar la posición de una cadena dentro de otra son algunas manipulaciones habituales de las cadenas. Echa un vistazo a algunas de ellas:

• Escribir cadenas en mayúsculas

str.capitalize('cookie')

'Cookie'

• Recupera la longitud de una cadena en caracteres. Ten en cuenta que los espacios también cuentan para el resultado final:

str1 = "Cake 4 U"
str2 = "404"
len(str1)

8

• Comprueba si una cadena está formada sólo por dígitos

str1.isdigit()

False

str2.isdigit()

True

• Sustituye partes de cadenas por otras cadenas

str1.replace('4 U', str2)

'Cake 404'

• Buscar subcadenas en otras cadenas; Devuelve el índice o la posición más baja dentro de la cadena en la que se encuentra la subcadena:

str1 = 'cookie'
str2 = 'cook'
str1.find(str2)

0

La subcadena

'cook'

se encuentra al principio de

'cookie'

. En consecuencia, te refieres a la posición dentro de

'cookie'

en la que encuentres esa subcadena. En este caso,

0

¡se devuelve porque empiezas a contar posiciones desde 0!

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

Del mismo modo, la subcadena

'cook'

se encuentra en la posición 12 dentro de

'I got you a cookie'

. ¡Recuerda que empiezas a contar desde 0 y que los espacios cuentan para las posiciones!

Puedes encontrar una lista exhaustiva de métodos de cadena en Python aquí.

Booleano

Este tipo de datos incorporado puede tomar los valores: True y False, lo que a menudo los hace intercambiables con los números enteros 1 y 0. Los booleanos son útiles en expresiones condicionales y de comparación, como en los ejemplos siguientes:

x = 4
y = 2
x == y

False

x > y

True

x = 4
y = 2
z = (x==y) # Comparison expression (Evaluates to false)
if z: # Conditional on truth/false value of 'z'
    print("Cookie")
else: print("No Cookie")

No Cookie

Conversión de tipos de datos

A veces, te encontrarás trabajando en el código de otra persona, y necesitarás convertir un entero en un flotante o viceversa, por ejemplo. O tal vez descubras que has estado utilizando un entero cuando lo que realmente necesitas es un flotante. En estos casos, ¡puedes convertir el tipo de datos de las variables!

Para comprobar el tipo de un objeto en Python, utiliza la función incorporada type(), como en las líneas de código siguientes:

i = 4.0
type(i)

float

Cuando cambias el tipo de una entidad de un tipo de datos a otro, esto se llama "encasillamiento". Puede haber dos tipos de conversiones de datos posibles: la implícita, denominada coerción, y la explícita, a menudo denominada fundición.

Conversión implícita de tipos de datos

Se trata de una conversión automática de datos, y el compilador se encarga de ello por ti. Echa un vistazo a los siguientes ejemplos:

# A float
x = 4.0 

# An integer
y = 2 

# Divide `x` by `y`
z = x/y

# Check the type of `z`
type(z)

float

En el ejemplo anterior, no has tenido que cambiar explícitamente el tipo de datos de y para realizar la división del valor flotante. El compilador lo hizo por ti de forma implícita.

Así de fácil.

Conversión explícita de tipos de datos

Este tipo de conversión de tipos de datos está definido por el usuario, lo que significa que tienes que informar explícitamente al compilador para que cambie el tipo de datos de determinadas entidades. Considera el fragmento de código siguiente para entenderlo bien:

x = 2
y = "The Godfather: Part "
fav_movie = y + x

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 x = 2
      2 y = "The Godfather: Part "
----> 3 fav_movie = y + x


TypeError: Can't convert 'int' object to str implicitly

El ejemplo anterior te ha dado error porque el compilador no entiende que estás intentando realizar una concatenación o una suma debido a los tipos de datos mezclados. Tienes un número entero y una cadena que intentas sumar.

Hay un desajuste evidente.

Para solucionarlo, primero tendrás que convertir el int en un string para luego poder realizar la concatenación.

Ten en cuenta que no siempre es posible convertir un tipo de datos en otro. Algunas funciones integradas de conversión de datos que puedes utilizar aquí son: int(), float(), y str().

x = 2
y = "The Godfather: Part "
fav_movie = (y) + str(x)
print(fav_movie)

The Godfather: Part 2

Estructuras de datos no primitivas

Los tipos no primitivos son los miembros sofisticados de la familia de las estructuras de datos. No almacenan sólo un valor, sino una colección de valores en varios formatos.

En el mundo tradicional de la informática, las estructuras de datos no primitivas se dividen en:

• Matrices
• Listas
• Archivos

Matriz

En primer lugar, las matrices en Python son una forma compacta de recopilar tipos de datos básicos, todas las entradas de una matriz deben ser del mismo tipo de datos. Sin embargo, las matrices no son muy populares en Python, a diferencia de otros lenguajes de programación como C++ o Java.

En general, cuando la gente habla de matrices en Python, en realidad se refiere a listas. Sin embargo, hay una diferencia fundamental entre ellos, y la verás dentro de un momento. Para Python, las matrices pueden verse como una forma más eficiente de almacenar cierto tipo de listas. Sin embargo, este tipo de lista tiene elementos del mismo tipo de datos.

En Python, las matrices están soportadas por el módulo array y es necesario importarlas antes de empezar a inicializarlas y utilizarlas. Los elementos almacenados en una matriz están limitados en su tipo de datos. El tipo de datos se especifica durante la creación de la matriz y se especifica mediante un código de tipo, que es un único carácter como el I que ves en el ejemplo siguiente:

import array as arr
a = arr.array("I",[3,6,9])
type(a)

array.array

La página de documentación de Python Array proporciona más información sobre los distintos tipos de códigos disponibles y las funcionalidades que ofrece el módulo array.

Lista

Las listas en Python se utilizan para almacenar colecciones de elementos heterogéneos. Son mutables, lo que significa que puedes cambiar su contenido sin cambiar su identidad. Puedes reconocer las listas por sus corchetes [ y ] que contienen elementos separados por una coma ,. Las listas están integradas en Python: no necesitas invocarlas por separado.

x = [] # Empty list
type(x)

list

x1 = [1,2,3]
type(x1)

list

x2 = list([1,'apple',3])
type(x2)

list

print(x2[1])

apple

x2[1] = 'orange'
print(x2)

[1, 'orange', 3]

Nota: como has visto en el ejemplo anterior con x1, las listas también pueden contener elementos homogéneos y, por tanto, satisfacer la funcionalidad de almacenamiento de una matriz. Esto está bien, a menos que quieras aplicar algunas operaciones específicas a esta colección.

Python proporciona muchos métodos para manipular y trabajar con listas. Añadir nuevos elementos a una lista, eliminar algunos elementos de una lista y ordenar o invertir una lista son manipulaciones habituales de las listas. Veamos algunas de ellas en acción:

• Añade 11 a la lista list_num con append(). Por defecto, este número se añadirá al final de la lista.

list_num = [1,2,45,6,7,2,90,23,435]
list_char = ['c','o','o','k','i','e']

list_num.append(11) # Add 11 to the list, by default adds to the last position
print(list_num)

[1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Utiliza insert() para insertar 11 en el índice o posición 0 de la lista list_num

list_num.insert(0, 11)
print(list_num)

[11, 1, 2, 45, 6, 7, 2, 90, 23, 435, 11]

• Elimina la primera aparición de 'o' de list_char con ayuda de remove()

list_char.remove('o') 
print(list_char)

['c', 'o', 'k', 'i', 'e']

• Elimina el elemento del índice -2 de list_char

list_char.pop(-2) # Removes the item at the specified position
print(list_char)

['c', 'o', 'k', 'e']

list_num.sort() # In-place sorting
print(list_num)

[1, 2, 2, 6, 7, 11, 11, 23, 45, 90, 435]

list.reverse(list_num)
print(list_num)

[435, 90, 45, 23, 11, 11, 7, 6, 2, 2, 1]

Si quieres saber más sobre las listas en Python, puedes seguir fácilmente el tutorial 18 preguntas más frecuentes sobre las listas en Python.

Matrices frente a listas

Ahora que ya has visto las listas en Python, puede que te preguntes para qué necesitas las matrices. La razón es que son fundamentalmente diferentes en cuanto a las operaciones que se pueden realizar con ellas. Con las matrices, puedes realizar fácilmente operaciones sobre todos sus elementos de forma individual, lo que no ocurre con las listas. He aquí una ilustración:

array_char = array.array("u",["c","a","t","s"])
array_char.tostring()
print(array_char)

array('u', 'cats')

Has podido aplicar la función tostring() del array_char porque Python es consciente de que todos los elementos de una matriz son del mismo tipo de datos y, por tanto, la operación se comporta igual en cada elemento. Así, las matrices pueden ser muy útiles cuando se trata de una gran colección de tipos de datos homogéneos. Como Python no tiene que recordar los detalles del tipo de datos de cada elemento individualmente, para algunos usos, las matrices pueden ser más rápidas y consumen menos memoria que las listas.

También merece la pena mencionar la matriz NumPy, ya que estamos hablando de matrices. Las matrices NumPy se utilizan mucho en el mundo de la ciencia de datos para trabajar con matrices multidimensionales. Son más eficaces que el módulo de matrices y que las listas de Python en general. Leer y escribir elementos en una matriz NumPy es más rápido, y admiten operaciones "vectorizadas" como la suma de elementos. Además, las matrices NumPy funcionan eficazmente con grandes conjuntos de datos dispersos. Para saber más, consulta el Tutorial Python Numpy Array de DataCamp.

Aquí tienes algo de código para iniciarte en NumPy Array:

import numpy as np

arr_a = np.array([3, 6, 9])
arr_b = arr_a/3 # Performing vectorized (element-wise) operations 
print(arr_b)

[ 1.  2.  3.]

arr_ones = np.ones(4)
print(arr_ones)

[ 1.  1.  1.  1.]

multi_arr_ones = np.ones((3,4)) # Creating 2D array with 3 rows and 4 columns
print(multi_arr_ones)

[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

Tradicionalmente, la estructura de datos de listas puede clasificarse a su vez en estructuras de datos lineales y no lineales. Stacks y Queues se denominan "estructuras de datos lineales", mientras que Graphs y Trees son "estructuras de datos no lineales". Estas estructuras y sus conceptos pueden ser relativamente complejos, pero se utilizan mucho por su parecido con los modelos del mundo real. En este tutorial podrás echar un vistazo a estos temas.

Nota: en una estructura de datos lineal, los elementos de datos se organizan secuencialmente o, dicho de otro modo, linealmente. Los elementos de datos se recorren en serie, uno tras otro, y todos los elementos de datos de una estructura de datos lineal pueden recorrerse en una sola ejecución. Sin embargo, en las estructuras de datos no lineales, los elementos de datos no se organizan secuencialmente. Eso significa que los elementos podrían estar conectados a más de un elemento para reflejar una relación especial entre estos elementos. Puede que no se recorran todos los elementos de datos de una estructura de datos no lineal en una sola ejecución.

Pilas

Una pila es un contenedor de objetos que se insertan y retiran según el concepto de último en entrar, primero en salir (LIFO). Piensa en una situación en la que en una cena en la que hay una pila de platos, siempre se añaden o quitan platos de la parte superior de la pila. En informática, este concepto se utiliza para evaluar expresiones y analizar sintaxis, programar algoritmos/rutinas, etc.

Las pilas pueden implementarse utilizando listas en Python. Cuando añades elementos a una pila, se conoce como operación push, mientras que cuando eliminas o borras un elemento se llama operación pop. Ten en cuenta que en realidad dispones de un método pop() cuando trabajas con pilas en Python:

# Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack = [1,2,3,4,5] 
stack.append(6) # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 (Top)
print(stack)

[1, 2, 3, 4, 5, 6]

stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 -> 5 (Top)
stack.pop() # Bottom -> 1 -> 2 -> 3 -> 4 (Top)
print(stack)

[1, 2, 3, 4]

Cola

Una cola es un contenedor de objetos que se insertan y eliminan según el principio FIFO (primero en entrar, primero en salir). Un ejemplo excelente de cola en el mundo real es la cola de una taquilla, en la que se atiende a las personas según su secuencia de llegada y, por tanto, la persona que llega primero es también la primera en irse. Las colas pueden ser de muchos tipos.

Las listas no son eficientes para implementar una cola, porque append() y pop() desde el final de una lista no son rápidas e incurren en un coste de movimiento de memoria. Además, la inserción al final y la eliminación desde el principio de una lista no son tan rápidas, ya que requieren un desplazamiento en las posiciones de los elementos.

Gráficos

Un grafo en matemáticas e informática son redes formadas por nodos, también llamados vértices, que pueden estar o no conectados entre sí. Las líneas o el camino que une dos nodos se llama arista. Si la arista tiene una dirección de flujo determinada, se trata de un grafo dirigido, y la arista de dirección se denomina arco. Si no se especifica ninguna dirección, el grafo se denomina grafo no dirigido.

Todo esto puede sonar muy teórico y puede volverse bastante complejo cuando profundizas. Sin embargo, los grafos son un concepto importante, especialmente en la ciencia de datos, y a menudo se utilizan para modelar problemas de la vida real. Las redes sociales, los estudios moleculares en química y biología, los mapas y los sistemas de recomendación se basan en los principios de la teoría de grafos y grafos.

Aquí encontrarás una sencilla implementación de un gráfico utilizando un Diccionario Python para ayudarte a empezar:

graph = { "a" : ["c", "d"],
          "b" : ["d", "e"],
          "c" : ["a", "e"],
          "d" : ["a", "b"],
          "e" : ["b", "c"]
        }

def define_edges(graph):
    edges = []
    for vertices in graph:
        for neighbour in graph[vertices]:
            edges.append((vertices, neighbour))
    return edges

print(define_edges(graph))

[('a', 'c'), ('a', 'd'), ('b', 'd'), ('b', 'e'), ('c', 'a'), ('c', 'e'), ('e', 'b'), ('e', 'c'), ('d', 'a'), ('d', 'b')]

Puedes hacer cosas muy chulas con los grafos, como intentar averiguar si existe un camino entre dos nodos o encontrar el camino más corto entre dos nodos, determinando ciclos en el grafo.

El famoso "problema del viajante de comercio" consiste, de hecho, en encontrar la ruta más corta posible que visite cada nodo exactamente una vez y vuelva al punto de partida. A veces, a los nodos o arcos de un grafo se les han asignado pesos o costes, puedes pensar que esto es como asignar un nivel de dificultad al camino, y te interesa encontrar el camino más barato o el más fácil.

Árboles

En el mundo real, un árbol es un ser vivo con las raíces en el suelo y las ramas que sostienen las hojas y los frutos al aire libre. Las ramas del árbol se extienden de forma algo organizada. En informática, los árboles se utilizan para describir cómo se organizan a veces los datos, con la diferencia de que la raíz está en la parte superior y las ramas, las hojas, le siguen, extendiéndose hacia la parte inferior y el árbol se dibuja invertido en comparación con el árbol real.

Para introducir un poco más de notación, la raíz siempre está en la parte superior del árbol. Manteniendo la metáfora del árbol, los demás nodos que le siguen se llaman ramas, y el nodo final de cada rama se llama hoja. Puedes imaginar cada rama como un árbol más pequeño en sí mismo. La raíz se suele llamar padre y los nodos a los que se refiere por debajo se llaman hijos. Los nodos con el mismo padre se llaman hermanos. ¿Ves por qué esto también se llama árbol genealógico?

Los árboles ayudan a definir escenarios del mundo real y se utilizan en todas partes, desde el mundo de los juegos hasta el diseño de analizadores XML, y también el principio de diseño del PDF se basa en árboles. En la ciencia de datos, el "Aprendizaje basado en árboles de decisión" constituye en realidad un amplio campo de investigación. Existen numerosos métodos famosos, como el bagging, el boosting, que utilizan el modelo de árbol para generar un modelo predictivo. Los juegos como el ajedrez construyen un enorme árbol con todas las jugadas posibles para analizarlas y aplicar la heurística para decidir la jugada óptima.

Puedes implementar una estructura de árbol utilizando y combinando las distintas estructuras de datos que has visto hasta ahora en este tutorial. Sin embargo, en aras de la simplicidad, este tema se abordará en otro post.

class Tree:
    def __init__(self, info, left=None, right=None):
        self.info = info
        self.left  = left
        self.right = right

    def __str__(self):
        return (str(self.info) + ', Left child: ' + str(self.left) + ', Right child: ' + str(self.right))

tree = Tree(1, Tree(2, 2.1, 2.2), Tree(3, 3.1))
print(tree)

1, Left child: 2, Left child: 2.1, Right child: 2.2, Right child: 3, Left child: 3.1, Right child: None

Has aprendido sobre las matrices y también has visto la estructura de datos lista. Sin embargo, Python proporciona muchos tipos diferentes de mecanismos de recogida de datos, y aunque no se incluyan en los temas tradicionales de estructura de datos en informática, merece la pena conocerlos, especialmente en lo que respecta al lenguaje de programación Python:

• Tuplas
• Diccionario
• Establece

Tuplas

Las tuplas son otro tipo de datos secuenciales estándar. La diferencia entre las tuplas y las listas es que las tuplas son inmutables, lo que significa que una vez definidas no puedes borrar, añadir o editar ningún valor de su interior. Esto puede ser útil en situaciones en las que quieras pasar el control a otra persona, pero no quieras que manipule los datos de tu colección, sino que tal vez sólo los vea o realice operaciones por separado en una copia de los datos.

Veamos cómo se implementan las tuplas:

x_tuple = 1,2,3,4,5
y_tuple = ('c','a','k','e')
x_tuple[0]

1

y_tuple[3]
x_tuple[0] = 0 # Cannot change values inside a tuple

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

 in ()
      1 y_tuple[3]
----> 2 x_tuple[0] = 0 # Cannot change values inside a tuple


TypeError: 'tuple' object does not support item assignment

Diccionario

Los diccionarios son exactamente lo que necesitas si quieres implantar algo parecido a una guía telefónica. Ninguna de las estructuras de datos que has visto antes es adecuada para una guía telefónica.

Aquí es cuando un diccionario puede resultar útil. Los diccionarios están formados por pares clave-valor. key se utiliza para identificar el elemento y value contiene, como su nombre indica, el valor del elemento.

x_dict = {'Edward':1, 'Jorge':2, 'Prem':3, 'Joe':4}
del x_dict['Joe']
x_dict

{'Edward': 1, 'Jorge': 2, 'Prem': 3}

x_dict['Edward'] # Prints the value stored with the key 'Edward'.

1

Puedes aplicar muchas otras funcionalidades incorporadas a los diccionarios:

len(x_dict)

3

x_dict.keys()

dict_keys(['Prem', 'Edward', 'Jorge'])

x_dict.values()

dict_values([3, 1, 2])

Este código muestra un ejemplo de utilización de un diccionario Python para almacenar y acceder a pares clave-valor.

Primero, el código llama a la función len() con x_dict como argumento. Esto devuelve el número de pares clave-valor del diccionario, que es 3.

A continuación, el código llama al método keys() en x_dict. Devuelve un objeto vista que contiene las claves del diccionario. En este caso, las claves son "Prem", "Eduardo" y "Jorge", como muestra el resultado.

A continuación, el código llama al método values() en x_dict. Devuelve un objeto vista que contiene los valores del diccionario. En este caso, los valores son 3, 1 y 2, respectivamente, como muestra la salida.

Establece

Los conjuntos son una colección de objetos distintos (únicos). Son útiles para crear listas que sólo contengan valores únicos en el conjunto de datos. Es una colección desordenada pero mutable, lo que resulta muy útil cuando se recorre un conjunto de datos enorme.

x_set = set('CAKE&COKE')
y_set = set('COOKIE')

print(x_set)

{'A', '&', 'O', 'E', 'C', 'K'}

print(y_set) # Single unique 'o'

{'I', 'O', 'E', 'C', 'K'}

print(x - y) # All the elements in x_set but not in y_set

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

 in ()
----> 1 print(x - y) # All the elements in x_set but not in y_set


NameError: name 'x' is not defined

print(x_set|y_set) # Unique elements in x_set or y_set or both

{'C', '&', 'E', 'A', 'O', 'K', 'I'}

print(x_set & y_set) # Elements in both x_set and y_set

{'O', 'E', 'K', 'C'}

El código crea dos conjuntos: x_set y y_set. Cada conjunto se crea pasando una cadena de caracteres como argumento a la función set(). En este caso, x_set se crea a partir de la cadena "TORTA&TORTA", mientras que y_set se crea a partir de la cadena "COOKIE".

A continuación, el código imprime cada conjunto utilizando la función print(). La primera sentencia print() imprime x_set, que contiene los caracteres únicos de la cadena "CAKE&COKE". La salida muestra que x_set contiene los caracteres "A", "&", "O", "E", "C" y "K". Del mismo modo, la segunda sentencia print() imprime y_set, que contiene los caracteres únicos de la cadena "COOKIE". La salida muestra que y_set contiene los caracteres "I", "O", "E", "C" y "K".

La tercera sentencia print() intenta imprimir el conjunto de todos los elementos de x_set que no están en y_set. Sin embargo, esta línea de código da como resultado un NameError porque no se ha definido la variable x. Es de suponer que esta línea debería ser print(x_set - y_set).

La cuarta sentencia print() imprime el conjunto de elementos únicos en x_set o y_set, o ambos. El resultado muestra que el conjunto resultante contiene todos los caracteres únicos tanto de x_set como de y_set.

Por último, la quinta sentencia print() imprime el conjunto de elementos que están tanto en x_set como en y_set. El resultado muestra que este conjunto contiene los caracteres "O", "E", "K" y "C".

Archivos

Tradicionalmente, los archivos forman parte de las estructuras de datos. Y aunque el big data es habitual en la industria de la ciencia de datos, un lenguaje de programación sin la capacidad de almacenar y recuperar información previamente almacenada difícilmente sería útil. Todavía tienes que hacer uso de todos los datos que se encuentran en archivos a través de bases de datos y aprenderás cómo hacerlo.

La sintaxis para leer y escribir archivos en Python es similar a la de otros lenguajes de programación, pero mucho más fácil de manejar. Éstas son algunas de las funciones básicas que te ayudarán a trabajar con archivos utilizando Python:

• open() para abrir archivos en tu sistema, el nombre del archivo es el nombre del archivo que se va a abrir;
• read() para leer archivos enteros;
• readline() para leer una línea cada vez;
• write() para escribir una cadena en un archivo y devolver el número de caracteres escritos; y
• close() para cerrar el archivo.

# File modes (2nd argument): 'r'(read), 'w'(write), 'a'(appending), 'r+'(both reading and writing)
f = open('file_name', 'w')

# Reads entire file
f.read() 

# Reads one line at a time
f.readline() 

# Writes the string to the file, returning the number of char written
f.write('Add this line.') 

f.close()

El segundo argumento de la función open() es el modo de archivo. Te permite especificar si quieres leer (r), escribir (w), añadir (a) o tanto leer como escribir (r+).

Para saber más sobre el manejo de archivos en Python, no dejes de consultar esta página.

¡Lo has conseguido!

¡Hurra! ¡Has llegado al final de este tutorial! Esto te acerca un tema más a tus sueños de conquistar el mundo de la ciencia de datos.

Si te interesa, el curso en dos partes de Data Science Toolbox de Python de DataCamp profundiza en las funciones, los iteradores, las listas, etc.

Tómate un descanso y, cuando estés listo, dirígete a uno de los tutoriales recomendados para continuar tu viaje.