Fundamentos de Programación en Python: Módulo 4

En este módulo, aprenderás:

 Cómo definir y utilizar funciones.

 Cómo pasar argumentos y las distintas formas de hacerlo.
 El alcance de los nombres.
 Tuplas y diccionarios.
 Procesamiento de datos.
¿Por qué necesitamos funciones?
Hasta ahorita has implementado varias veces el uso de funciones, pero solo se han visto algunas de sus
ventajas. Solo se han invocado funciones para utilizarlas como herramientas, con el fin de hacer la vida
mas fácil, y para simplificar tareas tediosas y repetitivas.

Cuando se desea mostrar o imprimir algo en consola se utiliza  print() . Cuando se desea leer el valor
de una variable se emplea  input() , combinados posiblemente con  int()  o  float() .

También se ha hecho uso de algunos métodos, las cuales también son funciones, pero declarados de una
manera muy especifica.

Ahora aprenderás a escribir tus propias funciones, y como utilizarlas. Escribiremos varias de ellas juntos,
desde muy sencillas hasta algo complejas. Se requerirá de tu concentración y atención.

Muy a menudo ocurre que un cierto fragmento de código se repite muchas veces en un programa. Se
repite de manera literal o, con algunas modificaciones menores, empleando algunas otras variables
dentro del programa. También ocurre que un programador ha comenzado a copiar y pegar ciertas partes
del código en más de una ocasión en el mismo programa.

Puede ser muy frustrante percatarse de repente que existe un error en el código copiado. El programador
tendrá que escarbar bastante para encontrar todos los lugares en el código donde hay que corregir el
error. Además, existe un gran riesgo de que las correcciones produzcan errores adicionales.
Definamos la primer condición por la cual es una buena idea comenzar a escribir funciones propias: si
un fragmento de código comienza a aparecer en más de una ocasión, considera la posibilidad de
aislarlo en la forma de una función invocando la función desde el lugar en el que originalmente se
encontraba.

Puede suceder que el algoritmo que se desea implementar sea tan complejo que el código comience a
crecer de manera incontrolada y, de repente, ya no se puede navegar por él tan fácilmente.

Se puede intentar solucionar este problema comentando el código, pero pronto te darás cuenta que esto
empeorará la situación - demasiados comentarios hacen que el código sea más difícil de leer y
entender. Algunos dicen que una función bien escrita debe ser comprensible con tan solo una
mirada.

Un buen desarrollador divide el código (o mejor dicho: el problema) en piezas aisladas, y codifica cada
una de ellas en la forma de una función.

Esto simplifica considerablemente el trabajo del programa, debido a que cada pieza se codifica por
separado y consecuentemente se prueba por separado. A este proceso se le llama
comúnmente descomposición.
Existe una segunda condición: si un fragmento de código se hace tan extenso que leerlo o entenderlo
se hace complicado, considera dividirlo pequeños problemas por separado e implementa cada uno
de ellos como una función independiente.

Esta descomposición continua hasta que se obtiene un conjunto de funciones cortas, fáciles de
comprender y probar.

Descomposición
Es muy común que un programa sea tan largo y complejo que no puede ser asignado a un solo
desarrollador, y en su lugar un equipo de desarrolladores trabajarán en el. El problema, debe ser
dividido entre varios desarrolladores de una manera en que se pueda asegurar su eficiencia y
cooperación.

Es inconcebible que más de un programador deba escribir el mismo código al mismo tiempo, por lo
tanto, el trabajo debe de ser dividido entre todos los miembros del equipo.

Este tipo de descomposición tiene diferentes propósitos, no solo se trata de compartir el trabajo, sino
también de compartir la responsabilidad entre varios desarrolladores.

Cada uno debe escribir un conjunto bien definido y claro de funciones, las cuales al ser combinadas
dentro de un módulo (esto se clarificara un poco mas adelante) nos dará como resultado el producto
final.
Esto nos lleva directamente a la tercera condición: si se va a dividir el trabajo entre varios
programadores, se debe descomponer el problema para permitir que el producto sea implementado
como un conjunto de funciones escritas por separado empacadas juntas en diferentes módulos.

¿De dónde provienen las funciones?

En general, las funciones provienen de al menos tres lugares:

 De Python mismo: varias funciones (como  print() ) son una parte integral de Python, y
siempre están disponibles sin algún esfuerzo adicional del programador; se les llama a estas
funciones funciones integradas.
 De los módulos preinstalados de Python: muchas de las funciones, las cuales comúnmente son
menos utilizadas que las integradas, están disponibles en módulos instalados juntamente con
Python; para poder utilizar estas funciones el programador debe realizar algunos pasos
adicionales (se explicará acerca de esto en un momento).
 Directamente del código: tu puedes escribir tus propias funciones, colocarlas dentro del
código, y usarlas libremente.
 Existe una posibilidad más, pero se relaciona con clases, se omitirá por ahora.
Tu primer función
Observa el fragmento de código en el editor.

Es bastante sencillo, es un ejemplo de como transformar una parte de código que se

esta repitiendo en una función.

El mensaje enviado a la consola por la función  print()  es siempre el mismo. El código es
funcional y no contiene errores, sin embargo imagina tendrías que hacer si tu jefe pidiera
cambiar el mensaje para que fuese mas cortés, por ejemplo, que comience con la
frase  "Por favor," .

Tendrías que tomar algo de tiempo para cambiar el mensaje en todos los lugares donde
aparece (podrías hacer uso de copiar y pegar, pero eso no lo haría mas sencillo). Es muy
probable que cometas errores durante el proceso de corrección, eso traería frustración a
ti y a tu jefe.

¿Es posible separar ese código repetido, darle un nombre y hacerlo reutilizable?

Significaría que el cambio hecho en un solo lugar será propagado a todos los lugares
donde se utilice.

Para que esto funcione, dicho código debe ser invocado cada vez que se requiera.

Es posible, esto es exactamente para lo que existen las funciones.

print("Ingresa un valor: ")

a = int(input())

print("Ingresa un valor: ")

b = int(input())

print("Ingresa un valor: ")

c = int(input())
Tu primer función
¿Cómo es que se crea dicha función?

Se necesita definirla. Aquí, la palabra define es significativa.

Así es como se ve la definición más simple de una función:

def nombreFuncion():
cuerpoFuncion

 Siempre comienza con la palabra reservada  def  (que significa definir)

 Después de  def  va el nombre de la función (las reglas para darle nombre a las
funciones son las mismas que para las variables).
 Después del nombre de la función, hay un espacio para un par
de paréntesis (ahorita no contienen algo, pero eso cambiará pronto).
 La línea debe de terminar con dos puntos.
 La línea inmediatamente después de  def  marca el comienzo del cuerpo de la
función - donde varias o (al menos una). instrucción anidada, será ejecutada
cada vez que la función sea invocada; nota: la función termina donde el
anidamiento termina, se debe ser cauteloso.
A continuación se definirá la función. Se llamará  mensaje  - aquí esta:

def mensaje():
print("Ingresa un valor: ")

La función es muy sencilla, pero completamente utilizable. Se ha nombrado  mensaje ,

pero eso es opcional, tu puedes cambiarlo. Hagamos uso de ella.

El código ahora contiene la definición de la función:

def mensaje():
print("Ingresa un valor: ")

print("Se comienza aquí.")

print("Se termina aquí.")

Nota: no se esta utilizando la función, no se esta invocando en el código.

Al correr el programa, se mostrará lo siguiente:

Se comienza aquí.
Se termina aquí.

Esto significa que Python lee la definición de la función y la recuerda, pero no la ejecuta
sin permiso.

Se ha modificado el código, se ha insertado la invocación de la función entre los dos

mensajes:

def mensaje():
print("Ingresa un valor: ")

print("Se comienza aquí.")

mensaje()
print("Se termina aquí.")

La salida ahora se ve diferente:

Se comienza aquí.
Ingresa un valor:
Se termina aquí.

Prueba el código, modifícalo, experimenta con el.

print("Ingresa un valor: ")

a = int(input())

print("Ingresa un valor: ")

b = int(input())

print("Ingresa un valor: ")

c = int(input())

El funcionamiento de las funciones

Observa la imagen:
La imagen intenta mostrar el proceso completo:

 Cuando se invoca una función, Python recuerda el lugar donde esto ocurre y salta hacia dentro
de la función invocada.
 El cuerpo de la función es entonces ejecutado.
 Al llegar al final de la función, Python regresa al lugar inmediato después de donde ocurrió la
invocación.

Existen dos consideraciones muy importantes, la primera de ella es:

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

Recuerda: Python lee el código de arriba hacia abajo. No va a adelantarse en el código para determinar si
la función invocada esta definida mas adelante, el lugar correcto para definirla es antes de ser invocada.

Se ha insertado un error en el código anterior - ¿Puedes notar la diferencia?

print("Se comienza aquí.")

mensaje()
print("Se termina aquí.")
def mensaje():
print("Ingresa un valor: ")

Se ha movido la función al final del código. ¿Podrá Python encontrarla cuando la ejecución llegue a la
invocación?

No, no podrá. El mensaje de error dirá:

NameError: name 'mensaje' is not defined

No intentes forzar a Python a encontrar funciones que no están definidas en el lugar correcto.

La segunda consideración es mas sencilla:

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

El siguiente fragmento de código es erróneo:

def mensaje():
print("Ingresa un valor: ")

mensaje = 1

El asignar un valor al nombre "mensaje" causa que Python olvide su rol anterior. La función con el
nombre de  mensaje  ya no estará disponible.

Afortunadamente, es posible combinar o mezclar el código con las funciones - no es forzoso colocar

todas las funciones al inicio del archivo fuente.

Observa el siguiente código:

print("Se comienza aquí.")

def mensaje():
print("Ingresa un valor: ")

mensaje()

print("Se termina aquí.")

Puede verse extraño, pero es completamente correcto, y funciona como se necesita.

Regresemos al ejemplo inicial para implementar la función de manera correcta:

def mensaje():
print("Ingresa un valor: ")

mensaje()
a = int(input())
mensaje()
b = int(input())
mensaje()
c = int(input())

El modificar el mensaje de entrada es ahora sencillo: se puede hacer con solo modificar el código una
única vez - dentro del cuerpo de la función.

Abre Sandbox, e inténtalo tu mismo.

Puntos Clave

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

2. 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 (se hablará acerca de ellas en
el Módulo 5 de este curso).
 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  (aprenderás acerca de ellas en el Módulo 6 del curso).

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

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

También es posible definir funciones con argumentos, como la siguiente que contiene un solo parámetro:

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

Se hablará mas acerca de funciones con parámetros en la siguiente sección.

Ejercicio 1

La función  input()  es un ejemplo de:

a) una función definida por el usuario

b) una función integrada

Revisar

b - es una función integrada

Ejercicio 2

¿Qué es lo que ocurre cuando se invoca una función antes de ser definida? Ejemplo:

hola()
def hola():
print("hola!")
Revisar

Se genera una excepción (la excepción  NameError )

Ejercicio 3

¿Qué es lo que ocurrirá cuando se ejecute el siguiente código?

def hola():
print("hola")

hola(5)
Revisar

Se genera una excepción (la excepción  TypeError ) - la función  hola()  no toma argumentos.

Funciones con parámetros

El potencial completo de una función se revela cuando puede ser equipada con una interface que es
capaz de aceptar datos provenientes de la invocación. Dichos datos pueden modificar el comportamiento
de la función, haciéndola mas flexible y adaptable a condiciones cambiantes.

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.
def funcion(parametro):
###

Recuerda que:

 Los parámetros solo existen dentro de las funciones (este es su entorno natural).

 Los argumentos existen fuera de las funciones, y son los que pasan los valores a los
parámetros correspondientes.
Existe una clara división entre estos dos mundos.

