Las funciones son código pre-escrito que puede ser llamado en cualquier momento de

la ejecución para que ejecute su tarea. Sirven para simplificar el código del
programa y abstraerlo, al este no requerir ser repetido, almenos no por lo general.
Reciben un parámetro de entrada entre ( ) y devuelven una salida.
Permiten modularizar el programa y desarrollar los distintos sectores del código
por separado, y de una manera mas simple.

Las funciones pueden dividirse en 2 grandes grupos, las funciones integradas y

propias.

# Funciones integradas (built-in)

Son aquellas funciones que ya vienen integradas como parte del lenguaje de
programación. Ej: `len(), print(), list()`.

## Min y Max
- **Min:** devuelve el valor mas bajo de un iterable.
- **Max:** devuelve el valor mas alto de un iterable.
- Si se les pasa de dato un String devolverán una excepción, ósea un Error.

Ej:
```Python
numeros = [4,7,1,42,15]

# ========== [ Max: ] ==========

# Encontrando el numero mayor de una lista

# Determina el valor mas alto de un elemento iterable
numero_mas_alto = max(numeros)
print(numero_mas_alto)

# ========== [ Max: ] ==========

# Encontrando el numero menor de una lista

# Determina el valor mas bajo de un elemento iterable
numero_mas_alto = min(numeros)
print(numero_mas_alto)
```

## Round
- Redondea el numero que le pasemos como parámetro.
- También es posible darle un segundo parámetro especificando después de una coma,
la cantidad de decimales en el resultado, de no dárselo la función redondeara a un
numero entero y no habrá decimales en el resultado.

Ej:
```Python
# Redondeando un numero de 6 decimales en un numero entero.
numero = round(12.345678)
print(numero)
# Rta: 12

# Redondeando un numero de 6 decimales a uno de 3

numero = round(12.345678,3)
print(numero)
#Rta: 12.345
```

## Bool
- Retorna False si se le pasa de parámetro --> 0 - un elemento vacío(ejemplo lista
vacía) - False - None.
- Retorna True si se le pasa de parámetro --> Un numero distinto de 0 - True -
Cadena de texto - Datos no vacíos(ejemplo lista con elementos)

```Python
# Retorna False -> Numero = 0 - Elemento vacio(Ej:lista vacia) - False - None /
True -> Numero distinto de 0 - True - Cadena de texto - Elementos no
vacios(Ej:tupla con datos)

# [ Respuesta = False: ]
resultado_bool = bool([])

print(resultado_bool)

# [ Respuesta = True: ]
resultado_bool = bool([25,37,'patata'])

print(resultado_bool)
```

## All
Hace lo opuesto a Bool(), envés de chequear un solo elemento para ver si es
Verdadero o Falso, lo que hace All es chequear todos los elementos de un iterable y
si todos estos son Verdaderos el resultado será Verdadero, pero si aunque sea uno
solo de los elementos del iterable es Falso la función devolverá Falso, sin
importar que todo el resto de elementos sean verdaderos.

### Ej:
#### Tabla de valores:
- Retorna False si se le pasa de parámetro --> 0 - un elemento vacío(ejemplo lista
vacía) - False - None.
- Retorna True si se le pasa de parámetro --> Un numero distinto de 0 - True -
Cadena de texto - Datos no vacíos(ejemplo lista con elementos)
```Python
# [ Respuesta = True: ]
resultado_all = all([10,"True",[134,544]])
print(resultado_all)

# [ Respuesta = False: ]
resultado_all = all([None,"True",[134,544]])
print(resultado_all)
```

## Sum
- La función sum() suma todos los valores dentro de un iterable. Si se le pasa de
dato un String devolverá una excepción, ósea un Error.

Ej:
```Python
numeros = [4,7,1,42,15]

suma_total = sum(numeros)
print(suma_total)
# Respuesta = 69
```

---

# Funciones propias
Son funciones creadas por nosotros los desarrolladores con el fin de mejorar
nuestro código, volviéndolo menos enrevesado y por consecuencia mas legible.

## Creando función simple

Cuando creamos una función hay que especificarlo de alguna forma al lenguaje, y en
Python se hace mediante la sentencia "def"(que es el comando que indica a Python
que queremos crear una función), seguido del nombre de la función. Una vez creada
la función podrá ser llamada desde cualquier parte siguiente del código como si
fuera una función built-in de Python.

Ej:
```Python
# Creando una funcion simple
def saludar():
print("Hola master, como andas?")

# Ejecutando la funcion
saludar()
saludar()
saludar()
saludar()
saludar()

# [ Rta: ]

# Hola master, como andas?

# Hola master, como andas?
# Hola master, como andas?
# Hola master, como andas?
# Hola master, como andas?
```

