01/03/23

TEORÍA

Introducción a la computación

Objeto: resolución de problemas

Pensamiento computacional es la forma de resolver problemas usando tecnología

 Modelos abstractos
 Enfoque algorítmico

Campos: descomposición de problemas, reconocimiento de patrones, abstracción, diseño lógico y

algorítmico

Concepto de divide y vencerás: descomposición de problemas y resolver

Un algoritmo es un grupo finito de instrucciones u operaciones organizadas de manera lógica que

al ser ejecutadas sobre un conjunto de entradas procederá por una secuencia de estados
perfectamente definidos para producir un resultado, permitiendo resolver un problema

El pensamiento algoritmo es la capacidad de realizar la abstracción para escribir el algoritmo

Pensamiento lógico

Su base es el pensamiento secuencial

Tomar ideas importantes

Problemas del universo: computables (solución) o no computables

Computables: tratables (máquina de Turing comprueba) (rápidos y útiles, descomposición de los

intratables) e intratables (tiempos indefinidos)

Conocimiento declarativo (declaraciones de hecho, es o no), conocimiento imperativo (que hacer,

procedimental, practico) (ejemplo algoritmo de la raíz)

Diagramas de flujo: conjunto de símbolos: inicio, fin, opera sobre entradas, tiene resultado,
distintos bloques representan operaciones y flechas de dirección

Quien ejecuta el algoritmo es la computadora programable o no

Arquitectura de una computadora

Unidad de procesamiento central:

 Unidad de control
 Unidad aritmético lógica (recibe la entrada de dispositivos y hace cálculos: tiene contacto
con la memoria y emite la salida a través de dispositivos)

Almacenamiento: guardar datos

  Memoria RAM
 Discos
 Pen drives

Capas de abstracción

(HARD) Semiconductores, sistemas analógicos, sistemas digitales, uArch, CPU,

(SOFT) Código de máquina, lenguaje ensamblador, lenguaje de alto nivel, algoritmo, problema

Bajo nivel -> Alto nivel

Lenguajes de programación

 Son formales
 Son explícitos
 Libres de ambigüedades

Construcciones primitivas: literales, operadores

Sintaxis

(semántica estática: define que sentencias sintácticamente validas tienen sentido)

(Semántica: el sentido de las sentencias y su ambigüedad)

Errores de sintaxis (escritura formal), errores de semántica estática (“sumar números y palabras”)
y errores de semántica (“bug, ejecuta, pero sin sentido”), palabras reservadas del lenguaje

Python

Datos: int, float, str, bool, NoneType

Variable: espacio en la memoria: identificador, asignacion, valor

Funciones built-in (integradas): abs(), help(), print(), input(), type(), str(), int(), float(), bool(), len(),
range(), round()

Secuencias de escape: ‘\n’ (salto), ‘\r’ (retrocede al comienzo de linea), ‘\b’ (retrocede un carácter
borrando el ultimo),’\t’ (agrega tabulación horizontal)

f-strings: x = f’hola {nombre} como estas’

Expresiones: literales (constantes), variables, operador, composiciones, sentencias

Consola

Interfaz para interactuar con el pc que ejecuta ordenes interpretadas por un Shell (interprete o
programa que interpreta las ordenes y comandos) de texto. Los más famosos: cmd, bash, zsh

Comandos básicos cmd: cd, dir, cls

08/03/23

Decisiones

Condicionales (if): estructura de control que cambia el flujo tomando decisiones, condición True o
False y una o mas sentencias en el cuerpo del if en caso de ser True (indentación necesaria)

If: Forma romboidal en diagrama de flujo, sentencias: forma rectangular

Operadores de comparación: ==,!=,<,>, <=, >=

Conversiones de tipos: implícita al comparar int con float o al ingresar “hola” el bool(“hola”) por
ejemplo o explicita utilizando la función de cada tipo por ejemplo bool(2132) es decir, castear

Guardar un valor en una línea (ahorrar if):

Number = 2

Is_positive = number > 0

If, else, elif

Diagrama de flujo: es un diagrama que describe la evolución de un algoritmo, proceso o sistema,

permite documentar y comprender de forma simple algunos procesos. Se usan figuras
geométricas. Evitar diagramas enormes: no es recomendable dibujar el programa completo.

Símbolos:

 Terminal: inicio o fin con rectángulo circular

 Entrada o input: paralelogramo
 Decisión: rombo
 Rectángulo: proceso o sentencia
 Salida u output (print): trozo de hoja
 Proceso predefinido (funciones) = caja con líneas dentro

Expresión condicional al asignar valor de variables:

Variable = <expresion1> if <condición> else <expresion2> if <condicion2> else <expresion3>

09/03/23

Lógica binaria

Es una construcción con 2 elementos: falso y verdadero (0 y 1)

