Está en la página 1de 14

Mdulo if , elif, else de python

# RESUMEN:

# =======

# 1. Operaciones condicionales

# 2. Lazos con if, tuplas y listas

# 3. Lazos con while

# 4. Caso de else en un lazo

# 5. La instruccion pass

# 6. Uso de modulos para generacion de valores aleatorios y temporizador

# MARQUEMOS LAS OPRERACIONES QUE YA CONOCEMOS EN PYTHON:

# * ACEPTAN ENTRADAS Y LAS ALMACENAN EN ALGUN REPOSITORIO DE INFORMACION

# * RETORNAN SALIDAS Y LAS MUESTRAS EN UNA PANTALLA, UN ARCHIVO, UNA IMPRESION,


ETC.

# - REALIZAN CIERTAS OPERACIONES SEGUN ALGUNA CONDICION

# - PUEDEN REALIZAR UN CONJUNTO DE OPERACIONES MULTIPLES VECES DE FORMA


REPETIDA

# - PUEDEN MODELAR OBJETOS DEL MUNDO REAL (PROGRAMACION ORIENTADA A OBJETOS)

# Vamos a revisar las operaciones condicionales:

edad = int(input("Ingrese su edad: "))

if edad < 18:

print("Aun es menor de edad")

else:

print("Es mayor de edad")

# 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).

edad = int(input("Ingrese su edad: "))

if edad < 18: print("Aun es menor de edad")


else: print("Es mayor de edad")

# En caso de tener mas de dos casos en la condicion, Python tiene la palabra reservada "elif"
(else if)

# para estos casos:

edad = eval(input("Ingrese su edad: ")) #eval() convierte un string en un entero si el dato es


correcto

if edad < 0:

print("Aun aun no ha nacido!!!")

elif edad < 18:

print("Aun es menor de edad")

else:

print("Es mayor de edad")

#############################################################################
###############

# 1. ESCRIBA UN PROGRAMA QUE MUESTRE Y CALCULE LO SIGUIENTE

# Ingrese un numero:

# Ingrese otro numero:

# Posibles respuestas:

# El primer numero es mayor que el segundo

# El segundo numero es mayor que el primero

# Ambos numeros son iguales

# 2. IMPLEMENTE LA SIGUIENTE CALCULADORA

# Ingrese una operacion [con +, -, x o /]: 2 x 6

# 2 x 6 = 12
#############################################################################
#################

# SOLUCION 2

# ==========

# num1, operacion, num2 = input("Ingrese una operacion: ").split()

# num1 = int(num1)

# num2 = int(num2)

# print(num1, operacion, num2, "= ", end='')

# if operacion == '+':

# print(num1 + num2)

# elif operacion == '-':

# print(num1 - num2)

# elif operacion == 'x':

# print(num1 * num2)

# elif operacion == '/':

# print(num1 / num2)

#Las operaciones condicionales pueden contener las operaciones logicas para formar
proposiciones

#aun mas complejas

anio = eval(input("Ingrese un ao: "))

#Un ao es bisiesto si es divisible entre 4...

#a excepcion que sea divisible entre 100...

#excepto si es divisible entre 400

if anio % 4 == 0 and anio % 100 != 0 or anio % 400 == 0:

print(anio, "si es un ao bisiesto")

else:

print(anio, "no es un ao bisiesto")

#Esto tambien se puede realizar anidando operaciones condicionales

anio = eval(input("Ingrese un ao: "))


if anio % 4 == 0:

if anio % 100 == 0:

if anio % 400 == 0:

print(anio, "si es un ao bisiesto")

else:

print(anio, "no es un ao bisiesto")

else:

print(anio, "si es un ao bisiesto")

else:

print(anio, "no es un ao bisiesto")

#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".

#De esta forma se puede integrar en un solo "if" multiples opciones

#Piense en los ( ) que definen una tupla como una "bola" que contiene datos: ya no no puede
abrir

#para agregar, quitar datos o incluso modificarlos. Es "inmutable".

num = eval(input("Ingrese un numero entre 0 y 10: "))

if num in (0, 2, 4, 6, 8, 10):

print("El numero ingresado es par")

else:

print("El numero ingresado no es par")

#Se pueden reemplazar las ( ) por [ ]...

num = eval(input("Ingrese un numero entre 0 y 10: "))

if num in [0, 2, 4, 6, 8, 10]:

print("El numero ingresado es par")

else:

print("El numero ingresado no es par")


#Esto hace uso de un tipo especial de datos llamado "lista". Una lista es un tipo que permte
agrupar

#datos y es "mutable" (piense en las [ ] de la lista como una caja donde se puede abrir para
meter

#y sacar datos).

#############################################################################
####################

# 3. ESCRIBA UN PROGRAMA QUE RETORNE EL NUMERO DE DIAS DE UN MES Y AO


PARTICULAR

# Ingrese el mes [1-12]: 2

# Ingrese el ao (ej. 2010): 2000

# Hay 29 dias en el mes

# Recuerde que los meses 1, 3, 5, 7, 8, 10 y 12 tienen 31 dias

# Asi tambien, los meses 4, 6, 9 y 11 tienen 30 dias

# El mes 2 tendra 28 o 29 dias dependiendo si el ao es bisiesto

# Controle que el dato del mes ingresado este en el rango 1 - 12

#############################################################################
#####################

# Otra de las habilidades de todo lenguaje de programacion es la capacidad de poder repetir


secciones

# de codigo de forma iterativa. La capacidad de crear lazos de repeticion de Python se puede


implementar

# 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

for each_element in [2, 4, 6, 8, 10]:

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

# acceder por medio de "in"

for i in range(10):

print("i = ", i) #Esta linea se repetira 10 veces

