Curso de Python

-----------------------------------------------------------------------------------------------------------------------------------

Funciones
Una función es un bloque de código que realiza una tarea especifica cuando la función es llamada
(invocada).
Las funciones son útiles para hacer que el código sea reutilizable, que este mejor organizado y más
legible.
Las funciones contienen parámetros y pueden regresar valores
Existen al menos cuatro tipos de funciones básicas en Python:
• Funciones integradas las cuales son partes importantes de Python (como lo es la función
print()). Puedes ver una lista completa de las funciones integradas de Python en la
siguiente liga: https://docs.python.org/3/library/functions.html.
• También están las que se encuentran en módulos pre-instalados
• Funciones definidas por el usuario las cuales son escritas por los programadores para los
programadores, puedes escribir tus propias funciones y utilizarlas libremente en tu código.
• Las funciones lambda

Las funciones propias se pueden definir utilizando la palabra reservada def y con la siguiente
sintaxis:

def tuFuncion (parámetros opcionales):

# el cuerpo de la función

No se debe invocar una función antes de que se haya definido.

Una función y una variable no pueden compartir el mismo nombre.

Se puede definir una función sin que haga uso de argumentos, por ejemplo:
def mensaje(): # definiendo una función
print("Hola") # cuerpo de la función

mensaje() # invocación de la función

def hola(nombre): # definiendo una función

print("Hola,", nombre) # cuerpo de la función

nombre = input("Ingresa tu nombre: ")

hola(nombre) # invocación de la función

Funciones con parametros

Un parámetro es una variable, pero existen dos factores que hacen a un parámetro diferente:
• Los parámetros solo existen dentro de las funciones en donde han sido definidos, y el
único lugar donde un parámetro puede ser definido es entre los paréntesis después del
nombre de la función, donde se encuentra la palabra reservada def.
• La asignación de un valor a un parámetro de una función se hace en el momento en que la
función se manda llamar o se invoca, especificando el argumento correspondiente.

Docente: Ing. Marcelino Torres Villanueva Pag. 1

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

def funcion(parametrotros):
#Cuerpo de la funcion

Especificar uno o mas parámetros en la definición de la función es un requerimiento, y se debe de

cumplir durante la invocación de la misma. Se debe proveer el mismo numero de argumentos
como haya parámetros definidos

Ejercicio:
Ingresar un numero entero n y mostrar todos sus divisores

def reporteDivisores(n):
for i in range(1,n+1):
if n % i==0:
print(i, end=" ")

while True:
n=int(input('Ingrese numero entero :'))
if n>0:
break
reporteDivisores(n)

En este programa el nombre del parametro n es identico al valor de n del programa, pero son 2
entidades completamente Diferentes.
En la invocacion de la funcion el parametro n recibe el valor de la variable n.

Paso de parámetros posicionales

La técnica que asigna cada argumento al parámetro correspondiente, es llamada paso de
parámetros posicionales, los argumentos pasados de esta manera son llamados argumentos
posicionales
Ejemplo: En la siguiente funcion colcamos 2 parametros el nombre y apellido
def presentar(nombre,apellido):
print("Hola, mi nombre es", nombre,apellido)
presentar('Yvan','Rodriguez')
presentar('Luis','Zegarra')
presentar('Sanchez','Julio')
El resultado:
Hola, mi nombre es Yvan Rodriguez
Hola, mi nombre es Luis Zegarra
Hola, mi nombre es Sanchez Julio

En la ultima invocacion le enviamos el apellido y luego el nombre python conoce que el primer
parametro es nombre y el segundo apellido, si le mandamos equivocado lo coloca asi.
Son parametros posicionales.

Docente: Ing. Marcelino Torres Villanueva Pag. 2

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

Paso de argumentos con palabras clave

Python ofrece otra manera de pasar argumentos, donde el significado del argumento esta definido
por su nombre, no su posición, a esto se le denomina paso de argumentos con palabras clave.

