Generar Diálogo: Assert: para establecer

Var1 = input(“Ingrese... ”) precondiciones y pruebas Módulo: Operadores básicos: Ej.Fn: Potencia

Var2 = input(“Ingrese… ”) If: instrucciones Tenemos 2 formas: %: entrega el resto de la # potencia: num int -> num
Var1,2= fn que relaciona ambas variables Estudio de caso: números primos 1)import nombrearchivo división # x elevado a entero y >= 0
print(f"texto {Var1,2} “) nombrearchivo.nombrefn( ) //: entrega división entera (no # Ej: potencia(1.5, 2) -> 2.25
-f necesario para insertar variable Valores booleanos -repitiendo el proceso de cada fn decimales) # potencia(15, 2) -> 225
-previo a input se debe indicar si queremos -para contrato: bool que llamemos /: división # potencia(15, 0) -> 1
trabajar con string o números, en el último Sentencias: -tambien podemos agregar as m, *: multiplicación def Potencia(x, y):
caso usamos int, num, float previo a input If: si la condición se evalúa con m nuevo nombre de archivo **: potencia assert type(x) = int or type(x) = float
verdadera, se ejecuta el código ==: igualdad assert type(y) = int and y>=0
Ej.Fn: random Elif: se pueden verificar más 2)from nombrearchivo import * >=: mayor o igual assert not (x==0 and y==0) #0**0
Import random condiciones nombrefn( ) <=: menor o igual indefinido
# escoge al azar: -> int Else: se ejecutará si la condición !=: distinto de if y == 0: #caso base
-de esta forma podemos llamar
# devuelve un numero al azar entre 1 y 10 es falsa (si ninguna condición se cualquier fn contenida en el not: negación return 1
def escogerAlAzar( ): cumple) modulo -Parametro por omisión: si va else: #caso recursive
#random.random retorna un numero al -en la receta, se deben incluir los guardando info, deemos ir return x * potencia(x, y-1)
-sirve únicamente cuando las fn
azar entre 0 y 1 distintos casos actualizándolo en cada # Test
no entran en conflicto
Return int(10 * random.random ( )) + 1 resultado. assert potencia(1.5, 2) == 2.25
# Test Estudio de caso – Ej.Fn: esPrimo assert potencia(15, 2) == 225
escogerAlAzar( ) <= 10 # esPrimo: int -> bool Ej. Uso de modulos assert potencia(15, 0) == 1 #caso base
escogerAlAzar( ) >= 1 # True si n > 1 es primo from math import *
# Ej: esPrimo(2) -> True, esPrimo(6) -> False (par) print('triángulo de lados a,b y ángulo alfa') Ej.Fn: Potencias positivas y negativas
Ej.Fn: invertir entero de 3 digitos # esPrimo(13) -> True, esPrimo(9) -> False(impar) #obtener datos # potencia: num int -> num
# invertir (escribir al revés) entero de 3 digitos def esPrimo(n): a=float(input('a?')) # x elevado a y, con y entero
n=int(input('n° de 3 dígitos?')) assert type(n) == int and n > 1 b=float(input('b?')) # Ej: potencia(2, 3) -> 8, potencia(2,-3) ->
d1=n//100 #primer digito (division entre #numero par: solo 2 es primo alfa=float(input('alfa?'))*pi/180 0.125
enteros) If n%2 == 0: return n == 2 def potencia(x,y):
d3=n%10 #ultimo digito (resto entre #numero impar: probar con divisores 3, 5, …, #calcular tercer lado assert type(x) == int or type(x) ==
enteros) raíz (n) c=sqrt(pow(a*sin(alfa),2) + pow(b-a*cos(alfa),2)) float
d2=n%100//10 #segundo digito(tambien def _esPrimo(n, divisor==3): #parametro por assert type(y) == int
d2=n//10%10) omision #calcular perímetro y area assert not(x == 0 and y == 0)
print(100*d3+10*d2+d1) If divisor*divisor > n: #divisor > sqrt(n) from triangulo import * def _potencia(x, y):
return True print('perímetro:',perimetro(a,b,c)) if y == 0: return 1
Ej.Fn: Cajero automatico print('area:',area(a,b,c)) p = _potencia(x, y// 2)
elif n % divisor == 0:
#cajero automatico que entrega minino de o if y%2 == 0:
return False
billetes import triangulo return p*p
else:
d=int(input('dinero que necesita?')) print('perímetro:',triangulo.perimetro(a,b,c)) else:
return _esPrimo(n, divisor+2)
print('billetes de 20000:',d//20000); print('area:',triangulo.area(a,b,c)) return x*p*p
return _esPrimo(n)
d=d%20000 if y<0:
assert esPrimo(2) and not esPrimo(6)
print('billetes de 10000:',d//10000); Ej.Fn: Ec. cuadrática return 1.0/_potencia(x, -y)
assert esPrimo(13) and not esPrimo(9)
d=d%10000 from math import * else:
print('billetes de 5000:',d//5000); d=d%5000 Ej.Fn: Años bisiestos print("resolver ax^2+bx+c=0") return _potencia(x, y)
print('billetes de 2000:',d//2000); d=d%2000 #bisiesto: int -> bool def leer(x): return float(input(x)) assert potencia(2, 3) == 8
print('billetes de 1000:',d//1000) #True si año x es bisiesto a=leer("a?"); b=leer("b?"); c=leer("c?"); assert potencia(2, -3) == 0.125
#ejs: bisiesto(2020)->True, bisiesto(2022)->False if a==0:
Ej.Fn: Factores primos def bisiesto(x): if b==0: Ej.Fn: Factorial de un numero n
# factoresPrimos: int -> assert type(x)==int and x>=0 #precondicion print("ecuacion incorrecta") # factorial: int -> int
# escribe factores primos de n>=1 return x%4==0 and x%100!=0 or x%400==0 else: # calcula el factorial de n
# Ej: factoresPrimos(24) escribe 2**3 y 3**1 assert bisiesto(2020) #prueba print("x=",-c/b) # Ej: factorial(10) devuelve 3628800
def factoresPrimos(n, factor=2): assert not bisiesto(2022) #prueba else: def factorial(n):
assert type(n)== int annd n>=1
d=b**2-4*a*c #discriminante If n == 0:
if n==1: return Ej.Fn: esPar
if d==0: return 1
# calcular y escribir potencia p de factor # esPar: int -> boolean
print("x=",-b/(2*a)) else:
primo # dado un numero, retorna el valor verdadero
elif d>0: return n * factorial(n - 1)
def potencia(n, factor): y el numero es par
r=sqrt(d) #raíz de discriminante # Test
if n % factor != 0: return 0 # en caso contrario retorna False
print("x=",(-b+r)/(2*a),(-b-r)/(2*a)) assert factorial(0) == 1
return 1 + potencia(n//factor, factor) def esPar(numero):
else: assert factorial(5) == 120
p = potencia(n, factor) return (numero % 2) == 0
print("raices complejas") assert factorial(10) == 3628800
if p>0: print(“factor:”, factor, “potencia:” , p) assert esPar(2)
# recursion con siguiente factor primo assert not esPar(5)
factoresprimos((n//factor**p, -recomendable uso de not para no generar
siguientePrimo(factor)) error en el codigo.
Ej: Fractal de Koch - “copo de Ej: Cant. De dígitos de un numero Ej.Fn: Det. Valor serie 1-1/2+1/3-1/4…+1/n
´ E
nieve” # dígitos: int -> int Int -> num
#koch.py # dado un numero retorna el numero de Def masmenos1divn(n):
from turtle import *; resetscreen() # dígitos que tiene ese numero If n == 1:
#fractal: int int -> # Ej: dígitos(4) retorna 1 return 1
#fractal de Koch de orden n y largo L # Ej: dígitos(123) retorna 3 else:
#ej: fractal(4,100) def dígitos(numero): If espar(n):
def fractal(n,L): if numero // 10 == 0: return (-1.0/n) + masmenos1divn(n-1)
def lado(n,L): return 1 else:
if n==1 or L<6: else: return (1.0/n) + masmenos1divn(n-1)
forward(L) return 1 + dígitos(numero // 10) assert cerca(masmenos1divn(1), 1, 0.001)
else: # Test
lado(n-1,L/3); left(60) assert digito(234) == 3 Ej.Fn: Det. Valor serie 1+1/2+1/3+1/4…+1/n
lado(n-1,L/3); right(120) assert digito(4) == 1 Int -> num
lado(n-1,L/3); left(60) Def unodiv2(n):
lado(n-1,L/3) Ej: Suma dígitos de un numero If n == 0:
assert type(n)==int and n>0 # sumarDigitos: int -> int return 1
assert type(L)==int and L>0 Def sumarDigitos(X): else:
lado(n,L); right(120) If X//10 == 0 return (1.0/ potencia2(n)) + unodiv2n(n-1)
lado(n,L); right(120) return X assert unodiv2n(0) == 1
lado(n,L) else:
return X % 10 + sumarDigitos(X//10) Ej.Fn: Sumar serie 1+..+n
Ej.Fn: Calculo de la r. cuadrada Def suma1n(n):
# heron_r: num num num -> num assert sumarDigitos(1) == 1
assert sumarDigitos(512) == 8 If n == 1
# helper function de heron, calcula la Return 1
raiz cuadrada de x Else:
# con precisión épsilon y valor inicial Ej.Fn: Posicion de dígitos
Return n + suma1n(n-1)
de estimación Def escribirEnPosicion(numero):
Assert (1) == 1
# Ej: heron_r(2, 0.00001, 1) PosiciónActual = 1
Assert(5) == 15
devuelve 1.414215… recorrerNumero(numero,
def heron_r(x, épsilon, estimación): posicionActual)
assert x > 0
if cerca(estimación *estimación, def recorrerNumero(num, posActual):
x, epsillon): if num < 10:
return estimación if (num == posActual):
else: print(num)
mejor_estimacion = (estimación return
+ x / estimación) / 2 else:
return heron_r(x, epsilon, digito = num % 10
major_estimacion) if digito == posActual:
print(digito)
# heron: num num -> num
# calcula la raiz cuadrada de x, con recorrerNumero(num//10, posActual + 1)
precisión épsilon
#Ej: heron(2, 0.1) devuelve 1.416…
def heron(x, eps):
return heron_r(x, eps, x / 2.0)
import math
assert cerca(heron(2, 0.1),
math.sqrt(2), 0.1)

Ej.Fn: Cerca
# cerca: num num num -> bool
# retorna True si x es igual a y con
# presicion épsilon
def cerca(x, y, épsilon):
diff = x – y
return abs(diff) < epsilon