Se construye sobre el Álgebra de Boole

 Operaciones unitarias: NO (not, -)

 Operaciones binarias: Y (and, .), O (or,+)

Tablas de verdad con F y V

Y operaciones con estas

En Python: operadores lógicos: not, and, or

Evaluación mínima: si tengo un f con and ya sé que es falso o así con un v en un or

Operadores aritméticos: /,*,//,…

Operadores de comparación: ==,!=,<,…

Operadores de asignación: =,+=,-=,*=,/=,//=,%=,**=

Operadores de pertenencia: in, not in (tiene un is implícito)

Operadores de identidad: is, is not (similar al ==)

Errores

Error de sintaxis -> mensaje de error (lo detecta el intérprete)

o SyntaxError: código mal escrito

Error semántico -> no genera excepción (se detecta con testing)

Error de ejecución -> genera excepción (difíciles de reproducir, programación defensiva)

o NameError: variable no creada se quiere acceder

o ZeroDivisionError: división por 0
o TypeError: operación o función a tipo de dato inapropiado
o AttributeError: llama un atributo que el objeto no posee
o IndexError: acceder a una sentencia con un índice que no existe
o KeyError: acceder a un diccionario con una key no existente
o FileNotFoundError: acceder a un archivo que no existe
Try:

Sdfsdfsd

Except <tipo de error>:

Fasdssdfaafds

Except:

Asdjaghf

*Agregar while True para que repita hasta conseguir el resultado buscado

15/03/23

Ciclos while (ciclo indefinido)

Ciclo: Estructura básica, repetir sentencias, estructura de repetición, existen ciclos con cantidad de
repeticiones desconocidas o indefinidas, existen ciclos con una cantidad de repeticiones fija,
definidas (desde que escribimos el código)

El while repite sentencias indefinidamente mientras se mantenga verdadera una condición,

cuando la condición deja de cumplirse, corta.

Pseudocódigo: manera análoga de escribir código con palabras

Diagrama de flujo while: circulo vacío + condición

Condición de corte (centinela): define la cant. De iteraciones

Ej: algoritmo de herón

El usuario define la cantidad de iteraciones

 Break: palabra para romper y salir el ciclo infinito

 Continue: termina el cuerpo del while pero vuelve a la condición sin salir delbucle.

No hay condición de corte: repetición infinita

16/03/2023

Ciclo for (ciclo definido)

Repite una cantidad de veces fija, depende de una secuencia de valores especificada, en cada
ciclo, se lee un valor de esa secuencia

Funcion range(): Comienza en start, para ANTES de stop, avanza de a step “for i in range(0 p
inicio ,4 o fin,1 o paso)”. Range(0,10,1) = Range(10). Devuelve un range, similar a “array”

23/03/23

Funciones

Párametros o entradas o argumentos -> f(x) -> salidas o valor de retorno

def <nombre>(param1, param2,…):

“””

Docstring (documentación)

“””

<sentencia>

Return <out>

Help(<nombre>) -> devuelve Docstring

Razones de usar funciones (divide el código en módulos):

 Separar problemas
 Autocontenidos
 Reutilizables
 Parametrizables
 Código ordenado y coherente

Alcance (scoping)

¿Se puede utilizar variables definidas fuera de la función dentro? Sí (con su valor en el momento
de invocar la función, aunque prioriza el valor local) (si ya está definido, sino: UnboundLocalError)
(variables globales)

pero no utilizar variables definidas o alteradas dentro de la función fuera. (estas variables sólo
existen dentro de la función: variables locales)

Importar y alterar variables globales dentro de una función a partir de: global <nombre>

Buenas prácticas: mantener variables globales por un lado y locales por otro

29/03/23

Funciones

Argumentos por omisión (set valores por default)

Def <name>(<arg1>=<value1>,…):

Type hints (typing)

Python: tipado dinámico de datos, no estático

Pero se agregan sugerencias en args, no se modifica, solo sirve para documentar e interpretar
mejor

Def <nombre>(<arg>: <tipo>) -> <tipo>:

Función Lambda

Funciones anónimas de una línea

lambda <argumentos>: <expresiones>

Admite args por omisión, multiples retornos y pueden pasarse como arg a otras funciones

Paradigmas

Fail fast, return early: probar errores al inicio, muchos puntos de salida, fácil de leer y depurar y de
encontrar lo que se quiere hacer

*Se puede colocar dos return: se devuelve el primero ejecutado

Single entry, signle exit: unico punto de entrada y salida (un return), prueba errores encadenados,
genera indentación (if if if if por cada error posible), fácil determinar donde sale la función

Módulos

Archivos de Python con extensión .py

Importar con import. Si esta en la misma carpeta se pone solo el nombre del archivo sino el path