Enriquezcamos la función anterior agregándole un parámetro, se utilizará para mostrar al usuario el valor
de un número que la función pide.

Se tendrá que modificar la definición  def  de la función, así es como se ve ahora:

def mensaje(numero):
###

Esta definición especifica que nuestra función opera con un solo parámetro con el nombre de  numero .
Se puede utilizar como una variable normal, pero solo dentro de la función - no es visible en otro lugar.

Ahora hay que mejorar el cuerpo de la función:

def mensaje(numero):
print("Ingresa el número:", numero)

Se ha hecho buen uso del parámetro. Nota: No se le ha asignado al parámetro algún valor. ¿Es correcto?

Si, lo es.

Un valor para el parámetro llegará del entorno de la función.

Recuerda: 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.

El no hacerlo provocará un error.

Funciones con parámetros: continuación

Intenta ejecutar el código en el editor.

Esto es lo que aparecerá en consola:

TypeError: mensaje() missing 1 required positional argument: 'numero'

Esto significa que se esta invocando la función pero esta faltando el argumento.

Aquí esta ya de manera correcta:

def mensaje(numero):
print("Ingresa un número:", numero)

mensaje(1)

De esta manera ya esta correcto. El código producirá la siguiente salida:

Ingresa un número: 1

¿Puedes ver como funciona? El valor del argumento utilizado durante la invocación ( 1 ) ha
sido pasado a la función, dándole un valor inicial al parámetro con el nombre de  numero .

Existe una circunstancia importante que se debe mencionar.

Es posible tener una variable con el mismo nombre del parámetro de la función.

El siguiente código muestra un ejemplo de esto:

def mensaje(numero):
print("Ingresa un número:", numero)

numero = 1234
mensaje(1)
print(numero)

Una situación como la anterior, activa un mecanismo denominado sombreado:

 El parámetro  x  sombrea cualquier variable con el mismo nombre, pero...

 ... solo dentro de la función que define el parámetro.

El parámetro llamado  numero  es una entidad completamente diferente de la variable

llamada  numero .
Esto significa que el código anterior producirá la siguiente salida:

Ingresa un número: 1
1234

Funciones con parámetros: continuación

Una función puede tener tantos parámetros como se desee, pero entre más
parámetros, es más difícil memorizar su rol y propósito.
Modifiquemos la función- ahora tiene dos parámetros:

def mensaje(que, numero):

print("Ingresa", que, "número", numero)

Esto significa que para invocar la función, se necesitan dos argumentos.

El primer valor va a contener el nombre del valor deseado.

Aquí esta:

def mensaje(que, numero):

 print("Ingresa", que, "número", numero)

mensaje("teléfono", 11)

mensaje("precio", 5)

mensaje("número", "número")

Estas es la salida del código anterior:

Ingresa teléfono número 11

Ingresa precio número 5

Ingresa número número número

Ejecuta el código, modifícalo, agrega mas parámetros y ve como esto afecta la salida.

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.
Ya se ha utilizado, pero Python ofrece mucho más. Se abordará este tema a continuación.

def miFuncion(a, b, c):

print(a, b, c)

miFuncion(1, 2, 3)

Nota: el paso de parámetros posicionales es usado de manera intuitiva por las personas
en muchas situaciones. Por ejemplo, es generalmente aceptado que cuando nos
presentamos mencionamos primero nuestro nombre(s) y después nuestro apellido, por
ejemplo, "Me llamo Juan Pérez."

Sin embargo, En Hungría se hace al revés.

Implementemos esa costumbre en Python. La siguiente función es utilizada para

presentar a alguien:

def presentar(primerNombre, segundoNombre):

print("Hola, mi nombre es", primerNombre, segundoNombre)

presentar("Luke", "Skywalker")

presentar("Jesse", "Quick")

presentar("Clark", "Kent")

¿Puedes predecir la salida? Ejecuta el código y verifícalo por ti mismo.

Ahora imaginemos que la función esta siendo utilizada en Hungría. En este caso, el código
sería de la siguiente manera:

def presentar(primerNombre, segundoNombre):

print("Hola, mi nombre es", primerNombre, segundoNombre)

presentar("Skywalker" ,"Luke" )

presentar("Quick", "Jesse")

presentar("Kent", "Clark")

La salida será diferente. ¿La puedes predecir?

Ejecuta el código para comprobar tu respuesta. ¿Es lo que esperabas?

¿Puedes construir más funciones de este tipo ?

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.

Observa el siguiente código:

def presentar (primerNombre, segundoNombre):

print("Hola, mi nombre es", primerNombre, segundoNombre)

presentar(primerNombre = "James", segundoNombre = "Bond")

presentar(segundoNombre = "Skywalker", primerNombre = "Luke")

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.

Debes de poder predecir la salida. Ejecuta el código y verifica tu respuesta.

Por supuesto que no se debe de utilizar el nombre de un parámetro que no existe.

El siguiente código provocará un error de ejecución:

def presentar (primerNombre, segundoNombre):

print("Hola, mi nombre es ", primerNombre, segundoNombre)

introduction(apellido="Skywalker", primerNombre="Luke")

Esto es lo que Python arrojará:

TypeError: presentar() got an unexpected keyword argument 'apellido'

Inténtalo tu mismo.

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.

Piénsalo por un momento y entenderás el porque.

Para mostrarte como funciona, se utilizara la siguiente función de tres parámetros:

def suma(a, b, c):

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

Su propósito es el de evaluar y presentar la suma de todos sus argumentos.

La función, al ser invocada de la siguiente manera:

suma(1, 2, 3)

Dará como salida:

1 + 2 + 3 = 6
Hasta ahorita es un ejemplo puro de un argumento posicional.

También, se puede reemplazar la invocación actual por una con palabras clave, como la
siguiente:

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

El programa dará como salida lo siguiente:

2 + 3 + 1 = 6

Ten presente el orden de los valores.

Ahora intentemos mezclar ambas.

Observa la siguiente invocación de la función:

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

Vamos a analizarla:

 El argumento ( 3 ) para el parametro  a  es pasado utilizando la manera posicional.

 Los argumentos para  c  y  b  son especificados con palabras clave.

Esto es lo que se verá en la consola:

3 + 2 + 1 = 6

Se cuidadoso, ten cuidado de no cometer errores. Si se intenta pasar mas de un valor a un

argumento, ocurrirá un error y se mostrará lo siguiente:

Observa la siguiente invocación, se le esta asignando dos veces un valor al parámetro  a :

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

La respuesta de Python es:

TypeError: suma() got multiple values for argument 'a'

Observa el siguiente código. Es un código completamente correcto y funcional, pero no

tiene mucho sentido:

suma(4, 3, c = 2)

Todo es correcto, pero el dejar solo un argumento con palabras clave es algo extraño -
¿Qué es lo que opinas?

Funciones con parámetros: mas detalles

En ocasiones ocurre que algunos valores de ciertos argumentos son mas utilizados que
otros. Dichos argumentos tienen valores predefinidos los cuales pueden ser
considerados cuando los argumentos correspondientes han sido omitidos.

Uno de los apellidos más comunes en Latinoamérica es González. Tomémoslo para el

ejemplo.

El valor por default para el parámetro se asigna de la siguiente manera:

def presentar(primerNombre, segundoNombre="González"):

print("Hola, mi nombre es", primerNombre, segundoNombre)

Solo se tiene que colocar el nombre del parámetro seguido del signo de  =  y el valor por
default.

Invoquemos la función de manera normal:

presentar("Jorge", "Pérez")

¿Puedes predecir la salida del programa? Ejecútalo y revisa si era lo esperado.

¿Y? No parece haber cambiado algo, pero cuando se invoca la función de una manera
inusual, como esta:

presentar("Enrique")

o así:

presentar (primerNombre="Guillermo")

no habrá errores, ambas invocaciones funcionarán, la consola mostrará los siguientes

resultados:

Hola, mi nombre es Enrique González

Hola, mi nombre es Guillermo González

Pruébalo.

Puedes hacerlo con mas parámetros, si te resulta útil. Ambos parámetros tendrán sus
valores por default, observa el siguiente código:

def presentar(primerNombre="Juan", segundoNombre="González"):

print("Hola, mi nombre es ", primerNombre, segundoNombre)

Esto hace que la siguiente invocación sea completamente valida:

presentar ()
Y esta es la salida esperada:

Hola, mi nombre es Juan González

Si solo se especifica un argumento de palabra clave, el restante tomará el valor por

default:

presentar(segundoNombre="Rodríguez")

La salida es:

Hola, mi nombre es Juan Rodríguez

Pruébalo.

Felicidades, has aprendido las maneras básicas de comunicación con funciones.

def presentar(primerNombre, segundoNombre="Smith"):

print("Hola, mi nombre es", primerNombre, segundoNombre)

# mandar llamar la función aquí (invocarla)

Puntos Clave

1. Se puede pasar información a las funciones utilizando parámetros. Las funciones pueden tener tantos
parámetros como sean necesarios.

Un ejemplo de una función con un parámetro:

def hola(nombre):
print("Hola,", nombre)

hola("Greg")

Un ejemplo de una función de dos parámetros:

def holaTodos(nombre1, nombre2):

print("Hola,", nombre2)
print("Hola,", nombre1)

holaTodos("Sebastián", "Felipe")

Un ejemplo de una función de tres parámetros:

def direccion(calle, ciudad, codigoPostal):

print("Tu dirección es:", calle, ciudad, codigoPostal)

c = input("Calle: ")
cp = input("Código Postal: ")
cd = input("Ciudad: ")

address(c, cd, cp)

2. Puedes pasar argumentos a una función utilizando las siguientes técnicas:

 Paso de argumentos posicionales en la cual el orden de los parámetros es relevante (Ejemplo

1).
 Paso de argumentos con palabras clave en la cual el orden de los argumentos es irrelevante
(Ejemplo 2).
 Una mezcla de argumentos posicionales y con palabras clave (Ejemplo 3).
Ejemplo 1
def resta(a, b):
print(a - b)

resta(5, 2) # salida: 3
resta(2, 5) # salida: -3

Ejemplo 2
def resta(a, b):
print(a - b)

resta(a=5, b=2) # salida: 3

resta(b=2, a=5) # salida: 3
Ex. 3
def resta(a, b):
print(a - b)

resta(5, b=2) # salida: 3

resta(5, 2) # salida: 3

Es importante recordar que primero se especifican los argumentos posicionales y después los de

palabras clave. Es por esa razón que si se intenta ejecutar el siguiente código:

def resta(a, b):

print(a - b)

resta(5, b=2) # salida: 3

resta(a=5, 2) # Syntax Error

Python no lo ejecutará y marcará un error de sintaxis  SyntaxError .

3. Se puede utilizar la técnica de argumentos con palabras clave para asignar valores predefinidos a los
argumentos:

def nombre(nombre, apellido="Pérez"):

print(nombre, apellido)

nombre("Andy") # salida: Andy Pérez

nombre("Bety", "Rodríguez") # salida: Bety Johnson (el argumento
de palabra clave es reemplazado por " Rodríguez ")

Ejercicio 1

¿Cuál es la salida del siguiente código?

def intro(a="James Bond", b="Bond"):

print("Mi nombre es", b + ".", a + ".")

intro()
Revisar
Mi nombre es Bond. James Bond.

Ejercicio 2

¿Cuál es la salida del siguiente código?

def intro(a="James Bond", b="Bond"):

print("Mi nombre es", b + ".", a + ".")

intro(b="Sergio López")
Revisar

Mi nombre es Sergio López. James Bond.

Ejercicio 3

¿Cuál es la salida del siguiente fragmento de código?

def intro(a, b="Bond"):

print("Mi nombre es", b + ".", a + ".")

intro("Susan")
Revisar

Mi nombre es Bond. Susan.

Ejercicio 4

¿Cuál es la salida del siguiente código?

