Subprogramas

Computación I
Descripción breve
La idea de dividir un problema complejo en pequeños problemas o subproblemas se conoce como
“programación modular” y consiste en resolver de forma independiente los subproblemas
resultantes de la descomposición de un problema, donde cada una de las soluciones a los
subproblemas constituye un subprograma o procedimiento. Esto implica que existe un proceso
principal, denominado programa principal, que transferirá el control y la información a los
distintos subprogramas para que efectúen la tarea solicitada cuando sean llamados, los cuales
una vez que terminen de efectuar su tarea o instrucciones definidas para alcanzarla, transferirán
de nuevo el control a quien lo llamó; sea este el programa principal u otro subprograma o
procedimiento. Un subprograma es entonces un bloque de instrucciones o sentencias que llevan a
cabo una tarea bien específica o definida y que puede utilizarse en un programa varias veces sin
necesidad de reescribir el código. Como representa una sección de código que se ejecutará y
establecerá comunicación con quien lo invoca o llama, esta comunicación o intercambio de
información se realizará a través de variables, que se denominarán parámetros. En este
documento encontrará la definición de subprograma, tipos, creación y usos. Adicionalmente por
ser un elemento imprescindible la definición de parámetros, tipos, declaración y uso apropiado.
Este material es introductorio y se omitirá todo aquello que no se empleará por los momentos.

Prof. Lisbeth Pacheco.

lpachecos@[Link]
 SUBPROGRAMAS

Contenido

Definiendo Subprogramas o Procedimientos ..................................................................... 1

Divide el problema y lo resolverás .................................................................................... 3
Ventajas de desarrollar Subprogramas ............................................................................. 4
Subprogramas,Procedimientos o Funciones ...................................................................... 5
Definiendo que son Parámetros o Argumentos.................................................................. 5
Parámetros Formales ......................................................................................................... 6
Parámetros Actuales/Argumentos ........................................................................................ 6
Más acerca de los Parámetros Formales ............................................................................... 7
Tipos de Parámetros Formales .......................................................................................... 8
Parámetros por Valor ......................................................................................................... 8
Parámetros por Referencia.................................................................................................. 9
Parámetros por valor o por referencia en PYTHON ............................................................... 10
Subprogramas en PYTHON .............................................................................................. 10
Cómo crear una función en PYTHON ................................................................................ 11
Sintaxis .......................................................................................................................... 11
La instrucción return ........................................................................................................ 12
Devolver un valor simple (un único return) ............................................................... 12
Devolver múltiples valores ........................................................................................ 12
Devolver None ........................................................................................................... 12
Salida anticipada de una función ............................................................................... 12
Creación de una función que retorne un único valor ............................................................. 13
Uso o llamada de una función que retorne un único valor ..................................................... 13
Creación de una función que retorne múltiples valores ......................................................... 15
Uso o llamada de una función que retorna múltiples valores ................................................. 16
Creación de una función no retorna nada ............................................................................ 18
Uso o llamada de una función que no retorna nada .............................................................. 18
Creación de una función con salida anticipada (varios return) ............................................... 19
Uso o llamada de una función con salida anticipada ............................................................. 20
Cómo Nombrar Adecuadamente una Función en Python ....................................................... 20
Parámetros posicionales y parámetros con nombre en una función ........................................ 21
¿Cómo enfrentar un problema? ....................................................................................... 22
Estructura general de un programa en Python de archivo único ..................................... 23
Ejemplo de programa en Python con funciones en un archivo único ....................................... 23
Referencias ..................................................................................................................... 25
 SUBPROGRAMAS

Definiendo Subprogramas o Procedimientos

A
menudo en la programación es muy común que un conjunto de instrucciones deba repetirse
varias veces dentro del mismo código, esto ocurre cuando el mismo proceso tiene que
realizarse varias veces con diferentes variables, de manera que deben escribirse las mismas
instrucciones varias veces solo cambiando las variables. Un ejemplo de lo descrito
anteriormente ocurre cuando se desea determinar el número de combinaciones posibles, para lo que
debe utilizarse la siguiente fórmula:

𝑚!
𝑐=
𝑛! ∗ (𝑚 − 𝑛)!
Si se desea realizar un programa que permita determinar el número de combinaciones C, usando
dicha fórmula, el análisis implica:

¿Cómo lo hago? o ¿cuáles son

¿Qué tengo? o ¿cuáles son
¿Qué me piden? o ¿cuáles las fórmulas o expresiones,
los datos necesarios para
son las incógnitas? restricciones y otros para
obtener C?
obtener las incógnitas?
𝒎!
MyN C 𝒄=
𝒏! ∗ (𝒎 − 𝒏)!
ALGORITMO BASICO PARA RESOLVER EL PROBLEMA
1. Inicio
2. Leer m
3. Leer n
4. Calcular el Factorial de N en la variable fn
5. Calcular el Factorial de M en la variable fm
6. Calcular el Factorial de M-N en la variable fm_n
7. Calcular c cómo fn / (fm * fm_n)
8. Escribir c
9. Fin

DEFINICIÓN DE FACTORIAL IMPORTANTE

Para determinar el factorial, éste
deberá determinarse por
definición.
El factorial de n se define como el
producto de todos los números
enteros positivos desde 1 hasta n.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 1

 SUBPROGRAMAS

PROGRAMA EN PYTHON
# Lectura de los datos, NO SE VALIDAN DATOS
m = int(input("Valor de M="))
n = int(input(f"Valor de N (< {m})="))
# Calcular Factorial de M
fm = 1 # Acumulador Productoria
# Generación de los números naturales entre 1 y M
for i in range(1,m+1):
# Productoria de los números naturales entre 1 y M
fm = fm * i
# Calcular Factorial de N
fn = 1 # Acumulador para la Productoria
# Generación de los números naturales entre 1 y N Observe que el
for i in range(1,n+1): código de los tres
# Productoria de los números naturales entre 1 y N
fn = fn * i
recuadros es
# Calcular Factorial de M -N prácticamente el
fm_n = 1 # Acumulador para la Productoria mismo, sólo cambian
# Generación de los números naturales entre 1 y M-N las variables: La que
for i in range(1,(m-n)+1):
representa el fin del
# Productoria de los números naturales entre 1 y N
fm_n = fm_n * i ciclo for (la cantidad
# Calcular el número de Combinaciones posibles de números naturales
c = fm / (fm_n*fn) a generar) y el
# Imprimir combinaciones acumulador de los
print(f"Combinaciones de {m} en {n} es de {c:.0f}")
números generados
(productoria) que
Para disminuir la cantidad de código se puede generalizar la tarea de permite determinar
calcular el factorial escribiéndola como un subprograma, esto el factorial
permitiría reutilizar el código sin necesidad de escribirlo más de una vez
en el programa, de tal manera que al llamar o usar el subprograma se
suministraría el valor al cual se quiere determinar el factorial.

