Tutorial de python – Parte 3

Estructura de datos

Una estructura de datos es la forma de trabajar con un gran volumen de datos de una manera eficiente.

En Python podemos encontrar múltiples formas de trabajar con grandes cantidades de datos:

  • Tuplas
  • Listas
  • Diccionarios

Listas

Es un tipo de dato que se escribe como una lista de valores separados por comas y entre corchetes, ademas cada elemento no tiene que ser del mismo tipo.

lista1 = ['a', 'b', 3, 4, 5.5]
print (lista1)

# ['a', 'b', 3, 4, 5.5]

Muy importante recordar, que como ocurre en otros tipos de datos en Python el indice comienza en el 0.

Para acceder a los valores de la lista, usaremos los corchetes y el valor de un indice

#!/usr/bin/env python
lista1 = ['a', 'b', 3, 4, 5.5]
print (lista1)       # ['a', 'b', 3, 4, 5.5]
print (lista1[0])    # a
print (lista1[1:3])  # ['b', 3]
print (lista1[:3])   # ['a', 'b', 3]
print (lista1[3:10]) # [4, 5.5]
print (lista1[:10])  # ['a', 'b', 3, 4, 5.5]

Los operadores + y * se pueden usar también en las listas, siendo + para concatenar y * para repetir.

A continuación algunas operaciones que se pueden realizar con las listas

#!/usr/bin/env python
# concat
concatenar = ['a', 'b', 'c'] + [1, 2, 3]
print (concatenar)                          # ['a', 'b', 'c', 1, 2, 3]
# repeat
repetir = ['a', 1] * 5
print (repetir)                             # ['a', 1, 'a', 1, 'a', 1, 'a', 1, 'a', 1]
repetir = 4 * ['a', 1]
print (repetir)                             # ['a', 1, 'a', 1, 'a', 1, 'a', 1]
# in
inTest = 'a' in ['b', 2, 2.5, 'a']
print (inTest)                              # True
inTest = 'z' in ['b', 2, 2.5, 'a']
print (inTest)                              # False
# for
for x in ['a', 'b', 'c', 'd', 'e']:
  print (x)                                 # a b c d e

Algunas funciones y métodos que podemos usar en Python 

#!/usr/bin/env python
# FUNCIONES
l1 = [1, 2]
l2 = [3, 4, 5, 6]
tuple = (1, 2, 'a')
# Tuple to List
tupleToList = list(tuple)
# Length
print (len(l1))             # 2
print (len(l2))             # 4
# Max value of the list
print (max(l1))             # 2
print (max(l2))             # 6
# Min value of the list
print (min(l1))             # 1
print (min(l2))             # 3
print (tupleToList)         # [1, 2, 'a']
#!/usr/bin/env python
# METHODS
l1 = [1, 2, 3, 4]
l2 = ['a', 'b', 'c']
l3 = [1, 2, 3, 4, 1, 5, 6, 2, 7]
# Añadir un valor
l1.append(2)
print (l1)           # [1, 2, 3, 4, 2]
l1.append([2,2,3])   # [1, 2, 3, 4, 2, [2, 2, 3]]
print (l1)           # [1, 2, 3, 4, 2]
# Contar cuantas veces se repite el elemento indicado
count = l1.count('a')
print (count)        # 0
count = l1.count(1)
print (count)        # 1
# Añade una lista dentro de otra lista
l1.extend(l2)
print (l1)           # [1, 2, 3, 4, 2, [2, 2, 3], 'a', 'b', 'c']
# Devuelve el indice mas bajo donde aparece el valor
print (l1.index(1))  # 0
print (l1.index(2))  # 1
# Insertar un valor en un indice indicado
l3.insert(3, 'texto')
print (l3)           # [1, 2, 3, 'texto', 4, 1, 5, 6, 2, 7]
# Elimina y devuelve el valor eliminado
print (l3.pop())     # 7
print (l3)           # [1, 2, 3, 'texto', 4, 1, 5, 6, 2]
# Elimina el valor del indice indicado
print (l3.pop(3))    # texto
print (l3)           # [1, 2, 3, 4, 1, 5, 6, 2]
# Elimina el valor
l3.remove(6)
print (l3)           # [1, 2, 3, 4, 1, 5, 2]
l3.append('texto2')
print (l3)           # [1, 2, 3, 4, 1, 5, 2, 'texto2']
l3.remove('texto2')
print (l3)           # [1, 2, 3, 4, 1, 5, 2]
# Invierte la lista
l2.reverse()
print (l2)           # ['c', 'b', 'a']
# Ordena la lista
l3.sort()
print (l3)           # [1, 1, 2, 2, 3, 4, 5]

Tuplas

Es un tipo de dato que se escribe como una lista de valores separados por comas y entre paréntesis.

Deberemos tener en cuenta que las tuplas son inmutables, no pudiendo añadir o eliminar ningún dato.

#!/usr/bin/env python
tuplaA = (1, 2, 3)               # Declaramos una tupla (se usan paréntesis)
print (tuplaA)
tuplaB = 1, 2, 3                 # Tambien se puede declarar sin paréntesis
print (tuplaB)
tuplaC = (100,)                  # Con un elemento hay terminar con ','
print (tuplaC)
tuplaD = tuplaA, 4, 5, 6         # concatenación de tuplas
print (tuplaD)
tuplaF = tuple([1, 2, 3, 4, 5])  # Convierte una lista en una tupla
print (tuplaF)                   
print (tuplaA[1:3])              # (2, 3), accede a los valores desde:hasta

Diccionarios

Un diccionario es un objeto que contiene una lista de parejas de elementos compuestos por una clave y un valor, parecido a un objeto de Javascript.

En ese listado de pares de elementos, cada uno tiene una finalidad:

  • clave: Es un valor único e inmutable, y lo usaremos para acceder al valor.
  • valor: El valor puede ser un número, cadena, boleano, lista o una tupla.

La estructura de un diccionario es la siguiente

#!/usr/bin/env python
computeParts = { 'keyboard': 'bluetooth', 'mouse': 'bluetooth', 'harddisk': 'ssd', 'graphicsCard': 'Gforce' }
print (computeParts)

A continuación algunas operaciones que podemos realizar sobre un diccionario

#!/usr/bin/env python
computeParts = { 'keyboard': 'bluetooth', 'mouse': 'bluetooth', 'harddisk': 'ssd', 'graphicsCard': 'Gforce' }
print (computeParts)
diccionarioA = dict((('PersonaA', 1), ('PersonaB', 2)))                 # Usando tupla
print (diccionarioA)
diccionarioB = dict(dato1='bar', dato2='foo')                           # Usando cadenas simples 
print (diccionarioB)
print(computeParts['keyboard'])                                         # Acceso a un valor por clave
print(computeParts.get('Printer', 'no existe'))                         # Acceso a un valor por clave
if 'keyboard' in computeParts: print('Has keyboard')                    # Comprueba si existe una clave
print(computeParts.items())                                             # Listado de tuplas clave:valor
print(computeParts.keys())                                              # Listado de las claves
print(computeParts.values())                                            # Listado de los valores
computeParts['Printer'] = 'Epson'                                       # Añade un nuevo par clave:valor
print (computeParts)
computeParts.update({'graphicsCard' : 'ATI'})                           # Añadie con update()
print (computeParts)
del computeParts['keyboard']                                            # Borra un par clave:valor 
print (computeParts)
for key, value in computeParts.items(): 
  print(key,' => ',value)

Con esto hemos terminado la parte sobre estructura de datos y las operaciones que podemos realizar.

Si quieres ampliar mas información sobre estructura de datos y/o Pythondesde su página tienes toda la documentación.