Keywords: easytut

Siguiente: Listas Arriba: Tutor de Python para No-programadores Anterior: Depuración Contenido
Subsecciones

- Creando Funciones
- Variables en funciones
- Caminata de una función
- Ejemplos
- Ejercicios

# Definiendo Funciones

# Creando Funciones

Para arrancar este capítulo, le voy a dar un ejemplo de lo pudiera pero no debiera hacer (así que no lo escriba):

    a = 23
    b = -23

    if a < 0:
        a = -a

    if b < 0:
        b = -b

    if a == b:
        print "Los valores absolutos de", a,"y",b,"son iguales"
    else:
        print "Los valores absolutos de a y b son diferentes"

y la salida del programa es:

    Los valores absolutos de 23 y 23 son iguales

Este programa parece un poco repetitivo. (Los programadores odian repetir cosas (Para eso están las computadoras, ¿verdad?)) Afortunadamente, Python permite crear funciones para eliminar duplicación. Aquí está el ejemplo re-escrito:

    a = 23
    b = -23

    def mi_abs(num):
        if num < 0:
            num = -num
        return num

    if mi_abs(a) == mi_abs(b):
        print "Los valores absolutos de", a,"y",b,"son iguales"
    else:
        print "Los valores absolutos de a y b son diferentes"

y la salida del programa es:

    Los valores absolutos de 23 y -23 son iguales

El aspecto clave de este programa es el enunciado `def` . `def` (apócope de define) comienza una definición de función. A `def` le sigue el nombre de la función `mi_abs`. Luego viene un`(`seguido de un parámetro `num` (el valor de `num` es pasado del programa a la función cuando la función es llamada). Los enunciados después de `:`son ejecutados cuando usamos la función. Los enunciados continúan hasta que los enunciados sangrados terminan, o hasta que encuentra un `return`. El enunciado `return` devuelve un valor al lugar donde la función fue llamada.

Note cómo los valores de a y b no sufren alteración. Por supuesto que podemos usar funcionea para repetir tareas que no devuelven un valor. Unos ejemplos:

    def hola():
        print "Hola"

    def area(anchura,altura):
        return anchura*altura

    def imprime_bienvenida(nombre):
        print "Bienvenido",nombre

    hola()
    hola()

    imprime_bienvenida("Pedro")
    ancho = 4
    alto = 5
    print "anchura =",ancho,"altura =",alto,"area =",area(ancho,alto)

y la salida es:

    Hola
    Hola
    Bienvenido Pedro
    anchura = 4 altura = 5 area = 20

Ese ejemplo muestra un poco más de lo que puede hacer con funciones. Note que puede usar cero argumentos, o dos o más. Note también que cuando una función no devuelve un valor, el return es opcional.

# Variables en funciones

Por supuesto, cuando uno elimina código repetido, con frecuencia hay variables en ese código. Python resuelve ese problema de un modo especial. Hasta ahora, todas las variables que hemos visto son variables globales. Las funciones tienen un tipo especial de variable llamada variable local. Estas variables sólo existen mientras la función está en ejecución. Cuando una variable local tiene el mismo nombre que una variable global, la variable local esconde a la variable global. ¿Confundido? Bueno, espero que el siguiente ejemplo (el cual es un poco complicado) aclare las cosas.

    var_a = 10
    var_b = 15
    var_e = 25

    def func_a(var_a):
        print "in func_a var_a = ",var_a
        var_b = 100 + var_a
        var_d = 2*var_a
        print "en func_a var_b = ",var_b
        print "en func_a var_d = ",var_d
        print "en func_a var_e = ",var_e
        return var_b + 10

    var_c = func_a(var_b)

    print "var_a = ",var_a
    print "var_b = ",var_b
    print "var_c = ",var_c
    print "var_d = ",var_d

La salida es:

    en func_a var_a =  15
    en func_a var_b =  115
    en func_a var_d =  30
    en func_a var_e =  25
    var_a =  10
    var_b =  15
    var_c =  125
    var_d =
    Traceback (innermost last):
      File "separate.py", line 20, in ?
        print "var_d = ",var_d
    NameError: var_d

En este ejemplo, las variables `var_a`, `var_b`, and `var_d` son variables locales cuando están dentro de la función `func_a`. Después de ejecutar el enunciado `return var_b + 10` , dejan de existir. La variable `var_a` es automáticamente una variable local ya que es un nombre de parámetro. Las variables `var_b` y `var_d`son variables locales dado que aparecen a la izquierda de un signo igual en la función en las declaraciones`var_b = 100 + var_a` y `var_d = 2*var_a` .

Como puede ver, una vez que la función termina, las variables locales `var_a` y `var_b` que habían escondido las variables globales del mismo nombre desaparecen. Entonces el enunciado `print "var_a = ",var_a`imprime el valor `10` y no `15` ya que la variable local que escondía la variable global ya no está.

Otra cosa que hay que notar es el `NameError` que sucede al final. Esto aparece porque la variable `var_d` ya no existe desde que `func_a` terminó. Todas las variables locales son borradas cuando la función sale. Si quiere que la función proporcione algo, tendrá que usar `return algo`.