CÓDIGO PARA CALCULAR EL FACTORIAL DE X

f = 1 # Acumulador Productoria
# Generación de los números naturales entre 1 y X
for i in range(1,x+1)
f = f * i 'Productoria de los números naturales entre 1 y X

El código para calcular el factorial de X, se transformará en una función para luego ser utilizada
en el programa como las funciones predefinidas del lenguaje que ya se han utilizado

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 2

 SUBPROGRAMAS

PROGRAMA EN PYTHON USANDO SUBPROGRAMAS

# El código repetido se convierte en tarea

# una función que dado X determina el factorial de X
# Subprogramas que determina el factorial de x
def factorial (x):
f = 1 # Acumulador Productoria
Observe que el código para
# Generación de los números naturales entre 1 y x
determinar el factorial se
for i in range(1,x+1):
escribe de manera genérica
# Productoria de los números naturales entre 1 y x
f = f * i como procedimiento,
# devolver el valor calculado subprograma o función,
return f # lo que se desea calcule y devuelva la función una pieza del
# PROGRAMA PRINCIPAL rompecabezas,
# Lectura de los datos, NO SE VALIDAN DATOS
m = int(input("Valor de M="))
n = int(input(f"Valor de N (< {m})="))
un subproblema.
# Calcular Factorial de M
# Asignamos a fm el resultado de evaluar la función Factorial para m
En el programa principal
fm = factorial(m) ahora se emplea la función,
# Calcular Factorial de N
# Asignamos a fn el resultado de evaluar la función Factorial para n
fn = factorial(n)
al igual que las funciones
# Calcular Factorial de M -N
# Asignamos a fm_n el resultado de evaluar la función Factorial para m-n predefinidas, asignando a
fm_n = factorial(m-n) una variable el resultado,
# Calcular el número de Combinaciones posibles en este caso determinar el
c = fm / (fm_n*fn) factorial de la variable que
# Imprimir combinaciones representa lo requerido o a
print(f"Combinaciones de {m} en {n} es de {c:.0f}") quien se quiere determinar
el factorial

Divide el problema y lo resolverás

La idea de dividir un problema complejo en pequeños problemas o
subproblemas se conoce como “programación modular” y consiste en
resolver de forma independiente los subproblemas resultantes de la
descomposición del problema original, cada una de las soluciones a los
subproblemas constituye un subprograma o procedimiento. Trabajar de esta
forma implica que existe un proceso principal, denominado programa
principal, que transferirá el control y la información (datos necesarios) a los
distintos subprogramas o procedimientos para que efectúen la tarea solicitada
cuando sean invocados o llamados, los cuales una vez
que terminen de efectuar su tarea, instrucciones definidas para alcanzarla,
transferirán de nuevo el control a quien lo invocó o llamó; sea este el programa
principal u otro subprograma o procedimiento.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 3

 SUBPROGRAMAS

Los subprogramas o procedimientos deberían ser cortos y para desarrollarlos se seguirán todas las
reglas de programación, así mismo se podrán emplear todas las estructuras y herramientas de
programación habituales, centrándose en resolver únicamente la tarea que se desea.

Un subprograma es un bloque de
instrucciones o sentencias que llevan a cabo
una tarea bien específica o definida y que
puede utilizarse en un programa varias
veces sin necesidad de reescribir el código.
Como representa una sección de código que
se ejecutará y establecerá comunicación con
quien lo invoca o llama, esta comunicación
o intercambio de información se realizará a
través de variables, que se denominarán
parámetros.

Ventajas de desarrollar Subprogramas

✓ Permiten eliminar líneas repetidas en el código. Sólo se escribirán
una vez, aunque se requiera realizar varias veces la misma tarea
para la solución del problema completo, pero se ejecutarán en el
programa cada vez que se necesite.
✓ Permite que los programas sean más legibles o fácilmente
comprensibles. Un programa dividido en varias partes más
pequeñas es más fácil de entender.
✓ Simplifican el desarrollo del programa. Los programas separados en
unidades lógicas o subproblemas son más fáciles de diseñar, escribir
y depurar.
✓ Se pueden volver a utilizar en otros proyectos o soluciones,
permitiendo el ahorro de tiempo. Los procedimientos o
subprogramas desarrollados pueden incorporarse en un módulo
estándar en otros proyectos, permitiendo así poder usarlos como los
que están predefinidos en el lenguaje.
✓ Varios programadores pueden trabajar simultáneamente,
repartiéndose los distintos subproblemas, ya que son módulos
independientes, que luego se engranan.
✓ Se podrá modificar un módulo o subproblema, sin afectar a los demás.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 4

 SUBPROGRAMAS

Subprogramas,Procedimientos
Subprograma o procedimiento
o Funciones son un conjunto de instrucciones
Python posee un solo tipo de subprogramas o que permiten realizar una tarea de
procedimientos principales llamadas FUNCIONES. manera generalizada, que puede ser
Antes de adentrarnos en el lenguaje, veamos ciertas utilizada, sin reescribir el código,
definiciones generales, válidas independientemente del varias veces en el programa o
lenguaje. subprograma que lo requiera;
establecen comunicación con quien
lo llame o requiera a través de
variables especiales denominadas
Definiendo que son parámetros.
Parámetros o Argumentos
Una de las características importantes de los
subprogramas es la posibilidad de comunicarse con el
programa principal u otros subprogramas. Esta
comunicación se realiza a través de variables
denominadas parámetros, dicho de otra manera
cuando un programa llama o usa un subprograma, la
información se transmite entre ambos a través de 1.- Los datos necesarios se pasan al
variables que se denominan parámetros, subprograma (Cada dato una
constituyéndose en la manera de pasar información o variable o parámetro)
valores a variables, del programa principal al
subprograma y viceversa.

Un parámetro o argumento es una variable que

