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