TUTORIAL 3

Lenguaje de programación: Python

Autor: José Gerardo Carrillo González

Contenido:
Objetos mutables e inmutables....................................................................................................................2
Ejemplo 1.................................................................................................................................................4
Funciones.....................................................................................................................................................6
Ejemplo 2.................................................................................................................................................6
Ejemplo 3.................................................................................................................................................8
Ejemplo 4...............................................................................................................................................10
Ejemplo 5...............................................................................................................................................10
Ejemplo 6...............................................................................................................................................11
Sentencia return......................................................................................................................................11
Ejemplo 7...........................................................................................................................................12
Variables globales y locales...................................................................................................................13
Ejemplo 8...........................................................................................................................................13
Parámetro especial *args........................................................................................................................15
Ejemplo 9...........................................................................................................................................15
Parámetro especial **kwargs.................................................................................................................16
Ejemplo 10.........................................................................................................................................16
Recursividad...........................................................................................................................................18
Ejemplo 11.........................................................................................................................................18
Función lambda......................................................................................................................................20
Módulos.....................................................................................................................................................21
Ejemplo 12.............................................................................................................................................21
Tarea..........................................................................................................................................................23
Tarea 1....................................................................................................................................................23
Tarea 2....................................................................................................................................................23

1
 Tarea 3....................................................................................................................................................23
Tarea 4....................................................................................................................................................24
Referencias................................................................................................................................................25

Objetos mutables e inmutables

En Python tenemos objetos mutables e inmutables. Los objetos de clase bool (booleano), int (número
entero), float (número flotante), str (secuencia de texto), tuple (secuencia de objetos), son inmutables.
Los objetos de clase list (lista), set (conjunto), dict (diccionario), son mutables. Un objeto mutable es
aquel que una vez definido le podemos hacer cambios y su identidad seguirá siendo la misma, por lo que
a pesar de las modificaciones continúa siendo el mismo objeto; un cambio puede ser agregar o eliminar
objetos, o reemplazar un objeto por otro. A un objeto inmutable no se le pueden hacer cambios. Un
objeto inmutable puede contener referencias a objetos mutables, por lo que estos pueden cambiar, sin
embargo, la colección de objetos a los que directamente hace referencia el objeto inmutable no puede
cambiar.

La identidad de un objeto es un número entero, único y constante durante el tiempo de vida del objeto,
se obtiene mediante la función id. Ejemplo:

>>> x=1
>>> y=x
>>> id(x)
2957801160944
>>> id(y)
2957801160944

Ambos identificadores (o nombres) tienen la misma identidad y hacen referencia al mismo objeto
(inmutable), si luego x hace referencia a otro objeto, su identidad cambiará.

>>> x=2
>>> id(x)
2957801160976

Con listas:

>>> lista1=[1]
>>> lista2=lista1
>>> id(lista1)
13176808

2
>>> id(lista2)
13176808
>>> [Link](2)
>>> lista2
[1, 2]
>>> lista1
[1, 2]
>>> id(lista1)
13176808
>>> id(lista2)
13176808

Podemos ver que lista1 se define como una lista con un valor, luego lista2=lista1, por lo que ambos
nombres hacen referencia al mismo objeto (mutable). Al hacer un cambio en lista2, es decir, agregarle
un objeto, el cambio se refleja en lista1, por lo que ambos identificadores (lista1 y lista2) hacen
referencia a la misma colección de objetos. Incluso podemos dejar lista1 vacío y ambas listas (lista1 y
lista2) tendrán el mismo id.

>>> lista1[:]=[]
>>> lista1
[]
>>> lista2
[]
>>> id(lista1)
13176808
>>> id(lista2)
13176808

Para el caso de objetos inmutables, operaciones que calculan un nuevo valor (de determinado tipo)
pudieran regresar una referencia a un objeto ya existente si este tiene el mismo valor y tipo, para el caso
de objetos mutables esto no es permitido. Entonces si escribimos,

>>> a=0
>>> b=0+0

Se puede tener que a y b sean o no referencias al mismo objeto, pero con,

>>> lista1=[]
>>> lista2=[]

Se tiene que lista1 y lista2 son objetos diferentes; son dos listas vacías, únicas y diferentes entre sí. Sin
embargo, si escribimos,

3
>>> lista1=lista2=[]

