Cómo codificar parámetros de URL en Python

La transferencia de parámetros de función en Python es mediante "asignación". Existen cuatro formas de recepción y transferencia de parámetros de función:

1. )

2. F(arg2=, arg3=...)

3.

El primer método

es el método más "tradicional": una función puede definir un número ilimitado de parámetros, y los parámetros (parámetros formales) se colocan en la pequeña cadena que sigue al nombre de la función. Entre paréntesis, cada parámetro está separado por comas. Cuando se llama a una función definida de esta manera, se debe proporcionar un número igual de valores (parámetros reales) entre paréntesis después del nombre de la función, 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, el maestro tomará el valor 2. addOn(1, 2, 3) y addOn

(1) son ambas 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) indica el valor de el parámetro formal x 6, y toma el valor 5. Además, la forma addOn(7) también es posible, lo que indica que el parámetro formal x toma el valor 7 e y toma el valor predeterminado 5. En este momento surgirá una pregunta: si desea que x tome el valor predeterminado, ¿qué debe hacer si usa parámetros reales para asignar un valor a y? Las dos primeras formas de llamada obviamente no funcionarán en este momento. Se debe utilizar el método de llamada de función en Python

──Método de asignación de palabras de Guan Jian. 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 este tipo de función, se deben seguir las siguientes reglas:

1. arg= debe ir después de arg

2 *arg debe ir después de arg=

3. **arg debe venir después de *arg

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

Primero, coloque "arg" en orden Los parámetros reales del formulario se asignan a los parámetros formales correspondientes

En segundo lugar, asigne los parámetros reales del formulario "arg=" al formulario

En tercer lugar, asigne el extra "arg" Los parámetros reales en este formulario forman una tupla para el parámetro formal con un asterisco

Cuarto, convierta el parámetro real adicional "clave=valor" en un diccionario con dos Los parámetros formales del asterisco.

Suena complicado, pero en realidad es muy sencillo. Muy intuitivo, veamos el ejemplo:

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

2. , b

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}