TIPOS DE DATOS

ESTRUCTURADOS
PROFESOR: ISAAC ZÚÑIGA SILGADO

TOMADO DE: Python Programación, Libro digital, versión 2.1 – 2015. Luís Rodríguez
Ojeda; Escuela Superior Politécnica del Litoral.
TIPOS DE DATOS

• DATOS SIMPLES
o Utilizan variables simples. En un instante determinado, estas variables sólo pueden almacenar
un sólo valor (dato).
o Tipos de datos simples básicos: integer (número entero), float (número real), string
(alfanumérico o cadena) y boolean (booleano: true or false).

• DATOS ESTRUCTURADOS
o Utilizan estructuras de datos.
o Tipos de datos estructurados: Listas, Tuplas, Cadenas de caracteres (strings), Diccionarios y
Conjuntos.
DATOS ESTRUCTURADOS

• En ciencias de la computación, las estructuras de datos pueden ser dinámicas o estáticas.

En las primeras, durante la ejecución de un programa los valores de los elementos de la
estructura de datos pueden cambiar y el número de elementos es variable (puede cambiar:
disminuir o aumentar), este es el caso de las listas en Python; en las segundas, durante la
ejecución de un programa el número de elementos es fijo (no cambia, es constante).
• El lenguaje Python dispone además de librerías especiales para operar con los tipos de
datos estructurados.
• Una líbrería es una colección de métodos y funciones para manipular datos estructurados.
LISTAS

• Una lista es una colección de datos que pueden tener diferente tipo. Los datos se escriben entre corchetes,
separados por comas.
[dato, dato, dato, ..., dato]

• Una propiedad fundamental de las listas es que los componentes de la lista se pueden modificar después de
haberlas creado. Las listas son estructuras de datos dinámicas, es decir que pueden extenderse o
modificarse en forma interactiva y durante la ejecución de programas.
• Las celdas son numeradas desde cero. El primer componente o primera celda, tiene índice 0. El segundo
componente, o segunda celda, tiene índice 1, etc.
• Se puede acceder a los componentes de una lista mediante un índice entre corchetes Se puede acceder a
varios elementos o componentes mediante un rango para el índice.
• El rango no incluye el extremo derecho especificado.
LISTAS
Referenciando los componentes de una lista

El índice fuera de rango

produce un error
LISTAS
Referenciando los componentes de una lista
Ejemplo:
LISTAS
Referenciando los componentes de una lista
Ejemplo:
LISTAS
Referenciando listas con componentes tipo lista
LISTAS
Referenciando listas con componentes tipo lista
Sentencia Descripción de la ejecución de la sentencia
L1 = [1, 2, 3, 4] Se asigna el nombre L1 a una lista con los datos 1,
2, 3, y 4.
L2 = [5, 1.2, True, 'caja'] Se asigna el nombre L2 a una lista con los datos 5,
1.2, True, 'caja'.
L3 = [L1, L2] La variable L3 es una lista que contiene dos listas
y podemos acceder a cualquiera de los elementos
usando dos índices. L1 se considera en la posición
0 de L3, y L2 se considera en la posición 1 de L3.
print L3 Se imprime [[1, 2, 3, 4], [5, 1.2, True, 'caja']]
L3[0] Llamado a la lista L1 que se encuentra en la
posición 0 de L3, respondiendo con los valores [1,
2, 3, 4].
L3[0][3] Llamado a la lista L3 su posición 0 que es L1 y
dentro de L1 su posición 3, respondiendo con el
valor 4.
L3[1] Llamado a la lista L2 que se encuentra en la
posición 1 de L3, respondiendo con los valores [5,
1.2, True, 'caja'].
L3[1][1] Llamado a la lista L3 su posición 1 que es L2 y
dentro de L2 su posición 1, respondiendo con el
valor 1.2.
LISTAS
Librerías Especiales

Colección de métodos y
funciones para manipular
listas.
LISTAS
Librerías Especiales

Para listar estos métodos en el interface

de Python, se escribe el nombre de la
variable seguida de un punto “.” y
aparece un menú de los métodos.

Para usar estos métodos se escribe la

variable seguida de un punto y el nombre
del método con los argumentos
necesarios. Veamos los siguientes
ejemplos con algunos de los métodos:
LISTAS
Librerías Especiales: El método append

El método append adiciona un elemento a la Sentencia Descripción de la ejecución de la sentencia

lista colocándolo en la posición superior del L1 = [1, 2, 3, 4] Se asigna el nombre L1 a una lista con los datos 1, 2,
3, y 4.
índice. Este método hace que la lista tenga un
elemento más y lo ubica en la posición print L1 Se imprime [1, 2, 3, 4].