def suma(a, b=2, c):

print(a + b + c)

suma(a=1, c=3)
Revisar
Efectos y resultados: la instrucción return
Todas las funciones presentadas anteriormente tienen algún tipo de efecto: producen un texto y lo envían
a la consola.

Por supuesto, las funciones, al igual que las funciones matemáticas, pueden tener resultados.

Para lograr que las funciones devuelvan un valor (pero no solo para ese propósito) se utiliza la
instrucción  return  (regresar o retornar).

Esta palabra nos da una idea completa de sus capacidades. Nota: es una palabra reservada de Python.

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.

Nota: si una función no está destinada a producir un resultado, emplear la instrucción  return no es

obligatorio, se ejecutará implícitamente al final de la función.

De cualquier manera, se puede emplear para terminar las actividades de una función, antes de que el
control llegue a la última línea de la función.

Consideremos la siguiente función:

def felizAñoNuevo(deseos = True):

print("Tres ...")

print("Dos ...")

print("Uno ...")

if not deseos:

return
 print("¡Feliz año nuevo!")

Cuando se invoca sin ningún argumento:

felizAñoNuevo()

La función produce un poco de ruido; la salida se verá así:

Tres ...

Dos...

Uno...

¡Feliz año nuevo!

Al proporcionar  False  como argumento:

felizAñoNuevo(False)

Se modificará el comportamiento de la función; la instrucción  return  provocará su terminación justo

antes de los deseos. Esta es la salida actualizada:

Tres ...

Dos...

Uno ...

return con una expresión

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

funcion():

return expresión

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.
Este ejemplo es sencillo:

def funcion_aburrida():

return 123

x = funcion_aburrida()

print ("La funcion_aburrida ha devuelto su resultado. Es: ", x)

El fragmento de código escribe el siguiente texto en la consola:

La funcion_aburrida ha devuelto su resultado. Es: 123

Vamos a investigarlo.

Analiza la siguiente figura:

La instrucción  return , enriquecida con la expresión (la expresión es muy simple aquí), "transporta" el
valor de la expresión al lugar donde se ha invocado la función.

El resultado se puede usar libremente aquí, por ejemplo, para ser asignado a una variable.

También puede ignorarse por completo y perderse sin dejar rastro.

Ten en cuenta que no estamos siendo muy educados aquí: la función devuelve un valor y lo ignoramos
(no lo usamos de ninguna manera):

def funcion_aburrida():

print("'Modo aburrimiento' ON.")

return 123