representa un dato que se pasa al subprograma y que
es necesario para ejecutar las instrucciones definidas en
la tarea, o que se devuelve del subprograma por ser lo
que se desea determinar.
Un parámetro entonces, puede ser una variable cuyo 2.- El subprograma efectúa la tarea,
valor debe ser proporcionado al subprograma una vez siguiendo las instrucciones definidas
invocado, o una variable cuyo valor debe ser devuelto
desde el subprograma porque se genera o calcula
mediante las instrucciones definidas para la tarea.

Los parámetros según su uso se clasifican en

parámetros formales o parámetros actuales.

3.- El subprograma una vez ejecutada

la tarea regresa el resultado generado
al programa o subprograma que lo
llamó o pidió su ejecución (Cada dato
una variable o parámetro)

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 5

 SUBPROGRAMAS

Parámetros Formales PROGRAMA EN PYTHON USANDO

Cuando se crea el procedimiento o subprograma en la SUBPROGRAMAS
definición o cabecera, se incluyen la lista de IDENTIFICANDO PARÁMETROS
parámetros o variables que permiten la comunicación,
#El código repetido se convierte en tarea, una
datos de entrada (necesarios para efectuar las #función que dado X determina el factorial de X
instrucciones) y datos de salida del subprograma
(resultantes de los cálculos o instrucciones que se Parámetro
Formal
requieren para procesos posteriores), estos se
denominan parámetros formales o ficticios. Ellos def factorial (x):
sirven para guardar la información de los valores de las f = 1 # Acumulador Productoria
variables que invocan o llaman al subprograma. Si lo # Generación de los números
vemos como una obra de teatro, cuando se escribe o naturales entre 1 y x
for i in range(1,x+1):
crea, los parámetros formales son los personajes de la
# Productoria de los números
obra. Para el subprograma definido para el cálculo del
naturales entre 1 y x
factorial de x, se tiene que x, es el dato necesario para
f = f * i
poder efectuar la tarea o cálculo, siendo x el parámetro
# devolver el valor calculado
formal, la cabecera del subprograma es la siguiente:
return f # lo que se desea
def factorial(x): calcule y devuelva la función
# PROGRAMA PRINCIPAL
# Lectura de los datos, NO SE VALIDAN
Parámetros Actuales/Argumentos DATOS
Los parámetros actuales, lo constituyen las variables m = int(input("Valor de M="))
que se utilizan cuando se emplea o llama al n = int(input(f"Valor de N (< {m})="))
subprograma o procedimiento, las variables que # Calcular Factorial de M
# Asignamos a fm el resultado de evaluar la
representan los datos en el momento; volviendo al
función Factorial para m
tema de la obra de teatro, cuando se interpreta o pone
Parámetro
en escena la obra, se ejecuta, cada personaje es
fm = factorial(m) Actual M
interpretado por un actor, el que toque en ese
# Calcular Factorial de N
momento. Los parámetros actuales deben coincidir en # Asignamos a fn el resultado de evaluar la
número, orden y tipo con los parámetros formales o función Factorial para n
ficticios definidos en la declaración o cabecera del Parámetro
subprograma. Para el ejemplo se usa o llama la función fn = factorial(n) Actual N
factorial en el programa principal tres veces: # Calcular Factorial de M -N
#Calcular Factorial de M # Asignamos a fm_n el resultado de evaluar la
fm = factorial(m) # para obtener el Factorial de M función Factorial para m-n
#Calcular Factorial de N Parámetro
fn = factorial(n) # para de obtener el factorial de N
Actual
#Calcular Factorial de M –N fm_n = factorial(m-n)
fm_n = factorial(m - n) #Calcular factorial de (M – N)

Observe que en cada llamada sólo se coloca el nombre # Calcular el número de