Un módulo puede importar otros módulos

Formas de importar

<modulo>.<variable o funcion> para usar una función o variable de un módulo

Import modulo1

Import modulo1 as mod (modifica el nombre del modulo a mod y ahora se invoca así)

From modulo1 import * (importa todas las variables o funciones sin necesidad de invocar de la
forma <mod>.<nombre>, puede haber colisión de nombres)

From modulo1 import pi, get_Radius (importa solo elementos especificados)

Modulos comunes: math, random, numpy as np, pandas as pd, matplotlib.pyplot as plt

Función main

Cuerpo principal del programa. Sin main interpreta todo lo de fuera de las funciones como main,
con def main(): se ejecuta solo main() al invocarla. Se ejecuta solo en el archivo en que esta

Si en cada modulo ponemos if __name__ == “__main__”:main() El cuerpo de ese if se ejecutara

solo si ese modulo se ejecuta como programa principal. Automático en el interprete. La condición
es falsa al ser importada por otro archivo

30/03/23

Secuencias: cadenas, tuplas, listas

Int, float son tipos escalares, str es un tipo estructurado, formado por la unión de caracteres
individuales

Secuencias: estructura de datos que agrupa varios elementos. Tienen orden, se puede iterar sobre
ellos, se pueden obtener los elementos directamente, soportan operaciones comunes.

Cadenas

Str, secuencias de caracteres inmutables

Tuplas

Tuple, entre paréntesis, separación por comas, inmutables

Listas

List, entre corchetes, separación por comas, mutables

Operaciones comunes: type, len, +. *, for in, in

Largo de las secuencias: len(cadena, tupla o lista) -> int

Indexing: secuencia[int], de 0 a len(secuencia)-1

Índices negativos: [-len(secuencia),-1] (tanto en positivos como en negatvos no se puede más alla
de su longitud de 0 a len o de 0 a -len)

Mutabilidad: solo en listas (al cambiar un string o tupla, se destruye la antigua y se crea una nueva
con un nuevo lugar en memoria, al cambiar una lista no se cambia el lugar de la memoria)

Slicing: se obtiene una subsecuencia de la secuencia original:

Secuencia[int:int:int] (desde que índice, hasta cual (no incluye el último) (se puede omitir para
tomar todos), paso)

Siempre con corchetes sin importar si es tupla o lista

05/04/23

Desempaquetado de elementos de secuencias en variables

Y en iteraciones

Funcion enumerate(<secuencia>, desde que numero)

Funciones comunes: len, min, max, count, conversiones, index, find (solo en cadenas, no devuelve
error si no esta), upper, lower, title, Split(delimitador), join(delimitador), isalpha, isalnum,
isdecimal, isupper, islower, append, remove, insert, pop, extend, copy, replace

Listas de comprensión:

<lista> = [<expresión> for <item> in <iterable>]

<lista> = [<expresión> for <item> in <iterable> if <condición>]

12/04/23

Diccionarios

Key – value

Dic = {“fdsa”:”sdfadf”, “dfssdf”:”asdadfs”}

Diccionarios dentro de diccionarios: doble claves para entrar

Operaciones:

Añadir: Dic[“nuevakey”] = {“ytee”:”yeytr”}

Borrar: del[key]

Funciones: keys(), values(), ítems(), get(key) (retorna el valor de esa clave), pop(key)

Diccionarios de compresión:

Dic = {10:”diez”, 20:”veinte”}

Dic2 = {k:v.upper() for (k,v) in Dic1.items()}

Diccionarios mezclados con funciones (meter funciones dentro de values de un diccionario y

usarlas con nombre de las keys, reasigna nombre de cierta forms)

Numero variable de argumentos - *args

Def usar_variables(x,*arg_values):

For values in arg_values:

Print(values)

Doble asterisco: **args: se permiten multiples parámetros con un nombre explícito: (estructura de
un diccionario dentro de los parámetros de la función, valores por default)

Def usar_variables(x, **arg_dict)

For key, value in arg_dict.items():

Print(key, value)

Usar_variables(“primero”,a2 = “fds”, a3=”fda”)

Manejo de archivos

Código ASCII: American Standard Code for Information Interchange

Codigo mediante el cual se le asigna un número a símbolos y caracteres alfanuméricos (ya que las
maquinas solo entienden números)

Carácter ASCII -> Valor decimal -> Valor binario

“g”-> 103 -> 01100111

Cada carácter tiene asignado un numero hasta 00 a 255 (en principio, 8 bits)

Estandar más amplio: Unicode (incluye ASCII y más)

Conversion entre carácter y decimal: chr(), ord()

Carácter: Chr(946) -> carácter = <BETA>

Ordinal: ord(“?”) -> ordinal = 63

Archivos

