Tomado del producto es ligeramente Biblioteca http://www.pinlue.com/article/2020/04/0210/5310100832703.html
Después de leer este artículo tarda aproximadamente ocho minutos, después de leer cuidadosamente mirar el código, mirar hacia atrás con cuidado, funciones, conocimientos básicos sobre Aceptar. El código es mejor llamar.
Nota PS especial: Muchas personas aprenden proceso de Python se encontrará con una variedad de problemas de que preocuparse, nadie ayuda a contestar fácil darse por vencido!
En primer lugar, la función básica
En pocas palabras, se trata de una combinación de un conjunto de sentencias de Python de las funciones que se pueden ejecutar una o más carreras en el programa. Python también se llama un proceso de función o subrutina en otros idiomas, a continuación, estos se empacó declaración a llamar a una función por su nombre.
Con la función, podemos copiar y pegar el número de código se reduce (creo que muchas personas tienen esta experiencia al principio) en gran medida. Podemos poner el mismo código se puede extraer para hacer una función en la que se necesita para simplemente llamada. Por lo tanto, mejorando así la reutilización de código, las miradas de código más conciso en general, no tan abultada.
Python es la función más básica en la estructura del programa, para nosotros maximizar código de multiplexación; Al mismo tiempo, puede ser una función compleja en una pluralidad de partes del sistema puede ser administrado, la programación simplificar, la reutilización de código .
A continuación nos fijamos en lo que es la función y cómo se define la función. Hay dos maneras de definir las funciones, a saber, def y palabra clave lambda.
1. Definición de la función
¿Por qué debería utilizar para resumir la función?
Maximizar la reutilización del código y minimizar código redundante;
El proceso de descomposición (desmontaje). El desmantelamiento de una tarea compleja en varias tareas pequeñas.
sintaxis de definición de la función es:
func_name def (arg1, arg2, arg3, ..., argN): valor de retorno declaración
De acuerdo con la definición anterior, se puede describir simplemente como: Python es una función que tiene cero o más parámetros, una pluralidad de líneas y que tiene un bloque de valor Las declaraciones de retorno (valor de retorno opcional) (indentación nota).
A continuación, definimos una función relativamente simple que no tiene argumentos, introduzca ipython entorno interactivo:
En [1]: def hola (): ...: print ( "Déjame en paz, el mundo") ...:
Llamar (realizar) esta función:
En [2]: hola () Déjame en paz, el mundo
Encontramos función hello () no instrucción de retorno en Python, si no se ejecute de forma explícita una instrucción de retorno, entonces el valor de retorno de los valores predeterminados de la función a ninguno.
Hemos dicho que hay dos formas de funciones definidas, otra forma es utilizar lambda para definir. El uso de definición de la función lambda es una función anónima, que se explica más adelante en el contenido, no la mesa aquí por el momento.
En segundo lugar, los parámetros de la función
funciones definidas, que pusieron el nombre y los parámetros ubicación determinada, la función de definición de interfaz es completa. Para la persona que llama de la función, sólo se necesita saber cómo pasar los parámetros correctos, así como qué tipo de valor que la función retorna suficientes, lógica compleja se encapsula dentro de la función, la necesidad de entender que llama.
Python definición de función es muy simple, pero la flexibilidad es muy grande. Además de la definición normal de los parámetros obligatorios, los parámetros por defecto se pueden utilizar, los parámetros variables y parámetros de palabras clave, las definiciones de interfaz función tal que no sólo puede manejar parámetros complejos, también puede simplificar el código de la persona que llama.
1. Los parámetros por defecto
Los parámetros por defecto para que la API es simple, pero sin perder flexibilidad. Cuando un parámetro tiene un valor predeterminado, cuando se llama a si no pasa este parámetro, se utilizará el valor predeterminado.
def inc (init, paso = 1): retorno init + Paso # llamar a esta función en >>> inc (3) 4 >>> inc (3, 2) 5
El parámetro por defecto tiene un pozo, que es parámetros no predeterminados para ser colocado en frente de los parámetros por defecto (de lo contrario Python intérprete informará de un error de sintaxis). Permite múltiples parámetros por defecto, pero los parámetros por defecto que poner la lista de parámetros de la superficie final.
def append (x, lst = []): retorno lst.append (x)
Esta función tiene un problema. (Función del parámetro es una variable global? Lst Lst llama la función de agregación, pero en el ámbito mundial, no sabemos LST nombre específico.)
Después de la función cambia de la siguiente manera:
def append (x, lst = None): si lst es Ninguno: LST = [] lst.append (x) lst retorno
En términos generales, cuando el parámetro por defecto es la variable de tiempo, es necesario prestar especial atención a la magnitud del problema, necesitamos por encima de habilidades (tipos de datos inmutables se pasan por valor, tipos de datos variables se pasan por referencia.). En la actualidad la lista variable de objeto, dict, juego, bytearray.
El parámetro por defecto es útil, pero el uso indebido caerá en un pozo. Los parámetros por defecto tienen la mayor fosa, demostrar lo siguiente:
Definir una función, pasando de una lista, añadir un extremo de vuelta
def add_end (L = []): L.append ( "END") de retorno L
Cuando llamamos a la normalidad, los resultados parecen ser bueno:
>>> add_end ([1, 2, 3]) [1, 2, 3, "END"] >>> add_end ([ "x", "y", "z"]) [ "x", "y ", "z", "END"]
Cuando se utilizan los parámetros por defecto, el resultado es el comienzo de la:
>>> add_end () [ "END"]
Sin embargo, cuando se llama add_end de nuevo (), el resultado no es correcto:
>>> add_end () [ "END", "END"] >>> add_end () [ "END", "END", "END"]
La razón se explica de la siguiente manera:
Cuando las funciones de Python definidas, el valor por defecto del parámetro L se calculó a cabo, es decir, [], porque el parámetro predeterminado L es también una variable que los puntos en el objeto [], cada vez que la función se llama, si L se cambia el contenido, la siguiente llamada, los parámetros por defecto se cambian, ya no es una definición de función [] a.
Por lo tanto, la definición de los parámetros por defecto a tener en cuenta una cosa: los parámetros por defecto debe apuntar a los mismos objetos!
Para modificar el ejemplo anterior, podemos utilizar este mismo objeto de implementar Ninguno:
def add_end (L = None): si L es Ninguno: L = [] L.append ( "END") de retorno L
¿Por str diseño, ninguna tal objeto constante? Dado que los objetos inmutables Una vez creados, los datos dentro de un objeto no se pueden modificar, reduciendo así los errores debidos a los cambios en los datos debido. Además, puesto que el objeto sin cambios, realizar múltiples tareas al mismo tiempo el medio ambiente leer objetos no lo hacen cerradura, y leyó ningún problema en absoluto. Cuando escribimos programas, si se puede diseñar un objetos inmutables, a continuación, tratar de diseñar el mismo objeto.
2. parámetros de posición
Vamos a escribir una función para calcular x ^ 2:
def potencia (x): return x * x
Para la función de alimentación (x), el parámetro es un parámetro de localización x. Cuando llamamos a la función de potencia, que debe haber pasado sólo un argumento y X:
>>> de potencia (5) 25 >>> potencia (15) 225
Ahora bien, si queremos calcular x ^ 3 cómo hacerlo? Power3 puede entonces definir una función, pero si se quiere calcular x ^ 4, 5 x ^, x ^ n, ¿cómo? No podemos definir un número ilimitado de funciones, podemos poner el poder (x) modificada al poder (x, n), se utiliza para calcular x ^ n, escrito y escribió:
def potencia (x, n): s = 1, mientras que n> 0: n = n - 1 s = s * x retorno s
3. Los argumentos de palabra clave
Los parámetros variables nos permiten pases 0 o cualquier número de parámetros, estos parámetros variables se montan automáticamente en una tupla de la llamada a la función. El parámetro clave le pasa 0 o cualquier número de parámetros, incluyendo el nombre del parámetro, los parámetros de estas palabras clave reunidos automáticamente en un diccionario dentro de la función. Ejemplos son los siguientes:
def persona (nombre, edad, kwargs **): print ( "nombre", el nombre, la "edad", la edad, el "otro", kwargs)
Además del nombre de la persona función parámetro obligatorio y la edad, pero también acepta parámetros kwargs de palabras clave. Cuando se llama a esta función, sólo se puede pasar parámetros obligatorios:
>>> persona ( "LavenLiu", 25) Nombre: Edad LavenLiu: 25 Otros: {}
También se puede pasar un número arbitrario de argumentos de palabra clave:
>>> persona ( "LavenLiu", 25) Nombre: Edad LavenLiu: 25 Otros: {} >>> persona ( "Taoqi", de 25 años, de la ciudad = "Hebei") Nombre: Edad Taoqi: 25 Otros: { "ciudad" : "Hebei"} >>> persona ( "James", de 31 años, sexo = "M", trabajo = "jugador de la NBA") nombre: James edad: 31 otros: { "género": "M", "trabajo": "jugador de la NBA"}
argumentos de palabra clave ¿Cuál es el uso? Se puede ampliar la funcionalidad de la función. Por ejemplo, en la función de la persona, podemos asegurar que el nombre recibido y edad de estos dos parámetros, sin embargo, si la persona que llama está dispuesto a proporcionar parámetros adicionales, que pueden recibir. Imagínese que usted está haciendo una función de registro de usuario, además del nombre de usuario y la edad son necesarios, hay otras opciones disponibles, utilizan parámetros de palabras clave para definir la función será capaz de cumplir con los requisitos de registro.
Los parámetros variables y similares, se pueden montar primero una dict, a continuación, para pasar en los parámetros de los convertidos dict palabras clave:
>>> kwargs = { "ciudad": "trabajo" "Hebei", "Test"} >>> persona ( "Taoqi", 25, ** kwargs) Nombre: Taoqi edad: 25 Otros: { "ciudad": "Hebei", "trabajo": "Prueba"}
4. parámetros de palabras clave y parámetros de posición
Los parámetros posicionales y parámetros de palabras clave es cuando el concepto de una llamada de función.
Cuando se utilizan los parámetros por defecto y los parámetros de palabras clave se combinan útil.
parámetros de palabras clave deben estar escritos después de los parámetros de posición, de lo contrario va a tirar un error de sintaxis.
def menos (x, y): return x - yminus (3, 5) el parámetro # posición, un signo menos parámetro de posición que pasa (5, 3) el parámetro # posición, un signo menos parámetro de posición que pasa (x = 5, y = 3) # palabras clave parámetros, los parámetros de palabras clave que pasan menos (y = 3, x = 5) los parámetros # clave, paso de parámetros de palabras clave
Los parámetros posicionales y parámetros de palabras clave pueden coexistir, pero los parámetros clave deben ser por escrito después de los parámetros posicionales.
Los parámetros de posición variable de
* Los parámetros variables definen la posición, en función vivo, el parámetro variable es la posición de una tupla.
parámetros de posición variable.
En [1]: def Fn (* args): ...: impresión (args) ...: En [2]: fn ((1, 2, 3, 4)) ((1, 2, 3, 4 ),) en [3]: tup01 = (1, 2, 3, 4) en [4]: fn (tup01) ((1, 2, 3, 4),) En [5]: fn (* tup01) (1, 2, 3, 4)
En función de la pitón, también se pueden definir los parámetros variables. El parámetro variable es el número de argumentos pasados es variable.
En [6]: def CaCl (* números): ...: suma = 0 ...: para n en números: ...: suma = suma + n * n ...: suma de retorno ...: En [7]: nums = [1, 2, 3] en [8]: CaCl (* nums) # donde si no precedida nums *, problemas? Fuera [8]: 14
6. Tales argumentos variables
** parámetros variables de palabras clave definidas en el cuerpo de la función, el parámetro variable es un diccionario de palabras clave. parámetros de palabras clave son la cadena de clave variable, y las especificaciones cumplen con la definición del identificador.
def fn (** kwargs): print (kwargs) dict01 = { "name": "Laven Liu", "edad": 29} fn (** dict01) # fn (dict01) fn (name = "Laven Liu", edad = 29) { "name": "Laven Liu", "edad": 29} { "name": "Laven Liu", "edad": 29}
parámetros de posición variable sólo se pueden llamar en forma de parámetros posicionales
El argumento de palabra clave variable sólo puede ser llamado como argumentos de palabra clave
Antes de que el parámetro de posición variable debe ser una palabra clave variable de argumentos
En [18]: def Fn (* args, ** kwargs): ...: impresión (args) ...: impresión (kwargs) ...: En [19]: fn (1, 2, 3, una = 1, b = 2) (1, 2, 3) { "a": 1, "b": 2} en [20]: FN de DEF (* args, x, y): ...: impresión (args ) ...: print (x, y) ...: En [21]: fn (1, 2, 3, 4) -------------------- -------------------------------------------------- ----- TypeError Rastreo (llamada más reciente pasado) <ipython-input-21-0ab4fbc96a17> en <módulo> () ----> 1 fn (1, 2, 3, 4) TypeError: fn () falta 2 requeridas de palabras clave de sólo argumentos: "x" e "y" En [22]: fn (1, 2, x = 3, y = 4) (1, 2) 3 4
parámetro variable trasera
Los parámetros variables y parámetros por defecto no aparecen juntos
7. La combinación de parámetros
En definidos por las funciones de Python, puede utilizar los parámetros obligatorios, los parámetros por defecto, parámetros variables y parámetros de palabras clave, estos cuatro parámetros se pueden utilizar juntos o sólo algunos, pero tenga en cuenta que el orden de los parámetros se debe definir: Los parámetros requeridos, los parámetros por defecto, parámetros variables y parámetros de palabras clave
Tales como la definición de una función, incluyendo los anteriores cuatro tipos de parámetros:
>>> def func (a, b, c = 0, * args, ** kwargs): ... print ( "a =", una "b =" b "" c = c, "args =", args, "kwargs =", kwargs)
Cuando la llamada a la función, la posición intérprete Python automáticamente de acuerdo con los parámetros y el correspondiente parámetro de nombre de parámetro pasado en ella.
>>> func (1, 2) a = 1 b = 2 c = 0 args = () kwargs = {} >>> func (1, 2, c = 3) a = 1 b = 2 c = 3 args = () kwargs = {} >>> func (1, 2, 3, "a", "b") a = 1 b = 2 c = 3 args = ( "a", "b") kwargs = {}> >> func (1, 2, 3, "a", "b", x = 99) a = 1 b = 2 c = 3 args = ( "a", "b") kwargs = { "x": 99 } >>>
El más sorprendente es a través de una tupla y dict, también puede llamar a la función:
>>> args = (1, 2, 3, 4) >>> kwargs = { "x": 99} >>> FUNC (* args, kwargs **) a = 1 b = 2 c = 3 args = ( 4,) kwargs = { "x": 99}
Por lo tanto, para cualquier función, puede ser invocado por un func similar (args *, kwargs **) forma, con independencia de sus parámetros están definidos.
8. deconstrucción Parámetro
Parámetros de deconstrucción se produce cuando la llamada de función, variable de función generadora de definición de parámetros. deconstrucción parámetros se dividen en dos tipos, uno es la deconstrucción parámetro de localización, el otro es un parámetro clave deconstrucción.
Dos formas de parámetros de la estructura:
Parámetros de ubicación deconstrucción, utilice un asterisco. objeto deconstrucción iterables resultado deconstrucción del parámetro de posición.
argumentos clave deconstrucción, utilice dos asteriscos. diccionario de objetos deconstrucción, el resultado de la deconstrucción como un parámetro clave.
Un ejemplo de parámetro de posición de deconstrucción:
En [23]: def fn (a, b, c): ...: impresión (a, b, c) ...: En [24]: LST = [1, 2, 3] en [25]: fn (LST [0], lst [1], lst [2]) 1 2 3 # de la forma también puede ser invocada en [26]: fn (* lst) # este enfoque se denomina parámetro de deconstrucción 123 # * Los números pueden ser desempaqueta configuración lineal posición parámetro lst = [1, 2, 3, 4] fn (* lst) # -> fn (LST [0], lst [1], lst [2], lst [3 ]) TypeError: fn () toma 3 argumentos posicionales pero 4 se les dio # ser dado aquí, esta función sólo recibiría tres parámetros posicionales, hay cuatro elementos LST, después de pasar a través de los parámetros de deconstrucción, cuatro parámetros se convierte así en el error.
Luego, busquen en el diccionario ejemplo de deconstrucción:
En [27]: d = { "a": 1, "b": 2, "c": 3} en [28]: fn (** d) 1 2 3 # ** Solución del diccionario se puede configurar palabras clave parámetros
Parámetros deconstrucción se produce cuando la función es llamada. Cuando la deconstrucción, deconstrucción lineal estructura es el parámetro de localización, diccionario deconstrucción es un parámetro clave.
Parámetro que pasa secuencia: parámetro de posición, una estructura de deconstrucción lineal; palabra clave de parámetro diccionario deconstrucción. Pruebe algunas utilización tanto de deconstrucción, a menos que realmente sabe qué hacer.
En [29]: def fn (a, b, c, d): ...: impresión (a, b, c, d) ...: En [30]: fn (0, * [2], c = 1, ** { "d": 3}) 0 2 1 39. parámetro ranura (parámetro de palabra clave-only) python3 introdujo. def fn (a, b, c): print (a, b, c) fn (a = 1, b = 2, c = 3)
Si desea forzar los parámetros de entrada como argumentos de palabra clave:
def fn (*, a, b, c): print (a, b, c) >>> fn (1, 2, 3) Rastreo (llamada más reciente pasado): El archivo "<pyshell # 17>", la línea 1 , en <módulo> fn (1, 2, 3) TypeError: después de fn () toma 0 argumentos posicionales pero 3 se les dio >>> fn (a = 1, b = 2, c = 3) 1 2 3 # * de parámetro debe pasar como parámetros de una palabra clave, llamados parámetros de ranura.
ranura Parámetros utiliza generalmente con parámetros por defecto.
>>> def fn (a, b, *, x, y): impresión (a, b) de impresión (x, y) >>> fn (1, 2, 3, 4) Rastreo (llamada último el más reciente): archivo "<pyshell # 23>", línea 1, en <módulo> fn (1, 2, 3, 4) TypeError: fn () toma 2 argumentos posicionales pero 4 se les dio >>> fn (1, 2, x = 3, y = 4) 1 23 4 >>> fn (1, 2, ** { "x": 3, "y": 4}) 1 23 4def fn (a, b, *): print (a, b) def fn (a, b, *): ... print (a, b) del archivo "<stdin>", la línea 1SyntaxError: argumentos con nombre debe seguir al descubierto *
Unos pocos ejemplos:
def FN01 (*, x = 1, y = 5): print (x) de impresión (y) >>> FN01 () 15def fn02 (x = 1, *, y): print (x) de impresión (y) >> > fn02 (y = 3) 13
Parámetros de ranura Pit:
* Después de que los parámetros deben tener
Cuando el parámetro llamado no tiene un valor por defecto, los parámetros con nombre puede no tiene valor predeterminado
Los parámetros por defecto debería ser el último parámetro en cada sección
Después de su uso en el parámetro, el parámetro de posición variable no puede ser utilizado, los parámetros clave deben ser colocados en el parámetro variable llamada
En tercer lugar, Uso avanzado
1. función recursiva
Dentro de la función, se puede llamar a otras funciones. Si una función se llama a sí mismo dentro de sí misma, esta función es una función recursiva.
def hecho (n): si n == 1: retorno 1 retorno n * hecho de (n-1)
La ventaja de utilizar la función recursiva es simple y lógica clara, la desventaja es demasiado profundo puede causar un desbordamiento de pila de llamadas.
Para la optimización de recursión de cola impide idioma desbordamiento de pila a través de la recursión de cola. bucle recursivo de cola y, de hecho, son equivalentes, no existe un lenguaje de programación de ciclos de bucle sólo puede lograrse a través de la recursión de cola.
2. lambda función anónima
Python usando lambda para crear una función anónima.
Sólo una expresión lambda, cuerpo de la función es mucho más simple que def.
expresión lambda es un cuerpo, en lugar de un bloque de código. Sólo podemos empaquetar una lógica limitado en la expresión lambda.
función lambda tiene su propio espacio de nombres, y no se puede acceder fuera de su propia lista de parámetros o parámetros de espacio de nombres global.
Aunque miradas función lambda sólo se puede escribir una sola línea, pero no es equivalente a C o C ++ funciones en línea, cuyo objetivo no ocupan la memoria de pila al llamar a funciones pequeñas para aumentar la eficiencia operativa.
fib = lambda n, x = 0, y = 1: x si no n otro fib (n-1, y, x + y) de impresión (fib (20))
3. función polimórfica Python
Un sentido de la operación depende del objeto tipo operado:
def veces (x, y): retorno X * Y >>> veces (2,4) >>> 8times ( "Python", 4) de datos # de transferencia con diferentes tipos de "PythonPythonPythonPython"
IV Resumen
funciones de Python tienen forma paramétrica muy flexible, ya sea llamada simple, y pueden pasar parámetros muy complejos.
El parámetro por defecto debe usar objetos inmutables, si el objeto es una variable, ejecute habrá un error lógico!
Para nota define la sintaxis de los parámetros variables y parámetros de palabras clave:
* Args es un parámetro variable, args se recibe una tupla;
** parámetros kwargs de palabras clave, kwargs recibieron un dict.
Y la forma de pasar parámetros variables y argumentos de palabra clave cuando se llama sintaxis de la función:
Ya sea directamente en el parámetro variable: func (1, 2, 3), sino también para reunir una lista o tupla, a continuación, pasa a través de args *: func (* (1, 2, 3));
parámetros de palabras clave se pueden pasar directamente: func (a = 1, b = 2) dict, sino también de montar, y luego pasa a través de kwargs: func ({ "a": 1, "b": 2}).
Uso * args y ** kwargs Python es el hábito de escribir, por supuesto, también se puede utilizar otro nombre de parámetro, pero el mejor uso de expresiones idiomáticas.
Nota: Muchas personas aprenden proceso de Python se encontrará con una variedad de problemas de que preocuparse, nadie ayuda a contestar fácil darse por vencido. Por esta razón pequeñas series construyeron un pitón-pila completa libre de Q y una falda: menos de siete Yiyi nueve jugadas de Pakistán y cinco de conversión (homónimo digital) se pueden encontrar, pero no los conductores de edad avanzada tienen problemas que resolver, también es el más reciente proyecto Tutorial de Python puede juntarse entre sí ,, supervisar el progreso juntos!
El texto y las imágenes en este artículo de la red con sus propias ideas, sólo para aprender, intercambiar, no para fines comerciales, pertenece al autor original