de la función y la variable a la que se desea calcular el # Combinaciones posibles
c = fm / (fm_n*fn)
factorial, esa variable es el parámetro actual, o valor
# Imprimir combinaciones
que se asignará a la variable x, parámetro formal del
print(f"Combinaciones de {m} en {n} es
subprograma para realizar las instrucciones del
de {c:.0f}")
subprograma.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 6

 SUBPROGRAMAS

Más acerca de los Parámetros Formales

Existen diferentes formas de transmisión o paso de parámetros a subprogramas, por lo que pueden
ser clasificados de acuerdo a ello, como:

Entradas: Permiten únicamente la transmisión o paso de datos desde el programa o

subprograma que llama o solicita la ejecución del subprograma.

Salidas: Sólo devuelven resultados desde el subprograma al programa o subprograma

que llama o solicita la ejecución del subprograma.

Entradas/Salidas: Actúan en los dos sentidos, tanto recibiendo datos del programa principal o
subprograma que llama o solicita la ejecución del subprograma; como
devolviendo resultados desde el subprograma al programa o subprograma que
llama o solicita la ejecución del subprograma

Esta definición puede ser útil, pero no es suficiente para definir los parámetros formales, que tendrá
un procedimiento o subprograma, por lo que debemos identificar los principales tipos de parámetros
formales.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 7

 SUBPROGRAMAS

Tipos de Parámetros Formales

En programación se manejan dos tipos de parámetros principales para la transmisión de datos
entre un subprograma y el programa o subprograma que lo utiliza o llama.

Parámetros por Valor

Para este tipo de parámetro, el parámetro formal
recibe como valor inicial una copia del parámetro
actual y con ellos se ejecutan las instrucciones
descritas en el subprograma, por lo tanto, los
cambios que se produzcan en ellos por las
instrucciones del subprograma no podrán afectar a
los parámetros actuales porque no se devolverá la
información al programa o subprograma llamador.
Estos se corresponden con los parámetros definidos
como entradas.

El parámetro actual, puede ser una variable,

constante o expresión, ya que sólo el valor resultante
es el que se asigna al parámetro formal.

Un parámetro por valor no puede modificar los valores del parámetro actual, por
lo que cualquier cambio del valor del parámetro formal durante la ejecución del
subprograma se destruye cuando termina de ejecutarse el subprograma,
permaneciendo el valor original.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 8

 SUBPROGRAMAS

Parámetros por Referencia

En muchas ocasiones se requiere que los parámetros sirvan como
salida, es decir que devuelvan los resultados al programa o
subprograma que lo llama. Para este tipo de parámetro, el parámetro
formal recibe la dirección de memoria del parámetro actual. De esta
forma una variable pasada como parámetro actual es compartida; es
decir, puede ser modificada directamente por el subprograma. Los
parámetros de este tipo corresponden con los de entrada/salida o con
los de salida si hablamos de un subprograma tipo Sub.

El parámetro actual, debe ser una variable, ya que recibirá el resultado

del cálculo o de lo que se genere en las instrucciones definidas en la tarea.

Un parámetro por referencia puede modificar los valores del parámetro actual, por
lo que cualquier cambio de los parámetros formales durante la ejecución del
subprograma se refleja en los parámetros actuales cuando termina de ejecutarse
el subprograma.

PARÁMETROS

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 9

 SUBPROGRAMAS

Parámetros por valor o por referencia en PYTHON

En Python se tiene que las variables o parámetros con tipo de dato inmutable se comportan como
parámetros por valor y las variables o parámetros con tipo de dato mutable se comportan como
parámetros por referencia. En relación a los tipos de datos que hemos manejado en la asignatura:

• Si la información que se pasa al subprograma es de tipo integer, float,

string o tuple, representa un parámetro por valor.
• Si la información que se pasa a un subprograma es de tipo lista,
parámetro por referencia.

Subprogramas en PYTHON
Los subprogramas son una parte fundamental de
cualquier lenguaje de programación, y Python no es una
excepción, en el caso de Python, se tienen las
funciones las cuales permiten organizar y reutilizar el
código de manera eficiente, proporcionando una forma
estructurada de dividir un programa en bloques lógicos
y autónomos. Una función es un bloque de código que
se ejecutará solo cuando ha sido llamada. Una función,
puede tener cualquier tipo de algoritmo y cualquier
cantidad de ellos y, utilizar cualquiera de las
características vistas hasta ahora. No obstante ello, una buena práctica, indica que la finalidad
de una función, debe ser realizar una única acción, reutilizable y por lo tanto, tan genérica
como sea posible.

El esquema básico de una función en Python es el siguiente:

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 10

 SUBPROGRAMAS

Cómo crear una función en PYTHON

A continuación, a través de un ejemplo sencillo se presenta la anatomía o partes de una función

CUERPO DE LA FUNCIÓN

VALOR A DEVOLVER

Sintaxis

La sintaxis básica de una función es la siguiente:

SINTAXIS

def FunctionName( Parámetros o argumentos): # Cabecera o encabezado

Instrucciones a ejecutar, cuerpo de la función

return Valor a devolver # si son varios valores a devolver se colocan separados por coma

IMPORTANTE
✓ FunctionName es el nombre de la función que está creando.
✓ Parámetros o argumentos, lista de parámetros o datos que se pasarán a la función para
que efectúe los cálculos o instrucciones.
✓ Instrucciones a ejecutar, cuerpo de la función, conjunto de instrucciones que
permiten ejecutar la acción o tarea para la cual fue definida, el cual debe ir indentado.
✓ Return Valor a devolver, con esto se indica que devuelva Valor(es) a devolver al
subprograma o programa que llama y cuáles son esos valores, sin embargo, debe cuidarse
al utilizarla ya que cuando se ejecuta la instrucción return, la función termina su ejecución,
así que si hay instrucciones después de ella no se ejecutarán, es por ello que generalmente
se coloca al final cuando se ha calculado todo, pero no es una obligatoriedad, si tiene claro
que una vez que se ejecuta el return, toda instrucción posterior no se ejecutará. Recuerde
que la instrucción return de existir, debe ir indentado.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 11

 SUBPROGRAMAS

La instrucción return
Entender cómo usar la instrucción return en Python es esencial para escribir código eficiente y
modular; la misma se utiliza para devolver un valor o resultado desde una función, al punto desde
donde se llamó a la función, la función procesa los datos y luego devuelve un valor o resultado para
que puede ser utilizado por otras partes del programa.

Cuando se encuentra la instrucción return, la ejecución de la función se detiene y el valor

especificado en el return se devuelve como resultado de la función, las instrucciones posteriores al
return se obvian o no se ejecutan, por lo que dependiendo de su utilización en una función pueden
encontrarse que un return devuelve un valor, devuelve varios valores, no devuelve nada o no
existe dentro del código.

Considerando entonces que encontrar un return en una función, indica que la misma ha
terminado de realizar las acciones para la que fue creada y lo expresado anteriormente se tiene
que una función puede tener un return, varios return o ninguno y que un return puede
devolver un valor, varios valores o ninguno.

Devolver un valor simple (un único return)

En su forma más simple, return se utiliza para devolver un valor específico desde una función,
generalmente una vez realizado todo el proceso, como última línea de la función.

Devolver múltiples valores

Python únicamente permite devolver un único valor en un return. Pero, el tipo devuelto puede ser
de cualquier tipo, lo que incluye agrupaciones de variables, si se tiene una lista de variables o valores
separados por coma, estos se devuelven como una tupla.

Adicionalmente se puede desde una función utilizando return, devolver tipos de datos complejos:
tupla, lista o cualquier otro tipo de estructura de datos que contenga los valores a devolver, todos
estos datos compuestos serán tratados en computación II.

Devolver None
Si una función no tiene una instrucción return o si se encuentra return sin ningún valor o variable
a retornar, la función devuelve None de forma implícita.

Salida anticipada de una función

return se puede utilizar para salir anticipadamente de una función en cualquier punto. A esto se le
denomina early return, puede ser útil cuando el valor a retornar dependa de la evaluación de
condiciones mutuamente excluyentes, esto significa que una vez encontrado el valor a devolver no
hace falta ejecutar el resto del código de la función. Bien usado, puede mejorar la legibilidad del
código.

A continuación, algunos ejemplos de funciones, creación y llamado.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 12

 SUBPROGRAMAS

Creación de una función que retorne un único valor

A continuación, algunos ejemplos:

EJEMPLO FUNCIÓN EN PYTHON Las funciones pueden o no devolver valores

al programa, subprograma o procedimiento
Cálculo del Factorial de X que lo llama o solicita su ejecución.
def factorial (x): En el caso de devolver valores, debe
f = 1 # Acumulador Productoria contener la instrucción return con los
# Generación de los números naturales de 1 a x
valores a devolver, generalmente como la
for i in range(1,x+1):
última instrucción en la función. Recuerde
# Productoria de los números de 1 a x
se coloca return y la lista de los valores que
f = f * i
se desean devolver separados por coma.
# devolver el valor calculado
return f # el factorial de x El nombre de la función debe aparecer del
lado derecho de una instrucción de
EJEMPLO DE FUNCION EN PYTHON asignación en las instrucciones a ejecutar
dentro del subprograma o procedimiento.
Cálculo de la distancia entre dos puntos
En el caso de que la función no retorne
# Dadas las coordenadas de dos puntos determine valores, debe aparecer como una
# la distancia entre ellos
instrucción del programa, con sus
def distancia(x1, y1, x2, y2):
correspondientes parámetros si los requiere
# Valor que debe devolver la función
d = ((x2-x1)**2 - (y2-y1)**2)** (1/2)
return d

Uso o llamada de una función que

retorne un único valor Revise en la página 6
PROGRAMA EN PYTHON USANDO
SUBPROGRAMAS
Para ejecutar, invocar, llamar o solicitar la ejecución
IDENTIFICANDO PARÁMETROS
de una función se coloca el nombre de la función
seguido de los parámetros actuales o argumentos del
'Calcular Factorial de M
lado derecho de una asignación o como parte de fm = factorial(M)
una expresión o formula, sólo si devuelve un 'Calcular Factorial de N
único valor. fn = factorial(N)
'Calcular Factorial de M –N
Los parámetros actuales o argumentos deben estar fm_n = factorial(M - N)

entre paréntesis y si son varios, separados por comas.

Por defecto, al llamar a una función los valores de los argumentos se asignan en el mismo orden en
el que se pasan al invocar a dicha función.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 13

 SUBPROGRAMAS

Ejemplo de llamado para la Función que Si observamos el problema de la página 6,

determina la Distancia entre dos puntos vemos el llamado del subprograma factorial,
donde los parámetros actuales son para
Determinar la distancia entre punto p2 de cada llamada respectivamente M, N y el
coordenadas x2 y y2 y el punto p3 de resultado de evaluar la expresión M-N.
coordenadas x3,y3, usando la función distancia

d23=distancia(x2,y2,x3,y3)

Cuando se ejecute la función distancia los Las funciones que devuelven un único valor
parámetros actuales pasarán a los formales el pueden llamarse dentro de una expresión o
valor de x2 o parámetro actual, lo tomará el incluso en una impresión, por ejemplo para
parámetro formal X1, el valor de y2 o parámetro el ejercicio del número de combinaciones,
actual, lo tomará el parámetro formal y1, el pudo colocarse c sin hacer uso de las
valor de x3 o parámetro actual, lo tomará el
variables fm, fn, fm_n, asignando
parámetro formal X2 y el valor de y3 o
parámetro actual, lo tomará el parámetro formal directamente a c el calculo. De igual forma
y2. Por defecto, al llamar a una función los pudo imprimirse directamente el valor de
valores de los argumentos se asignan en el las combinaciones sin hacer uso de c, a
mismo orden en el que se pasan al invocar a continuación, se presentan ambos códigos.
dicha función.

PROGRAMA EN PYTHON QUE DETERMINA EL

NUMERO DE COMBINACIONES SIN CALCULAR
CADA FACTORIAL EN UNA VARIABLE

# una función que dado X determina el factorial de X Observe que el código para
# Subprogramas que determina el factorial de x determinar el factorial se
escribe de manera genérica
def factorial (x): como procedimiento,
f = 1 # Acumulador Productoria subprograma o función,
# Generación de los números naturales entre 1 y x una pieza del
for i in range(1,x+1): rompecabezas,
f = f * i
return f # devolver el valor calculado

# PROGRAMA PRINCIPAL un subproblema.

# Lectura de los datos, NO SE VALIDAN DATOS En el programa principal
m = int(input("Valor de M=")) ahora se emplea la función,
n = int(input(f"Valor de N (< {m})="))
# Calcular el número de Combinaciones posibles

c = factorial(m)/(factorial(m-n)* factorial(n)) al igual que las funciones

# Imprimir combinaciones predefinidas, asignando a c
print(f"Combinaciones de {m} en {n} es de {c:.0f}") el resultado de la expresión

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 14

 SUBPROGRAMAS

PROGRAMA EN PYTHON QUE IMPRIME EL NUMERO DE COMBINACIONES SIN

CALCULAR ANTES EN UNA VARIABLE

# Subprogramas que determina el factorial de x

def factorial (x):
f = 1 # Acumulador Productoria
# Generación de los números naturales entre 1 y x
for i in range(1,x+1):
f = f * i
return f # devolver el valor calculado
# PROGRAMA PRINCIPAL
# Lectura de los datos, NO SE VALIDAN DATOS
m = int(input("Valor de M="))
n = int(input(f"Valor de N (< {m})="))

# Imprimir combinaciones
print(f"Combinaciones de {m} en {n} es de {factorial(m) / (factorial(m-n)* factorial(n)):.0f}")

Creación de una función que retorne múltiples valores

En Python, una función solo puede devolver directamente un único valor. Sin embargo, puedes
devolver múltiples empleando en una estructura de datos compuesta como una tupla, lista o
diccionario, pero ese tratamiento se empleará en computación II, en nuestro caso para devolver
múltiples valores se realizará colocando en la instrucción return la lista de variables o valores a
devolver separados por coma. Python crea automáticamente una tupla que contiene estos valores.
Luego, podemos desempaquetar la tupla en variables separadas durante la llamada a la función, esto
es colocando tantas variables a la izquierda como valores retorne la función; sí lo asigna a una única
variable, debe tratarla como a una tupla, esto significa que debe colocar el nombre de la variable e
indicar a cuál elemento o posición desea acceder.

Enunciado de ejercicio de función que retorne múltiples valores

Desarrolle un subprograma que determine dadas las coordenadas de tres puntos p1(x1, y1), p2(x2, y2)
y p3(x3, y3) que corresponden a los vértices de un triángulo, usando la función distancia de la página
12 y sólo las fórmulas que se indican a continuación, determine el semiperímetro y el área del triángulo
según la fórmula del semiperímetro
𝑑12+𝑑13+𝑑23
𝑎𝑟𝑒𝑎 = √𝑠 ∗ (𝑠 − 𝑑12) ∗ (𝑠 − 𝑑13) ∗ (𝑠 − 𝑑23) Donde 𝑠=
2

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 15

 SUBPROGRAMAS

Creación de la función para dar solución al enunciado anterior

# dadas las coordenadas de tres puntos p1(x1, y1), p2(x2, y2) y p3(x3, y3) que corresponden a los
# vértices de un triángulo, usando la función distancia de la página 12 y sólo las fórmulas que se
# indican a continuación, determine el semiperímetro y el área del triángulo según la fórmula del
# semiperímetro
def area_semiperimetro(x1, y1, x2, y2, x3, y3):
# se determinan las distancias
d12=distancia(x1,y1,x2,y2)
d13=distancia(x1,y1,x3,y3)
d23=distancia(x2,y2,x3,y3)
# se determina el semiperímetro
s=(d12+d13+d23)/2
# se determina el área
area=(s*(s-d12)*(s-d13)*(s-d23))**(1/2)
# se indican los valores a devolver
return s,area

Uso o llamada de una función que retorna múltiples valores

Para ejecutar, invocar, llamar o solicitar la ejecución de una función se coloca el nombre de la
función seguido de los parámetros actuales o argumentos del lado derecho de una asignación,
deben existir del lado izquierdo tantas variables como valores retorne y deben corresponderse en
orden y cantidad.

Los parámetros actuales o argumentos deben estar entre paréntesis y si son varios, separados por
comas.

Llamado a la función area_semiperimetro

Supongamos que en el programa principal se tienen las coordenadas de los tres puntos como
px1,py1,px2,py2,px3,py3, el llamado sería:

semiperimetro , area_triangulo = area _ semiperimetro(px1,py1,px2,py2,px3,py3)

Observe que en el lado derecho aparecen dos variables, ya que cuando se creó la función
area_semiperimetro se colocó en el return que devuelve dos valores en el siguiente orden
primero devuelve s, que corresponde al semiperímetro y después devuelve area, que corresponde
al área del triangulo, de acuerdo a ese llamado s se asignará a semiperímetro y area a
area_triangulo

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 16

 SUBPROGRAMAS

Llamado a la función area_semiperimetro asignándola a una única variable

Supongamos que en el programa principal se tienen las coordenadas de los tres puntos como
px1,py1,px2,py2,px3,py3, el llamado sería:

resultados= area _ semiperimetro(px1,py1,px2,py2,px3,py3)

semiperímetro=resultados[0]
area_triangulo=resultados[1]

Observe que en el lado derecho aparecen una única variables, la misma es una tupla
que contiene dos elementos, en la posición 0 estará el valor del semiperímetro y en la posición 1
estará el valor del área; se pueden usar directamente colocando la posición o guardarlas
posteriormente en las variables semiperímetro y area_triangulo

Llamados incorrectos de la función area_semiperimetro

Supongamos que en el programa principal se tienen las coordenadas de los tres puntos como
px1,py1,px2,py2,px3,py3, el llamado sería:

area_triangulo , semiperimetro = area _ semiperimetro(px1,py1,px2,py2,px3,py3)

Si bien no reportará un error de sintaxis, de acuerdo a ese llamado s se asignará a la

variable area_triangulo el valor de s, y a semiperímetro el valor de area, siendo un error de lógica,
ya que se trabajaría con los valores incorrectos.

area_triangulo = area _ semiperimetro(px1,py1,px2,py2,px3,py3)

semiperimetro = area _ semiperimetro(px1,py1,px2,py2,px3,py3)

Si bien no reportará un error de sintaxis, de acuerdo a ese llamado a la variable

area_triangulo se le asignará una tupla, que estaría compuesta de los dos valores que devuelve la
función, por lo que area_triangulo contendría (s,area_triangulo), dos valores y no podría trabajarse
como una variable simple. Las variables area_triangulo y semiperímetro serían dos tuplas iguales.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 17

 SUBPROGRAMAS

Creación de una función no retorna nada

En Python, un función puede no devolver ningún valor, en cuyo caso no tiene o se omite la
instrucción return, en general estos subprogramas para el caso de la asignatura, serán aquellos que
no realicen cálculos y su tarea sea imprimir.

Enunciado de ejercicio de función que no retorna nada

Desarrolle un subprograma en el que dadas las coordenadas (x,y) de un punto las escriba en un archivo sin
bajar de línea de modo que aparezcan ambas coordenadas entre paréntesis y separadas por una coma. El archivo
pasa como parámetro

Solución al enunciado anterior

def imprimir_archivo(archivo,x,y):
[Link](f" ( {x:.2f} , {y:.2f} ) ")

Uso o llamada de una función que no retorna nada

Para ejecutar, invocar, llamar o solicitar la ejecución de una función se coloca el nombre de la
función seguido de los parámetros actuales o argumentos como una instrucción del código, NO
PUEDE APARECER DEL LADO DERECHO DE UNA INSTRUCCIÓN DE ASIGNACIÓN.

Llamado a la función imprimir archivo

Supongamos que en el programa principal se tiene una variable de nombre archivo_salida en

donde se hace la asignación y apertura del archivo que usará el programa para imprimir los
resultados, en el programa principal si se desea imprimir a ese archivo las coordenadas del
los puntos px1,py1,px2,py2,px3,py3 y el área todos en la misma línea de la forma:

(px1,py1) (px2,py2) (px3,py3) area

Cada línea del archivo debe contener la

forma indicada anteriormente, en el
programa principal se colocaría, donde Observe, cada llamada a
corresponda realizar la impresión
imprimir_archivo imprimirá un punto con las
indicada:
coordenadas entre paréntesis, con formato y sin
imprimir_archivo(archivo_salida,px1,py1) bajar de línea, hay tres llamados implica tres
imprimir_archivo(archivo_salida,px2,py2) impresiones, luego se imprime al archivo de
imprimir_archivo(archivo_salida,px3,py3) forma convencional el area con formato y se
archivo_salida.write(f" {area:.2f} \n ") coloca el carácter de salto de línea a fin de que
cualquier otra cosa a imprimir quede en la línea
a continuación.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 18

 SUBPROGRAMAS

Llamados incorrectos de la función imprimir_archivo

area_triangulo = imprimir_archivo(archivo_salida,px1,py1)
imprimir_archivo(px2,py2,archivo)

En el primer llamado, aunque no reportará error a la variable area_triangulo se le asignara

none dado que esa función no tiene return por lo que no retorna nada. En el segundo llamado
reportará un error indicando que el tipo de la variable px2 no tiene el atributo write, esto significa
que no es un archivo y por tanto no puede intentar usar write.

Creación de una función con salida anticipada (varios return)

En Python, una función puede requerir de decisiones para determinar el valor o valores a devolver,
en cuyo caso una vez determinado el valor o valores a devolver no hace falta ejecutar el resto del
código.

Enunciado de ejercicio de función que no retorna nada

Desarrolle un subprograma en el que dadas las coordenadas (x,y) de un punto las escriba en un archivo sin
bajar de línea de modo que aparezcan ambas coordenadas entre paréntesis y separadas por una coma. El archivo
pasa como parámetro

Solución al enunciado anterior

Observe que por cada

def verificar_numero_negativo(numero):
if numero < 0: rama de la decisión existe un
return "El número es negativo" return, si hay varias decisiones
else: anidadas debe aparecer un return
return "El número es positivo o cero" en cada rama o al menos una
asignación como valor
predeterminado antes de el inicio
de las mismas, para garantizar que
siempre devuelve algo la función

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 19

 SUBPROGRAMAS

Uso o llamada de una función con salida anticipada

Para ejecutar, invocar, llamar o solicitar la ejecución de este tipo de función se realizará
dependiendo de la cantidad de valores que retorne.

Llamado a la función verificar_numero_negativo

# Llamada a la función dentro de una impresión

print(verificar_numero_negativo(-5)) # Salida: El número es negativo
print(verificar_numero_negativo(10)) # Salida: El número es positivo o cero

# Llamada a la función del lado derecho de una asignación

Resultado= verificar_numero_negativo(-5))
print(Resultado) # Salida: El número es negativo
Resultado= verificar_numero_negativo(10))
print(Resultado) # Salida: El número es positivo o cero