Un último punto a notar es que el valor de `var_e` permanece sin cambiar dentro de `func_a` ya que no es un parámetro y nunca aparece a la izquierda de un signo igual dentro de `func_a`. Cuando una variable global es leída dentro de una función, es la variable global de afuera de la función.

Las funciones permiten variables locales que existen sólo dentro de la función y que pueden ocultar otras variables que están fuera de la función.

# Caminata de la función

POR HACER Mover esta sección a un nuevo capítulo, Funciones avanzadas.

Ahora caminaremos a través del siguiente programa:

    def mult(a,b):
        if b == 0:
            return 0
        rest = mult(a,b - 1)
        valor = a + rest
        return valor

    print "3*2 = ",mult(3,2)

Basicamente este programa crea una función para multiplicar enteros positivos (que es mucho más lenta que la función interconstruida correspondiente de python) y luego demuestra esta función con el uso de la función.

Pregunta: ¿Qué es lo primero que hace el programa?

Respuesta: Lo primero que hace el programa es definir la función mult con los siguientes renglones:

    def mult(a,b):
        if b == 0:
            return 0
        rest = mult(a,b - 1)
        valor = a + rest
        return valor

Esto crea una función que toma dos parámetros y devuelve un valor cuando ha terminado. Esta función puede ser ejecutads después.

Pregunta: ¿Luego qué pasa?

Respuesta: El siguiente renglón después de la función, `print "3*2 = ",mult(3,2)`es ejecutado.

Pregunta: ¿Y esto que hace?

Respuesta: Imprime `3*2 =` y el valor devuelto por `mult(3,2)`

Pregunta: ¿Y qué devuelve `mult(3,2)`?

Respuesta: Necesitamos caminar a través de la función `mult` para descubrirlo.

Pregunta: ¿Luego qué pasa?

Respuesta: La variable `a` es asignada el valor 3 y la variable `b` es asignada el valor 2.

Pregunta: ¿Y luego?

Respuesta: La declaración `if b == 0:` es ejecutada. Ya que el valor de `b`es igual a 2, esta expresión resulta falsa así que nos saltamos el `return 0`.

Pregunta: ¿Y luego qué?

Respuesta: El renglón `rest = mult(a,b - 1)` es ejecutado. Este renglón asigna a la variable local `rest` el valor de `mult(a,b - 1)`. El valor de `a` es 3 y el valor de `b` es 2 así que la función llamada es `mult(3,1)`

Pregunta: ¿Entonces cuál es el valor de`mult(3,1)` ?

Respuesta: Necesitamos ejecutar la función `mult` con los parámetros 3 y 1.

Pregunta: ¿Luego qué pasa?

Respuesta: Las variables locales en la más reciente llamada de la función son asignadas valores, así que `a` es 3 y `b` es ahora 1. Ya que estas son variables locales, no afectan los valores previos de `a`y `b`.

Pregunta: ¿Y luego?

Respuesta: Dado que el valor de `b` es 1, la expresión evaluada por el if es falsa, el siguiente renglón ejecutado es `rest = mult(a,b - 1)`.

Pregunta: ¿Y este renglón qué hace?

Respuesta: Este renglón asigna el valor de `mult(3,0)` a rest.

Pregunta: ¿Cuál es ese valor?

Respuesta: Tendremos que ejecutar la función una vez más para saber. Esta vez `a` vale 3 y `b` vale 0.

Pregunta: ¿Luego qué pasa?

Respuesta: El primer renglón en la función es `if b == 0:` . `b` vale 0 así que el siguiente renlgón ejecutado es `return 0`

Pregunta: ¿Y qué hace `return 0`?

Respuesta: Este renglón devuelve el valor 0 hacia afuera de la función.

Pregunta: ¿Y?

Respuesta: Así que ahora sabemos que `mult(3,0)` vale 0. Ahora sabemos lo que hizo `rest = mult(a,b - 1)` ya que ejecutamos la función `mult` con los parámetros 3 y 0. Hemos terminado ejecutando `mult(3,0)` y estamos de vuelta ejecutando `mult(3,1)`. La variable `rest` obtiene el valor 0.

Pregunta: ¿Cuál es el siguiente renglón?

Respuesta: El renglón `valor = a + rest` es ejecutado a continuación. En esta ejecución, `a=3` y `rest=0` así que `valor=3`.

Pregunta: ¿Luego qué pasa?

Respuesta: El renglón `return valor` es ejecutado. Esto devuelve 3 desde la función. Esto también sale de ejecutar la función `mult(3,1)`. Después de ejecutar `return`, regresamos a la ejecución de `mult(3,2)`.

Pregunta: ¿Dónde nos quedamos en `mult(3,2)`?

Respuesta: Teníamos las variables `a=3` y `b=2`y estábamos examinando el renglón `rest = mult(a,b - 1)` .

Pregunta: ¿Y ahora qué pasa?

