Semana 8 - Programacion Imperativa Parte 2

Arreglos

Secuencias de una cantidad fija de valores del mismo tipo
Declaradas con nombre y tipo, (en algunos lenguajes tambien se debe indicar un tamaño fijo, en Python la longitud es variable)
Solamente hay valores en las posiciones validas (dentro de su tamaño)
Una sola variable contiene muchos valores, a cada valor se le accede mediante corchetes, y el primer elemento es el de indice 0
Como las listas, tambien son secuencias de elementos de un tipo, pero los arreglos suelen tener longitud fija, y se puede aceder a sus elementos de foram independiente y directa, mientras que los de la lista se acceden secuencialmente.

Arreglos en Python

Deberemos importar un modulo $a r r a y$ o $N u m P y$ para utilizarlos, y veremos que estan diseñados para trabajar con datos numericos, al ser creados se indica su tipo y opcionalmente su contenido inicial, el cual definira el tipo que deben tener el resto de sus elementos,

from array import *
a: array = array('i', [10, 20, 30])

Puede usar tipos Char, Float, Double, Int.
Podremos operar con ellas usando:

Funcion	Accion
a[i]	Obtiene el valor del elemento i de a
a[i] = x	Asigna x en el elemento i de a
a.append(x)	Añade x como nuevo elemento de a
a.remove(x)	Elimina el primer elemento de a que coincida con x
a.index(x)	Obtiene la posicion del primer elemento de a que coincida con x
a.count(x)	Devuelve la cantidad de apariciones de x en a
a.insert(p,x)	Inserta el elemento x delante de la posicion p en a

Listas en Python

En python, las listas pueden tener elementos de diferentes tipos de datos, y son parte de las estructuras de datos integradas en Python, sin requerir modulos adicionales. Al igual que los arrays, tienen tamaño dinamico, y son un poco menos eficientes que los arreglos en cuanto a memoria y rendimiento cuando se trabaja con grandes volumenes de datos numericos.
Se las declara como: $v a r i a b l e L i s t a = []$ para una lista vacia (tambien $o t r a V a r i a b l e L i s t a = l i s t ()$ ), o $o t r a V a r i a b l e = [1, 2, T r u e,^{'} H o l a^{'}, 5.8]$ (alternativamente $u n a M a s = l i s t ([4, 9, F a l s e,^{'} H o l a^{'}])$ )
Se operan con las mismas funciones que los arreglos, pero a diferencia de los arreglos, no podemos obtener una tupla con dirección de memoria actual de los arrays y numero de sus elementos, lo cual podríamos obtener con Buffer Info en arreglos.

Recorrer listas

Podemos recorrer los elementos de una lista utilizando indices y estructuras de control de ciclo, por ejemplo:

edades: list = [20, 41, 6, 18, 23]

# Recorriendo los indices
for i in range(len(edades)):
	print(edades[i])

# Con while y los indices
indice = 0
wihle indice < len(edades):
	print(edades[indice])
	indice += 1

# Recorriendo directamente mediante for
for edad in edades
	print(edad)

Matrices

Podemos pensar una matriz como una lista de listas, y recorrerla a traves de sus indices:

ganadores = [['Messi', 'Cristiano', 'Mbappe'], [7, 5, 1]]

# Recorriendo los indices, i serian las filas
for i in range(len(ganadores)):
	for j in range(len(ganadores[i])):
		print("ganadores["+str(i)+"]("+str(j)+") ="+str(ganadores[i][j]))

# Con while y los indices
fila = 0
while fila < len(ganadores):
	columna = 0
	while columna < len(ganadores[fila]):
		print("ganadores["+str(fila)+"]("+str(columna)+") ="+str(ganadores[fila][columna]))
		columna += 1
	fila += 1

Tipos Abstractos de Datos

Son modelos que definen valores y las operaciones que se pueden realizar sobre ellos. Son abstractos ya que la intencion es que quien los utiliza no necesite conocer los detalles de la representacion interna o como se implementan sus operaciones.
Las listas, por ejemplo, son TAD, se definen como una serie de elementos, tienen operaciones asociadas y desconocemos como se usa/guarda la info dentro del tipo.

Pila

Son listas de elementos de la cual se puede extraer el ultimo elemento insertado, tambien conocidas como listas LIFO (Last In-First Out), y tienen operaciones basicas como apilar (ingresar un elemento a la pila), desapilar (remover un elemento de la pila), tope (devolver el ultimo elemento insertado sin sacarlo) y vacia (retorna verdadero si esta vacia).
En Python, el tipo lista provee los metodos necesarios para operar una pila: $a p p e n d$ , $p o p$ , $a [- 1]$ y $l e n (a) == 0$ respectivamente.

Cola

Listas de elementos en donde siempre se insertan nuevos elementos al final de la lista y se extraen elementos desde el inicio de la lista, tambien conocidos como listas FIFO (First In-First Out). Sus operaciones son encolar, sacar o vacia, en python sus equivalentes serian $a p p e n d$ , $p o p (0)$ y $l e n (a) == 0$ .