print("¡Esta lección es interesante!)

funcion_aburrida()

print("Esta lección es aburrida ...")

El programa produce el siguiente resultado:

¡Esta lección es interesante!

'Modo aburrimiento' ON.

Esta lección es aburrida ...

¿Esta mal? De ninguna manera.

La única desventaja es que el resultado se ha perdido irremediablemente.

No olvides:

 Siempre se te permite ignorar el resultado de la función y estar satisfecho con el efecto de la

función (si la función tiene alguno).
 Si una función intenta devolver un resultado útil, debe contener la segunda variante de la
instrucción  return .

Espera un segundo, ¿Significa esto que también hay resultados inútiles? Sí, en cierto sentido.

Unas pocas palabras acerca de None

Permítenos presentarte un valor muy curioso (para ser honestos, un valor que es
ninguno) llamado  None .

Sus datos no representan valor razonable alguno; en realidad, no es un valor en lo

absoluto; por lo tanto, no debe participar en ninguna expresión.
Por ejemplo, un fragmento de código como el siguiente:

print(None + 2)

Causará un error de tiempo de ejecución, descrito por el siguiente mensaje de

diagnóstico:

TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

Nota:  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.

Al igual que aquí:

valor = None
if valor == None:
print("Lo siento, no tienes ningún valor")

No olvides 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 .

Vamos a probarlo.

Algunas palabras acerca de None: continuación

Echa un vistazo al código en el editor.

Es obvio que la función  strangeFunction  devuelve  True  cuando su argumento es par.

¿Qué es lo que regresa de otra manera?

Podemos usar el siguiente código para verificarlo:

print(strangeFunction(2))

print(strangeFunction(1))
Esto es lo que vemos en la consola:

True

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.

Efectos y resultados: listas y funciones

Hay dos preguntas adicionales que deben responderse aquí.

El primero es: ¿Se puede enviar una lista a una función como un argumento?

¡Por supuesto que se puede! Cualquier entidad reconocible por Python puede
desempeñar el papel de un argumento de función, aunque debes asegurarte de que la
función sea capaz de hacer uso de él.

Entonces, si pasas una lista a una función, la función tiene que manejarla como una lista.

Una función como la siguiente:

def sumaDeLista(lst):
 sum = 0

for elem in lst:

sum += elem

return sum

y se invoca así:

print(sumaDeLista([5, 4, 3]))

Regresará  12  como resultado, pero habrá problemas si la invocas de esta manera

riesgosa:

print(sumaDeLista(5))

La respuesta de Python será la siguiente:

TypeError: 'int' object is not iterable

Esto se debe al hecho de que el bucle  for  no puede iterar un solo valor entero.
Efectos y resultados: listas y funciones - continuación
La segunda pregunta es: ¿Puede una lista ser el resultado de una función?

¡Si, por supuesto! Cualquier entidad reconocible por Python puede ser un resultado de
función.

Observa el código en el editor. La salida del programa será así:

[4, 3, 2, 1, 0]

Ahora puedes escribir funciones con y sin resultados.

Vamos a profundizar un poco más en los problemas relacionados con las variables en las
funciones. Esto es esencial para crear funciones efectivas y seguras.
Tiempo estimado
10-15 minutos

Nivel de dificultad
Fácil

Objetivos
Familiarizar al estudiante con:

 Proyectar y escribir funciones con parámetros.

 Utilizar la sentencia return.
 Probar las funciones.

Escenario
Tu tarea es escribir y probar una función que toma un argumento (un año) y
devuelve  True  si el año es un año bisiesto, o  False  sí no lo es.

Parte del esqueleto de la función ya está en el editor.

Nota: también hemos preparado un breve código de prueba, que puedes utilizar para
probar tu función.

El código utiliza dos listas: una con los datos de prueba y la otra con los resultados
esperados. El código te dirá si alguno de tus resultados no es válido.

def isYearLeap(year):

# coloca tu código aquí

testData = [1900, 2000, 2016, 1987]

testResults = [False, True, True, False]

for i in range(len(testData)):

yr = testData[i]

print(yr,"->",end="")

result = isYearLeap(yr)

if result == testResults[i]:

print("OK")

else:

print("Error")
Tiempo estimado
15-20 minutos

Nivel de dificultad
Medio

Requisitos previos
LABORATORIO 4.1.3.6

Objetivos
Familiarizar al estudiante con:

 Proyectar y escribir funciones parametrizadas.

 Utilizar la sentencia return.
 Utilizar las funciones propias del estudiante.
Escenario
Tu tarea es escribir y probar una función que toma dos argumentos (un año y un mes) y
devuelve el número de días del mes/año dado (mientras que solo febrero es sensible al
valor  year , tu función debería ser universal).

La parte inicial de la función está lista. Ahora, haz que la función devuelva  None  si los
argumentos no tienen sentido.

Por supuesto, puedes (y debes) utilizar la función previamente escrita y probada (LAB
4.1.3.6). Puede ser muy útil. Te recomendamos que utilices una lista con los meses.
Puedea crearla dentro de la función; este truco acortará significativamente el código.

Hemos preparado un código de prueba. Amplíalo para incluir más casos de prueba.

def isYearLeap(year):

# tu código del laboratorio anterior

def daysInMonth(year, month):

# coloca tu código aqui

testYears = [1900, 2000, 2016, 1987]

testMonths = [2, 2, 1, 11]

testResults = [28, 29, 31, 30]

for i in range(len(testYears)):

yr = testYears[i]

mo = testMonths[i]

print(yr, mo, "->", end="")

result = daysInMonth(yr, mo)

if result == testResults[i]:
 print("OK")

else:

print("Error")

Tiempo estimado
20-30 minutos

Nivel de dificultad
Medio

Requisitos previos
LAB 4.1.3.6
LAB 4.1.3.7

Objetivos
Familiarizar al estudiante con:
  Proyectar y escribir funciones con parámetros.
 Utilizar la sentencia return.
 Construir un conjunto de funciones de utilidad.
 Utilizar las funciones propias del estudiante.

Escenario
Tu tarea es escribir 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.

Debes utilizar las funciones previamente escritas y probadas. Agrega algunos casos de
prueba al código. Esta prueba es solo el comienzo.

def isYearLeap(year):

# tu código del LAB 4.1.3.6

def daysInMonth(year, month):

# tu código del LAB 4.1.3.7

def dayOfYear(year, month, day):

# pon tu código nuevo aquí

print(dayOfYear(2000, 12, 31))

Tiempo estimado
15-20 minutos

Nivel de dificultad
Medio

Objetivos
 Familiarizar al estudiante con nociones y algoritmos clásicos.
 Mejorar las habilidades del estudiante para definir y usar funciones.

Escenario
Un número natural es  primo  si es mayor que 1 y no tiene divisores más que 1 y si mismo.

¿Complicado? De ningúna manera. Por ejemplo, 8 no es un número primo, ya que puedes

dividirlo entre 2 y 4 (no podemos usar divisores iguales a 1 y 8, ya que la definición lo
prohíbe).

Por otra parte, 7 es un número primo, ya que no podemos encontrar ningún divisor para
el.
Tu tarea es escribir una función que verifique si un número es primo o no.

La función:

 Se llama  isPrime .
 Toma un argumento (el valor a verificar).
 Devuelve  True  si el argumento es un número primo, y  False  de lo contrario.

Sugerencia: intenta dividir el argumento por todos los valores posteriores (comenzando
desde 2) y verifica el resto: si es cero, tu número no puede ser un número primo; analiza
cuidadosamente cuándo deberías detener el proceso.

Si necesitas conocer la raíz cuadrada de cualquier valor, puedes utilizar el operador  ** .

Recuerda: la raíz cuadrada de x es la misma que x0.5

Complementa el código en el editor.

Ejecuta tu código y verifica si tu salida es la misma que la nuestra.

Datos de prueba
Salida esperada:

2 3 5 7 11 13 17 19

def isPrime(num):

# coloca tu código aquí

for i in range(1, 20):

if isPrime(i + 1):

print(i + 1, end=" ")

print()
Tiempo estimado
10-15 minutos

Nivel de dificultad
Fácil

Objetivos
 Mejorar las habilidades del estudiante para definir, utilizar y probar funciones.

Escenario
El consumo de combustible de un automóvil se puede expresar de muchas maneras diferentes. Por
ejemplo, en Europa, se muestra como la cantidad de combustible consumido por cada 100 kilómetros.

En los EE. UU., se muestra como la cantidad de millas recorridas por un automóvil con un galón de
combustible.

Tu tarea es escribir un par de funciones que conviertan l/100km a mpg(milas por galón), y viceversa.

Las funciones:

 Se llaman  l100kmampg  y  mpgal100km  respectivamente.

 Toman un argumento (el valor correspondiente a sus nombres).
 Complementa el código en el editor.

Ejecuta tu código y verifica si tu salida es la misma que la nuestra.

Aquí hay información para ayudarte:

 1 milla = 1609.344 metros.

 1 galón = 3.785411784 litros.

Datos de prueba
Salida esperada:

60.31143162393162

31.36194444444444

23.52145833333333

3.9007393587617467

7.490910297239916

10.009131205673757
 







  Sandbox


Code
def l100kmtompg(liters):
#
# coloca tu código aqui
#

def mpgtol100km(miles):
#
# coloca tu código aqui
#

print(l100kmtompg(3.9))
print(l100kmtompg(7.5))
print(l100kmtompg(10.))
print(mpgtol100km(60.3))
print(mpgtol100km(31.4))
print(mpgtol100km(23.5))

1
2
3
4
5
 6
7
8
9
10
11
12
13
14
15
16
def l100kmtompg(liters):
#
# coloca tu código aqui
#
def mpgtol100km(miles):
#
# coloca tu código aqui
#
print(l100kmtompg(3.9))
print(l100kmtompg(7.5))
print(l100kmtompg(10.))
print(mpgtol100km(60.3))
print(mpgtol100km(31.4))
print(mpgtol100km(23.5))

 Console 

def l100kmtompg(liters):
#

# coloca tu código aqui

def mpgtol100km(miles):

# coloca tu código aqui

print(l100kmtompg(3.9))

print(l100kmtompg(7.5))

print(l100kmtompg(10.))

print(mpgtol100km(60.3))

print(mpgtol100km(31.4))

print(mpgtol100km(23.5))
Puntos clave

1. Puedes emplear la palabra clave  return  para decirle a una función que devuelva algún valor. La
instrucción  return  termina la función, por ejemplo:

def multiply(a, b):

return a * b

print(multiply(3, 4)) # salida: 12

def multiply(a, b):

return

print(multiply(3, 4)) # salida: None

2. El resultado de una función se puede asignar fácilmente a una variable, por ejemplo:

def deseos():

return "¡Felíz Cumpleaños!"

d = deseos()

print(d) # salida: ¡Felíz Cumpleaños!

Observa la diferencia en la salida en los siguientes dos ejemplos:

# Ejemplo 1

def deseos():

print("Mis deseos")

return "¡Felíz Cumpleaños!"

deseos() # salida: Mis deseos

# Ejemplo 2

def deseos():

print("Mis Deseos")

return "¡Feliz Cumpleaños!"

print(deseos()) # salidas: Mis Deseos

# ¡Feliz Cumpleaños!

3. Puedes usar una lista como argumento de una función, por ejemplo:

def HolaaTodos(myList):

for nombre in myList:

print("Hola,", nombre)

HolaaTodos(["Adam", "John", "Lucy"])

4. Una lista también puede ser un resultado de función, por ejemplo:

def createList(n):

myList = []

for i in range(n):

myList.append(i)

return myList

print(createList(5))
Ejercicio 1

¿Cuál es la salida del siguiente fragmento de código?

def hola():

return

print("¡Hola!")

hola()

Revisar

La función devolverá un valor  None  implícito

Ejercicio 2

¿Cuál es la salida del siguiente fragmento de código?

def isInt(data):

if type(data) == int:

return True

elif type(data) == float:

return False

print(isInt(5))

print(isInt(5.0))

print(isInt("5"))

Revisar

True

False

None
Ejercicio 3

¿Cuál es la salida del siguiente fragmento de código?

def evenNumLst(ran):

lst = []

for num in range(ran):

if num % 2 == 0:

lst.append(num)

return lst

print(evenNumLst(11))

Revisar

[0, 2, 4, 6, 8, 10]

Ejercicio 4

¿Cuál es la salida del siguiente fragmento de código?

def listUpdater(lst):

updList = []

for elem in lst:

elem **= 2

updList.append(elem)

return updList

l = [1, 2, 3, 4, 5]

print(listUpdater(l))

Revisar
 [1, 4, 9, 16, 25]

Las funciones y sus alcances (scopes)

Comencemos con una definición:

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.

Vamos a revisarlo. Observa el código en el editor. ¿Que ocurrirá cuando se ejecute?

El programa no correrá. El mensaje de error dirá:

NameError: name 'x' is not defined

Esto era de esperarse.

Vamos a conducir algunos experimentos para mostrar como es que Python define los
alcances y como los puedes utilizar para tu beneficio.

def scopeTest():

x = 123

scopeTest()

print(x)

Las funciones y sus alcances (scopes): continuación

Comencemos revisando si una variable creada fuera de una función es visible dentro de
una función. En otras palabras, ¿El nombre de la variable se propaga dentro del cuerpo de
la función?

Observa el código en el editor. Ahí esta nuestro conejillo de indias.

El resultado de la prueba es positivo, el código da como salida:

¿Conozco a la variable? 1
1

La respuesta es: una variable que existe fuera de una función tiene alcance dentro
del cuerpo de la función.

Esta regla tiene una excepción muy importante. Intentemos encontrarla.

Hagamos un pequeño cambio al código:

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

var = 1
miFuncion()
print(var)

El resultado ha cambiado tambiénm el código arroja una salida con una ligera diferencia:

¿Conozco a la variable? 2
1

¿Qué es lo que ocurrió?

 La variable  var  creada dentro de la función no es la misma que la que se definió

fuera de ella, parece ser que hay dos variables diferentes con el mismo nombre.
 La variable de la función es una sombra de la variable fuera de la función.

La regla anterior se puede definir de una manera mas precisa y adecuada:

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.
También significa que el alcance de una variable existente fuera de una función solo
se puede implementar dentro de una función cuando su valor es leído. El asignar un
valor hace que la función cree su propia variable.

Asegúrate bien de entender esto correctamente y de realizar tus propios experimentos.

def miFuncion():

print("¿Conozco a la variable?", var)

var = 1

miFuncion()

print(var)

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? Esto sería muy incomodo.

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.
En otras palabras, este nombre se convierte en global (tiene un alcance global, y no
importa si se esta leyendo o asignando un valor).

Observa el código en el editor.

Se ha agregado la palabra  global  a la función.

El código ahora da como salida:

¿Conozco a aquella variable? 2

Esto debe de ser suficiente evidencia para mostrar lo que la palabra

reservada  global  puede hacer.

def miFuncion():

global var

var = 2

print("¿Conozco a aquella variable?", var)

var = 1

miFuncion()

print(var)

Como interactúa la función con sus argumentos

Ahora descubramos como la función interactúa con sus argumentos.

El código en editor nos enseña algo. Como puedes observar, la función cambia el valor de
su parámetro. ¿Este cambio afecta el argumento?

Ejecuta el programa y verifícalo.

La salida del código es:

Yo obtuve 1
Yo ahora tengo 2
1

La conclusión es obvia - al cambiar el valor del parámetro este no se propaga fuera de
la función (más específicamente, no cuando la variable es un valor escalar, como en el
ejemplo).

Esto también significa que una función recibe el valor del argumento, no el argumento
en sí. Esto es cierto para los valores escalares.

Vale la pena revisar cómo funciona esto con las listas (¿Recuerdas las peculiaridades de
asignar rodajas de listas en lugar de asignar la lista entera?)

El siguiente ejemplo arrojará luz sobre el asunto:

def miFuncion(miLista1):
print(miLista1)
miLista1 = [0, 1]

miLista2 = [2, 3]
miFuncion(miLista2)
print(miLista2)

La salida del código es:

[2, 3]
[2, 3]

Parece ser que se sigue aplicando la misma regla.

La diferencia se puede observar en el siguiente ejemplo:

def miFuncion(miLista1):
print(miLista1)
del miLista1[0]

miLista2 = [2, 3]
miFuncion(miLista2)
print(miLista2)

No se modifica el valor del parámetro  miLista1  (ya se sabe que no afectará el

argumento), en lugar de ello se modificará la lista identificada por el.

El resultado puede ser sorprendente. Ejecuta el código y verifícalo:

[2, 3]
[3]

¿Lo puedes explicar?

Intentémoslo:

 Si el argumento es una lista, el cambiar el valor del parámetro correspondiente no

afecta la lista (Recuerda: las variables que contienen listas son almacenadas de
manera diferente que las escalares).
 Pero si se modifica la lista identificada por el parámetro (Nota: ¡La lista no el
parámetro!), la lista reflejará el cambio.

Es tiempo de escribir algunos ejemplos de funciones. Lo harás en la siguiente sección.

def miFuncion(n):

print("Yo obtuve", n)

n += 1

print("Yo ahora tengo", n)

var = 1

miFuncion(var)

print(var)

Puntos Clave
1. Una variable que existe fuera de una función tiene alcance dentro del cuerpo de la función. (Ejemplo
1) al menos que la función defina una variable con el mismo nombre. (Ejemplo 2, y Ejemplo 3), por
ejemplo:

Ejemplo 1:

var = 2

def multByVar(x):

return x * var

print(multByVar(7)) # salida: 14

Ejemplo 2:

def mult(x):

var = 5

return x * var

print(mult(7)) # salida: 35

Ejemplo 3:

def multip(x):

var = 7

return x * var

var = 3

print(multip(7)) # salida: 49

2. Una variable que existe dentro de una función tiene un alcance solo dentro del cuerpo de la función
(Ejemplo 4), por ejemplo:

Ejemplo 4:

def sum(x):
 var = 7

return x + var

print(sum(4)) # salida: 11

print(var) # NameError

3. Se puede emplear la palabra reservada  global  seguida por el nombre de una variable para que el
alcance de la variable sea global, por ejemplo:

var = 2

print(var) # salida: 2

def retVar():

global var

var = 5

return var

print(retVar()) # salida: 5

print(var) # salida: 5

Ejercicio 1

¿Qué ocurrirá cuando se intente ejecutar el siguiente código?

def message():

alt = 1

print("Hola, mundo!")
print(alt)

Revisar

Se arrojará una excepción  NameError ( NameError: name 'alt' is not defined )

Ejercicio 2

¿Cuál es la salida del siguiente fragmento de código?

a = 1

def fun():

a = 2

print(a)

fun()

print(a)

Revisar

Ejercicio 3

¿Cuál es la salida del siguiente fragmento de código?

a = 1

def fun():

global a

a = 2
 print(a)

fun()

a = 3

print(a)

Revisar

Ejercicio 4

¿Cuál es la salida del siguiente fragmento de código?

a = 1

def fun():

global a

a = 2

print(a)

a = 3

fun()

print(a)

Revisar

2
Funciones Simples: Calcular el IMC
Definamos una función que calcula el Índice de Masa Corporal (IMC).

Como puedes observar, la formula ocupa dos valores:

 peso (originalmente en kilogramos)

 altura (originalmente en metros)

La nueva función tendrá dos parámetros. Su nombre será  imc , pero si prefieres utilizar
otro nombre, adelante.

Codifiquemos la función.

La función esta completa aquí abajo (y en la ventana de editor):

def imc(peso, altura):

return peso / altura ** 2

print(imc(52.5, 1.65))

El resultado del ejemplo anterior es el siguiente:

19.283746556473833

La función hace lo que deseamos, pero es un poco sencilla - asume que los valores de
ambos parámetros son significativos. Se debe comprobar que son confiables.

Vamos a comprobar ambos y regresar  None  si cualquiera de los dos es incorrecto.

def imc(peso, altura):

return peso / altura ** 2

print(imc(52.5, 1.65))

Algunas funciones simples: calcular el IMC y convertir

unidades del sistema inglés al sistema métrico
Observa el código en el editor. Hay dos cosas a las cuales hay que prestar atención.

Primero, se asegura que los datos que sean ingresados sean correctos, de lo contrario la salida será:

None
Segundo, observa como el símbolo de diagonal invertida ( \ ) es empleado. Si se termina una línea de
código con el, Python entenderá que la línea continua en la siguiente.

Esto puede ser útil cuando se tienen largas líneas de código y se desea que sean mas legibles.

Sin embargo, hay algo que omitimos: las medias en sistema inglés. La función no es útil para personas
que utilicen libras, pies y pulgadas.

¿Qué podemos hacer por ellos?

Escribimos dos funciones sencillas para convertir unidades del sistema inglés al sistema métrico.
Comencemos con las pulgadas.

Es bien conocido que  1 lb = 0.45359237 kg . Esto lo emplearemos en nuestra nueva función.

Esta función se llamará  lbakg :

def lbakg(lb):

return lb * 0.45359237

print(lbakg(1))

El resultado de la prueba es el siguiente:

0.45359237

Haremos lo mismo ahora con los pies y pulgadas:  1 pie = 0.3048 m , y  1 pulgada = 2.54 cm
= 0.0254 m .

La función se llamará  piepulgam :

def piepulgam(pie, pulgada):

return pie * 0.3048 + pulgada * 0.0254

print(piepulgam(1, 1))

El resultado de una prueba rápida es:

0.3302

Resulta como esperado.

Vamos a convertir seis pies a metros:

print(piespulgam(6, 0))

Esta es la salida:

1.8288000000000002

Es muy posible que en ocasiones se desee utilizar solo pies sin pulgadas. ¿Python nos ayudará? Por
supuesto que si.

Se ha modificado el código un poco:

def piepulgam(pie, pulgada = 0.0):

return pie * 0.3048 + pulgada * 0.0254

print(piepulgam(6))

Ahora el parámetro  pulgada  tiene como valor predeterminado el  0.0 .

El código produce la siguiente salida, esto es lo que se esperaba:

1.8288000000000002

Finalmente, el código es capaz de responder a la pregunta: ¿Cual es el IMC de una persona que tiene
5'7" de altura y un peso de 176 lbs?

Este es el código que debemos de escribir:

def piespulgam(pies, pulgadas = 0.0):

return pies * 0.3048 + pulgadas * 0.0254

 def lbsakg(lb):

return lb * 0.45359237

def imc(peso, altura):

if altura < 1.0 or altura > 2.5 or \

peso < 20 or peso > 200:

return None

return peso / altura ** 2

print(imc(peso = lbsakg(176), altura = piespulgam(5, 7)))

La respuesta es:

27.565214082533313

Ejecuta el código y pruébalo.







  Sandbox


Code
def imc(peso, altura):
if altura < 1.0 or altura > 2.5 or \
peso < 20 or peso > 200:
return None

return peso / altura ** 2

print(imc(352.5, 1.65))
 1
2
3
4
5
6
7
8
9
def imc(peso, altura):
if altura < 1.0 or altura > 2.5 or \
peso < 20 or peso > 200:
return None

return peso / altura ** 2

print(imc(352.5, 1.65))

 Console 

def imc(peso, altura):

if altura < 1.0 or altura > 2.5 or \

peso < 20 or peso > 200:

return None

return peso / altura ** 2

print(imc(352.5, 1.65))
Algunas funciones simples: continuación
Ahora trabajaremos con triángulos. Comenzaremos con una función que verifique si tres
lados de ciertas longitudes pueden formar un triángulo.

En la escuela aprendimos que la suma arbitraria de dos lados tiene que ser mayor que la
longitud del tercer lado.

No será algo difícil. La función tendrá tres parámetros - uno para cada lado.

Regresará  True  si todos los lados pueden formar un triángulo, y  False  de lo contrario. En
este caso,  esUnTringulo  es un buen nombre para dicha función.

Observa el código en el editor. Ahí se encuentra la función. Ejecuta el programa.

Parece que funciona perfectamente: estos son los resultados:

True
False

¿Se podrá hacer más compacta?. Parece tener demasiadas palabras.

Esta es la versión mas compacta:

def esUnTriangulo(a, b, c):

if a + b <= c or b + c <= a or \

c + a <= b:

return False

return True

print(esUnTriangulo(1, 1, 1))

print(esUnTriangulo(1, 1, 3))

¿Se puede compactar aun mas?

Por supuesto, observa:

def esUnTriangulo (a, b, c):

return a + b > c and b + c > a and c + a > b

print(esUnTriangulo (1, 1, 1))

print(esUnTriangulo (1, 1, 3))

Se ha negado la condición (se invirtieron los operadores relacionales y se reemplazaron

los  or s con  and s, obteniendo una expresión universal para probar triángulos).

Coloquemos la función en un programa más grande. Se le pedirá al usuario los tres

valores y se hará uso de la función.
def esUnTriangulo(a, b, c):

if a + b <= c:

return False

if b + c <= a:

return False

if c + a <= b:

return False

return True

print(esUnTriangulo (1, 1, 1))

print(esUnTriangulo (1, 1, 3))

Algunas funciones simples: triángulos y el teorema de

Pitágoras
Observa el código en el editor. Le pide al usuario tres valores. Después hace uso de la
función  esUnTriangulo . El código esta listo para correrse.
En el segundo paso, intentaremos verificar si un triángulo es un triángulo rectángulo.

Para ello haremos uso del Teorema de Pitágoras:

c2 = a2 + b2

¿Cómo saber cual de los tres lados es la hipotenusa?

La hipotenusa es el lado mas largo.

Aquí esta el código:

def esUnTriangulo(a, b, c):

return a + b > c and b + c > a and c + a > b

def esUnTrianguloRectangulo(a, b, c):

if not esUnTriangulo (a, b, c):

return False

if c > a and c > b:

return c ** 2 == a ** 2 + b ** 2

if a > b and a > c:

return a ** 2 == b ** 2 + c ** 2

print(esUnTrianguloRectangulo(5, 3, 4))

print(esUnTrianguloRectangulo(1, 3, 4))

Observa como se establece la relación entre la hipotenusa y los dos catetos. Se eligió el
lado mas largo y se aplico el Teorema de Pitágoras para verificar que todo estuviese en
orden. Esto requiere tres revisiones en total.

def esUnTriangulo(a, b, c):

return a + b > c and b + c > a and c + a > b

a = float(input("Ingresa la longitud del primer lado: "))

b = float(input("Ingresa la longitud del segundo lado: "))

c = float(input("Ingresa la longitud del tercer lado: "))

if esUnTriangulo(a, b, c):

print("Felicidades, puede ser un triángulo.")

else:

print("Lo siento, no puede ser un triángulo.")

Algunas funciones simples: evaluando el campo de un

triángulo
También es posible evaluar el campo de un triángulo. La Formula de Heron será útil
aquí:
Vamos a emplear el operador de exponenciación para calcular la raíz cuadrada - puede
ser extraño, pero funciona.

Este es el código resultante:

def esUnTriangulo(a, b, c):

return a + b > c and b + c > a and c + a > b

def heron(a, b, c):

p = (a + b + c) / 2

return (p * (p - a) * (p - b) * (p - c)) ** 0.5

def campoTriangulo(a, b, c):

if not esUnTriangulo(a, b, c):

return None

return heron(a, b, c)

print(campoTriangulo(1., 1., 2. ** .5))

Lo probaremos con un triángulo rectángulo la mitad de un cuadrado y con un lado igual a

1. Esto significa que su campo debe ser igual a 0.5.

Es extraño pero el código produce la siguiente salida:

0.49999999999999983

Es muy cercano a 0.5, pero no es exactamente 0.5,¿Que significa?, ¿Es un error?

No, no lo es. Son solo los cálculos de valores punto flotantes. Pronto se discutirá el
tema.

def esUnTriangulo(a, b, c):

return a + b > c and b + c > a and c + a > b

a = float(input("Ingresa la longitud del primer lado: "))

b = float(input("Ingresa la longitud del segundo lado: "))

c = float(input("Ingresa la longitud del tercer lado: "))

if esUnTriangulo(a, b, c):

print("Felicidades, puede ser un triángulo.")

else:

print("Lo siento, no puede ser un triángulo.")

Algunas funciones simples: factoriales

La siguiente función a definir calcula factoriales. ¿Recuerdas cómo se calcula un factorial?

0! = 1 (¡Si!, es verdad.)

1! = 1

2! = 1 * 2

3! = 1 * 2 * 3

4! = 1 * 2 * 3 * 4

n! = 1 * 2 ** 3 * 4 * ... * n-1 * n

Se expresa con un signo de exclamación, y es igual al producto de todos los números

naturales previos al argumento o número dado.
Escribamos el código. Creemos una función con el nombre  factorialFun . Aquí esta el
código:

def factorialFun(n):

if n < 0:

return None

if n < 2:

return 1

producto = 1

for i in range(2, n + 1):

producto *= i

return producto

for n in range(1, 6): # probando

print(n, factorialFun(n))

Observa como se sigue el procedimiento matemático, y como se emplea el

bucle  for  para encontrar el producto.

Estos son los resultados obtenidos de un código de prueba:

1 1

2 2

3 6

4 24

5 120

Algunas funciones simples: Serie Fibonacci

¿Estás familiarizado con la serie Fibonacci?

Son una secuencia de números enteros los cuales siguen una regla sencilla:

  El primer elemento de la secuencia es igual a uno (Fib1 = 1).
 El segundo elemento también es igual a uno (Fib2 = 1).
 Cada numero después de ellos son la suman de los dos números anteriores (Fibi =
Fibi-1 + Fibi-2).

Aquí están algunos de los primeros números en la serie Fibonacci:

fib1 = 1
fib2 = 1
fib3 = 1 + 1 = 2
fib4 = 1 + 2 = 3
fib5 = 2 + 3 = 5
fib6 = 3 + 5 = 8
fib7 = 5 + 8 = 13

¿Que opinas acerca de implementarlo como una función?

Creemos nuestra propia función  fib  y probémosla, aquí esta:

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

elem1 = elem2 = 1
sum = 0
for i in range(3, n + 1):
sum = elem1 + elem2
elem1, elem2 = elem2, sum
return sum

for n in range(1, 10): # probando

print(n, "->", fib(n))

Analiza el codigo del bucle  for  cuidadosamente, descifra como se mueven las
variables  elem1  y  elem2  a través de los números subsecuentes de la serie Fibonacci.

Al probar el código, se generan los siguientes resultados:

1 -> 1
2 -> 1
3 -> 2
4 -> 3
5 -> 5
6 -> 8
7 -> 13
8 -> 21
9 -> 34

Algunas funcione simples: recursividad

Existe algo mas que se desea mostrar: es la recursividad.

Este termino puede describir muchos conceptos distintos, pero uno de ellos, hace
referencia a la programación computacional.

Aquí, la recursividad es una técnica donde una función se invoca a si misma.

Tanto el factorial como la serie Fibonacci, son las mejores opciones para ilustrar este
fenómeno.

La serie de Fibonacci es un claro ejemplo de recursividad.

Fibi = Fibi-1 + Fibi-2

El número ith se refiere al número i-1, y así sucesivamente hasta llegar a los primeros dos.

¿Puede ser empleado en el código? Por supuesto que puede. Puede hacer el código mas
corto y claro.

La segunda versión de la función  fib()  hace uso directo de la recursividad:

def fib(n):

if n < 1:

return None

if n < 3:

return 1

return fib(n - 1) + fib(n - 2)

El código es mucho mas claro ahora.

¿Pero es realmente seguro?, ¿Implica algún riesgo?

Si, existe algo de riesgo. Si no se considera una condición que detenga las
invocaciones recursivas, el programa puede entrar en un bucle infinito. Se debe ser
cuidadoso.

El factorial también tiene un lado recursivo. Observa:

n! = 1 × 2 × 3 × ... × n-1 × n

Es obvio que:

1 × 2 × 3 × ... × n-1 = (n-1)!

Entonces, finalmente, el resultado es:

n! = (n-1)! × n

Esto se empleará en nuestra nueva solución.

Aquí esta:

def factorialFun(n):

if n < 0:

return None

if n < 2:

return 1

return n * factorialFun(n - 1)

¿Funciona? Claro que si. Pruébalo por ti mismo.

Nuestro viaje funcional esta por terminar. La siguiente sección abordara dos tipos de
datos en Python: tuplas y diccionarios.

def fib(n):

if n < 1:

return None

if n < 3:

return 1

elem1 = elem2 = 1

sum = 0

for i in range(3, n + 1):

sum = elem1 + elem2

elem1, elem2 = elem2, sum

return sum

for n in range(1, 10):

print(n, "->", fib(n))

Puntos Clave

1. Una función puede invocar otras funciones o incluso a sí misma. Cuando una función se invoca a si
misma, se le conoce como recursividad, y la función que se invoca a si misma y contiene una condición
de terminación (la cual le dice a la función que ya no siga invocándose a si misma) es llamada una
función recursiva.

2. Se pueden emplear funciones recursivas en Python para crear funciones limpias, elegantes, y dividir
el código en trozos más pequeños. Sin embargo, se debe tener mucho cuidado ya que es muy fácil
cometer un error y crear una función la cual nunca termine. También se debe considerar que las
funciones recursivas consumen mucha memoria, y por lo tanto pueden ser en ocasiones ineficientes.

Al emplear la recursividad, se deben de tomar en cuenta tanto sus ventajas como desventajas.
La función factorial es un ejemplo clásico de como se puede implementar el concepto de recursividad:

# Implementación recursiva de la función factorial

def factorial(n):

if n == 1: # la condición de terminación

return 1

else:

return n * factorial(n - 1)

print(factorial(4)) # 4 * 3 * 2 * 1 = 24

Ejercicio 1

¿Qué ocurrirá al intentar ejecutar el siguiente fragmento de código y porque?

def factorial(n):

return n * factorial(n - 1)

print(factorial(4))

Revisar

La función no tiene una condición de terminación, por lo tanto Python arrojara una excepción
( RecursionError: maximum recursion depth exceeded )

Ejercicio 2

¿Cuál es la salida del siguiente fragmento de código?

def fun(a):
 if a > 30:

return 3

else:

return a + fun(a + 3)

print(fun(25))

Revisar

56

Tipos de secuencias y mutabilidad

Antes de comenzar a hablar acerca de tuplas y diccionarios, se deben introducir dos conceptos
importantes: tipos de secuencia y mutabilidad.

Un tipo de secuencia es un tipo de dato en Python el cual es capaz de almacenar mas de un valor (o
ninguno si la secuencia esta vacía), los cuales pueden ser secuencialmente (de ahí el nombre)
examinados, elemento por elemento.

Debido a que el bucle  for  es una herramienta especialmente diseñada para iterar a través de las
secuencias, podemos definirlas de la siguiente manera: una secuencia es un tipo de dato que puede ser
escaneado por el bucle  for .

Hasta ahora, has trabajado con una secuencia en Python, la lista. La lista es un clásico ejemplo de una
secuencia de Python. Aunque existen otras secuencias dignas de mencionar, las cuales se presentaran a
continuación.

La segunda noción - la mutabilidad - es una propiedad de cualquier tipo de dato en Python que describe
su disponibilidad para poder cambiar libremente durante la ejecución de un programa. Existen dos tipos
de datos en Python: mutables e inmutables.

Los datos mutables pueden ser actualizados libremente en cualquier momento, a esta operación se
le denomina "in situ".

In situ es una expresión en Latín que se traduce literalmente como en posición, en el lugar o momento.
Por ejemplo, la siguiente instrucción modifica los datos "in situ":
list.append(1)

Los datos inmutables no pueden ser modificados de esta manera.

Imagina que una lista solo puede ser asignada y leída. No podrías adjuntar ni remover un elemento de la
lista. Si se agrega un elemento al final de la lista provocaría que la lista se cree desde cero.

Se tendría que crear una lista completamente nueva, la cual contenga los elementos ya existentes mas el
nuevo elemento.

El tipo de datos que se desea tratar ahora se llama tupla. Una tupla es una secuencia inmutable. Se
puede comportar como una lista pero no puede ser modificada en el momento.

¿Qué es una tupla?

Lo primero que distingue una lista de una tupla es la sintaxis empleada para crearlas. Las tuplas utilizan
paréntesis, mientras que las listas usan corchetes, aunque también es posible crear una tupla tan solo
separando los valores por comas.

Observa el ejemplo:

tupla1 = (1, 2, 4, 8)

tupla2 = 1., .5, .25, .125

Se definieron dos tuplas, ambas contienen cuatro elementos.

A continuación se imprimen en consola:

print(tupla1)

print(tupla2)

Esto es lo que se muestra en consola:

(1, 2, 4, 8)

(1.0, 0.5, 0.25, 0.125)

Nota: cada elemento de una tupla puede ser de distinto tipo (punto flotante, entero, cadena, etc.).
¿Cómo crear una tupla?
¿Es posible crear una tupla vacía? Si, solo se necesitan unos paréntesis:

tuplaVacia = ()

Si se desea crear una tupla de un solo elemento, se debe de considerar el hecho de que, debido a la
sintaxis (una tupla debe de poder distinguirse de un valor entero ordinario), se debe de colocar una coma
al final:

tuplaUnElemento1 = (1, )

tuplaUnElemento2 = 1.,

El quitar las comas no arruinará el programa en el sentido sintáctico, pero serán variables no tuplas.

¿Cómo utilizar un tupla?

Si deseas leer los elementos de una tupla, lo puedes hacer de la misma manera que se
hace con las listas.

Observa el código en el editor.

El programa debe de generar la siguiente salida, ejecútalo y comprueba:

1000

(10, 100, 1000)

(1, 10)

10

100

1000
Las similitudes pueden ser engañosas - no intentes modificar en contenido de la
tupla ¡No es una lista!

Todas estas instrucciones (con excepción de primera) causarán un error de ejecución :

miTupla = (1, 10, 100, 1000)

miTupla.append(10000)

del miTupla[0]

miTupla[1] = -10

Este es el mensaje que Python arrojará en la ventana de consola:

AttributeError: 'tuple' object has no attribute 'append'

miTupla = (1, 10, 100, 1000)

print(miTupla[0])

print(miTupla[-1])

print(miTupla[1:])

print(miTupla[:-2])

for elem in miTupla:

print(elem)
¿Cómo utilizar una tupla? continuación
¿Qué más pueden hacer las tuplas?

 La función  len()  acepta tuplas, y regresa el numero de elementos contenidos

dentro.
 El operador  +  puede unir tuplas (ya se ha mostrado esto antes).
 El operador  *  puede multiplicar las tuplas, así como las listas.
 Los operadores  in  y  not in  funcionan de la misma manera que en las listas.

El fragmento de código en el editor presenta todo esto.

La salida es la siguiente:

9
(1, 10, 100, 1000, 10000)
(1, 10, 100, 1, 10, 100, 1, 10, 100)
True
True

Una de las propiedades de las tuplas mas útiles es que pueden aparecer en el lado
izquierdo del operador de asignación. Este fenómeno ya se vio con anterioridad,
cuando fue necesario encontrar una manera de intercambiar los valores entre dos
variables.
Observa el siguiente fragmento de código:

var = 123

t1 = (1, )
t2 = (2, )
t3 = (3, var)

t1, t2, t3 = t2, t3, t1

print(t1, t2, t3)

Muestra tres tuplas interactuando en efecto, los valores almacenados en ellas "circulan"
entre ellas.  t1  se convierte en  t2 ,  t2  se convierte en  t3 , y  t3  se convierte en  t1 .

Nota: el ejemplo presenta un importante hecho mas: los elementos de una tupla

pueden ser variables, no solo literales. Además, pueden ser expresiones si se
encuentran en el lado derecho del operador de asignacion.

miTupla = (1, 10, 100)

t1 = miTupla + (1000, 10000)

t2 = miTupla * 3

print(len(t2))

print(t1)

print(t2)

print(10 in miTupla)

print(-10 not in miTupla)

¿Qué es un diccionario?
El diccionario es otro tipo de estructura de datos de Python. No es una secuencia (pero puede adaptarse
fácilmente a un procesamiento secuencial) y además es mutable.

Para explicar lo que es un diccionario en Python, es importante comprender de manera literal lo que es
un diccionario.

Un diccionario en Python funciona de la misma manera que un diccionario bilingüe. Por ejemplo, se
tiene la palabra en español "gato" y se necesita su equivalente en francés. Lo que se haría es buscar en el
diccionario para encontrar la palabra "gato". Eventualmente la encontrarás, y sabrás que la palabra
equivalente en francés es "chat".
En el mundo de Python, la palabra que se esta buscando se denomina  clave(key) . La palabra que se
obtiene del diccionario es denominada  valor .

Esto significa que un diccionario es un conjunto de pares de claves y valores. Nota:

 Cada clave debe de ser única. No es posible tener una clave duplicada.

 Una clave puede ser un tipo de dato de cualquier tipo: puede ser un número (entero o
flotante), o incluso una cadena.
 Un diccionario no es una lista. Una lista contiene un conjunto de valores numerados, mientras
que un diccionario almacena pares de valores.
 La función  len()  aplica también para los diccionarios, regresa la cantidad de pares (clave-
valor) en el diccionario.
 Un diccionario es una herramienta de un solo sentido. Si fuese un diccionario español-
francés, podríamos buscar en español para encontrar su contraparte en francés mas no viceversa.

A continuación veamos algunos ejemplos:

¿Cómo crear un diccionario?
Si deseas asignar algunos pares iniciales a un diccionario, utiliza la siguiente sintaxis:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

numerosTelefono = {'jefe' : 5551234567, 'Suzy' : 22657854310}

diccionarioVacio = {}

print(dict)

print(numerosTelefono)

print(diccionarioVacio)

En este primer ejemplo, el diccionario emplea claves y valores las cuales ambas son cadenas. En el
segundo, las claves con cadenas pero los valores son enteros. El orden inverso (claves → números,
valores → cadenas) también es posible, así como la combinación número a número.

La lista de todos los pares es encerrada con llaves, mientras que los pares son separados por comas, y
las claves y valores por dos puntos.

El primer diccionario es muy simple, es un diccionario Español-Francés. El segundo es un directorio

telefónico muy pequeño.

Los diccionarios vacíos son construidos por un par vacío de llaves - nada inusual.

El diccionario entero se puede imprimir con una invocación a la función  print() . El fragmento de
código puede producir la siguiente salida:

{'perro': 'chien', 'caballo': 'cheval', 'gato': 'chat'}

{'Suzy': 5557654321, 'boss': 5551234567}

{}

¿Has notado que el orden de los pares impresos es diferente a la asignación inicial?, ¿Qué significa esto?

Primeramente, recordemos que los diccionarios no son listas - no guardan el orden de sus datos, el
orden no tiene significado (a diferencia de los diccionarios reales). El orden en que un
diccionario almacena sus datos esta fuera de nuestro control. Esto es normal. (*)
NOTA

(*) En Python 3.6x los diccionarios se han convertido en colecciones ordenadas de manera

predeterminada. Tu resultado puede variar dependiendo en la versión de Python que se este utilizando.

¿Cómo utilizar un diccionario?

Si deseas obtener cualquiera de los valores, debes de proporcionar una clave válida:

print(dict['gato'])
print(numerosTelefono['Suzy'])

El obtener el valor de un diccionario es semejante a la indexación, gracias a los corchetes

alrededor del valor de la clave.

Nota:

 Si una clave es una cadena, se tiene que especificar como una cadena.
 Las claves son sensibles a las mayúsculas y minúsculas:  'Suzy'  sería diferente
a  'suzy' .

El fragmento de código da las siguientes salidas:

chat
5557654321

Ahora algo muy importante: No se puede utilizar una clave que no exista. Hacer algo
como lo siguiente:

print(numerosTelefono['presidente'])

Provocará un error de ejecución. Inténtalo.

Afortunadamente, existe una manera simple de evitar dicha situación. El operador  in ,

junto con su acompañante,  not in , pueden salvarnos de esta situación.

El siguiente código busca de manera segura palabras en francés:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}
words = ['gato', 'leon', 'caballo']