Respuesta: La variable `rest` es asignada el valor 3. El siguiente renglón `value = a + rest` le asigna a `valor` el resultado de `3+3` o 6.

Pregunta: ¿Y luego qué pasa?

Respuesta: Es ejecutado el siguiente renglón, éste devuelve 6 desde la función. Ahora estamos de vuelta ejecutando `print "3*2 = ",mult(3,2)`el cual puede ahora imprimir el 6.

Pregunta: ¿Qué es lo que ha sucedido globalmente?

Respuesta: Básicamente usamos dos hechos para multiplicar dos números. El primero es que cualquier número multiplicado por 0 es 0 (`x * 0 = 0`). El segundo es que un número multiplicado por otro es igualal primer número más el primer número multiplicado por el segundo número menos uno (`x * y = x + x * (y - 1)`). Así que lo que sucede es que `3*2` es convertido a `3 + 3*1`. Luego `3*1` es convertido a `3 + 3*0`. Sabemos que cualquier número por cero es cero entonces`3*0` es 0. Luego podemos calcular que `3 + 3*0` es `3 + 0` el cual es `3`. Ahora sabemos el valor de `3*1` y podemos calcular que `3 + 3*1` es `3 + 3` el cual es `6`.

Así es como funciona esto:

    3*2
    3 + 3*1
    3 + 3 + 3*0
    3 + 3 + 0
    3 + 3
    6

Estas dos secciones fueron escritas recientemente. Si tiene algún comentario, ha encontrado errores o piensa que necesito más o mejores explicaciones envíeme un correo electrónico. En el pasado, he logrado hacer que cosas muy simples sean completamente incomprensibles. Si el resto del tutor ha tenido sentido, pero esta sección no lo tiene, probablemente es por un error mío y me gustaría saber. Gracias.

# Ejemplos

factorial.py

    #define una funcion que calcula el factorial

    def factorial(n):
        if n <= 1:
            return 1
        return n*factorial(n-1)

    print "2! = ",factorial(2)
    print "3! = ",factorial(3)
    print "4! = ",factorial(4)
    print "5! = ",factorial(5)

Salida:

    2! =  2
    3! =  6
    4! =  24
    5! =  120

temperatura2.py

    #convierte temperatura a fahrenheit o celsius

    def imprime_opciones():
        print "Opciones:"
        print " 'p' imprime opciones"
        print " 'c' convierte de celsius"
        print " 'f' convierte de fahrenheit"
        print " 'q' termina el programa"

    def celsius_a_fahrenheit(c_temp):
        return 9.0/5.0*c_temp+32

    def fahrenheit_a_celsius(f_temp):
        return (f_temp - 32.0)*5.0/9.0

    seleccion = "p"
    while seleccion != "q":
        if seleccion == "c":
            temp = input("Temperatura en Celsius:")
            print "Fahrenheit:",celsius_to_fahrenheit(temp)
        elif seleccion == "f":
            temp = input("Temperatura en Fahrenheit:")
            print "Celsius:",fahrenheit_to_celsius(temp)
        elif seleccion != "q":
            imprime_opciones()
        seleccion = raw_input("opcion:")

Muestra:

    > python temperatura2.py
    Opciones:
     'p' imprime opciones
     'c' convierte de celsius
     'f' convierte de fahrenheit
     'q' termina el programa
    opcion:c
    Temperatura en Celsius:30
    Fahrenheit: 86.0
    opcion:f
    Temperatura en Fahrenheit:60
    Celsius: 15.5555555556
    opcion:q

area2.py

    #By Amos Satterlee
    #traducido por Victor M. Rosas-Garcia
    print
    def hola():
        print 'Hola!'

    def area(anchura,altura):
        return anchura*altura

    def imprime_bienvenido(nombre):
        print 'Bienvenido,',nombre

    name = raw_input('Su nombre: ')
    hola(),
    imprime_bienvenido(nombre)
    print
    print 'Para hallar el area de un rectangulo,'
    print 'Escriba la anchura y la altura abajo.'
    print
    an = input('Anchura:  ')
    while an <= 0:
        print 'Debe ser un número positivo'
        an = input('Anchura:  ')
    al = input('altura: ')
    while al <= 0:
        print 'Debe ser un número positivo'
        al = input('Altura: ')
    print 'Anchura =',an,' Altura =',al,' entonces el Area =',area(al,an)

Muestra:

    Su nombre: Josh
    Hola!
    Bienvenido, Josh

    Para hallar el area de un rectangulo,
    Escriba la anchura y la altura abajo.

    Anchura:  -4
    Debe ser un número positivo
    Anchura:  4
    Altura: 3
    Anchura = 4  Altura = 3  entonces el Area = 12

# Ejercicios

Vuelva a escribir el programa area.py de la sección 3.2para tener funciones separadas para el área de un cuadrado, el área de un rectángulo y el área de un círculo. (3.14 * radio**2). Este programa debería incluir una interfase de menú.

Siguiente: Listas Arriba: Tutor de Python para No-programadores Anterior: Depuración Contenido
Traducido por Victor M. Rosas-Garcia quimico69@yahoo.com