## Creando una función con parámetros

Un parámetro es una variable que existe solo dentro de la función, que contendrá
los dantos de entrada para la función.
Crear una función con parámetros es tan simple como crear una función simple, con
el extra del nombre de la variable que será usada de parámetro entre paréntesis
( ).

Ej:
```Python
# Creando funcion con parametros
def saludar(nombre):
print(f"Hola {nombre}, como andas master?")

# Ejecutando la funcion
saludar("Juan")
# Rta: Hola Juan, como andas master?
```

### Creando funciones con mas de un parámetro

Para crear una función con mas de un parámetro es tan simple como separar los
parámetros con comas " , ".

Ej:
```Python
# Creando funcion con varios aparametros
def saludar(nombre,sexo):
sexo = sexo.lower()
if (sexo == "mujer"):
adjetivo = "reina"
elif (sexo == "hombre"):
adjetivo = "titan"
else:
adjetivo = "amor"
print(f"Hola {nombre}, como andas mi {adjetivo}?")

saludar("Pedro","hombre")
saludar("Camila","mujer")
saludar("Patata","patata")

# [ Rta: ]
# Hola Pedro, como andas mi titan?
# Hola Camila, como andas mi reina?
# Hola Patata, como andas mi amor?
```

## Creando una función que nos retorne valores

Para crear una función que nos retorne valores hay que usar la sentencia return al
final de la función.

Ej:
```Python
def crear_contraseña_random(num):
chars = "abcdefghij" # Define una lista de caracteres
num_entero = str(num) # Convierte el numero de entrada en string
num = int(num_entero[0]) # Convierte en int el primer caracter del string
c1 = num - 2
c2 = num # Se crea una serie de numeros random a partir de la entrada
c3 = num - 5
contraseña = f"{chars[c1]}{chars[c2]}{chars[c3]}{num*2}"
# Se crea una contraseña aleatoria con los numeros random
return contraseña # Se devulve el resultado con return

# Se prueba que funcione

password = crear_contraseña_random(9)
print(f"Tu contraseña nueva es: {password}")
# Rta = hje18
```

### Creando una función que retorne mas de un valor

Para crear una función que retorne mas de un valor a la vez es tan simple como
cambiar el tipo de dato de salida de variable a tupla o lista.

Ej:
```Python
# Funcion que multiplica 2 numeros a la vez x2.

def mult_2num_x2(a,b):
a = a*2
b = b*2
return [a,b]

resultado1,resultado2 = mult_2num_x2(3,25) # Desempaquetamos la lista en 2

variables
print(f"El primer resultado es: {resultado1}")
print(f"El segundo resultado es: {resultado2}")
# [ Respuesta: ]
# El primer resultado es: 6
# El segundo resultado es: 50
```

## Formas optimas y no optimas de sumar valores

### Forma no optima de sumar valores

```Python
def suma(lista):
numeros_sumados = 0
for num in lista:
numeros_sumados = numeros_sumados + num
return numeros_sumados

resultado = suma([10,25,6])
print(resultado)
# Respuesta = 41
```

### Forma optima de sumar valores (Operador args)

Para sumar valores de forma optima se debe usar un parámetro con el operador args,
el cual lo que hace es tomar todos los parámetros que le pasamos y ponerlos dentro
de una lista. Si queremos tener mas de un parámetro dentro de la función este
deberá estar ubicado antes del parámetro con el operador args, ya que de lo
contrario el código dará una excepción.
Para definir un parámetro con operador args es tan fácil como poner un asterisco
antes del nombre del parámetro. Solo puede haber un único parámetro con operador
args por función y debe estar siempre ordenado como el ultimo.
El operador args puede estar tanto como de argumento/parametro de la funcion, como
tambien dentro de esta.

Ej:
```Python
# Forma optima de sumar valores, con el operador *args dentro de la funcion.
def suma_total(numeros)
return sum([*numeros])

resultado2 = suma_total(10,25,6)
print(resultado2)
# Respuesta = 41

# Forma optima de sumar valores, pero utilizando el operador (*args) como argumento
de la funcion
def suma(nombre,*numeros):
return f"{nombre}, la suma de tus numeros es: {sum(numeros)}"

resultado = suma("Juan",10,25,6)
print(resultado)
# Respuesta = Juan, la suma de tus numeros es: 41
```

## Insertando parámetros en diferente orden usando keywords arguments