Secuencia de datos almacenados en memoria, identificado por nombre a nivel de usuario (la
extensión es parte del nombre), el SO nos da funciones para usarlo

Existen dos: archivos de texto (ASCII), archivos binarios

 Archivos binarios: no es legible por una persona (ej: program.exe), la info se interpreta a
nivel de bit o byte (visor de archivos lo ve de forma determinada)
 Archivo de texto: datos son todos caracteres ASCII/Unicode, no incluyen info como tipo de
letra, cursiva, negrita, no necesito software especializado, solo un editor de texto plano,
tienen líneas separadas por el ‘\n’ o ‘\r\n’ (ej: archivos.py,.txt,.csv), la extensión es por
comodidad, para identificarlos

Apertura de archivos

Archivo_x = Open(“file.txt”, mode = ‘r’)

r = read, w = write, x = create, a = append, b = binario, r+, w+, a+, x+, rt

Cierre de archivos

Archivo_x.close()

Cerrarlo cuando se dejan de utilizar, no se guardan cambios hasta que se cierra

Lectura de archivos - .readline() o .readline(n) (n= hasta que caaracter)

Línea1 = Archivo_x.readline()

Línea2 = Archivo_x.readline()

Lee una línea hasta \n del archivo

.readlines(), retorna todas las líneas almacenadas en una lista

Iteración : for línea in Archivo_x: o

Lista_De_lineas = Archivo_X.readlines()

for línea in lista_De_lineas

Métodos de cadenas de archivos: .strip(caracteres) elimina ese carácter en ambos

extremos, .rstrip() elimina solo desde la derecha, .lstrip() elimina solo desde la izquierda, sin
parámetros elimina los caracteres especiales: espacios, saltos de línea, tabs, etc. RETORNA LA
LINEA NUEVA, NO ES UNA FUNCION AUTONOMA

Archivos de escritura: .write()

13/04/23

Operador de contexto: with open(“nombre.txt”) as archivo:

Cierre automático al final

SEGUNDO BIMESTRE

08/05/23

Algoritmos de búsqueda

 Index: falla en caso de no existir el elemento

 Find: solo para strings

Se necesita un nuevo algoritmo.

Lineal:

Busqueda lineal con corte: (El orden de una cadena es alfabético, un caracter es menor a otro de
acuerdo a su valor Unicode 'aardonyx'<'abelisaurus' Es True), si el elemento no esta se evita
recorrer el resto.

Para todo i entre 0 y N (no inclusive):

si lista[i] es igual a target entonces:

devolver i

si lista[i] es mayor a target entonces:

devolver -1

devolver -1

Puede ser mejor:

Comparación por bisección o

Algoritmo de búsqueda binaria

Complejidad temporal T(N)

En el algoritmo de búsqueda lineal T(N) es proporcional a N

En búsqueda binaria, si largo N = 2k, se necesitan k pasos en total. Para expresar k en función de N,
tomamos logaritmo y k = log2(N) entonces T(N) es proporcional a log2(N) (crece logarítmicamente y
no linealmente)

Nociones de complejidad temporal

Big O Notation: T(N) como función, el algoritmo se asegura ser mejor o igual que el anterior
diciendo que pertenece al conjunto O(vieja funcion). O = orden
10/05/23

Propiedades de Big O: multiplicar por una constante o sumarle una constante no modifica el
orden, grado de mayor peso

Que complejidad temporal tiene

 Constante: O(1)
O(n2) O(log(n)
)

Lineal: O(n)
O(n2) O(n log(n))

Complejidad de funciones built-in de pyhton: pagina web

Algoritmos de ordenamiento

Para la búsqueda binaria necesita estar ordenada la lista:

Utilizar la función sort. Complejidad temporal de sort?, tiene que pasar una vez por cada
elemento, por lo que la complejidad temporal es peor o igual a la búsqueda lineal tradicional

Entonces conviene hacer búsqueda binaria:

 Cuando necesitemos hacer mas de una búsqueda sobre la misma lista

 Se la ordena una sola vez y luego se busca las veces necesarias

Ordenamiento Bogo

Random -> Ordenado? -> Repetir o terminar

Repetir ciclo:

Revisar lista completa

Si lista esta ordenada

Retornar lista

Sino

Mezclar lista

Mejor caso: solo requiere recorrer n elementos (O(n)), Peor caso: nunca se comprueba,
complejidad indefinida

Ordenamiento por selección

Buscar el minimo -> Intercambiar el minimo con el primero -> Definir nueva lista excluyendo los
ordenados -> Repetir
Para j entre [0, n-2]

Para k entre [j,n-1]

Chequear y guardar minimo de sublista

Intercambiar minimo con inicio lista sin ordenar

1+2+3+…+N = N*(N+1)/2 Suma de Gauss

