# RESUMEN:
# =======
# 1. Operaciones condicionales
# 5. La instruccion pass
else:
# Igual que en el caso de try...except, Python es muy estricto con el uso de los ":" y los
# cuatro espacios para definir el bloque. Aunque si el bloque de instrucciones solo consiste en
# una sola linea se puede colocar toda la instruccion en la misma linea del condicional (aunque
# no es lo recomendado).
# En caso de tener mas de dos casos en la condicion, Python tiene la palabra reservada "elif"
(else if)
if edad < 0:
else:
#############################################################################
###############
# Ingrese un numero:
# Posibles respuestas:
# 2 x 6 = 12
#############################################################################
#################
# SOLUCION 2
# ==========
# num1 = int(num1)
# num2 = int(num2)
# if operacion == '+':
# print(num1 + num2)
# print(num1 - num2)
# print(num1 * num2)
# print(num1 / num2)
#Las operaciones condicionales pueden contener las operaciones logicas para formar
proposiciones
else:
if anio % 100 == 0:
if anio % 400 == 0:
else:
else:
else:
#La instruccion if puede manejar "tuplas". Una tupla es un tipo de datos en Python que
permite
#agrupar datos. Se puede acceder a validar los datos de una tupla con la palabra reservada
"in".
#Piense en los ( ) que definen una tupla como una "bola" que contiene datos: ya no no puede
abrir
else:
else:
#datos y es "mutable" (piense en las [ ] de la lista como una caja donde se puede abrir para
meter
#y sacar datos).
#############################################################################
####################
#############################################################################
#####################
# de multiples formas:
# Por ejemplo, se puede utilizar un for para recorrer los elementos de una lista. Esto es un uso
clasico
# de una lista con for (una lista es un elemento "iterable") y es algo mas "pythonico", ya que el
# codigo se escribe de manera natural
print(each_element)
# Existe otro tipo de datos (que puede confundirse con una funcion) llamado "rango".
a = range(10)
print(a)
type(a)
# Un rango es una secuencia de valores enteros (al igual que la lista, es un iterable) a los que se
puede
for i in range(10):
# La funcion range(n) genera valores entre 0 y n-1. Se puede especificar un rango especifico:
print("i = ", i)
print("i = ", i)
#############################################################################
######################
# Numero inicial: 12
# Numero final: 27
# 13
# 15
# 17
# 19
# 21
# 23
# 25
# 27
# Ingrese un numero: 5
# 5.0 x 1 = 5.0
# 5.0 x 2 = 10.0
# 5.0 x 3 = 15.0
# 5.0 x 4 = 20.0
# 5.0 x 5 = 25.0
# 5.0 x 6 = 30.0
# 5.0 x 7 = 35.0
# 5.0 x 8 = 40.0
# 5.0 x 9 = 45.0
# 5.0 x 10 = 50.0
#############################################################################
######################
i=5
while i > 0:
print(i)
i -= 1
print("BOOM!!!")
# Se pueden utiliar las instrucciones "break" y "continue" para obviar una iteracion o romper
# el lazo de repeticion
i=1
if (i % 2) == 0:
i += 1
continue
if i == 15:
break
print("Impar : ", i)
# Se incrementa el valor de i
i += 1
# Python no tiene implementado un lazo "do...while". Por lo que tiene que construirse
utilizando
while True:
if edad <= 0:
else:
break
# Se puede utilizar una combinacion de while y try...except para controlar que se ingrese un
valor
while True:
try:
else:
break
except ValueError:
#############################################################################
#######################
# Si N es par, N = N /2
# Si N es impar, N = 3N+1
# Ingrese un numero : 1
# Ingrese un numero: 5
# 5
# 16
# 8
# 4
# 2
# 1
#############################################################################
#######################
# Los lazos for y while pueden incluir de forma opcional la instruccion while, lo que los
diferencia
# En el caso del lazo for, la clausula else contiene un bloque de codigo que se ejecutara cuando
el
digitos = [1, 2, 3]
for i in digitos:
print(i)
else:
# En el caso del lazo while, la clausula else contiene un bloque de codigo que se ejecutara
cuando la
# condicion que sostiene el lazo se haga Falsa. La diferencia con el caso for es que es posible
que un
# lazo while termine de forma anticipada por una instruccion break; en este caso, el bloque
else se ignora
contador = 0
contador = contador + 1
else:
# La inclusin del "else" en los lazos es con el espiritu de hacer que el codigo en Python sea
mas legible.
pass
# el compilador no ignora esta sentencia como si lo hace con los comentarios. Esta reservado
para
# Uno de los usos mas comunes de los lazos es para repetir operaciones dentro de una
simulacion.
# Para tener pruebas de concepto basicas, en lugar de contar con datos reales, se puede iniciar
# Las funciones que hemos visto hasta ahora forma parte de la "bibloteca estandar" de Python
y estan
# incluidas en el kernel del lenguaje de programacion (es decir que son interpretadas
directamente
# por el interprete de Python). Una de las fortalezas de Python es que se le pueden agregar
nuevas
# ya existentes.
# Para utilizar una nueva funcionalidad hay que "impotar" el modulo. Por ejemplo, para
generar
import random
rand_num = random.randrange(1,51)
while (i != rand_num):
i += 1
#Para generar valores reales entre 0 y 1 sera necesario llamar al metodo random:
for i in range(10):
print(random.random())
#Si se quiere generar valores reales dentro de un rango se puede operar el resultado anteriore
#para ajustar el valor resultante a un nuevo rango, o se puede utilizar el metodo "uniform"
for i in range(10):
print(random.uniform(1.0, 5.0))
#Otro modulo util para hacer que nuestros programas sean atractivos es el modulo "time"
import random
import time
for i in range(10):
print(random.random())
#Un metodo util al momento de importar modulos es hacer un alias de estas; esto es, hacer
que el
#nombre del modulo sea igual a alguna letra o palabra que sea mas facil de recordar
import random as r
import time as t
for i in range(10):
print(r.random())
t.sleep(0.5)
#Ahora que podemos constuir codigos mas largos y tomando en cuenta lo importante que es
el
#formato en Python, existe una guia de estilo de escritura de codigo llamada PEP-8. Aqui
algunos
# - Llamar a las funciones en minusculas y con "_" para reemplazar los espacios.
#############################################################################
######################
# Generando un numero aleatorio... -> Espere un segundo entre la impresion de cada punto
# Adivine el numero:
# Intento 1/7 : 30
# - Es menor al valor generado
# Intento 2/7 : 60
# Intento 3/7 : 80
# Intento 4/7 : 70
# Intento 5/7 : 75
# Intento 6/7 : 73
# - Exacto!!!
#############################################################################
#######################
#############################################################################
#######################
#Modifique el programa anteror para que la maquina sea quien intente adivinar el numero de
forma
#inteligente utilizando la logica de la busqueda binaria (dividir el rango por la mitad en cada
#intento).
#############################################################################
#######################