después del último elemento. L1.append(-2) Se le adiciona un elemento a L1 y lo ubica en la

posición más superior. L1 queda así: L1 = [1, 2, 3, 4,
-2].
Ejemplo: Dada la lista L1 = [1, 2, 3, 4], en las siguientes
instrucciones primero se adiciona -2 y luego 3. print L1 Se imprime [1, 2, 3, 4, -2].
L1.append(3) Se le adiciona un elemento a L1 y lo ubica en la
El uso del método append nos muestra que el tamaño o posición más superior. L1 queda así: L1 = [1, 2, 3, 4,
número de elementos (componentes) de una lista puede -2, 3].
cambiar. Por ejemplo, nosotros podemos definir una lista
sin ningún elemento, así: L=[]; después podemos utilizar print L1 Se imprime [1, 2, 3, 4, -2, 3]
el método append para adicionarle valores (datos).
LISTAS
Librerías Especiales: El método count
El método count cuenta cuantos
elementos de una lista son iguales a un
argumento.
Ejemplo: Dada la lista L1 = [1, 2, 3, 4, -2,
3], en la tabla siguiente se describe el
resultado de ejecutar las instrucciones que
se encuentran en la primera columna de la
tabla.
Sentencia Descripción de la ejecución de la sentencia
L1 = [1, 2, 3, 4, -2, 3] Se asigna el nombre L1 a una lista con los datos 1, 2, 3,
4, -2 y 3.
L1.count(3) La ejecución de esta sentencia nos imprime en
pantalla el valor 2. En este caso encontró que dos
elementos de L1 son iguales a 3.
L1.count(2) La ejecución de esta sentencia nos imprime en
pantalla el valor 1. En este caso encontró que un
elemento de L1 es igual a 2.
L1.count(50) La ejecución de esta sentencia nos imprime en
pantalla el valor 0 (cero). En este caso encontró que
ningún elemento de L1 es igual a 50.
LISTAS
Librerías Especiales: El método insert
El método insert permite insertar en
la posición definida por el primer
argumento, un elemento cualquiera
en la lista, definido por el segundo
argumento.
Sentencia Descripción de la ejecución de la sentencia
L1 = [1, 2, 3, 4, -2, -2, 1, 2, Se asigna el nombre L1 a una lista con los datos 1, 2, 3, 4,
3, 4, -2, -2] -2, -2, 1, 2, 3, 4, -2, -2.
L1.insert(0,111) Se inserta el elemento 111 en la posición del índice 0 de
la lista L1. Quedando L1 = [111, 1, 2, 3, 4, -2, -2, 1, 2, 3, 4, -
2, -2].
L1.insert(4,3333) Luego de ejecutar la sentencia anterior, se inserta el
elemento 3333 en la posición del índice 4 de la lista L1.
Quedando L1 = [111, 1, 2, 3, 3333, 4, -2, -2, 1, 2, 3, 4, -2, -
2].
LISTAS
Librerías Especiales: El método sort

El método sort ordena los elementos de la lista

según un criterio, en este ejemplo, el
ordenamiento es de forma ascendente
colocando en el primer índice el elemento
Sentencia Descripción de la ejecución de la sentencia
L1 = [111, 1, 2, 3, 3333, Se asigna el nombre L1 a una lista con los datos 111,
4, -2, -2, 1, 2, 3, 4, -2, - 1, 2, 3, 3333, 4, -2, -2, 1, 2, 3, 4, -2, -2.
2]

menor y en el último índice el elemento

mayor. L1.sort() La ejecución de esta sentencia nos ordena L1 en
forma ascendente . En este caso los elementos de
L1 quedan ubicados de la siguiente manera: L1 = [-2,
-2, -2, -2, 1, 1, 2, 2, 3, 3, 4, 4, 111, 3333].
Ejemplo: Dada la lista L1 = [111, 1, 2, 3, 3333,
4, -2, -2, 1, 2, 3, 4, -2, -2], en la tabla siguiente
se describe el resultado de ejecutar las
instrucciones que se encuentran en la primera
columna de la tabla.
LISTAS
Librerías Especiales: El función len()

Adicional a los métodos de los objetos

Sentencia Descripción de la ejecución de la
tipo lista, existen también funciones del sentencia
Python que se pueden aplicar a estas L1 = [111, 1, 2, 3, Se asigna el nombre L1 a una lista con los
listas, como por ejemplo la función len(). 3333, 4, -2, -2, 1, 2, datos 111, 1, 2, 3, 3333, 4, -2, -2, 1, 2, 3, 4, -2, -
3, 4, -2, -2] 2.