Complejidad: O(n2) (gana n cuadrado de la suma de Gauss)

Ordenamiento por burbujeo

Comenzar comparando dos elementos de la izq -> Si el de la izquierda es mayor, intercambiar ->
Incrementar una posición y continuar hasta recorrer toda la lista -> Definir sublista excluyendo el
ultimo elemento de la sublista anterior -> Repetir hasta que la nueva sublista sea de largo 1

Para j entre [1, n-1]

Para k entre [1, n-j]

Si der < izq

Intercambiar izq y der

1 +2 +3 +…+ n-1 Suma de Gauss -> T(N) = O(N 2)

Ordenamiento por inserción

Tomar la posición 1 como referencia -> Comparar el elemento acyual con anteriores -> Insertar
elemento actual a la derecha del primer elemento menor al actual o en la posición 0-> Repetir

Para j entre [1,n-1]

Actual = elemento j

K=j

Mientras k>0 and elemento k-1 > actual

Guarder element k-1 en k

K = k-1

Guardar actual en k

1 + 2+ 3+…+ n-1 Suma de Gauss T(N) = O(N2)

Bubblesort:

def bubblesort(lista):

for j in range(len(lista)):

for k in range(0,len(lista)-j-1):
 if lista[k+1]< lista[k]:

lista[k],lista[k+1] = lista[k+1], lista[k]

print(f"Iteración {j+1}: {lista}")

11/05/23

Recursión

Recursividad es el proceso mediante el que una función se llama a si misma de forma repetida
hasta que se satisface alguna condición

Se usa en muchos aspectos. Ejemplo de la ciudadanía. (efecto infinito). Def. recursiva tiene dos
partes:

1- Caso recursivo: resolver un problema reduciéndolo a una versión más pequeña (bucle
constante)
2- Caso base: especifica directamente el resultado para un caso particular. Garantiza que el
algoritmo recursivo termine y se resuelva en un tiempo finito (final)

Algorítmicamente: nos permite dividir el problema y resolver, semánticamente: usar una función
que se invoca a sí misma.

Def func(x):

func(x)

func(3)

(infinito)

Pila (stack)

1- Cuando se llama una función se crea un nuevo marco de pila o stack frame
2- Cuando finaliza el stack frame desaparece
3- Si se invoca una dentro de otra. Los stack frames se van acumulando
4- A medida que las funciones terminan se libera primer el stack frame añadido más reciente
y por último el más antiguo
5- El ultimo que entra es el primero que sale

Pila en recursión

Def func(n):

Print(n)

Func(n-1)

Func(3)

Infinitos stack frames, no hay caso base, RecursionError

Def func2(n):

If n>0:

Print(n)

Func2(n-1)

Func2(5)

Caso base en el que concluye la recursión: cuando n deja de ser positivo (0), a partir de ahí se
borran los frames acumulados previamente

Def func2(n):

If n>0:

Func2(n-1)

Print(n)

Func2(5)

Imprime en orden inverso

Multiplicacion desde perspectiva recursiva

Ejemplo suma de Gauss

Serie de Fibonacci: su definición es recursiva, por cada valor, me pregunto el valor de los términos
anteriores y así hasta el caso base, cada numero suma de los anteriores 2

Es más ineficiente con

recursión (árbol binario exponencial)

Memoization

Llevar registro de lo que se va calculando y ahorrarse ese cáclulo para el futuro: diccionarios
17/05/23

Continuación algoritmos de ordenamiento

Merge Sort

Si la lista posee un elemento se devuelve ese elemento

Sino dividir la lista desordenada en dos mitades

o Se aplica el algoritmo merge sort recursivamiente a cada mitad para obtener dos sublistas
ordenadas
o Se obtiene la lista total ordenada fusionando ordenadamente las dos sublistas

Def mergesort(lista):

If len(lista)<2:

Return lista

Else:

Medio = len(lista)//2

Lista1_ord = merge_Sort(lista[:medio])

Lista2_ord = merge_Sort(lista[medio:])

Return merge(lista1_ord, lista2_ord)

Def merge(lista1, lista2):

I,j = 0,0

Result = []

While(i<len(lista1) and j < len(lista2)):

If (lista1[i]<lista2[j]):

Result.append(lista1[j])

I+=1

Else:

Result.append(lista2[j])

J+=1

Result += lista1[i:]

Result += lista2[j:]

Return result

Complejidad temporal

o Costo merge sort tamaño n: T(N)

o Costo merge sort tamaño n/2: T(n/2)
o Costo merge: c n (c= nro de operaciones fijas)

T(N) = 2 T(N/2) + cn

[diapo 2 a la k y big O]

POO

Objetos de python: int, float, string, list, dict

Posee tipo, representación interna y procedimientos

Un objeto es una instacia particular de un tipo