Observe que en este caso la función devuelve un único valor por lo que puede llamarse
directamente en una impresión o guardar su resultado en una única variable y luego imprimir

Cómo Nombrar Adecuadamente una Función en Python

En programación es importante tener en cuenta ciertas reglas para permitir un mejor orden y hacer
más fácil el trabajo colaborativo para la solución de problemas, por esto es bueno considerar estas
normas a la hora de crear funciones.

1. Los nombres de las funciones deben empezar con una letra o un guión bajo _, seguido
por cualquier combinación de letras, números o guiones bajos. Ejemplo: def
calcular_area_triangulo ():

2. Los nombres de las funciones deben ser descriptivos y transmitir el propósito de la función.
Ejemplo: def calcular_area_triangulo():

3. Los nombres de las funciones son sensibles a mayúsculas y minúsculas, lo que significa
que mi_funcion y Mi_Funcion son nombres diferentes. Ejemplo: def mi_funcion(): y def
Mi_Funcion(): son dos funciones diferentes.

4. Los nombres de las funciones no deben ser iguales a una palabra clave de Python, como
print o if.

5. Los nombres de las funciones deben seguir la convención de nomenclatura de "snake_case",

donde las palabras están separadas por guiones bajos. Esta convención hace que los nombres
de las funciones sean más legibles y fáciles de entender. Ejemplo: def calcular_area():

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 20

 SUBPROGRAMAS