Entonces lista1 y lista2 son el mismo objeto.

Ejemplo 1

Dada una lista de números ordenarlos de menor a mayor. No usar el método sort, tampoco las funciones
min y max.

En línea 2 tenemos una lista con números, lista1. En línea 3 hacemos una copia profunda de lista1 y la
nombramos lista2, para hacer la copia profunda importamos el módulo copy y lo hacemos con la
función deepcopy. En línea 4 definimos c1, que es el número de valores en lista1 menos 1. En línea 6
tenemos un while, ya que la condición de este es True su bloque de instrucciones (línea 7 a la 20) se
ejecutará una y otra vez indefinidamente hasta que un break lo finalice. En línea 7 tenemos s=0, que es
la variable que usaremos para finalizar el while. El for en línea 8 inicialmente hace nueve iteraciones (el
valor actual de c1) y tiene por índice i que tomará valores de 0 a 8, este for lo usaremos para ir
comparando en pares los valores en lista2 con la condición del if en línea 10. Primero comparamos los
valores con índices 0 y 1, es decir lista2[0]=90 y lista2[1]=60, respectivamente. Si la condición
lista2[i]<=lista2[i+1] es True, los valores comparados están ordenados de manera correcta y se ejecuta
la línea 11, en la cual incrementamos el valor de s en una unidad (i.e., acumulamos un acierto el cual lo
contabilizamos con s). Si la condición da False se ejecuta el bloque del else (en línea 12) que comprende
de la línea 13 a la 15. Debido a que 90<=60 da False, en línea 13 tem=lista2[0] (=90), en línea 14

4
lista2[0]=lista2[1] (=60), y en línea 15 lista2[1]=tem (=90), por lo que el 90 y el 60 intercambiaron
posiciones y ahora lista2= [60,90,80,40,100,20,10,50,30,70]. Cabe mencionar que con la siguiente línea
se logra el equivalente a lo que hacen las líneas de la 13 a la 15:

lista2[i],lista2[i+1]= lista2[i+1], lista2[i]

ya que de esta manera ambas asignaciones se hacen al mismo tiempo. En la siguiente iteración del for
(en línea 8) i se incrementa en una unidad, por lo que ahora la comparación será entre los valores con
posiciones 1 y 2, es decir lista2[1]=90 y lista2[2]=80, nuevamente mediante el bloque de instrucciones
del else (en línea 12) quedaría lista2[1]=80 y lista2[2]=90. Continuamos así hasta comparar los valores
de las posiciones 8 y 9 de lista2. Después de finalizar el for en línea 8, en línea 17 tenemos un if que
tiene por condición s==c1, cuando esta condición es True significa que previamente durante las
iteraciones del for en línea 8 la comparación en línea 10 siempre fue True, es decir lista2[i]<=lista2[i+1]
fue True para todos los valores que puede tomar i, por lo que los números en lista2 ya estarán ordenados
de menor a mayor, entonces si la condición del if en línea 17 es True pasamos a la línea 18 para ejecutar
un break que finaliza el while en línea 6. Si la condición en línea 17 es False continuamos con la línea
20 en donde reducimos el valor de c1 en una unidad, esto por consiguiente cambiará el número de
iteraciones del for en línea 8. Lo que se puede garantizar hasta este punto es que el número de mayor
valor en lista2 estará en la posición 9, por lo que esta posición ya no es necesario incluirla en las
comparaciones que se hacen en línea 10. Pasamos a la siguiente iteración del while (en línea 6) y como
resultado de haber modificado el valor de c1 en línea 20, ahora el índice i del for en línea 8 tomará
valores de 0 a 7. El while en línea 6 continúa haciendo iteraciones hasta que la condición en línea 17 es
True, de ser así el break en línea 18 finaliza el while en línea 6 y pasamos a imprimir en pantalla lista1
(no ordenada) y lista2 (ordenada) en líneas 22 y 23, respectivamente. Al correr el programa la salida es:

lista1 = [90, 60, 80, 40, 100, 20, 10, 50, 30, 70]
lista2 = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Otra manera de resolver el problema es:

5
Para practicar se puede modificar el programa para ordenar la lista de mayor a menor. Además, pueden
medir el tiempo de ejecución del programa [1] considerando una lista de mayor longitud (con más
números).

Funciones