Instancias de un tipo int: 1234, 26

Se puede crear un objeto, asignar una instancia a una variable, interactuar con el objeto y destruir
el objeto

Los objetos son modelos que permiten capturar:

o Una representación interna de sus características a través de atributos, contenido, estado,

datos que guarda ese objeto
o Una interfaz para interactuar con el objeto mediante métodos, funciones para interactuar
con el objeto
Clases

Un caso general, una plantilla para crear objetos (instancias, casos particulares)

Class <nombre>:

Def __init__(self, <atrib1>, <atrib2>): -> Constructor

Self.atributo1 = <atrib1>

Self.atributo2 = <atrib2>

Self.__atributoEncapsulado = <atrib3>

Def metodo1(self, <arg>, args):

<sentencias>

Def getAtributo(self):

Return self.atributo1

Getter y setter

Variable = <nombre de la clase>(<atrib1>,<atrib2>)

Característica = Variable.getAtributo()

18/05/23

POO

Estructura de objetos: mutable e inmutable

Objeto mutable

[diapo: clase Player con class food]

Palabra reservada pass: no hacer nada momentáneamente

Objeto inmutable, devolver un nuevo objeto por cada método, sobreescribiéndolo

[diapo]

Métodos especiales

Constructor:

 __init__(self, atributos)

Aritméticos:

 __add__(self, other) -> self + other: suma objetos, para eso hay que definir dentro del
método cual será la operación de suma y su retorno [diapo]
 __sub__(self, otro) -> self – otro: resta objetos, hay que definir dentro del método como
se realiza la resta entre esos objetos
  __mul__(self, otro) -> self * otro: “”
 __truediv__(self, otro) -> self / otro: “”

Comparación

 self == other -> __eq__(self, other) [diapo]

 self != other -> __ne__(self, other)
 self < other -> __lt__(self, other) [diapo]
 self > other -> __gt__(self, other)
 self <= other -> __le__(self, other)
 self >= other -> __ge__ (self, other)

Representación

 str(obj) -> __str__(self) [diapo]

 repr(obj) -> __repr__(self): da información más detallada y técnica

Secuencias personalizadas

 len(obj) -> __len__(self): determina que retorna cuando se le hace len al objeto [diapo]
 Obj[ítem] -> __getitem__(self, item): permite definer el comportamiento del objeto
cuando se accede a un elemento de ese objeto [diapo]
 Obj[item] -> __setitem__(self, item): permite definer el comportamiento del objeto
cuando se agrega un elemento a ese objeto

Destrucción

 Del(obj) -> __del__(self): además de borrar el objeto, define que hacer cuando se lo borra

31/05/23

Codigo de calidad: programación defensiva/ testing/ debugging

Programacion defensiva

 Documentar funciones
 Modularizar programas
 Validar entradas y salidas

Testing

 Diseñar pruebas: luego el código que las pasa (TDD) o al revés, cada entrada una salida
 Tipos de pruebas:
1. Test unitarios: valida cada pieza del programa, cada función
2. Test de regresión: se agregan al encontrar un bug, atrapan bugs que fueron
solucionados y se reintrodujeron
3. Test de integración: prueba el funcionamiento general del programa
 Entradas: Partición natural: ¿cuáles son los extremos del problema? Casos de borde
Pruebas aleatorias: no hay una partición evidente, más pruebas más
probabilidadde saber, es un último recurso
  Enfoques:
1. Black box testing: diseñamos pruebas sin mirar el código, mejor si lo hace otra
persona no el developer, se pueden reutilizar las pruebas si el código cambia,
avanza por especificación, prueba las particiones naturales y las condiciones de
borde
2. Glass box testing: miramos el código para diseñar pruebas, probamos ramas de
ejecución (ifs); ciclos fors y ciclos whiles, es “de camino completo” si recorre todas
las posibles ramas, si pasa por todas las líneas es Coverage 100% o path complete,
contras: puede pasar por ciclos cualquier cantidad de veces y Coverage < 100%

Debugging

 Busca eliminar todos los bugs

 Nunca sabremos cuando eliminamos todos
 Herramientas: Python debugger (IDE), Python tutor, print() (antes de ingresar a una
función, al ingresar, al terminar la función, al salir, si no se sabe donde esta el problema:
bisección, prints de mitad a mitad)
 Pasos recomendados:
1. Estudiar el código fuente
2. Usar el método científico

Tipos de errores: *de sint9axis: interprete, semántico: testing y de ejecución: programación

defensiva* (repaso arriba)

Errores de lógica: formas de solucionar problema: pensar, luego programar

Don´t: hacer el programa entero. Do: hacer el programa e ir debuggeando

Propagación de excepciones: error en una función f se propága en las funciones en las que se

llama a f