En general, se recomienda elegir un nombre de función que sea descriptivo, fácil de entender,
y siga las convenciones de nomenclatura para funciones en Python.

Parámetros posicionales y parámetros con nombre en una

función
Cuando se realiza el llamado a una función en Python con diferentes argumentos, los valores se
asignan a los parámetros en el mismo orden en que se indican en la cabecera cuando se crea o define
la función. Siguiendo con el ejemplo anterior para la función imprimir_archivo, el llamado de la
siguiente manera:

imprimir_archivo(archivo_salida,px1,py1)

De este modo, al parámetro archivo se le asignará archivo_salida, al parámetro x el valor px1 y al

parámetro y el valor px2. Esto es así porque el valor en el que se asignan los argumentos
depende del orden con el que se llaman. Sin embargo, el orden se puede cambiar si llamamos
a la función indicando el nombre de los parámetros. Para que lo veas más claro, los siguientes
ejemplos son todos válidos:

imprimir_archivo(archivo=archivo_salida,x=px1,y=py1)
imprimir_archivo(x=px1,y=py1, archivo=archivo_salida)
imprimir_archivo(y=py1, x=px1, archivo=archivo_salida)
imprimir_archivo(y=py1, archivo=archivo_salida, x=px1)

Se puede observar que se pueden mezclar el orden de los parámetros si se indica su

