Cómo pasar parámetros a funciones en una clase en Python

Los parámetros de función en Python se pasan a través de "asignación". Pero esta regla sólo responde a la "cuestión estratégica" del paso de parámetros de función, y no responde a la "cuestión táctica", lo que significa que no responde a la pregunta de cómo asignar valores. El uso de parámetros de función se puede dividir en dos aspectos: uno es cómo se definen los parámetros de la función y el otro es cómo se analizan los parámetros cuando se llama a la función. Este último está determinado por el primero. Hay cuatro formas de definición de parámetros de función:

1. F(arg1, arg2,...)

2. ; valuegt;...)

3. F(*arg1)

4. F(**arg1)

La primera forma es la más " Método tradicional" ": una función puede definir un número ilimitado de parámetros. Los parámetros (parámetros formales) se colocan entre paréntesis después del nombre de la función y cada parámetro está separado por comas. Las funciones definidas de esta manera también deben proporcionar un número igual de valores (parámetros reales) entre paréntesis después del nombre de la función cuando se llama, ni más ni menos, y el orden debe ser el mismo. Es decir, el número de parámetros formales y los parámetros reales deben ser consistentes, y el valor que desea darle al parámetro formal 1 debe ser el primero en los parámetros reales. Existe una correspondencia uno a uno entre los parámetros formales. y parámetros reales, es decir, "parámetro formal 1 = parámetro real 1 parámetro formal 2 = parámetro real 2...". Es evidente que se trata de una forma muy inflexible. Por ejemplo: "def addOn(x, y): return x y", la función addOn definida aquí se puede llamar en forma de addOn(1, 2), lo que significa que el parámetro formal x tomará el valor 1 y el principal El parámetro tomará el valor 2. addOn(1, 2, 3) y addOn (1) son formas incorrectas.

El segundo método es mejor que el primero. Se han definido valores predeterminados para cada parámetro formal durante la definición. Por lo tanto, al llamar a dicha función, si no se pasan parámetros reales a los parámetros formales correspondientes, se utilizará el valor predeterminado para los parámetros formales. Por ejemplo: "def addOn(x=3, y=5): return x y", entonces la forma de llamada de addOn(6, 5) significa que el parámetro formal x toma el valor 6 e y toma el valor 5. Además, la forma addOn(7) también es posible, lo que significa que el parámetro formal x toma el valor 7 e y toma el valor predeterminado 5. Surgirá una pregunta en este momento. Si desea que x tome el valor predeterminado, ¿qué debe hacer si usa parámetros reales para asignar un valor a y? Los dos primeros formularios de llamada obviamente no funcionarán. En este momento, se debe utilizar otro truco del método de llamada de función en Python: el método de asignación de palabras clave. Puede usar addOn (y = 6), lo que significa que x toma el valor predeterminado de 3 e y toma el valor de 6. Este método puede lograr un "ataque preciso" a los parámetros formales especificando los parámetros formales. Una función de subbanda no tiene que seguir el orden de los parámetros formales, como: addOn(y=4, x=6), this. también es posible de. Este método de asignación de punto fijo mediante parámetros formales también es aplicable a funciones definidas en el primer método.

El número de parámetros formales definidos en los dos métodos anteriores es fijo. Por ejemplo, si se definen 5 parámetros formales al definir una función, solo se le pueden pasar 5 parámetros reales. Pero en la programación real, no siempre es posible determinar cuántos parámetros tendrá una función. El tercer método se utiliza para afrontar esta situación. Está representado por un * más el nombre del parámetro formal. Los parámetros reales de esta función no son necesariamente ciertos y pueden ser cero o N. No importa cuántos haya, se almacenan en tuplas con nombres de parámetros formales como identificadores dentro de la función. Por ejemplo:

Puedes llamar a esta función addOn() addOn(2) addOn(3, 4, 5, 6), etc.

De manera similar al tercer método, se agregan dos * delante del nombre del parámetro formal y los parámetros se almacenarán en un diccionario con un identificador de nombre formal dentro de la función. En este momento, la función de llamada debe tener la forma clave1 = valor1, clave2 = valor2 ...

Por ejemplo:

1. def addOn(**arg):

2. suma = 0

3 si len(arg) == 0: devuelve 0

4. más:

5 para x en arg.itervalues():

6. 7. return sum

Entonces la llamada a esta función se puede llamar con addOn() o métodos como addOn(x=4, y=5, k=6), etc.

Los cuatro métodos mencionados anteriormente para definir formas de funciones y sus métodos de llamada se analizan por separado. De hecho, estos cuatro métodos se pueden combinar para formar formas de definición de parámetros formales complejas y diversas. Al definir o llamar a una función de este tipo, se deben seguir las siguientes reglas:

1. arg=lt; valuegt; debe ir después de arg

2. lt; valuegt; after

3. **arg debe ser posterior a *arg

Durante el proceso de llamada a la función, el proceso de asignación de parámetros formal es el siguiente:

Primero asigne los parámetros reales del formulario "arg" a los parámetros formales correspondientes en orden

Segundo, asigne los parámetros reales del formulario "arg=lt;valuegt;" >

Tercero, use los parámetros reales adicionales en forma de "arg" para formar una tupla para el parámetro formal con un asterisco

Cuarto, use la "clave=valor" adicional para formar una tupla El argumento formal se convierte en un diccionario para el parámetro formal con dos asteriscos.

Ejemplo:

1. def prueba(x, y=5, *a, **b):

2. , b

Es una función tan simple, echemos un vistazo a los resultados de llamar a esta función:

test(1) ===gt; /p>

prueba(1, 2) ===gt; 1 2 () {}

prueba(1, 2, 3) ===gt; }

prueba(1, 2, 3, 4) ===gt 1 2 (3, 4)

prueba(x=1) ===gt; () {}

prueba(x=1, y=1) ===gt 1 1 () {}

prueba(x=1, y=1 , a =1) ===gt; 1 1 () {'a'：1}

prueba(x=1, y=1, a=1, b=1) ===gt ; 1 () {'a': 1, 'b': 1}

prueba(1, y=1) ===gt 1 1 () {}

prueba; (1, 2, y=1) ===gt; Error, diciendo que a y se le han asignado múltiples valores

test(1, 2, 3, 4, a=1) === gt; 1 2 (3, 4) {'a': 1}

prueba(1, 2, 3, 4, k=1, t=2, o=3) ===gt; (3, 4) {'k': 1, 't': 2, 'o': 3}