Una función la usaremos para ejecutar su bloque de código cada vez que esta se mande a llamar, para
mandarla a llamar es necesario haberla definido previamente. Una función puede tener opcionalmente
parámetros; si tiene parámetros que no tienen valor por default, cuando se manda a llamar es necesario
pasar argumentos, estos son los valores que se asignan a los parámetros; si tiene parámetros con valor
por default cuando se manda a llamar es opcional pasar argumentos para dichos parámetros, en caso de
pasar un valor a un parámetro que tiene valor por default, dicho valor reemplazará al valor por default;
es posible que una función tenga parámetros sin valor por default y parámetros con valor por default, al
definir la función es obligatorio escribir primero los parámetros que no tienen valor por default y luego
los que si tienen, de no ser así se generará el error ‘non-default argument follows default argument’. Una
función puede devolver (opcionalmente) datos de salida con la sentencia return, además, esta sentencia
finaliza la función (el resto de las líneas de código no son ejecutadas).
Una función se define con la sentencia def y tiene la siguiente estructura:
def nombre_función(parámetro_1, parámetro_2,…, parámetro_n):
bloque de código

El nombre de la función es nombre_función y entre paréntesis van los parámetros. El bloque de código
de la función va indentado. Es importante diferenciar entre parámetros y argumentos; los parámetros son
los nombres (variables) de la función, los argumentos son los valores que le pasamos a la función
cuando la mandamos llamar y que se vinculan con los parámetros.

6
Ejemplo 2

Definir una función para generar la secuencia Fibonacci hasta el número n. La secuencia empieza así: 0,
1; para continuar la secuencia se van sumando los últimos dos números.

El nombre de la función es fib y tiene un parámetro, n. En la función definimos lista1 para que tenga los
primeros dos números de la secuencia, el último número de la secuencia lo asignamos en b y el
penúltimo en a, es decir a=0 y b=1. Con la condición del while en línea 6 tenemos el control para parar
la secuencia, a+b es la suma de los dos últimos número de la secuencia y nos interesa continuar la
secuencia (agregar a+b a lista1) mientras que (a+b)<=n, cuando esta condición es True agregaremos
a+b a lista1, para luego volver a vincular el penúltimo número de la secuencia con a y el ultimo número
de la secuencia con b, así continuamos hasta que la condición de False, de ser así pasamos a la línea 11
en la cual con la sentencia return la función devuelve el contenido de lista1. Entonces cuando llamamos
la función fib, regresa el valor de lista1 en la función.
Fuera de la función, en línea 13 llamamos la función fib con 2000 como argumento, en la función este
valor se vincula con el parámetro n. El resultado de llamar la función lo vinculamos con lista2. La línea
14 es para imprimir en pantalla lista2. Al correr el módulo:

[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]

Con expresión de asignación, el ejemplo 2 quedaría:

7
Y más aún, se puede omitir el uso de las variables a y b.

Cabe mencionar que en el código anterior lista1 solo existe dentro de la función. En el ejemplo siguiente
definimos lista1 fuera de la función y debido a que es un objeto mutable se puede modificar dentro de la
función, es decir, podemos llamar la función y posteriormente fuera de la función el valor de lista1 será
el mismo que como quedo dentro de la función, esto implicaría que no es necesario usar la sentencia
return dentro de la función para devolver el valor de lista1 como lo hicimos con el código anterior.
Entonces:

Considerando el código anterior si lista1 no es definido fuera de la función (sino dentro de la función),
obtendríamos el error ‘name 'lista1' is not defined.’, debido a la línea para imprimir en pantalla lista1; no
es posible acceder al valor de un nombre en un ámbito en el cual no fue definido.
Los nombres de una función que no se especifiquen como global global existen en el ámbito local de la
función, es decir, solo existen en la función. Entonces, los parámetros de una función existen en el
espacio de nombres local de la función.

8
Ejemplo 3

Implementar una función para preguntar si se desea continuar, si la respuesta es 'si' regresa True, si es
'no' regresa False, cualquier otra respuesta resta un intento. Al no dar una respuesta valida imprimir en
pantalla el número de intentos que quedan. Además, si no quedan más intentos imprimir 'Respuesta no
valida.' y salir de la función.