for word in words:

if word in dict:
print(word, "->", dict[word])
else:
print(word, "no está en el diccionario")

La salida del código es la siguiente:

gato -> chat

leon no está en el diccionario
caballo -> cheval

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

numerosTelefono = {'jefe' : 5551234567, 'Suzy' : 22657854310}

diccionarioVacio = {}

###
¿Cómo utilizar un diccionario? El método keys()
¿Pueden los diccionarios ser examinados utilizando el bucle  for , como las listas o tuplas?

No y si.

No, porque un diccionario no es un tipo de dato secuencial - el bucle  for  no es útil aquí.

Si, porque hay herramientas simples y muy efectivas que pueden adaptar cualquier
diccionario a los requerimientos del bucle  for  (en otras palabras, se construye un
enlace intermedio entre el diccionario y una entidad secuencial temporal).

El primero de ellos es un método denominado  keys() , el cual es parte de todo

diccionario. El método retorna o regresa una lista de todas las claves dentro del
diccionario. Al tener una lista de claves se puede acceder a todo el diccionario de una
manera fácil y útil.

A continuación se muestra un ejemplo:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for key in dict.keys():

print(key, "->", dict[key]

El código produce la siguiente salida:

caballo -> cheval

perro -> chien

gato -> chat

La función sorted()
¿Deseas que la salida este ordenada? Solo hay que agregar al bucle  for  lo siguiente:

for key in sorted(dict.keys()):

La función  sorted()  hará su mejor esfuerzo y la salida será la siguiente:

caballo -> cheval

gato -> chat

perro -> chien

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for key in dict.keys():

print(key, "->", dict[key])

¿Cómo utilizar un diccionario? Los

métodos item() y values()
Otra manera de hacerlo es utilizar el método  items() . Este método regresa una lista de tuplas (este
es el primer ejemplo en el que las tuplas son mas que un ejemplo de si mismas) donde cada tupla es un
par de cada clave con su valor.

Así es como funciona:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

 for spanish, french in dict.items():

print(spanish, "->", french)

Nota la manera en que la tupla ha sido utilizada como una variable del bucle  for .

El ejemplo imprime lo siguiente:

cat -> chat

dog -> chien

horse -> cheval

También existe un método denominado  values() , funciona de manera muy similar al de  keys() ,
pero regresa una lista de valores.

Este es un ejemplo sencillo:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for french in dict.values():

print(french)

Como el diccionario no es capaz de automáticamente encontrar la clave de un valor dado, el rol de este
método es algo limitado.

Esta es la salida esperada:

cheval

chien

chat
 







  Sandbox


 Code
dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for spanish, french in dict.items():

print(spanish, "->", french)

1
2
3
4
5
dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}
for spanish, french in dict.items():
print(spanish, "->", french)

 Console 


dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for spanish, french in dict.items():

print(spanish, "->", french)

¿Cómo utilizar un diccionario? Modificar, agregar y
eliminar valores
El asignar un nuevo valor a una clave existente es sencillo, debido a que los diccionarios
son completamente mutables, no existen obstáculos para modificarlos.

Se va a reemplazar el valor  "chat"  por  "minou" , lo cual no es muy adecuado, pero

funcionará con nuestro ejemplo.

Observa:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

dict['gato'] = 'minou'

print(dict)

La salida es:

{'perro': 'chien', 'caballo': 'cheval', 'gato': 'minou'}

Agregando nuevas claves
El agregar una nueva clave con su valor a un diccionario es tan simple como cambiar un
valor. Solo se tiene que asignar un valor a una nueva clave que no haya existido antes.

Nota: este es un comportamiento muy diferente comparado a las listas, las cuales no
permiten asignar valores a índices no existentes.

A continuación se agrega un par nuevo al diccionario, un poco extraño pero valido:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

dict['cisne'] = 'cygne'

print(dict)

El ejemplo muestra como salida:

{'cisne': 'cygne', 'caballo': 'cheval', 'perro': 'chien', 'gato':

'chat'}

EXTRA

También es posible insertar un elemento al diccionario utilizando el método  update() ,