¿Qué hacer cuando hay error? Que falle silenciosamente (reemplazar valores de entrada para los

que si funciona), devolver códigos de error (-1 por ejemplo), frenar la ejecución (lanzando

excepciones)

try, except

Manejo completo

Try:

Except <tipo> as <nombre>:

Except:

Else: # si lo del try se ejecuta sin excepciones

Finally: # siempre se ejecuta, después de try except y else

Lanzar excpeciones

raise <nombre_excepcion>(<mensaje>)

Lanzamiento de condiciones si no se cumple una condición, como un if pero en false lanza

Excepción de tipo assertion (para encontrar bugs apenas son ingresados, como suplemento al

testing, para validación de entradas) (se pueden deshabilitar los asserts con un comando en

consola: $ python3 -0 programa.py)

assert <condición>, <mensaje>

Introducción a C

 Alta eficiencia, velocidad y rendimiento

 Mayor control de memoria y recursos del sistema
 Programación a bajo nivel
 Esencial para el aprendizaje de programación
 Más difícil de mantener
 Mayor dificultad de entender
 Más difícil corregir errores
 Se usan en S.O., BB.DD, Animaciones 3D, kernels de Celulares, Sistemas embebidos
(robótica)
 Python es con intérprete, C compilador (transforma el código a archivo ejecutable en
binario)

Diferencias interpretado vs compilado

[diapo]

Main() (no importa el indentado)

#include <stdio.h>

Int main(void)

puts(“hola mundo”);

return 0;

Compilar: $gcc –Wall –std=c17 –o –ejecutable codigo.c

Ejecutar: $./ejecutable

Comentarios: // o en bloque /*aykfadfg */

Tipos de datos: con registros, bytes (8 bits), y bits

Tipos de datos (cada uno ocupa una cantidad de bytes): char[0 a 256](1 byte), short [0 a 65535](2
bytes), int[0 a 4 mil millones](4 bytes), long[0 a 1 trillon](8bytes), float(4bytes), double(8 bytes)

01/06/23

<tipo> <variable>;

Definir constantes

#define <NOMBRE> <valor>

Directivas del preprocesador

Empiezan con #, traducen ciertas directivas a C antes de compilar

#include “mi_biblioteca.h” como un import

Operadores

Cambian: &&, ||, !a, a++, a--, sizeof(a)

Biblioteca estándar <stdio.h>

Incluye las def de la biblioteca estándar de C, se debe incluir inicialmente en el código con #define

Operaciones built in

puts(<string>); imprime en la terminal

printf(“texto %<formato> texto %<formato> texto…”,x,y);

%<formato> = %i, %c (char), %hd (short), %s (char *), %f segun el tipo, x e y tomarán el valor
respectivamente

Char nombre[] = “Elfo”;

Int edad = 300;

Printf(“Su nombre es %s y tiene %i años”,nombre, edad)

Scanf(“%<formato>”, &<variable>), si es un array no hace falta &

Printf(“Ingrese un entero: “);

Scanf(“%d”, &n);

Printf(“Entero: %d\n”, n);

Estructuras de control

