def factorial():
numero = 5
factorial = 1
while numero > 0:
factorial = factorial * numero
numero -= 1
my_print(factorial)
def nueva_funcion(*args, **kwargs):
inicio_msg()
result = func(*args, **kwargs)
fin_msg()
return result
return nueva_funcion # C
@decorador2
def suma2(v_1, v_2):
return v_1 + v_2
resultado = suma2(10, 50)
my_print(resultado)
# Decorador con parámetros
def decorador3(is_valid):
def _decorador3(func):
def msg_ini():
my_print("Inicio...")
def msg_fin():
my_print("Fin...")
def nueva_funcion(*args, **kwargs):
msg_ini()
resultado = 0
if is_valid:
# mediante indices
# Para almacenar valores en un diccionario, cada valor almacenado debe poseer una "Llave" o "Clave"
# la cual nos permitirá acceder a dicho valor
# Las llaves pueden ser strings o números, pero deben ser inmutables
# Si en el diccionario existen 2 llaves iguales, se tomará el valor de la última llave o clave
diccionario = {
'key1': "Primer valor",
'key2': "Segundo valor",
8: 123456,
(1, 2): "Valor llave tupla",
'key2': 5000
}
my_print(diccionario)
# Es posible agregar o quitar valores a un diccionario.
# diccionario[llave] = valor a agregar a la llave.
# Agregar
diccionario['key3'] = "Valor agregado"
my_print(diccionario)
# Reemplazar el valor de una clave. Si no encuentra la llave, creará una nueva.
diccionario['key3'] = "Valor reemplazado"
my_print(diccionario)
# Obtención de datos de un diccionario
valor_1 = diccionario['key3']
def factorial2(numero):
factorial = 1
while numero > 0:
factorial = factorial * numero
numero -= 1
my_print(factorial)
# MÉTODOS DE CADENAS
from my_function import my_print
curso = "Curso"
impartidor = "Código Facilito"
# Método de concatenación FORMAT
salida = "{} de {}".format(curso, impartidor)
my_print(salida)
#Le daremos un alias a cada entrada, pará así identificar donde reemplazar el valor
salida = "{a} de {b} {a}".format(a=curso, b=impartidor)
my_print(salida)
# Convertir toda la cadena en minúscula
salida = salida.lower()
my_print(salida)
# Convertir toda la cadena a Mayúscula
salida = salida.upper()
my_print(salida)
# Formatear el string como un Titulo
# El método reemplaza la primera letra de cada palabra por la misma en mayúscula
salida = salida.title()
my_print(salida)
def nueva_funcion(*args, **kwargs):
my_print("Inicio ejecución función")
func(*args, **kwargs)
my_print("Término de ejecución función")
def msg_ini():
my_print("Inicio...")
def inicio_msg():
my_print("Inicio process")
# Tuplas from my_function import my_print # Tipos de dato que permiten almacenar diferentes tipos de datos, al igual que las listas. # Las tuplas son inmutables, no se pueden agregar ni quitar elementos # Creación de tupla # Las tuplas se crean con (); las listas co [] mi_tupla = (1, "Dos", 3, "Cuatro") my_print(mi_tupla) # Al igual que las listas, es posible acceder a cierto elemento según el índice. # Impresión de elemento en x posición. my_print(mi_tupla[2]) # Impresión desde x elemento hasta y elemento (no incluye el y elemento) my_print(mi_tupla[1:3]) # Las tuplas se utilizan para mantener datos que sean constantes, que no deberán # alterar sus valores durante la ejecución del programa
# Listas
from my_function import my_print
# Una lista puede ser cargada con distintos tipos de datos
# dentro de la misma
mi_lista = ["String", 1, 3.5, False, True]
my_print(mi_lista)
# Agregar elementos a una lista
# Método append inserta al final de la lista
mi_lista.append("nuevo elemento")
my_print(mi_lista)
# Método insert inserta un dato en la posición x indicada.
# lista.insert(x,elemento)
mi_lista.insert(0, 'Elemento agregado')
my_print(mi_lista)
# El acceso a los datos de la lista, son accesibles mediante indices
my_print(mi_lista[0])
# Método para remover un elemento de la lista
mi_lista.remove(False)
my_print(mi_lista)
def aplica_funcion(funcion):
resultado = funcion()
my_print(resultado)
def validacion():
my_print("se ejecuta validación")
return num_uno > 0 and num_dos > 0
from my_function import my_print
# FUNCIONES ANIDADAS
def validacion(num_uno, num_dos):
return num_uno > 0 and num_dos > 0
def division(num_uno, num_dos):
if validacion(num_uno, num_dos): # Llamado de funciones
return num_uno / num_dos
resultado = division(10, 0)
my_print(resultado)
# Funcion anidada
def division2(num_uno, num_dos):
def validacion():
return num_uno > 0 and num_dos > 0 # utiliza variables del parámetro
if validacion(): # Llamado de funcione dentro de otra
return num_uno / num_dos # utiliza variables del parámetro también
resultado = division2(60, 0)
my_print(resultado)
def mostrar_resultado(funcion):
my_print(funcion)
from my_function import my_print
# Funciones - parte 2
def suma(valor_uno, valor_dos, valor_tres):
return (valor_uno + valor_dos + valor_tres)
resultado = suma(1, 20, 30)
my_print(resultado)
def division(valor_1, valor_2):
return (valor_1 / valor_2)
resultado = division(100, 10)
my_print(resultado)
# Es posible nombrar lo valores a asignar sin depender del orden de los parametros
def division2(valor_uno, valor_dos):
return (valor_uno / valor_dos)
resultado = division2(valor_dos=20, valor_uno=100)
my_print(resultado)
# Se puede indicar un valor inicial para un parametro, si, solo si
def saludo():
my_print("Hi!")
def suma(n_1, n_2):
my_print(n_1 + n_2)
# lista = [ valor for valor in lista1 ] # ejemplo: lista = [ x for y in z ] # x: valor a agregar # y: elemento al que se le asigna cada elemnto de la lista y luego se agrega # z: lista a iterar para obtener valores a agregar """ 1- valor a agregar a lista 2- Un ciclo """ # se agregan números desde el 1 hasta el 100 lista = [ valor for valor in range(1,101) ] my_print(lista) # Condición al comprehension # Se agregan solamente los números pares lista2 = [ valor for valor in range(1,101) if valor % 2 == 0] my_print(lista2) # Creación de tuplas mediante comprehension # para tupla, se debe hacer un cast --> tuple(comprehension) tupla = tuple((valor for valor in range(1,101) if valor % 2 != 0)) my_print(tupla) # Creación de diccionarios mediante comprehension
def fin_msg():
my_print("Fin process")
from my_function import my_print #FOR LO UTILIZAREMOS CUANDO TENGAMOS CONOCIMIENTO DE LA CANTIDAD DE ITERACIONES #Nos permitirá iterar objetos iterables, listas, tuplas, strings. lista = [1,2,3,4,5,6,7,8,9,10] # No ha sido necesario indicar un índice para indicar la posición actual for valor in lista: my_print(valor) # se crea un objeto con valores numéricos desde el 0 al 9 # range(x,y) x: desde; y: hasta --> entrega un objeto iterable nuevo_rango = range(0,10) for valor in nuevo_rango: my_print(valor) # Si range() solamente lleva 1 parámetro, se obtendrá un objeto iterable # dsde la posición 0, hasta la que se indique como único parámetro nuevo_rango2 = range(15) for valor in nuevo_rango2: my_print(valor) # Si range(x,y,z) contiene 3 parámetros, el desgloce sería el siguiente_ # x: desde; y: hasta; z: saltos entre valores nuevo_rango3 = range(0,21,2) for valor in nuevo_rango3:
def msg_fin():
my_print("Fin...")
from my_function import my_print
# Condicional IF
# Para decirle que acción debe tomar una condición, debe ir el bloque a ejecutar
# abajo de la condición, con un tab (identado).
# Python no trabaja con llaves {}
valor1 = "mivalor"
# if condicion :
# bloque a ejecutar
if valor1 == "mivalor":
my_print("El valor cumple la condición")
else:
my_print("El valor no cumple la condición")
# IF reducido a una línea
valor2 = "mivalor1"
mensaje = "El valor es igual" if valor2 == "mivalor1" else "El valor no es igual"
my_print(mensaje)
# IF con multiples condiciones
valor3 = "mivalor2"
if valor3 == "mivalor":
# VARIABLES GLOBALES
# Una variable local no puede modificar a una variable global
# La variable global puede ser declarada antes o despues de la función que la utiliza
# pero la función que la utiliza, no puede ser invocada antes de crear la variable
def palindromo(frase):
frase = frase.replace(
' ', '') # Variable local. Solo existe en el contexto de la función
return frase == frase[::-1]
frase = 'anita lava la tina' # Variable global
resultado = palindromo(frase)
my_print(resultado)
# Palindromo que lee como frase una variable global
def palindromo2():
nuevo_valor = frase.replace(' ', '')
return nuevo_valor == nuevo_valor[::-1]
resultado2 = palindromo2()
my_print(resultado2)
# Modificar una variable global dentro de una función
variable_global = "variable"
from my_function import my_print
# GENERADORDES
# Los generadores permiten crear objetos, sin necesidad de almacenarlos
# en la memoria RAM
def generador(*args):
for valor in args:
yield valor * 10, True
# Si indicaramos un return, en el ejemplo de arriba,
# daría error, ya que no retorna un valor iterable, por lo
# que se utilizará yield, lo que devuelve un valor iterable
# Yienld puede retornar más de un valor, yield se utiliza para los generadores.
for valor_1, valor_2 in generador(1, 2, 3, 4, 5, 6, 7, 8, 9):
my_print(("{} {}".format(valor_1, valor_2)))
# invocar función
factorial()
# Creando función factorial, recibiendo argumentos para cualquier número
def factorial2(numero):
factorial = 1
while numero > 0:
factorial = factorial * numero
numero -= 1
my_print(factorial)
factorial2(5)
factorial2(6)
factorial2(7)
# Retornar valores desde una funcion
def factorial3(numero):
factorial = 1
while numero > 0:
factorial = factorial * numero
numero -= 1
return factorial
my_print(factorial3(10))
def suma2(**kwargs):
valor = kwargs.get('cadena', 'No contiene valor')
my_print(valor)
#CICLO WHILE LO UTILIZAREMOS CUANDO DESCONOSCAMOS LA CANTIDAD DE ITERACIONES
from my_function import my_print
# while condicion:
# codigo
# else(opcional):
# codigo
# Ejemplo utilizando break para cerrar el ciclo
contador = 0
while contador < 10: #Es posible el uso de condicionales >; >=; < ; <=; ==; !=
my_print(contador)
contador += 1
if contador == 4:
continue
if contador == 6:
break
else:
my_print("Final")
# Ejemplo utilizando variable Bandera para finalizar MEJOR FORMA
contador2 = 0
bandera = True
# La documentación se coloca sobre la primera línea de la función
def generador(*args):
"""Recibe N cantidad de números y regres el número, ademas
regresa True si el número es mayor a 5, de lo contrario,
retorna False.
"""
for valor in args:
yield valor, True if valor > 5 else False
# funcion.__name__ nos retorna el nombre de la función
nombre = generador.__name__
# funcion.__doc__ nos trae los comentarios o ducumentación que
# indicamos dentro de la función documentada.
documentacion = generador.__doc__
print(nombre, " : ")
my_print(documentacion)
"""
Para obtener la documentación desde el interprete de python
se debe escribir python3, en la consola de comandos, luego
importar la función desde la cual se desea recibir la documentacion,
se importa con "from (nombre archivo sin extensión) import (nombre de la función)"
luego se escribe "help(nombre de función)", lo que retorna los datos
asociados a dicha función.
"""