nombre. No obstante todavía se debe especificar el número correcto de argumentos.

En conclusión, al llamar a una función por defecto los valores de los argumentos se asignan en el
mismo orden en el que se pasan al invocar a dicha función, pero esto se puede este orden sí
cuando se invoca la función se indica el nombre de los parámetros. HAY OTROS TIPOS DE
PARÁMETROS Y FORMAS QUE POR AHORA NO SE TRATARÁN.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 21

 SUBPROGRAMAS

¿Cómo enfrentar un problema?

✓ Analice el problema e identifique los datos necesarios, las
incognitas o salida deseada y
los procesos que permitan
efectuar dicha tarea.
✓ Establezca los procesos,
tareas o subproblemas
que se aplicarían en el
problema a resolver,
separe cada subproblema y
resuélvalo por separado.
✓ Diseñe la solución a cada
subproblema considerando exclusivamente la tarea solicitada, los
datos que se necesitan, si no pueden generarse, deben entrar al
subprograma y serán por tanto parámetros. Lo que necesita
calcular, determinar o devolver será colocado en la instrucción
return.
✓ Cuando diseñe un subprograma, sí alguna tarea a realizar en el mismo se encuentra
previamente creada en un subprograma, use el subprograma de acuerdo al tipo,
especificando los parámetros o variables que representan los datos o información que
se suministrará al subprograma y las variables o parámetros donde devolverá los
resultados en caso de ser un procedimiento Sub.
✓ Diseñados los subprogramas solicitados, desarrolle el
programa principal, leyendo el problema a resolver,
identifique las entradas o datos y las salidas o resultados,
cada uno representará una variable, seleccione el nombre
apropiado.
✓ Establezca la estructura que le permitirá leer la
información y de manera general los pasos para resolver el problema, para cada paso
revise si tiene un subprograma que haga el cálculo o tarea,
de ser así use el subprograma apropiadamente,
especificando los parámetros o variables que representan
los datos o información que se suministrará al
subprograma y las variables o parámetros donde
devolverá los resultados, al unir todas las partes del
rompecabezas tendrá la solución a su problema.

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 22

 SUBPROGRAMAS

Recuerde el Programa principal es el que