por ejemplo:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

dict.update({"pato" : "canard"})

print(dict)

Eliminado claves
¿Puedes deducir como eliminar una clave de un diccionario?

Nota: al eliminar la clave también se removerá el valor asociado. Los valores no

pueden existir sin sus claves.
Esto se logra con la instrucción  del .

A continuación un ejemplo:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

del dict['perro']

print(dict)

Nota: el eliminar una clave no existente, provocará un error.

El ejemplo da como salida:

{'gato': 'chat', 'caballo': 'cheval'}

EXTRA

Para eliminar el ultimo elemento de la lista, se puede emplear el método  popitem() :

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

dict.popitem()

print(dict) # outputs: {'gato' : 'chat', 'perro' : 'chien'}

En versiones anteriores de Python, por ejemplo, antes de la 3.6.7, el

método  popitem()  elimina un elemento al azar del diccionario.

dict = {"gato" : "perro", "dog" : "chien", "caballo" : "cheval"}

dict['gato'] = 'minou'

print(dict)
Las tuplas y los diccionarios pueden trabajar juntos
Se ha preparado un ejemplo sencillo, mostrando como las tuplas y los diccionarios pueden trabajar
juntos.

Imaginemos el siguiente problema:

 Necesitas un programa para calcular los promedios de tus alumnos.

 El programa pide el nombre del alumno seguido de su calificación.
 Los nombres son ingresados en cualquier orden.
 El ingresar la palabra exit da por terminado el ingreso de nombres.
 Una lista con todos los nombre y el promedio de cada alumno debe ser mostrada al final.

Observa el código en el editor, se muestra la solución.

Ahora se analizará línea por línea:

 Línea 1: crea un diccionario vacío para ingresar los datos: el nombre del alumno es empleado
como clave, mientras que todas las calificaciones asociadas son almacenadas en una tupla (la
tupla puede ser el valor de un diccionario, esto no es un problema).
 Línea 3: se ingresa a un bucle "infinito" (no te preocupes, saldrémos de el en el momento
indicado).
 Línea 4: se lee el nombre del alumno.
 Línea 5-6: si el nombre es  exit , nos salimos del bucle.
 Línea 8: se pide la calificación del alumno (un valor entero en el rango del 1-10).
 Línea 10-11: si el nombre del estudiante ya se encuentra en el diccionario, se alarga la tupla
asociada con la nueva calificación (observa el operador +=).
  Línea 12-13: si el estudiante es nuevo (desconocido para el diccionario), se crea una entrada
nueva, su valor es una tupla de un solo elemento la cual contiene la calificación ingresada.
 Línea 15: se itera a través de los nombres ordenados de los estudiantes.
 Línea 16-17: inicializa los datos necesarios para calcular el promedio (sumador y contador).
 Línea 18-20: Se itera a través de la tupla, tomado todas las calificaciones subsecuentes y
actualizando la suma junto con el contador.
 Línea 21: se calcula e imprime el promedio del alumno junto con su nombre.

Este es un ejemplo del programa:

Ingresa el nombre del estudiante (o exit para detenerse): Bob

Ingresa la calificación del alumno (0-10): 7
Ingresa el nombre del estudiante (o exit para detenerse): Andy
Ingresa la calificación del alumno (0-10): 3
Ingresa el nombre del estudiante (o exit para detenerse): Bob
Ingresa la calificación del alumno (0-10): 2
Ingresa el nombre del estudiante (o exit para detenerse): Andy
Ingresa la calificación del alumno (0-10): 10
Ingresa el nombre del estudiante (o exit para detenerse): Andy
Ingresa la calificación del alumno (0-10): 3
Ingresa el nombre del estudiante (o exit para detenerse): Bob
Ingresa la calificación del alumno (0-10): 9
Ingresa el nombre del estudiante (o exit para detenerse): exit
Andy : 5.333333333333333
Bob : 6.0

grupo = {}

while True:

nombre = input("Ingresa el nombre del estudiante (o exit para detenerse): ")

if nombre == 'exit':

break

calif = int(input("Ingresa la calificación del alumno (0-10): "))

if nombre in grupo:

grupo[nombre] += (calif,)

else:

grupo[nombre] = (calif,)
for nombre in sorted(grupo.keys()):

sum = 0

contador = 0

for calif in grupo[nombre]:

sum += calif

contador += 1

print(nombre, ":", sum / contador)

Puntos Clave: Tuplas

1. Las Tuplas son colecciones de datos ordenadas e inmutables. Se puede pensar en ellas como listas
inmutables. Se definen con paréntesis:

miTupla = (1, 2, True, "una cadena", (3, 4), [5, 6], None)

print(miTupla)
miLista = [1, 2, True, "una cadena", (3, 4), [5, 6], None]

print(miLista)

Cada elemento de la tupla puede ser de un tipo de dato diferente (por ejemplo, enteros, cadenas,
boleanos, etc.). Las tuplas pueden contener otras tuplas o listas (y viceversa).

2. Se puede crear una tupla vacía de la siguiente manera:

tuplaVacia = ()

print(type(tuplaVacia)) # salida: <class 'tuple'>

3. La tupla de un solo elemento se define de la siguiente manera:

tuplaUnElemento = ("uno", ) # paréntesis y coma

tuplaUnElemento2 = "uno", # sin paréntesis, solo la coma

Si se elimina la coma, Python creará una variable no una tupla:

miTup1 = 1,

print(type(miTup1)) # salida: <class 'tuple'>

miTup2 = 1

print(type(miTup2)) # salida: <class 'int'>

4. Se pueden acceder los elementos de la tupla al indexarlos:

miTupla = (1, 2.0, "cadena", [3, 4], (5, ), True)

print(miTupla[3]) # salida: [3, 4]

5. Las tuplas son inmutables, lo que significa que no se puede agregar, modificar, cambiar o quitar
elementos. El siguiente fragmento de código provocará una excepción:

miTupla = (1, 2.0, "cadena", [3, 4], (5, ), True)

miTupla[2] = "guitarra" # se levanta una excepción TypeError

Sin embargo, se puede eliminar la tupla completa:

miTupla = 1, 2, 3,

del miTupla

print(miTupla) # NameError: name 'miTupla' is not defined

6. Puedes navegar a través de los elementos de una tupla con un bucle (Ejemplo 1), verificar si un
elemento o no esta presente en la tupla (Ejemplo 2), emplear la función  len()  para verificar cuantos
elementos existen en la tupla (Ejemplo 3), o incluso unir o multiplicar tuplas (Ejemplo 4):

# Ejemplo 1

t1 = (1, 2, 3)

for elem in t1:

print(elem)

# Ejemplo 2

t2 = (1, 2, 3, 4)

print(5 in t2)

print(5 not in t2)

# Ejemplo 3

t3 = (1, 2, 3, 5)

print(len(t3))

# Ejemplo 4

t4 = t1 + t2

t5 = t3 * 2

print(t4)
print(t5)

EXTRA

También se puede crear una tupla utilizando la función integrada de Python  tuple() . Esto es
particularmente útil cuando se desea convertir un iterable (por ejemplo, una lista, rango, cadena,
etcétera) en una tupla:

miTup = tuple((1, 2, "cadena"))

print(miTup)

lst = [2, 4, 6]

print(lst) # salida: [2, 4, 6]

print(type(lst)) # salida: <class 'list'>

tup = tuple(lst)

print(tup) # outputs: (2, 4, 6)

print(type(tup)) # salida: <class 'tuple'>

De la misma manera, cuando se desea convertir un iterable en una liste, se puede emplear la función
integrada de Python denominada  list() :

tup = 1, 2, 3,

lst = list(tup)

print(type(lst)) # outputs: <class 'list'>

Puntos Clave: diccionarios

