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
¿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í.

untos 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

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

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.

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)

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

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

SyntaxError  - a non-default argument ( c ) follows a default argument ( b=2 )

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.

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 .

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.

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):
if year%4==0 and (not year%100==0 or year%400==0):
return True

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

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

def isPrime(num):
EsPrimo=True
for x in range(2, num):
if num%x==0:
EsPrimo=False
break
return EsPrimo

for i in range(1, 20):

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

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

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

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

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))

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

2
Esto debe de ser suficiente evidencia para mostrar lo que la palabra reservada  global  puede hacer.

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

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.

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

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

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

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'

¿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

¿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

¿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

¿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

¿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

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.

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

6. Si deseas examinar los elementos (claves y valores) del diccionario, puedes emplear el método  items()  por ejemplo:

polEspDict = {

"zamek" : "castillo",

"woda" : "agua",

"gleba" : "tierra"

for clave, valor in polEspDict.items():

print("Pol/Esp ->", clave, ":", valor)

7. Para comprobar si una clave existe en un diccionario, se puede emplear la palabra reservada  in :

polEspDict = {

"zamek" : "castillo",

"woda" : "agua",

"gleba" : "tierra"

if "zamek" in polEspDict:

print("SI")

else:

print("NO")

8. Se puede emplear la palabra reservada  del  para eliminar un elemento, o un diccionario entero. Para eliminar todos los
elementos de un diccionario se debe emplear el método  clear() :

polEspDict = {

"zamek" : "castillo",

"woda" : "agua",
 "gleba" : "tierra"

print(len(polEspDict)) # salida: 3

del polEspDict["zamek"] # elimina un elemento

print(len(polEspDict)) # salida: 2

polEspDict.clear() # elimina todos los elementos

print(len(polEspDict)) # salida: 0

del polEspDict # elimina el diccionario

9. Para copiar un diccionario, emplea el método  copy() :

polEspDict = {

"zamek" : "castillo",

"woda" : "agua",

"gleba" : "tierra"

copyDict = polEspDict.copy()

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)