De acuerdo con el ejemplo 3, el nombre de la función es preguntar y tiene tres parámetros, con valor
predeterminado (por default) cada uno. Si un parámetro tiene valor predeterminado, cuando se manda a
llamar la función si al parámetro se le pasa un valor, este valor reemplazará el valor predeterminado. Por
ejemplo, la función se puede llamar de la siguiente manera: preguntar(intentos=3), de esta manera los
parámetros texto1 y texto2 quedan con el valor predeterminado, que es '¿Desea continuar? si/no: ' y
'Responder si o no.', respectivamente, pero el valor predeterminado de intentos (un 2) es reemplazado
por un 3. La respuesta del usuario la vinculamos con respuesta (nombre local), si escribe 'si' la función
regresa True, si escribe 'no' regresa False. Cuando la respuesta no es 'si' y no es 'no' se resta un intento e
imprimimos en pantalla texto2, que es 'Responder si o no.', y el número de intentos que quedan.
Además, cuando intentos es igual a cero imprimimos en pantalla 'Respuesta no valida.', luego
finalizamos la función con la sentencia return (línea 17). Cuando una sentencia return se ejecuta la
función termina (así como un break finaliza un while) y no se ejecuta el resto de las instrucciones de la
función. Una función devuelve None (un objeto de clase NoneType) cuando no se ejecuta un return, o
bien se ejecuta un return sin especificar que debe devolver. Al correr el módulo:
¿Desea continuar? si/no: q
Responder si o no. Le queda(n) 1 intento(s).
¿Desea continuar? si/no: k
Responder si o no. Le queda(n) 0 intento(s).

9
Respuesta no valida.
None

Podemos comprobar que lo que devuelve la función es None. Otra manera de llamar la función podría
ser preguntar(intentos=4), y la salida es:

¿Desea continuar? si/no: 1

Responder si o no. Le queda(n) 3 intento(s).
¿Desea continuar? si/no: no
False

Ejemplo 4

Si tenemos una función con parámetros que tienen valor predeterminado cuando llamemos la función
podemos pasar valores (argumentos), de no ser así los parámetros se quedan con el valor
predeterminado.

Definir una función que multiplique dos valores.

Podemos ver las diferentes maneras de llamar la función. Al correr el módulo:

8
10
4
18
21

Ejemplo 5

Definir una función para determinar si un número es par o impar y que llame a otra función para
imprimir el resultado.

10
La función par_impar tiene por parámetro num, que es el número por determinar si es par o impar. Si el
residuo de dividir num entre dos es cero, entonces num es par y llamamos mensaje(num, 'par'), si el
residuo es diferente de cero entonces num es impar y llamamos mensaje(num, 'impar'). La función
mensaje tiene dos parámetros, num y p1, que son para imprimir en pantalla si num es par o impar. Se
puede ver que num es un parámetro de la función par_impar y de la función mensaje, pueden tener el
mismo nombre aunque cada cual existe dentro de su ámbito respectivo. Recordemos que los argumentos
son los valores que le pasamos a los parámetros y que estos existen en el ámbito local de la función. Al
correr el módulo:
El 10 es par

Ejemplo 6

Definir una función que regrese el valor absoluto de un número.

La función valor_absoluto tiene 1 parámetro: n, de ser positivo o cero, regresa n, cuando n es negativo
regresa -1*n. En líneas 2 a 5 tenemos un comentario. Cuando en una función lo primero que escribimos
es un comentario esta será el docstring de la función, al cual se accede mediante el atributo especial
__doc__. Al correr el módulo:
3

11
 Esta función
regresa el valor absoluto

Sentencia return

La sentencia return se usa para que una función devuelva un valor (o varios). Si se escribe solamente
return la función devuelve el valor especial None. Cuando se llega a un return la función termina, es
decir, el resto de las instrucciones de la función no se ejecutan.

Ejemplo 7

Este ejemplo es para mostrar el uso de la sentencia return.

Al correr el módulo:
v1=1, v2=2
v1=uno, v2=dos
r=[1, 2]

La función asignar1 le asigna un valor a cada una de dos variables locales y con un return (línea 4)
devuelve dichos valores. En línea 13 tenemos: v1,v2 = asignar1(), ya que la función devuelve dos
valores, el primer valor se vincula con la variable global v1 y el segundo con v2, de modo que v1='uno'
y v2='dos'. La función asignar2 le asigna un valor a cada una de dos variables locales, con la sentencia
return la función devuelve una lista con dichas variables (p1 y p2). En línea 15 tenemos r=asignar2(),
por lo que r queda vinculado con [1,2].