1. Los diccionarios son *colecciones indexadas de datos, mutables y desordenadas. (*En

Python 3.6x los diccionarios están ordenados de manera predeterminada.

Cada diccionario es un par de clave : valor. Se puede crear empleado la siguiente sintaxis:
miDictionario = {

clave1 : valor1,

clave2 : valor2,

clave3 : valor3,

2. Si se desea acceder a un elemento del diccionario, se puede hacer haciendo referencia

a su clave colocándola dentro de corchetes (ejemplo 1) o utilizando el
método  get()  (ejemplo 2):

polEspDict = {

"kwiat" : "flor",

"woda" : "agua",

"gleba" : "tierra"

elemento1 = polEspDict["gleba"] # ejemplo 1

print(elmento1) # salida: tierra

elemento2 = polEspDict.get("woda")

print(elemento2) # salida: agua

3. Si se desea cambiar el valor asociado a una clave especifica, se puede hacer haciendo
referencia a la clave del elemento, a continuación se muestra un ejemplo:

polEspDict = {

"zamek" : "castillo",

"woda" : "agua",

"gleba" : "tierra"

polEspDict["zamek"] = "cerradura"
item = polEspDict["zamek"] # salida: cerradura

4. Para agregar o eliminar una clave (junto con su valor asociado), emplea la siguiente
sintaxis:

miDirectorioTelefonico = {} # un diccionario vacio

miDirectorioTelefonico ["Adan"] = 3456783958 # crear o añadir un

par clave-valor

print(miDirectorioTelefonico) # salida: {'Adan': 3456783958}

del miDirectorioTelefonico ["Adan"]

print(miDirectorioTelefonico) # salida: {}

Además, se puede insertar un elemento a un diccionario utilizando el método  update() ,

y eliminar el ultimo elemento con el método  popitem() , por ejemplo:

polEspDict = {"kwiat" : "flor"}

polEspDict = update("gleba" : "tierra")

print(polEspDict) # salida: {'kwiat' : 'flor', 'gleba' : 'tierra'}

polEspDict.popitem()

print(polEspDict) # outputs: {'kwiat' : 'flor'}

5. Se puede emplear el bucle  for  para iterar a través del diccionario, por ejemplo:

polEspDict = {

"zamek" : "castillo",

"woda" : "agua",

"gleba" : "tierra"

}
for item in polEspDict:

print(item) # salida: zamek

# woda

# gleba

Puntos Claves: Tuplas y diccionarios

Ejercicio 1

¿Que ocurrirá cuando se intente ejecutar el siguiente código?

miTup = (1, 2, 3)

print(miTup[2])

Revisar

El programa imprimirá  3  en pantalla.

Ejercicio 2

¿Cuál es la salida del siguiente fragmento de código?

tup = 1, 2, 3

a, b, c = tup

print(a * b * c)

Revisar

El programa imprimirá  6  en pantalla. Los elementos de la tupla  tup  han sido "desempaquetados" en las
variables  a ,  b , y  c .
Ejercicio 3

Completa el código para emplear correctamente el método  count()  para encontrar la cantidad
de  2  duplicados en la tupla siguiente.

tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9

duplicados = # tu código

print(duplicados) # salida: 4

Revisar

tup = 1, 2, 3, 2, 4, 5, 6, 2, 7, 2, 8, 9

duplicates = tup.count(2)

print(duplicado) # salida: 4

Ejercicio 4

Escribe un programa que "una" los dos diccionarios ( d1  y  d2 ) para crear uno nuevo ( d3 ).

d1 = {'Adam Smith':'A', 'Judy Paxton':'B+'}

d2 = {'Mary Louis':'A', 'Patrick White':'C'}

d3 = {}

for elemento in (d1, d2):

# tu código

print(d3)

Revisar
Solución Muestra:
d1 = {'Adam Smith':'A', 'Judy Paxton':'B+'}

d2 = {'Mary Louis':'A', 'Patrick White':'C'}

d3 = {}

for elemento in (d1, d2):

d3.update(elemento)

print(d3)

Ejercicio 5

Escribe un programa que convierta la lista  l  en una tupla.

l = ["carro", "Ford", "flor", "Tulipán"]

t = # tu código

print(t)

Revisar

Solución muestra:
l = ["carro", "Ford", "flor", "Tulipán"]

t = tuple(l)

print(t)
Ejercicio 6

Escribe un programa que convierta la tupla  colores  en un diccionario.

colores = (("verde", "#008000"), ("azul", "#0000FF"))

# tu código

print(colDict)

Revisar

Solución Muestra:
colores = (("verde", "#008000"), ("azul", "#0000FF"))

colDict = dict(colores)

print(colDict)

Ejercicio 7

¿Que ocurrirá cuando se ejecute el siguiente código?

miDict = {"A":1, "B":2}

copyMiDict = myDict.copy()

miDict.clear()

print(copyMiDict)

Revisar

El programa mostrará  {'A': 1, 'B': 2}  en pantalla

Ejercicio 8
¿Cuál es la salida del siguiente programa?

colores = {

"blanco" : (255, 255, 255),

"gris" : (128, 128, 128),

"rojo" : (255, 0, 0),

"verde" : (0, 128, 0)

for col, rgb in colores.items():

print(col, ":", rgb)

Revisar

blanco : (255, 255, 255)

gris : (128, 128, 128)

rojo : (255, 0, 0)

verde : (0, 128, 0)

Tiempo estimado
30-60 minutos

Nivel de dificultad
Medio/difícil

Objetivos
 Perfeccionar las habilidades del estudiante al emplear Python para resolver problemas
complejos.
 La integración de técnicas de programación en un solo programa consistente de varias partes.
Escenario
Tu tarea es escribir un simple programa que simule jugar a tic-tac-toe (nombre en inglés) con el
usuario. Para hacerlo más fácil, Hemos decidido simplificar el juego. Aquí están nuestras reglas:

 La maquina (por ejemplo, el programa) jugará utilizando las  'X' s.

 El usuario (por ejemplo, tu) jugará utilizando las  'O' s.
 El primer movimiento es de la maquina: siempre coloca una  'X'  en el centro del tablero.
 Todos los cuadros están numerados comenzando con el  1  (observa el ejemplo para que tengas
una referencia).
 El usuario ingresa su movimiento introduciendo el numero de cuadro elegido. El numero debe
de ser valido, por ejemplo un valor entero mayor que  0  y menor que  10 , y no puede ser un
cuadro que ya esté ocupado.
 El programa verifica si el juego ha terminado. Existen cuatro posibles veredictos: el juego
continua, el juego termina en empate, tu ganas, o la maquina gana.
 La maquina responde con su movimiento y se verifica el estado del juego.
 No se debe implementar algún tipo de inteligencia artificial, la maquina elegirá un cuadro de
manera aleatoria, eso es suficiente para este juego.

El ejemplo del programa es el siguiente:

+-------+-------+-------+

| | | |

| 1 | 2 | 3 |

| | | |

+-------+-------+-------+

| | | |

| 4 | X | 6 |

| | | |

+-------+-------+-------+

| | | |

| 7 | 8 | 9 |

| | | |

+-------+-------+-------+

Ingresa tu movimiento: 1

+-------+-------+-------+

| | | |
| O | 2 | 3 |

| | | |

+-------+-------+-------+

| | | |

| 4 | X | 6 |

| | | |

+-------+-------+-------+

| | | |

| 7 | 8 | 9 |

| | | |

+-------+-------+-------+

+-------+-------+-------+

| | | |

| O | X | 3 |

| | | |

+-------+-------+-------+

| | | |

| 4 | X | 6 |

| | | |

+-------+-------+-------+

| | | |

| 7 | 8 | 9 |

| | | |

+-------+-------+-------+

Ingresa tu movimiento: 8

+-------+-------+-------+

| | | |

| O | X | 3 |

| | | |
+-------+-------+-------+

| | | |

| 4 | X | 6 |

| | | |

+-------+-------+-------+

| | | |

| 7 | O | 9 |

| | | |

+-------+-------+-------+

+-------+-------+-------+

| | | |

| O | X | 3 |

| | | |

+-------+-------+-------+

| | | |

| 4 | X | X |

| | | |

+-------+-------+-------+

| | | |

| 7 | O | 9 |

| | | |

+-------+-------+-------+

Ingresa tu movimiento: 4

+-------+-------+-------+

| | | |

| O | X | 3 |

| | | |

+-------+-------+-------+

| | | |
| O | X | X |

| | | |

+-------+-------+-------+

| | | |

| 7 | O | 9 |

| | | |

+-------+-------+-------+

+-------+-------+-------+

| | | |

| O | X | X |

| | | |

+-------+-------+-------+

| | | |

| O | X | X |

| | | |

+-------+-------+-------+

| | | |

| 7 | O | 9 |

| | | |

+-------+-------+-------+

Ingresa tu movimiento: 7

+-------+-------+-------+

| | | |

| O | X | X |

| | | |

+-------+-------+-------+

| | | |

| O | X | X |

| | | |
+-------+-------+-------+

| | | |

| O | O | 9 |

| | | |

+-------+-------+-------+

¡Has Ganado!

Requerimientos
Implementa las siguientes características:

 El tablero debe ser almacenado como una lista de tres elementos, mientras que cada elemento es
otra lista de tres elementos (la lista interna representa las filas) de manera que todos los cuadros
puedas ser accedidos empleado la siguiente sintaxis:

board[fila][columna]

 Cada uno de los elementos internos de la lista puede contener  'O' ,  'X' , o un digito
representando el número del cuadro (dicho cuadro se considera como libre).
 La apariencia de tablero debe de ser igual a la presentada en el ejemplo.
 Implementa las funciones definidas para ti en el editor.

Para obtener un valor numérico aleatorio se puede emplear una función integrada de Python
denominada  randrange() . El siguiente ejemplo muestra como utilizarla (El programa imprime 10
números aleatorios del 1 al 8).

Nota: La instrucción  from-import  provee acceso a la función  randrange  definida en un módulo

externo de Python denominado  random .

from random import randrange

for i in range(10):

print(randrange(8))
def DisplayBoard(board):

# la función acepta un parámetro el cual contiene el estado actual del tablero

# y lo muestra en la consola

def EnterMove(board):

# la función acepta el estado actual del tablero y pregunta al usuario acerca de su movimiento,

# verifica la entrada y actualiza el tablero acorde a la decisión del usuario

def MakeListOfFreeFields(board):

# la función examina el tablero y construye una lista de todos los cuadros vacíos

# la lista esta compuesta por tuplas, cada tupla es un par de números que indican la fila y columna

def VictoryFor(board, sign):

# la función analiza el estatus del tablero para verificar si

# el jugador que utiliza las 'O's o las 'X's ha ganado el juego

def DrawMove(board):

# la función dibuja el movimiento de la maquina y actualiza el tablero

#
¡Felicidades, has completado el Módulo 4!

¡Bien hecho! Has llegado al final del Módulo 4 y también has terminado una parte importante de tu
educación sobre programación en Python. A continuación se presenta un corto resumen de los objetivos
cubiertos en el módulo:

 La declaración y uso de funciones, su propósito, y sus usos.

 El concepto de cómo pasar argumentos de diferentes maneras y como colocarles valores
predeterminados junto con los mecanismos para que la función retorne o regrese resultados.
 El alcance de los nombres de variables.
 Nuevos tipos de datos: tuplas y diccionarios, y su rol en el procesamiento de datos.

Ahora estas listo para tomar el quiz del módulo e intentar el desafío final: Examen del Módulo 4, el cual
te ayudará a determinar que tanto has aprendido hasta ahora.
¡Felicidades!
Has completado la Parte 1 del curso:  Fundamentos de
Programación en Python.

¡Bien hecho! Has llegado al final de la Parte 1 del Curso: Fundamentos de Programación en Python, y
has completado una parte importante de tu educación sobre la programación en Python.

Ahora estas listo para tomar el examen de certificación PCEP - Programador Certificado en Python
Nivel Básico, el cual es un paso que te acerca a la certificación PCAP - Programador Certificado en
Python Nivel Asociado así como el comenzar una carrera en el desarrollo de software, la programación
en Python y tecnologías relacionadas.