def presentar(nombre,apellido):
print("Hola, mi nombre es", nombre,apellido)
presentar(nombre='Yvan',apellido='Rodriguez')
presentar('Luis','Zegarra')
presentar(apellido='Sanchez',nombre='Julio')
Hola, mi nombre es Yvan Rodriguez
Hola, mi nombre es Luis Zegarra
Hola, mi nombre es Julio Sanchez

El concepto es claro: los valores pasados a los parámetros son precedidos por el nombre del
parámetro al que se le va a pasar el valor, seguido por el signo de =.
La posición no es relevante aquí, cada argumento conoce su destino con base en el nombre
utilizado.

El combinar argumentos posicionales y de palabras clave

Es posible combinar ambos tipos si se desea, solo hay una regla inquebrantable: se deben colocar
primero los argumentos posicionales y después los de palabras clave.

def suma(a, b, c):

print(a, "+", b, "+", c, "=", a + b + c)

suma(1, 2, 3)
suma(c = 1, a = 2, b = 3)
suma(3, c = 1, b = 2)

suma(3, a = 1, b = 2)
# Esta invocación es incorrecta porque, se le esta asignando dos veces un valor al parámetro a

Parametros con valores por defecto

Se le puede colocar valores por defecto a los parametros. Primero se deben colocar los
parametros sin valores por defecto y luego los parametros con valores por defecto.
Ejemplo:
def calculo(a,b=3,c=4):
print(a,b,c)

calculo(5)
calculo(5,8)
calculo(5,8,12)
Resultado
534
584
5 8 12

Docente: Ing. Marcelino Torres Villanueva Pag. 3

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

Funciones que devuelven un valor

Para lograr que las funciones devuelvan un valor (pero no solo para ese propósito) se utiliza la
instrucción return (regresar o retornar)
La instrucción return tiene dos variantes diferentes: considerémoslas por separado.
return sin una expresión
La primera consiste en la palabra reservada en sí, sin nada que la siga.
Cuando se emplea dentro de una función, provoca la terminación inmediata de la ejecución de la
función, y un retorno instantáneo (de ahí el nombre) al punto de invocación

return con una expresión

La segunda variante de return está extendida con una expresión

def nombreFuncion(parametros)
Instrucciones
return expresion

Hay dos consecuencias de usarla:

• Provoca la terminación inmediata de la ejecución de la función (nada nuevo en comparación con
la primer variante).
•Además, la función evaluará el valor de la expresión y lo devolverá (de ahí el nombre una vez
mas) como el resultado de la función.

Ejercicio
Ingresar 3 numeros reales y reportar el mayor de ellos. Use funciones

def ingresoNumero(mensaje):
num=float(input(mensaje))
return num

def mayor(a,b,c):
may=a
if b>may:
may=b
if c>may:
may=c
return may

num1=ingresoNumero('Primer Numero:')
num2=ingresoNumero('Segundo Numero:')
num3=ingresoNumero('Tercer Numero:')
print('El mayor es: ',mayor(num1,num2,num3))

Docente: Ing. Marcelino Torres Villanueva Pag. 4

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

return multiple
Una característica interesante, es la posibilidad de devolver valores múltiples separados por
comas:
Ejemplo:
def prueba():
return "Juan perez", 18, [6,9,15]

print(prueba())
Resultado:
('Juan perez', 18, [6, 9, 15])

Crear una funcion que dado el radio de un circulo devuelva el area y la longitud de la
circunferencia

def calculo(r):
area=3.1416*r**2
longitud=2*3.1416*r
return area,longitud

r= float(input('Valor del radio:'))

a,b=calculo(r)
print('El area es:',a)
print('La longitud es:',b)

La funcion calculo tiene un parametro de entrada que se llama r, donde se ingresa el radio y
devolvera 2 valores el area y la longitud, esto lo hacemos con la sentencia return.