12
Por medio de una función podemos asignar a variables globales los valores que le pasamos a la función
cuando la llamamos:

Salida en pantalla:
v1=10, v2=20

Variables globales y locales

Una variable global es aquella que existe fuera de una función (o de una clase), es decir, existe en el
ámbito global. Una variable en el ámbito local es la que existe dentro de una función (o de una clase).
Una variable local se puede usar dentro de la función donde fue definida, después de haberla definido.
Dentro de una función se puede acceder a una variable del ámbito global, sin embargo, si a una variable
que existe en el ámbito global se le asigna un valor en el ámbito local, la variable global hará referencia
al objeto que se le asigno en el ámbito global y la variable local hará referencia al objeto que se le asigno
en el ámbito local, por lo que es válido usar el mismo nombre dentro y fuera de una función. Si una
variable global (definida en el ámbito global) hace referencia a un objeto mutable, se le pueden hacer
cambios dentro de una función y estos prevalecerán fuera de esta, por lo que el objeto es el mismo en el
ámbito global y local.
Si en el ámbito local declaramos una variable como global (la sentencia global seguido del nombre de la
variable), después de que le asignemos un valor en el ámbito local este valor será el mismo que tendrá
en el ámbito global, es decir, la variable es la misma en ambos ámbitos. Además, si una variable
declarada como global es mutable, después de haberla definido se le pueden hacer cambios en el ámbito
local y tendrán efecto en el ámbito global, así como los cambios que se le hagan en el ámbito global
tendrán efecto en el local, porque la variable es la misma en ambos ámbitos.

Ejemplo 8

13
Al ejecutar el programa:
El valor de a dentro de la función es: 2
El valor de b dentro de la función es: [1, 2, 3, 4]
El valor de a fuera de la función es: 1
El valor de b fuera de la función es: [1, 2, 3, 4]

Tenemos que en el ámbito global a=1 (línea 7), y que en el ámbito local a=2 (línea 2). Dentro de la
función la variable a no se declaró como global, por lo que a dentro y fuera de la función son variables
diferentes, es decir, no hacen referencia al mismo objeto. Tenemos que b se definió en el ámbito global
en línea 8, al agregar un 4 a b en el ámbito local en línea 3, como se trata de una clase mutable (una
lista), este cambio prevalece en el ámbito global (fuera de la función), por lo que b en línea 3 (ámbito
local) y b en línea 11 (ámbito global) hacen referencia al mismo objeto. Los cambios que se le pueden
hacer a un objeto mutable son: agregar o quitar objetos, o reemplazar un objeto por otro en determinada
posición; la instrucción nombre=objeto no es hacer un cambio, es hacer una definición. Si ahora:

La función prueba2 tiene un parámetro, c. En el ámbito global definimos a=1 y b=[1,2,3]. Cuando
llamamos la función (línea 8) le pasamos b por referencia, por lo que ahora b y c hacen referencia al
mismo objeto. En el ámbito local en línea 2 declaramos a como global y en línea 3 le asignamos un 2
(que ahora también será el valor al que hace referencia en el ámbito global); en línea 4 a c le agregamos
un 4, que tiene efecto en b ya que esta se pasó por referencia y no por valor. Al correr el módulo:

El valor de a en el ámbito global es: 2

El valor de b en el ámbito global es: [1, 2, 3, 4]

14
De acuerdo con el código anterior, para conseguir que un cambio a c en el ámbito local no tenga efecto
en b en el ámbito global, cuando se manda a llamar la función le pasamos una copia profunda (deep
copy) de b, lo hacemos así:

Salida:
El valor de b fuera de la función es: [1, 2, 3]

Resumen:

 Una variable definida dentro de una función es local.

 Una variable definida fuera de una función es global.
 Para que una variable en el ámbito local sea global se usa la sentencia global.

Nota 1: En una función no es posible declarar con global los nombres de los parámetros; de acuerdo con
las reglas de Python, los parámetros de una función deben considerarse locales, ver referencia [2].