La función len() responde con el número

len(L1) La ejecución de esta sentencia nos imprime
de elementos que tiene la lista que se el valor de 14 indicándonos que L1 tiene 14
define en el argumento. Ver ejemplo de elementos.
la siguiente tabla
LISTAS
Librerías Especiales: La función range ()
Esta función range() propia del Python
genera listas de números enteros donde
los argumentos son el valor inicial, el
valor final y cada cuanto el incremento
para generar un numero,
respectivamente. La sintaxis es:
range(valor inicial, el valor final,
incremento para generar un número).
En la siguiente tabla se muestra ejemplos
de como se pueden generar listas con
esta función:
Sentencia Descripción de la ejecución de la sentencia
L4 = range(0, 8, 2) Se genera la lista L4 con números empezando en 0 y
terminando en 8, con incrementos o saltos de 2 en 2. La
lista L4 queda con los elementos 0, 2, 4, 6.
L4 = range(0, 9, 2) Se genera la lista L4 con números empezando en 0 y
terminando en 8, con incrementos o saltos de 2 en 2. La
lista L4 queda con los elementos 0, 2, 4, 6, 8. Este ejemplo
se utiliza para aclarar que los elementos de L4 se
generan hasta un valor menor que el argumento dado
porque el siguiente (10) queda por fuera del rango
definido.
L4 = range(4, 15, 3) Se genera la lista L4 con números empezando en 4 y
terminando en 15, con incrementos o saltos de 3 en 3. La
lista L4 queda con los elementos 4, 7, 10, 13. Este ejemplo
se utiliza para aclarar que los elementos de L4 se
generan hasta el porque el siguiente (16) queda por fuera
del rango definido.
LISTAS
Definición de una lista

Definición de una lista vacía: Definición de una lista con range():

X=[] X = range (2, 11, 2)

La lista x no contiene elementos La lista X contiene números pares del 2 al

10
Definición de una lista con componentes:
X = range (1, 11, 2)
X = [123,'Algebra',[50,70],5,73.25]
La lista X contiene números impares del 1
La lista X contiene 5 elementos al 9
LISTAS
Definición de una lista
Ejemplo: Asignar el nombre Saldo a una lista con los Forma 2:
5 datos (componentes): 0.0, 0.0, 0.0, 0.0 y 0.0.
Saldos = [ ]
for i in range(5):
Forma 1: Saldos.append(0.0)

Ejemplo: El ejemplo anterior, pero ahora los valores

de los componentes de la lista Saldos se digitan desde
el teclado y pueden ser diferentes de 0.0