Es posible ingresar los parámetros de una función en un orden distinto al
establecido por la misma mediante el uso de keywords arguments, que son iguales a
la sintaxis para definir una variable.
Ej:
```Python
# Creando una funcion de 3 parametros
def frase(nombre,apellido,adjetivo):
return f"Hola {nombre} {apellido}, sos muy {adjetivo}"

# Utilizando keyword arguments para ingresar los parametros en un orden distinto

frase_resultante = frase(adjetivo="fachero",nombre="Lucas",apellido="Dalto")
print(frase_resultante)
# Respuesta = Hola Lucas Dalto, sos muy fachero
```

## Crear funciones con parámetros opcionales con valores por defecto

Para definir un valor por defecto para un parámetro opcional, es tan fácil como
definir el parámetro deseado como si fuera una variable.
Ej:
```Python
# Creando una funcion con un parametro opcional y un valor por defecto
def frase(nombre,apellido,adjetivo = "tonto"):
return f"Hola {nombre} {apellido}, sos muy {adjetivo}"

# Ej usando el valor por defecto:

frase_resultante = frase("Lucas","Dalto")
print(frase_resultante)
# Respuesta = Hola Lucas Dalto, sos muy tonto

# Ej añadiendo un valor opcional:

frase_resultante = frase("Lucas","Dalto","inteligente")
print(frase_resultante)
# Respuesta = Hola Lucas Dalto, sos muy inteligente
```

---

# Funciones lamda
Lambda es una forma para crear una función anónima, ósea sin nombre. Y que
significa esto? Significa que podemos saltarnos el proceso del def y definir una
función en una única linea de código, enlazándola a una variable. Lo cual es
extremadamente beneficioso a la hora de ahorrar tiempo al momento de escribir el
código, ya que nos saltamos varios pasos al momento de definir una función simple,
además del hecho de que retornan de forma automática, sin necesidad de la sentencia
return. Aunque hay que tener en cuenta el hecho de que esto sirve solo para
funciones simples, ya que si necesitamos una función con mas instrucciones
deberemos volver a usar la sintaxis del def, debido a la limitación de una única
linea de código lo cual la hace poco apta para esta tarea.

Ej:
```Python
# Funcion definida en modo tradicional
def funcion_tradicional(x):
return x*2

# Funcion definida como funcion lambda

funcion_lambda = lambda x : x*2

print(funcion_tradicional(5)) # [ Rta ] = 10
print(funcion_lambda(5)) # [ Rta ] = 10
```

#### Ejemplo de ahorrar espacio en una función que retorna que números son pares
con filter().

>[!note] "Filter() es una función integrada que tiene 2 parámetros, en el primero

va una función que retorne Verdadero o Falso, y en el segundo una lista. La función
filter pasa la lista del segundo parámetro a la función del primero como un
parámetro y dependiendo del resultado que de la función del primer parámetro, la
funcion filter devolverá un valor del segundo parámetro o saltara a analizar el
siguiente. Además actúa por si misma como si fuera un bucle.
>Ósea que filtra números de una lista tomando de argumento de filtrado una función
propia.
> Nota: Para obtener un resultado útil se debe aplicar la función list() al
resultado de filter().

```Python
numeros = [1,2,3,4,5,6,7,8,9]

# [ Creando funcion comun que diga si es par o no: ]

def es_par(num):
if (num%2 == 0):
return True

# Usando filter con una funcion comun

numeros_pares = filter(es_par,numeros)

print(list(numeros_pares))
# Respuesta = [2,4,6,8]

# [ Creando lo mismo que antes pero con lambda: ]

numeros_pares = filter(lambda numero:numero%2 == 0,numeros)

print(list(numeros_pares))
# Respuesta = [2,4,6,8]
```

---

# Saltar función y detener ejecución del código

Para saltar la función debemos usar la sentencia pass, la cual seguirá seguirá
ejecutando el resto del código.
```Python
def saltar():
 pass

saltar()

print('Hola')
# RTA: Hola
```

En cambio para detener la ejecución del código debemos usar la sentencia break, que
detendrá por completo la ejecución del mismo.
```Python
def detener():
break

detener()

print('Hola')
# RTA:
```

---

Nexo: [[200_-_Memoria_Digital/Programacion/Cursos/Nexo cursos de programacion de

dalto|Nexo cursos de programacion de dalto]]

Anterior: [[200_-_Memoria_Digital/Programacion/Cursos/Python/Bucles|Bucles]]

Siguiente: [[200_-_Memoria_Digital/Programacion/Cursos/Python/Modulos|Modulos]]

#programacion #Python