Nota 2: La función globals() regresa un diccionario con los nombres y los respectivos valores que
existen en el espacio global. La función locals() regresa un diccionario con los nombres y los respectivos
valores del espacio donde fue llamada, por lo que, si se llama en el espacio global regresa lo mismo que
la función globals(), ver referencia [3].

Parámetro especial *args

Ejemplo 9

Definir una función que tome como argumento una lista de números y que regrese el número menor de
dicha lista. Nota: no usar la función min().

15
En línea 16 llamamos la función get_min1 y pasamos como argumento lista1 (que se definió en la línea
15), en la función el parámetro p1 hace referencia a lista1. Dentro de la función asignamos el primer
objeto (que está en la posición 0) de p1 en mi (variable que hará referencia al número menor encontrado
hasta ese momento). Con un for accedemos a los valores de p1 desde el valor en la posición 1 hasta el
valor en la última posición, el valor en turno es referenciado con obj. Dentro del for, con un if se evalúa
la condición obj<mi, si resulta True entonces mi lo vinculamos con el valor al que hace referencia obj, y
así sucesivamente hasta que el for finaliza. El return en línea 6 devuelve mi, que hace referencia al
número menor en p1.
En línea 19 llamamos la función get_min2 y como argumento pasamos una colección de valores. En
línea 8 definimos la función get_min2 que tiene un parámetro: *p1, así indicamos que p1 es de clase
tuple y que puede tomar un número indeterminado de valores, que le pasamos a la función cuando la
llamamos. Para encontrar el mínimo procedemos de manera similar que en la función get_min1, con la
diferencia de que en el for usamos range por lo que i es la posición para acceder a un valor de p1. Con
ambas funciones, return devuelve -89.

Parámetro especial **kwargs

Ejemplo 10

La información completa de un automóvil es tener marca, modelo, año, y número de serie. Pasarle a una
función los datos de un automóvil para imprimirlos en pantalla y determinar si los datos son la
información completa.

16
Si el parámetro de una función lo escribimos con dos asteriscos y luego el nombre del parámetro,
estamos indicando que el parámetro es de clase diccionario, por lo que al llamar la función podemos
pasarle como argumento una colección de pares (por par se entiende una clave y un valor), el número de
pares puede variar. Cuando llamamos f1 en línea 12, le pasamos como argumento cuatro pares con la
sintaxis clave_1=valor_1,…,clave_n=valor_n. En la función el for se usa para por cada par imprimir la
clave y el valor e ir incrementando en 1 unidad el valor de h, con esta variable se cuenta el número de
pares. El for tiene la siguiente estructura:
for clave, valor in [Link]():
bloque de código

En cada iteración clave y valor hacen referencia a los valores del par en turno del diccionario (objecto
de clase 'dict'). Al terminar el for, en línea 7 se tiene un if con condición h>=4, si es True la información
está completa, si es False está incompleta. Cuando llamamos f1 como en línea 12, en línea 7 se tiene que
h>=4 es True, por lo que la información está completa. Cuando llamamos f1 como en línea 13, en línea
7 se tiene que h>=4 es False, por lo que la información está incompleta Al correr el módulo:
Marca : Ford
Modelo : Mustang
Año : 2000
Número_de_serie : 123
Información completa

Marca : Nissan
Modelo : Aprio
Año : 2012
Información incompleta

La forma en la que escribimos el ejemplo 10 no garantiza que la información que pasamos sea
precisamente la requerida para que la información este completa. Esto lo podemos solucionar de la
siguiente manera:

17
Salida en pantalla:

Marca : Ford
Modelo : Mustang
Año : 2000
Número_de_serie : 123
Información completa

Marca : Nissan
Modelo : Aprio
Información incompleta, falta:
Año
Número_de_serie

Recursividad

Una función es recursiva si se manda a llamar a sí misma.

Ejemplo 11

Definir una función para calcular el factorial de un número. El factorial consiste en multiplicar entre si
los números enteros entre uno y el número dado, el cual debe ser positivo y entero.