Saldos = [ ]
for i in range(5):
dato=float(input("Digite un número tipo real:")
Saldos.append(dato)
LISTAS
Uso de listas
Ejemplo1: Crear una lista con el nombre Nom, que contenga los nombres Ejemplo2: Crear una lista con el nombre Defi que contenga las notas definitivas
de n estudiantes. de n estudiantes.

n = int(input("Digite el número de estudiantes: ")) n = int(input("Digite el número de estudiantes: "))

Nom = [] Defi = []
for i in range(n): for i in range(n):
nombre = raw_input("Digite el nombre del estudiante:") promedio = float(input("Digite la nota definitiva del estudiante:")
Nom.append(nombre) Defi.append(promedio)

Ejemplo3: Crear una lista con el nombre Nom, que contenga los nombres de
n estudiantes.

n = int(input("Digite el número de estudiantes: "))

Nom = []
Defi = []
for i in range(n):
nombre = raw_input("Digite el nombre del estudiante:")
promedio = float(input("Digite la nota definitiva del estudiante:")
Nom.append(nombre)
Defi.append(promedio)
LISTAS
Uso de listas
Ejemplo: Elabore un programa en Python que cree una lista de N componentes, estos se leen desde el teclado. Luego lea un valor X y averigüe e
imprima si ese valor está o no en la lista. Imprima además cuántas veces el valor de X está en la lista.

n=int(input("digite el valor de n:")) # DEFINICIÓN DE VARIABLES Y EXPLICACIÓN DE LO QUE

v=[0.0 for i in range(n)] HACE
for i in range(n): # EL PROGRAMA
v[i]=float(input("digite el valor a guardar en la lista:")) #
print v # v es el nombre de la lista
x=float(input("digite el valor de x:")) # n es el número de elementos de v
c=0 # la variable contador c nos permite averiguar cuántas veces el valor leído
for j in range(n): # en la variable x se encuentra en v. La variable c se inicia en cero porque
if x==v[j]: # suponemos que el valor de x no se encuentra en v. Se compara el valor
c=c+1 # de x con cada uno de los elementos de v, cada vez que encuentra un
# Sí c no es mayor que cero es porque no encontró el valor de x igual # elemento igual al valor de x, la variable c se incrementa en 1.
# a ningún elemento de la lista v. # Después de salir del ciclo de j, sí c no es mayor que cero es porque no #
if c>0: encontró el valor de x igual a ningún elemento de v.
print "x esta en el vector "
else:
print"x no esta en el vector"

# fin del programa

TUPLAS

Una tupla es una colección de datos que pueden tener diferente tipo. Los datos se escriben entre paréntesis, separados por comas con la
siguiente sintaxis. Opcionalmente se pueden omitir los paréntesis:

(dato, dato, dato, ..., dato)

Son estructuras de datos estáticas, es decir que no se pueden extenderse o modificarse en forma interactiva y durante la ejecución
de programas. Los componentes de una tupla no se pueden modificar después de haber sido creados.
Las celdas son numeradas desde cero. El primer componente, o primera celda, tiene índice 0. El segundo componente, o segunda celda,
tiene índice 1, etc.
Se puede acceder a los componentes de una tupla mediante un índice entre corchetes
Se puede acceder a varios elementos o componentes mediante un rango para el índice.
El rango no incluye el extremo derecho especificado.
TUPLAS
Creación de una tupla

Ejemplo. Descripción de una tupla con 5 componentes de tipo diferente.

>>> x = ('abc', 73, 5.28, 'rs', 5)
La representación de una tupla en celdas de memoria numeradas desde cero:

Son los mismos ejemplos usados en la sección anterior para describir las listas, pero ahora
los resultados son tuplas.
TUPLAS
Creación de una tupla

Son los mismos ejemplos

usados en la sección
anterior para describir las
listas, pero ahora los
resultados son tuplas.
TUPLAS
Creación de una tupla
Los paréntesis son opcionales para definir tuplas
x = ('abc', 73, 5.28, 'rs', 5)
print x
('abc', 73, 5.28, 'rs', 5)
Se puede escribir
x = 'abc', 73, 5.28, 'rs', 5
print x
('abc', 73, 5.28, 'rs', 5)
TUPLAS
Tupla con componentes de tipo lista
LISTAS Y TUPLAS
Analogías y Diferencias

• Enunciar un problema y resolverlo de dos maneras diferentes. Una forma utilizando listas
y la otra utilizando tuplas.
• Explicar brevemente dos analogías en el uso de listas y tuplas.
• Explicar brevemente dos diferencias en el uso de listas y tuplas.
DICCIONARIOS

Los diccionarios son colecciones de datos con un formato especial que permite definir y
acceder a los componentes únicamente mediante una clave. Cada componente de un
diccionario es un par clave:valor y se escriben entre llaves o corchetes, separados por
comas con la siguiente sintaxis:
{clave: valor, clave: valor, clave: valor, ..., clave: valor}

Las claves pueden ser de diferentes tipos y los datos también pueden ser de diferentes tipos,
inclusive listas o tuplas. No se pueden modificar las claves pero si se pueden modificar
los valores que están asociados a las claves.
Los componentes de un diccionario no están en un orden específico.
Para acceder a los elementos de un diccionario debe especificarse la clave entre corchetes.
DICCIONARIOS
Referenciando los componentes de un diccionario
Ejemplo. Descripción de un diccionario con clave numérica entera y valor tipo cadena.

>>> x={123: 'Algebra', 325: 'Física', 215: 'Química'}

Su representación conceptual en la memoria con celdas identificadas con la clave

>>> x[123] Mediante la clave se accede al valor

'Algebra'

>>> x[215]
'Química'

>>> x[123]='Matemáticas’ Se puede modificar el valor

>>> x
{123: 'Matemáticas', 325: 'Física', 215: 'Química'}
DICCIONARIOS
Referenciando los componentes de un diccionario

Ejemplos

diccionario = {"nombre":“Carlos"} La llave es nombre, y el valor es Carlos

diccionario = {
"nombre":“Carlos" ,
"Edad":23,
"Cédula":"1009876352",
}
DICCIONARIOS
Referenciando los componentes de un diccionario
Para acceder al valor de la llave “Edad”:
print(diccionario["Edad"])
>>> 23

Para ver cuáles son las llaves de mi diccionario:

print(diccionario.keys())
>>> dicc_keys(["nombre“, "Edad", "Cédula"])

Para crear una lista con las llaves de mi diccionario:

Lista_Llaves = diccionario.keys()
Lista_Llaves = ["nombre“,"Edad", "Cédula"]
DICCIONARIOS
Referenciando los componentes de un diccionario

Para saber cuáles son los valores de cada llaves de mi diccionario:

print(diccionario.values())
>>> dicc_values([“Carlos”, 23, "1009876352“])

Para crear una lista con los valores de las llaves de mi diccionario:
Lista_Valores = diccionario.values()
Lista_Valores = [“Carlos”, 23, "1009876352“]
DICCIONARIOS
Referenciando los componentes de un diccionario
Para conocer las llaves de mi diccionario:
for key in diccionario:
print(key)

Para conocer los valores de las llaves de mi diccionario:

for key in diccionario:
print(diccionario[key])

Para conocer las llaves con sus valores de mi diccionario:

for key in diccionario:
print(key, diccionario[key])
Para conocer las llaves con sus valores de mi diccionario:
print(diccionario.items())
DICCIONARIOS
Diccionarios con componentes de tipo lista

Defina un diccionario con clave numérica y valor asociado definido mediante una
lista de dos componentes: nombre y edad.

>>> x={123:['Anita',25],234:['Elena',34],456:['Carmen',45]}

>>> x
{456: ['Carmen', 45], 234: ['Elena', 34], 123: ['Anita', 25]}

>>> x[123]

['Anita', 25]
DICCIONARIOS
Diccionarios con componentes de tipo lista

Defina un diccionario con clave numérica y valor asociado definido mediante una
lista de dos componentes: nombre y edad.
>>> x[123][0]
'Anita'

>>> x[123][1]
25

>>> x[123][0]='María’ Se puede cambiar el nombre

>>> x
{456: ['Carmen', 45], 234: ['Elena', 34], 123: ['María', 25]}

>>> x[123][1]=27 Se puede cambiar la edad

>>> x
{456: ['Carmen', 45], 234: ['Elena', 34], 123: ['María', 27]}
DICCIONARIOS
Diccionarios con componentes de tipo lista

Eliminar elementos del diccionario dada una clave: del

>>> del x[234]
>>> x
{456: ['Carmen', 45], 123: ['María', 27]}

Listar las claves: keys

>>> c=x.keys()
>>> list(c)
[456, 123]

Detectar si el diccionario contiene una clave: in

>>> 123 in x
True
>>> 234 in x
False
DICCIONARIOS
Diccionarios con componentes de tipo lista

Agregar elementos a un diccionario

>>> x[572]=['Juanita',26]
>>> x
{456: ['Carmen', 45], 123: ['María', 27], 572: ['Juanita', 26]}

Recorrido de los componentes de un diccionario

>>> for i in x:
print(i,x[i])

456 ['Carmen', 45]

123 ['María', 27]
572 ['Juanita', 26]
LISTAS, TUPLAS Y DICCIONARIOS
Analogías y Diferencias
• Enunciar un problema y resolverlo de tres maneras diferentes. Una forma utilizando listas; otra,
utilizando tuplas; y la otra, utilizando diccionario.

• Explicar brevemente dos analogías en el uso de listas y tuplas.

• Explicar brevemente dos diferencias en el uso de listas y tuplas.
• Explicar brevemente dos analogías en el uso de listas y diccionarios.
• Explicar brevemente dos diferencias en el uso de listas y diccionarios.
• Explicar brevemente dos analogías en el uso de tuplas y diccionarios.
• Explicar brevemente dos diferencias en el uso de tuplas y diccionarios.
LISTAS, TUPLAS Y DICCIONARIOS
Ejemplos de Aplicación/Uso

• Cite dos casos (ejemplos) donde se puedan utilizar las listas.

• Cite dos casos (ejemplos) donde se puedan utilizar las tuplas.
• Cite dos casos (ejemplos) donde se puedan utilizar los diccionarios.
ARRAYS

• Definición de arreglo
• Componentes de un arreglos: nombre, subíndice, elemento, número de elementos
• Tipos de arreglos: arreglos unidimensionales, bidimensionales, tridimensionales, , cuatridimensionales,…,
n-dimensionales.
• Referencia a un arreglo y a sus elementos ¿Cómo utilizo los datos/elementos de un arreglo?
• Operaciones con arreglos
• Casos especiales del tipo de datos lista: vectores (unidimensionales) y matrices (bidimensionales)
• Referencia a un vector y/o a una matriz
GRACIAS