indicará que tarea o subprograma se debe
ejecutar y con qué valores. Ud. es el que dirige
las acciones así que el éxito de la tarea es suya

Estructura general de un programa en Python de

archivo único
Un programa en python de archivo único, deberá contener las siguientes secciones:

#Importación de librerías o funciones externas, librerías del lenguaje o propias

#Subprogramas o funciones propias
#Programa principal
A continuación, se ejemplifica con un problema.

Ejemplo de programa en Python con funciones en un archivo

único

DESARROLLE LOS SIGUIENTES SUBPROGRAMAS O FUNCIONES EN PYTHON

1. Desarrolle un subprograma que dadas las coordenadas de dos puntos p1(x1, y1) y
p2(x2, y2), determine la distancia entre los dos puntos. 𝑑 = √(𝑥2 − 𝑥1)2 + (𝑦2 − 𝑦1)2

2. Desarrolle un subprograma en el que dadas las coordenadas (x,y) de un punto las escriba
en un archivo sin bajar de línea de modo que aparezcan ambas coordenadas entre
paréntesis y separadas por una coma. El archivo pasa como parámetro
PROGRAMA A DESARROLLAR

En un archivo de datos de nombre “[Link]” que contiene la información de un conjunto

de pares de puntos en el plano, desarrolle un programa en Python que usando
exclusivamente los subprogramas solicitados, procese la información del archivo
“[Link]” y genere un archivo de nombre “[Link]” el cual debe contener en
cada línea por cada par de puntos: las coordenadas de los puntos y la distancia entre los
mismos, como se indica a continuación:
(x1,y1) (x2,y2) distancia
Los números deben aparecer según lo especificado y mostrando sólo dos decimales

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 23

 SUBPROGRAMAS

# ***** IMPORTACIÓN DE LIBRERIAS, DE SER NECESARIAS *****

#importación de la librería de funciones matemáticas
import math
# ***** CREACIÓN DE SUBPROGRAMAS *****
#Creacion de la función distancia
#Dadas las coordenadas de dos puntos determine la distancia entre ellos
def distancia(x1,y1,x2,y2):
return [Link]((x2-x1)**2+(y2-y1)**2)

#Creacion de la función imprimir_archivo

#Subprograma en el que dadas las coordenadas (x,y) de un punto las escriba en un archivo sin bajar de
#línea de modo que aparezcan ambas coordenadas entre paréntesis y separadas por una coma.
#El archivo pasa como parámetro
def imprimir_archivo(archivo,x,y):
[Link](f"( {x:.2f} , {y:.2f} )")
# ***** PROGRAMA PRINCIPAL *****
#programa principal que lee un archivo de datos de nombre [Link], que contiene en cada
#linea las coordenadas de dos puntos y genere un archivo [Link] que contenga en cada
#línea las coordenadas de los dos puntos y la distancia de la siguiente
manera:
#(x1,y1) (x2,y2) distancia

#ABRIR ARCHIVOS
archivo_entrada=open("[Link]","r")
archivo_salida=open("[Link]","w")

#CICLO PARA PROCESAR EL ARCHIVO

for linea in archivo_entrada:
puntos=[Link]().split(",")
#aprovechandonos de la lista en lugar de asignar cada elemento por posición, para repasar listas
#recorremos la lista y convertimos cada elemento en un dato real, sobre la misma lista
for i in range(len(puntos)):
puntos[i]=float(puntos[i])
#ASIGNA cada elemento de la lista a las variables a la izq. deben corresponderse una a una
x1,y1,x2,y2=puntos
#llamada por parámetros posicionales, de acuerdo a lo definido en la cabecera
imprimir_archivo(archivo_salida,x1,y1)
#llamado usando los nombres de los parámetros a los que se le asigna que valor usará
imprimir_archivo(y=y2,x=x2, archivo=archivo_salida)
archivo_salida.write(f"{distancia(x1,y1,x1,y2):.2f} \n")

#UNA VEZ PROCESADO TODA LA INFORMACIÓN CERRAR LOS ARCHIVOS

archivo_entrada.close()
archivo_salida.close()
print("SE HA EJECUTADO SU PROGRAMA CON EXITO, ABRA EL ARCHIVO [Link]")

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 24

 SUBPROGRAMAS

Algunas referencias y recursos de utilidad

Enlaces a páginas empleadas para desarrollar este material:

[Link]

[Link]

[Link]

[Link]

[Link]

[Link]

Paginas interesantes:

[Link]

Aquí les suministro una selección de videos que les serán de utilidad para comprender la teoría.
DEFINICIÓN DE SUBPROGRAMAS/FUNCIONES
FUNCIONES en PROGRAMACIÓN Concepto FUNDAMENTAL (12:47 min)
FUNCIONES EN PYTHON
A partir de un conjunto de videos continuaremos desarrollando ciertos Conceptos básicos de programación modular
FUNCIONES en Python PRIMEROS PASOS (12:25 min)
COMPOSICIÓN de FUNCIONES en Python (6:31 min)
FUNCIONES con VARIOS PARÁMETROS y REUTILIZACIÓN en Python (15:54 min)
FUNCIÓN sin RETORNO en Python (12:08 min)
ARGUMENTOS con PALABRAS CLAVE en Python (6:46 min)
MÓDULOS en Python Reutilizar FUNCIONES como un PRO (10:09 min)
DOCUMENTAR FUNCIONES en Python con DOCSTRING(10:09 min)
No funciona como se indica en Thonny pero la idea general es apropiada
Algunos ejercicios de desarrollo, dado un enunciado plantear los módulos y subprogramas y desarrollarlos, interesantes de
revisar incluye validación de datos.
EJERCICIO de FUNCIONES en Python 15: RESUELTO Paso a Paso (30:06 min)
EJERCICIO de FUNCIONES en Python 16: RESUELTO Paso a Paso (13:05 min)

En el siguiente enlace tendrá un conjunto de videos que tienen una posible solución a los ejercicios propuestos de
exámenes de la cátedra, a fin de que le puedan servir de apoyo:
CANAL YOUTUBE: Computación I y II. Ingeniería. UC. Venezuela. EJERCICIOS RESUELTOS DE SUBPROGRAMAS
Cómo son videos desarrollados de prueba y para tratar de repasar lo visto hace unos meses, accederán por el vínculo
suministrado ya que no están públicos.
[Link]

MATERIAL DE COMPUTACIÓN I – PROF. LISBETH PACHECO 25