If (<condición_1>){

<sentencia_1>;

Else if (){}
Else{}

Switch:

Switch(<valor>){

Case <expresión 1>:

<sentencias 1>;

Break

Case <expresión 2>:

<sentencias 2>;

break

default:

<sentencias3>;

Ciclos

While (<condición>){

<sentencia1>

Se puede usar el break y continue

For(<exp_inicial>;<exp_condicion>;<exp_iteracion>){

<sentencia1>

for (n= 0; n<10;n++){

printf(“Iteracion numero %i\n”, n);

Rand y srand

#include <stdlib.h>

Rand()

Numero entero entre 0 y RAND_MAX (constante definida)

Srand()
Da una semilla para esa generación aleatoria. Si no se fija una semilla por defecto será 1. Siempre
genera lo mismo aleatoriamente con la misma semilla

#include <time.h>

Time()

Permite obtener el tiempo actual en segundos, desde el 1 de enero de 1970. Es útil utilizar el
tiempo actual como semilla

Acotar el valor posible de aleatorios

Int max_value = 100

Int random_number = rand() % max_value /*Numero aleatorio entre 0 y max_value-1 */

07/06/23

Funciones en C

<tipo> <function>(<tipo> <arg>, <tipo> <arg2>,…){

<sentencia_1>

<sentencia_2>

Return <valor_retorno>;

Int main(void){

Return 0;

Function utilizada en main debe ser definida antes de ser utilizada. O al menos ser declarada antes
sin asignación de variables y luego ser asignada luego del main()

Int function (int,int); DECLARACION

Int function(int x, int y){ DEFINICION

Funciones sin argumentos: argumento void

Funciones sin salida: de tipo void

Funcion sin entrada ni salida: (se pueden invocar sin args)

Void menu (void){

Printf(“Hola\n”);

}
Variables de alcance local: las variables definidas dentro de una función son locales y corresponen
al ámbito de esa función (luego desaparecen al terminar la llamada)

Variables de alcance global (no tan buena práctica): definirla afuera de las otras funciones, afuera
del main

Modularizacion

Dividir el código en varios archivos, es decir, definir nuevos módulos

Dos tipos de archivos:

 Archivos.c: contienen el código e incluye variables y funciones con #define e #include

(main.c + calcular.c + interfaz.c por ejemplo)
 Archivos.h: son archivos de cabecera o “header”. Incluyen directivas. (calcular.h, donde
tengo la declaración de las funciones definidas en calcular.c, arriba del todo al igual que
interfaz.h para interfaz.c, o un main.h que incluya ambos)

[diapo completa de división de modulos][diapo 2 completa de división ya hecha]

Siempre prototipos (declaraciones de funciones y variables) antes de main

Proceso de compilación

[diapo]

Comandos de compilación

1)Compilar

& gcc main.c –Wall –std=c2x –o ejecutable

2)Ejecutar

$./ejecutable

En el ejemplo, se debe agarrar main.c y modulo.c y hacer el proceso de compilación con ambos a
la vez. Si no no tengo definidas mis funciones

1)Compilar

& gcc main.c modulo.c –Wall –std=c2x –o ejecutable

2)Ejecutar

$./ejecutable

Conversión de tipos
Cuando tengo distintos tipos y hago operaciones, se guarda en el tipo más grande según jerarquía:

1. Doublé
2. Flout
3. Unsigned long
4. Long
5. Unsigned int
6. Int

[diapo de ejemplo]

Castear tipos: con paréntisis antes

Int x = 3

Int y = 2

Float z;

Z = (float)x/y;

Y por jerarquía gana el float en el que se guarda en una variable float

08/06/23

Arrays

<tipo> <nombre>[<largo>], elementos de mismo tipo

Escritura: <nombre>[<índice>] = <valor>

Lectura: <variable> = <nombre>[<índice>]

Float array1[10];

Float array2[] = {2,4,5,6,8,10}

Array1[0] = 1.2;

Un string es un array con elementos de tipo char

El ultimo elemento es el carácter fin de cadena “\0”. Dos formas de definir:

Char cadena1[] = “hola mundo”;

Char cadena2[] = {‘a’,’r’,’r’,’a’,’y’,’\0’};

Si no esta el \0 imprime infinitamente los caracteres en memoria sin frenar, (con %s)

Punteros

Variable que guarda una dirección de memoria. Necesario apuntar el tipo del dato que será
apuntado

<tipo> * <puntero>;
Manipulacióon de punteros

<puntero> = &<variable> (copia dirección de la varaible en un puntero)

*<puntero> = <valor>; (copia el valor de una variable en la dirección que apunta el puntero)

<variable> = *<puntero> (guarda en una variable el valor en una dirección)

*acceder al dato de una direccion, &acceder a la dirección de la variable

Int x = 5;

Int a[]= {3,5,6,7}

Char buffer[] = “martes”

Int *p; (dirección de memoria que a punta a una variable de tipo entero

Char *s;

P = &x; (se guarda en p la dirección de memoria de x)

Printf(…,*p)

P = a;

Printf(…, p[0])

Argumentos por referencia

Si queremos que una función nos pueda devolver varios resultados se pueden devolver por
referencia en lugar de por valor:

Padando punteros ocmo args

Punteros en vez de variable como argumento

Int func(int * y1, int * y3){

<sentencias

*y1 = expresión;

Invoco una función(&variable;)

Con la dirección y luego en la función accedo al valor

Función(*var){

*var = jdaospn

Y se modifica el valor de la dirección indirectamente

[revisar diapo]

Tamaño de una variable

<tamaño> = sizeof(<variable>) (en bytes)

Saber cantidad de elementos de un array

Int vec[] = {6,2,3,4,7}

N = sizeof(vec)/sizeof(int)

Funciones para strings con <string.h>

Longitud = strlen(<cadena>);

Longitud de una cadena (no tiene en cuenta el \0)

Memcpy(<dest>,<src>,n);

Copia los elementos de una cadena a otra en memoria

Char src[] = “otra cadena”

Char dest[20]

Memcpy(dest, src, strlen(src)+1)

Strcpy: copia directamente una cadena a otra

Strcmp, devuelve 0 si las cadenas son iguales en orden, o <0 o >0 según si la primera es menor o
mayor a la segunda

Strcat, concatena una cantidad especifica de caracteres de una cadena de origen al final de una
cadena de destino. Siempre que tenga espacio en el primer string

Strcat(“hola”,”, mundo”);