Palabra None:
Es una palabra reservada
Solo hay dos tipos de circunstancias en las que None se puede usar de manera segura:
- Cuando se le asigna a una variable (o se devuelve como el resultado de una función).
- Cuando se compara con una variable para diagnosticar su estado interno.
Ejemplo:
valor = None
if valor == None:
print("Lo siento, no tienes ningún valor")

No olvidar esto: si una función no devuelve un cierto valor utilizando una cláusula de expresión
return, se asume que devuelve implícitamente None.

def esPar(x):
if x % 2 ==0:
return True

print(esPar(2))
print(esPar(3))

True

Docente: Ing. Marcelino Torres Villanueva Pag. 5

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

None
Es obvio que la función esPar devuelve True cuando su argumento es par, como no hemos
colocado nada cuando es Impar devuelve None.
No te sorprendas la próxima vez que veas None como el resultado de la función, puede ser el
síntoma de un error sutil dentro de la función.

Ingresar un numero mayor o igual que cero y reportar su Factorial. Use funciones
def ingresoNumero():
while True:
n=int(input('Ingrese numero:'))
if n>0:
return n

def factorial(n):
if n<0:
return None
if n<=1:
return 1
f=1
for i in range(1,n+1):
f=f*i
return f

num=ingresoNumero()
print('El factorial es: ',factorial(num))

Funciones y Listas
- Si se pasa una lista a una función, la función tiene que manejarla como una lista.
- Una lista puede ser el resultado de una funcion

Crear una funcion para sumar los elementos de una lista.

def sumarLista(lista):
suma = 0

for elem in lista:

suma += elem

return suma

lista=[1,5, 6,8, 10]

print('La suma de los elementos es: ',sumarLista(lista))

Crear una funcion para que se le ingrese un valor de n y devuelva una lista con valores desde el 1
hasta el n.

Docente: Ing. Marcelino Torres Villanueva Pag. 6

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

def listaNumeros(n):
lista = []
for i in range(1, n+1):
lista.append(i)
return lista

print(listaNumeros(5))

Eescribir y probar una función que toma tres argumentos (un año, un mes y un día del mes) y
devuelve el día correspondiente del año, o devuelve None si cualquiera de los argumentos no es
válido
def esAñoBisiesto(año):
if (año %4 ==0 and año %100 !=0) or año %400==0 :
return True
else:
return False

def numDiasMes(mes, año):

if año<=0 or (mes<1 or mes>12):
return None
else:
if mes in [1, 3, 5, 7, 8, 10, 12]:
return 31
else:
if mes in [4,6,9,11]:
return 30
else:
if esAñoBisiesto(año):
return 29
else:
return 28

def diaDelAño(dia,mes,año):

