Comprender las funciones en Python

Question

Estoy tratando de usar el módulo Turtle en Python para dibujar la bandera estadounidense usando funciones separadas, primero tengo draw_flag que calcula todas las dimensiones, y luego draw_rectangle que en realidad dibuja la forma de la bandera, luego haré draw_stars, etc., para dibujar la estrellas y líneas.

Pero tengo algunos problemas para entender cómo funcionan las funciones... aquí está mi código hasta ahora:

import turtle
import time
import random

def draw_rectangle(length, height):
    turtle.up()
    x = length
    y = height

    turtle.begin_fill()
    turtle.setpos(x,y)
    turtle.down()
    turtle.forward(418)
    turtle.right(90)
    turtle.forward(220)
    turtle.right(90)
    turtle.forward(418)
    turtle.right(90)
    turtle.forward(220)
    turtle.end_fill()

    turtle.sleep(2)
    turtle.bye

def draw_flag(A):
    height = int(A)
##    length = height*1.9
##    union_height = height*(7/13)
##    union_length = length*(2/5)
##    E = F = union_height/10
##    G = H = union_length/12
##    stripe_width = height/13
##    diameter_star = stripe_width*(4/5)
    length = height*1.9
    return

A = input("Please enter the height of the flag: ")

draw_rectangle(length, height)

Esperaba que regresara dibujando un rectángulo, pero sigue diciendo que la longitud no está definida y no estoy seguro de dónde colocar "longitud" donde reconocerá la variable.

Estoy usando Python 3, gracias.

Answer 1

He aquí una buena manera de pensarlo.Una función es una "caja negra" que toma una cierta cantidad de valores, llamada argumentos, en un orden específico y hace algo con ellos para producir algún otro valor.Cuando digo "caja negra", quiero decir que cuando usas la función, no tienes que preocuparte cómo hace lo que hace, simplemente le das algunos valores y obtienes un valor a cambio.

Consideremos una función muy simple que simplemente resta los dos números que se le dan:el primero menos el segundo.En otras palabras, haremos una función que implementa la regla "Argumento #1 - Argumento #2". Ahora, cuando está escribiendo el código para esta función, necesita alguna forma de decirle a la computadora cuándo desea usar el argumento #1 y cuando desee usar el argumento #2.En algunos otros lenguajes de programación, debe hacerlo especificando explícitamente el número del argumento que desea usar (#1 o #2), pero es mucho más fácil escribir código si puede dar nombres a estos valores.Entonces Python, como la mayoría de los otros lenguajes, te permite referirte a los argumentos de una función usando los nombres que elijas.Por ejemplo, supongamos que desea que el argumento n.º 1 vaya bajo el nombre x, y el argumento n.º 2 para ir bajo el nombre y.Podrías indicarlo escribiendo esto:

def subtract(x, y):

A esto le seguiría el código que constituye la función.Para el ejemplo de la resta, sería

def subtract(x, y):
    return x - y

Cuando el compilador de Python encuentra esto, traduce el código en su representación interna de "Calcular el valor #1 - Valor #2 y enviarlo a mi persona que llama". Luego empaca ese bloque de código y lo guarda bajo el nombre subtract (porque así es como le dijiste que querías nombrar la función).

Con suerte, tendrá sentido que una vez que este bloque de código termine de ejecutarse, ya no tenga sentido referirse al "argumento n.° 1" o al "argumento n.° 2", ¡porque no se pueden tener argumentos sin una función!De manera similar, una vez que la función ha hecho su trabajo, las etiquetas que le diste a los argumentos, x y y, ya no tiene ningún significado.Las etiquetas solo existen mientras dura el código de la función.Se llama alcance:limitando las etiquetas a la parte del código donde significan algo.

porque las etiquetas x y y son alcance local, como se podría decir, en cierto modo ni siquiera importa cuáles sean.Por ejemplo, si tuvieras esa definición de subtract en su código, puede decidir arbitrariamente cambiarlos a first y second, y todo lo que tendrías que cambiar sería el código dentro de esa función.Simplemente cambiarías la definición a

def subtract(first, second):
    return first - second

y eso es todo: su código es funcionalmente exactamente el mismo.En cualquier otro lugar del programa que x y y ocurren, se refieren a algo distinto a los argumentos de esta función, por lo que no es necesario cambiarlos cuando cambia el nombre de los argumentos.

Lo que pasa en tu caso es que intentaste usar la etiqueta length en algún lugar fuera de la función para la que se definió (es decir, la función que almacenó como draw_rectangle).Python sabe que no puedes referirte al argumento de una función en la que no estás, por lo que espera que ya la hayas definido. length para significar algo más.Pero no lo hiciste.Es por eso que recibes un error.(Bueno, ese error, de todos modos)

Answer 2

Tienes dos problemas.Primero, defines la función. draw_flag pero nunca lo llamas.