# La funcion range(n) genera valores entre 0 y n-1. Se puede especificar un rango especifico:

for i in range(5, 10):

print("i = ", i)

# O se puede especificar un "paso" entre el rango

for i in range(0, 10, 2):

print("i = ", i)

#############################################################################
######################

# 4. ESCRIBA UN PROGRAMA QUE IMPRIMA TODOS LOS NUMEROS IMPARES EN UN RANGO


ESPECIFICADO

# Numero inicial: 12

# Numero final: 27

# 13
# 15

# 17

# 19

# 21

# 23

# 25

# 27

# 5. ESCRIBA UN PROGRAMA QUE PIDA UN NUMERO Y RETORNE LA TABLA DE MULTIPLICAR


DE ESTE VALOR HASTA 10

# 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

#############################################################################
######################

# Otra forma de establecer lazos de repticion en Python es utilizando la instruccion while:

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

while i <= 20:

# Si un numero es par, no se imprimira

if (i % 2) == 0:

i += 1

continue

# Si el numero ha llegado a 15, el programa e detiene

if i == 15:

break

# Se imprimen los valores impares

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

# las instrucciones anteriores

while True:

num = eval(input("Ingrese su edad: "))

if edad <= 0:

print("Dato invalido. Vuelva a intentarlo")

else:

break

# Se puede utilizar una combinacion de while y try...except para controlar que se ingrese un
valor

while True:

try:

edad = int(input("Ingrese su edad: "))


if edad <= 0:

print("Dato invalido. Vuelva a intentarlo...")

else:

break

except ValueError:

print("No ha ingresado un valor. Vuelva a intentarlo")

print("La edad ingresada fue {}".format(edad))

#############################################################################
#######################

# 6. ESCRIBA UN PROGRAMA QUE PIDA AL USUARIO UN NUMERO ENTERO POSITIVO MAYOR


QUE 1 Y SIGA

# LA SIGUIENTE REGLA PARA CONSTRUIR UNA SECUENCIA DE COLLATZ:

# Si N es par, N = N /2

# Si N es impar, N = 3N+1

# PARA CUALQUIER N > 1, LA SECUENCIA TERMINA EN EL VALOR DE 1 (CONJETURA DE


COLLATZ)

# Ingrese un numero : 1

# El dato ingresado es invalido. Intente nuevamente...

# 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

# de lenguajes como C o C++.

# En el caso del lazo for, la clausula else contiene un bloque de codigo que se ejecutara cuando
el

# lazo haza concluido

digitos = [1, 2, 3]

for i in digitos:

print(i)

else:

print("No hay mas digitos")

# 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

while contador < 3:

print("Dentro del lazo")

contador = contador + 1

else:

print("Dentro del else")

# La inclusin del "else" en los lazos es con el espiritu de hacer que el codigo en Python sea
mas legible.

# Hay otra instruccion que puede parecer inutil...


if numero == 0:

pass

# Esto no hara absolutamente nada. La instruccion pass es simplemente un "continuar". Sin


embargo,

# el compilador no ignora esta sentencia como si lo hace con los comentarios. Esta reservado
para

# futuras implementaciones o para marcar algo que se quiere hacer posteriormente en el


codigo.

# 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

# la simulacion contando con informacion aleatoria generada por el propio equipo.

# 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

# capacidades agregando "modulos" al lenguaje. Esto es, agregarle nuevas funciones y


metodos a los

# ya existentes.

# Para utilizar una nueva funcionalidad hay que "impotar" el modulo. Por ejemplo, para
generar

# valores aleatorios sera necesario importar el modulo "random"

import random

#Se genera un valor entero en el rango 1 - 50

rand_num = random.randrange(1,51)

#Se inicializa la variable que servira como iterador


i=1

#Mientras el iterador no sea igual al numero generado...

while (i != rand_num):

#...se incrementara el iterador

i += 1

#Se imprime el iterador que sera igual al numero generado

print("El valor aleatorio generado es", i)

#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())

time.sleep(0.5) #La impresion de los numeros sucede cada medio segundo

#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

#ejemplos de las buenas practicas del PEP-8 (https://www.python.org/dev/peps/pep-0008/):

# - Usar cuatro espacios en lugar de indentacin

# - Limitar el tamao de las lineas de codigo a 79 caracteres

# - Separar funciones y definiciones de clase con dos lineas en blanco.

# Definiciones de metodos dentro de un objeto separadas por una linea en blanco

# - Separar con un espacio los arguementos, luego de la coma

# - Rodear los operadores con espacios en blanco (a excepcion de la definicion de opciones

# por defecto de los argumentos de una funcion

# - Evitar los comentarios en la misma linea de codigo

# - Llamar a las funciones en minusculas y con "_" para reemplazar los espacios.

# Los objetos se escriben en formato camello (cajaRedonda)

#############################################################################
######################

# 7. ESCRIBA UN PROGRAMA QUE ADIVINE UN NUMERO DENTRO DEL RANGO [1-100].


TEORICAMENTE, EL NUMERO

# MAXIMO DE INTENTOS PARA ESE RANGO ES DE 7 INTENTOS (BUSQUEDA BINARIA)

# 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

# - Es menor al valor generado

# Intento 3/7 : 80

# - Es mayor al valor generado

# Intento 4/7 : 70

# - Es mayor al valor generado

# Intento 5/7 : 75

# - Es mayor al valor generado

# Intento 6/7 : 73

# - Exacto!!!

# Si supera los 7 intentos debera de indicar el mensaje

# "No logro adivinar el numero en los intentos permitidos: <numero generado>

#############################################################################
#######################

#############################################################################
#######################

#DESAFIO DE FIN DE SEMANA!!!

#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).

#############################################################################
#######################