meses=['Enero','Febrero','Marzo','Abril','Mayo','Junio','Julio','Agosto','Setiembre','Octubre','Novie
mbre','Diciembre']
if año<=0:
return None
else:
if mes<1 or mes>12:
return None
else:
if dia<1 or dia>numDiasMes(mes,año):
return None
else:
diaAño=str(dia)+" de "+meses[mes-1]+" del "+str(año)
return diaAño
print(diaDelAño(31, 12, 2000))

Docente: Ing. Marcelino Torres Villanueva Pag. 7

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

Un número natural es primo si es mayor que 1 y no tiene divisores más que 1 y si mismo.
Crear una funcion que tenga como parametro un numero y devuelva verdadero si es Primo y falso
sino lo es. Usarlo para reportar todos los numeros primos menores o iguales que 20

def esPrimo(num):
lim =int(round(num ** 0.5,0))
for d in range(2,lim+1):
if num % d==0:
return False
return True

for i in range(1, 20):

if isPrime(i + 1):
print(i + 1, end=" ")
print()

Resultado:
2 3 5 7 11 13 17 19

Las funciones y sus alcances (scopes)

El alcance de un nombre (por ejemplo, el nombre de una variable) es la parte del código donde el
nombre es reconocido correctamente.
Por ejemplo, el alcance del parámetro de una función es la función en si misma. El parámetro es
inaccesible fuera de la función.

Si ejecutamos este programa

def pruebaAmbito():
x = 123
pruebaAmbito()
print(x)

Saldra error pues x solo esta definida en la funcion.

Una variable que existe fuera de una función tiene un alcance dentro del cuerpo de la función,
excluyendo a aquellas que tienen el mismo nombre.

def miFuncion():
var = 2
print("¿Conozco a la variable?", var)

var = 1
miFuncion()
print(var)
Resultado:
¿Conozco a la variable? 2
1

Docente: Ing. Marcelino Torres Villanueva Pag. 8

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

Las funciones y sus alcances (scopes): la palabra reservada global

Al llegar a este punto, debemos hacernos la siguiente pregunta: ¿Una función es capaz de
modificar una variable que fue definida fuera de ella?
Afortunadamente, la respuesta es no.
Existe un método especial en Python el cual puede extender el alcance de una variable incluyendo
el cuerpo de las funciones para poder no solo leer los valores de las variables sino también
modificarlos.
Este efecto es causado por la palabra reservada llamada global:
global name
global name1, name2, ...
El utilizar la palabra reservada dentro de una función con el nombre o nombres de las variables
separados por comas, obliga a Python a abstenerse de crear una nueva variable dentro de la
función; se empleará la que se puede acceder desde el exterior.
Ejemplo:

def miFuncion():
global var
var = 2
print("¿Conozco a aquella variable?", var)
var = 1
miFuncion()
print(var)
Resultado
¿Conozco a aquella variable? 2
2

Como interactua la funcion con sus argumentos.?

Los parametros escalares de las funciones son por valor. Eso quiere decir que el parametro recibe
una copia de la variable pasada como argumento y no se puede modificar el argumento.

def calculo(n):
n=n+3

x=2
calculo(x)
print(x)

Resultado: 2
La variable x copia su valor al parametro n, n recibe 2 y luego n se incrementa en 3 entonces n
vale 5 pero x sigue siendo 2. Al imprimir x saliendo de la funcion el valor es 2

Docente: Ing. Marcelino Torres Villanueva Pag. 9

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

Funciones Recursivas

Una funcion recursiva es cuando se llama a si misma

Crear una funcion recursiva para reportar el enesimo termino de la serie de fibonacci

def fib(n):
if n < 1:
return None
if n < 3:
return 1
return fib(n - 1) + fib(n - 2)

print(fib(3))

- Calcular el factorial de un numero entero n

def factorial(n):
if n < 0:
return None
if n < 2:
return 1
return n * factorial(n - 1)

print(factorial(5))

Paso de parametros por Valor y por Referencia

Los tipos simples se pasan por valor: Enteros, flotantes, cadenas, lógicos...
Los tipos compuestos se pasan por referencia: Listas, diccionarios, conjuntos..

Ejemplo de paso por valor

En el siguiente ejemplo estamos utilizando como parametro una variable numerica. Cuando un
parametro se pasa por valor se crea una copia dentro de la funcion, por eso no le afecta
externamente lo que se haga con el.

def triplicar(x):
x = x*3

a=5
triplicar(a)
print(a)

Si corremos el programa imprimira 5, Pues al llamar a la funcion se hace una copia de la variable a
hacia el parametro x, el que triplica es x y no a.

Docente: Ing. Marcelino Torres Villanueva Pag. 10

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

Ejemplo de paso por referencia

Los tipos compuestos como las listas u otras colecciones se pasan por defecto por referencia y si
las modificamos dentro de la función estaremos modificándolas también fuera:

def modificar_lista(datos):
for i in range(len(datos)):
datos[i] += 10

ns = [3,12,20,40]
modificar_lista(ns)
print(ns)
El resultado sera:
[13, 22, 30, 50]

Para modificar los tipos simples podemos devolverlos modificados y reasignarlos:

def triplicar(x):
return x * 3

a = 10
a = triplicar(a)
print(a)

En este codigo el valor de a al final es 30

Docente: Ing. Marcelino Torres Villanueva Pag. 11