18
Como ejemplo el factorial de 4. En la función factorial mientras que n sea diferente que 1, return regresa
n*factorial(n-1), cuando sea igual a 1, return regresa 1. Llamamos la función en línea 8 y como
argumento pasamos un 4, en la función el valor que pasamos es referenciado con n y como 4!=1 la
función devuelve:
4*factorial(3)
Al llamar factorial(3) regresa:
3*factorial(2)
Al llamar factorial(2) regresa:
2*factorial(1)
Al llamar factorial(1) tenemos que 1!=1 es False, por lo que se ejecuta el bloque del else y el return en
línea 6 devuelve un 1. Entonces factorial(1) devuelve un 1, al ir sustituyendo:
2*factorial(1) = 2*1
3*factorial(2) = 3*2*1
4*factorial(3) = 4*3*2*1=24
Entonces, la salida de correr el módulo es: 24.

Para complementar este tema podemos programar la serie de Fibonacci (interrumpida hasta un número
menor o igual que 1000):

19
Salida:
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987]

Para calcular una potencia teniendo en cuenta que la base puede ser un número entero o fraccionario y
que el exponente puede ser un número entero:

Salida:
16

Para ordenar una lista de números de menor a mayor lo podemos hacer de la siguiente manera:

Salida:
[1, 3, 6, 9, 10, 15, 18, 24, 31]

Función lambda

La función lambda es una función anónima que puede tener cualquier número de parámetros (separados
por coma), y una expresión. La sintaxis es,

20
lambda parámetros : expresión
Ejemplo: Calcular cuánto representa una cantidad respecto de otra en porcentaje.

En este caso queremos determinar el porcentaje que representa x con respecto de y, por lo que la función
tiene dos parámetros y al llamarla se evalúa la expresión (x/y)*100. Para saber el porcentaje que
representa 2 de 8 llamamos la función como porcentaje(2,8), de modo que el 2 se vincula con x y el 8
con y. Lo que devuelve la función al evaluar la expresión seria 25, por lo que en pantalla aparece 25.0%.

Tenemos la función filter(), la cual para mandarla a llamar se le pasa una función y un iterable [4].
Ejemplo: Depurar una lista para tener solo los números en el rango [0,10].

Salida:
[1, 5, 4, 6, 8, 3]
En el ejemplo anterior cada valor del iterable lista1 es referenciado con el parámetro x de la función
lambda, cuya expresión a evaluar es: (x>=0) and (x<=10). Si se evalúa True el valor en turno
(referenciado con x) se incluye en el objeto que devuelve filter(), caso contrario no lo incluye. La
función filter() devuelve un objeto de clase filter, que lo convertimos a clase list.

Tenemos la función map(), con dos argumentos para mandarla a llamar: una función y un iterable.
Ejemplo: Tenemos una lista con números de clase int y los queremos convertir a clase float.

Salida:

[1.0, 5.0, 4.0, 6.0, 8.0, 11.0, 3.0, 12.0]

En el ejemplo anterior cada valor del iterable lista1 es referenciado con el parámetro x de la función
lambda, para cada valor se evalúa la expresión x*1.0 y se incluye en el objeto que devuelve map(). Este
objeto es de clase map y contiene el resultado al que se redujo la expresión de la función lambda para
cada valor que puede tomar x. Con la función lambda cada valor en lista1 lo multiplicamos por 1.0 (que
es float), y con eso basta para que el resultado de la expresión sea un objeto de clase float. El objeto que
devuelve map() es convertido a clase list y vinculado con lista2.

21
Módulos
En Python un módulo es un objeto que contiene código, en este pueden estar definidas funciones y
variables. Un módulo se guarda como un archivo con extensión .py. Desde un módulo podemos
importar las definiciones (funciones y variables) de otro módulo.

Ejemplo 12

Crear un archivo llamado modulo_1.py, donde definimos dos variables globales y una función.

modulo_1.py

Luego crear modulo_2.py.

modulo_2.py

Al correr modulo_2.py:

modulo_1 ejecutado
__name__=modulo_1
3
__name__=__main__

Con la sentencia import y a continuación el nombre del módulo importamos su contenido [5], este se
ejecuta y quedan disponibles las variables y funciones del módulo; para acceder a estas escribimos el
nombre del módulo, seguido de punto, seguido del nombre de la variable o función. Entonces para
acceder a una variable de un módulo importado (nombre_modulo) escribimos:

nombre_modulo.nombre_variable

22
Para usar una función escribimos:

nombre_modulo.nombre_funcion()

Al importar modulo_1 en modulo_2 el código de modulo_1 se ejecuta y quedan disponible sus