Sin embargo, si lo llamaras, no funcionaría, porque tu función draw_flag realmente no hace nada.Simplemente define algunas variables dentro de sí mismo y luego las descarta cuando finaliza.Debes devolver la longitud y la altura con return length, height, entonces hazlo length, height = draw_flag(A) y llama draw_rectangle con esos valores.(O podrías hacer draw_rectangle(*draw_flag(A)).)

length, height = draw_flag(A)
draw_rectangle(length, height)

Las funciones no se comunican mágicamente entre sí.Una función toma entradas y produce un valor de retorno.Si desea utilizar ese valor de retorno en otro lugar, debe llamar a la función en el lugar donde desea utilizar el valor.

Answer 3

Estás llamando a la función. draw_rectangle, que espera dos argumentos: una longitud y una altura.La longitud está siendo calculada por el draw_flag función;pero no devuelves el valor.

Tienes algunas formas de resolver esto.Una es simplemente llamar al draw_flag funciona con la altura proporcionada por el usuario, guarda el valor de retorno y luego llama draw_rectangle:

def draw_flag(A):
    height = int(A)
##    length = height*1.9
##    union_height = height*(7/13)
##    union_length = length*(2/5)
##    E = F = union_height/10
##    G = H = union_length/12
##    stripe_width = height/13
##    diameter_star = stripe_width*(4/5)
    return height*1.9

A = input("Please enter the height of the flag: ")
length = draw_flag(A)
draw_rectangle(length, int(A))

La otra es mover tu input hacia draw_flag función y luego llamar a la draw_rectangle funcionar desde el interior del draw_flag función.Si haces esto, entonces el draw_flag La función no necesita ningún argumento en absoluto:

def draw_flag():
    A = input("Please enter the height of the flag: ")
    height = int(A)
##    length = height*1.9
##    union_height = height*(7/13)
##    union_length = length*(2/5)
##    E = F = union_height/10
##    G = H = union_length/12
##    stripe_width = height/13
##    diameter_star = stripe_width*(4/5)
    draw_rectangle(height*1.9, height)

draw_flag()

Creo que también deberías consultar la sección de tu libro de Python sobre alcances variables.Le ayudará más adelante cuando espere que se impriman algunas variables pero obtenga errores extraños, especialmente si está utilizando funciones.

Answer 4

Pruebe lo siguiente

import turtle
import time
import random

def draw_rectangle(length, height):
   turtle.up()
   x = length
   y = height

   turtle.begin_fill()
   turtle.setpos(x,y)
   turtle.down()
   turtle.forward(418)
   turtle.right(90)
   turtle.forward(220)
   turtle.right(90)
   turtle.forward(418)
   turtle.right(90)
   turtle.forward(220)
   turtle.end_fill()

   turtle.sleep(2)
   turtle.bye

 def draw_flag(A):
   height = int(A)
   length = height*1.9
   draw_rectangle(length,height)
   return

A = input("Please enter the height of the flag: ")

draw_flag(A)

Answer 5

De acuerdo, para responder a su pregunta más general, las funciones en Python aceptan argumentos cuando los llame, estos se pasan por referencia, lo que significa que usted termina con los mismos datos dentro de la función que en el espacio de llamada. Esto es importante para los tipos mutables, porque si se cambian dentro de la función, también se cambian fuera de la función. (STR, INT, Float y Tuple no son mutables, DICT y LIST son). Cuando se devuelve una función, el valor después de que se pase el token de retorno a la persona que llama, por lo que si dice a=input('input? '), la entrada de la función toma un argumento para que la solicitud muestre al usuario, tenga en cuenta que esto se pasa por referencia, no es Una copia de la cadena. Devuelve la entrada generada por el usuario, que se almacena en un. Puede devolver varios valores de una función, se convierten automáticamente a una tupla; Si tienes

def test():
    return 1,2
a,b = test()

obtendrás A= 1 y B= 2. Se deben definir nombres utilizados dentro de una función. Primero se buscan dentro de la función, luego en cualquier espacio de nombres adjuntado, finalmente en BURTINS. No se pueden usar variables definidas en otras funciones, porque no están en el espacio de nombres local ni en ninguno de sus padres. Para acceder a los valores de estos nombres, debe pasarlos a la función, tenga en cuenta que los nombres utilizados dentro de la función no tienen que coincidir con los nombres fuera de la función. Considere:

def fun1(a):
    return a * 2
def fun2():
    b = 5
    c = fun1(b)
    print c
fun2()

El valor 5 se almacena en la memoria bajo el nombre B, luego pasó por referencia a Fun1, esta vez en el nombre A, se duplica y devuelta, (la devolución también es como referencia), el valor de retorno se almacena. Bajo el nombre C, que luego se imprime.

Answer 6

return devuelve todo lo que le devuelves a la persona que llama.Lo hace no automáticamente hacer que las variables locales dentro de la función estén disponibles afuera (estas son local ¡por una razón!).Tenga en cuenta también que return sin ningún argumento devolverá el valor especial None (por lo que es equivalente a return None).

Entonces, si desea devolver algunos valores, use return height, length dentro de la función, y height, length = draw_flag(A) afuera.