definiciones (dos variables y una función). Después de correr modulo_2 se vuelve visible el nombre del
módulo importado [6]; si en IDLE Shell escribimos globals() tenemos que en el espacio global es visible
modulo_1, a2 y b2, sin embargo, no es visible a1, b1 y sumar; para acceder a las definiciones de
modulo_1 se escribe el nombre del módulo (modulo_1), seguido de punto, seguido del nombre de la
variable o función. Es importante mencionar que en el programa principal el intérprete asigna el valor de
'__main__' al atributo __name__, en el caso de los módulos importados el atributo __name__ toma el
valor del nombre del módulo y es de tipo str.

Cuando se desea importar un módulo que no se encuentra en el directorio del módulo del cual se hace la
importación, Python busca en los directorios que se encuentran en [Link]. Si modulo_1.py se
encuentra en C:\modulos y modulo_2.py en otro directorio, se tiene que importar sys, y en la lista
[Link] agregamos el directorio donde está el módulo que se desea importar. Además, el código de un
módulo se ejecuta cuando el módulo es importado, para volver a ejecutarlo es necesario importar
importlib, y con [Link](nombre_modulo) se ejecuta nombre_modulo. Ejemplo:

modulo_2.py

Al ejecutar [Link]:
modulo_1 ejecutado
__name__=modulo_1
30
modulo_1 ejecutado
__name__=modulo_1
3
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__',
'a1', 'b1', 'sumar']

23
En línea 8 cuando llamamos la función modulo_1.sumar(modulo_1.a1,modulo_1.b1) regresa 30 debido
a que previamente en línea 5 le asignamos un 10 a modulo_1.a1 y en línea 6 un 20 a modulo_1.b1. En
línea 9 con [Link](modulo_1) se ejecuta modulo_1, entonces nuevamente modulo_1.a1=1 y
modulo_1.b1=2, por lo que ahora modulo_1.sumar(modulo_1.a1,modulo_1.b1) regresa un 3, que es el
valor que se imprime en pantalla con la línea 10. Con la función dir(nombre_modulo) se obtiene una
lista con los nombres definidos en nombre_modulo. En la lista que regresa dir(modulo_1) podemos ver
(entre otros) '__name__', 'a1', 'b1' y 'sumar', estos valores son de tipo str.

Para ejecutar directamente un módulo desde IDLE Shell:

exec(open(r'C:\ruta\nombre_modulo.py ').read())

C:\ruta es la ubicación de nombre_modulo. La r antes de la cadena es para ponerla en el formato raw

string, esto para que el carácter backslash (\) sea interpretado como un carácter regular y no tome en
cuenta \n como cambio de línea. Además, desde IDLE Shell se puede terminar la ejecución de un
módulo con Ctrl+c, que puede ser útil cuando un ciclo while entra en un bucle infinito y es necesario
detener el programa.

Tarea
Tarea 1

Definir las funciones para calcular el área de un triángulo y de un rombo.

Tarea 2

Diseñar una función que convierta un número entero (del sistema base 10), entre 1 y 999, a romano.

Tarea 3

Diseñar una función para construir el siguiente patrón:

*
**
***
****
*****
****
***
**
*

24
Notar que en este caso el máximo de asteriscos en una línea es n=5. Implementar la función de tal
manera que n sea una variable.

Tarea 4

Diseñar una función para verificar que una contraseña escrita por el usuario cumpla con los siguientes
requisitos: debe tener por lo menos una letra minúscula, una letra mayúscula, un número, y un guion o
guion bajo. Además, debe tener una longitud mínima de 6 y máxima de 16 caracteres. Si la contraseña
introducida no es válida, mostrar un mensaje para dar a conocer los requisitos que no cumple.

Referencias

[1] "How do I get time of a Python program's execution?"

[Link]
execution (accessed.
[2] Stackoverflow. ""Name 'x' is parameter and global" exception."
[Link]
(accessed.

25
[3] stackoverflow. "Python locals() and globals() are the same?"
[Link]
(accessed.
[4] Pythonlikeyoumeanit. "Iterables."
[Link] (accessed.
[5] Realpython. "The import Statement." [Link] (accessed.
[6] Softwareengineering. "How does a symbol table relate to a namespace?"
[Link]
relate-to-a-namespace (accessed.
[7] Datatofish. "How to add Python to Windows PATH." [Link]
windows-path (accessed.

26