Funciones avanzadas de Python

En la sección anterior aprendimos sobre la definición e invocación de funciones y comprendimos los conceptos básicos de la función. En esta sección, aprenderemos más sobre las funciones relacionadas con la función y obtendremos una comprensión profunda de las funciones, incluidos: parámetros predeterminados, parámetros de palabras clave, parámetros posicionales, alcance de las variables, etc.

Diferencia entre parámetros formales y parámetros reales.

Primero, primero entendamos dos conceptos:

Parámetros, que son nombres de parámetros declarados al definir una función, que definen los tipos de parámetros que la función puede aceptar;
Los argumentos son los valores reales pasados a la función cuando se llama a la función.
Por ejemplo, la siguiente definición de función:

def func(foo, bar=True, **kwargs):
    pass

Foo, bar, kwargs son los parámetros de una función.

Cuando llamamos func , por ejemplo:

func(20, bar=False, abc='xyz')

Los valores pasados a la función 20 , False y 'xyz' son argumentos.

Valor predeterminado del parámetro

El parámetro predeterminado es dar al parámetro un valor predeterminado cuando se define la función. Al llamar a esta función, no puede pasar valores a parámetros con valores predeterminados, por lo que los parámetros pueden reducirse cuando se le llama.

Vea el ejemplo a continuación:

def say_hi(name, greeting='Hi', more=''):
    print(greeting, name, more)

Esta función tiene tres parámetros, de los cuales el greeting y more tienen valores predeterminados. Al llamar a esta función, hay varias formas:

Pase solo un valor al nombre: say_hi ('Tom')
Pase el valor del parámetro opcional saludo: say_hi ('Tom', 'Hola')
Pasa valores para todos los parámetros: say_hi ('Tom', 'Hola', 'como estas')

Una función puede tener cualquier número de parámetros predeterminados, o todos los parámetros tienen valores predeterminados. Sin embargo, los parámetros que no tienen un valor predeterminado no pueden ser seguidos por un parámetro con un valor predeterminado, de lo contrario se informará un error. En otras palabras, el orden de los parámetros no debe ser un valor predeterminado antes del parámetro, hay un parámetro de valor predeterminado al final.

In [175]: def foo(a=1, b): 
     ...:     return a + b
  File "<ipython-input-175-f8e0e97b520a>", line 1
    def foo(a=1, b):
           ^
SyntaxError: non-default argument follows default argument

El valor predeterminado del parámetro solo se genera una vez. Si el valor predeterminado es un objeto variable como list, dict, set, etc., habrá diferentes resultados, así que tenga mucho cuidado al usarlo. En el siguiente ejemplo, el valor predeterminado es una lista vacía. Cuando se llama a la función, coloca el primer parámetro en la lista.

def func(a, L=[]):
    L.append(a)
    return L

print(func(1))
print(func(2))
print(func(3))

La salida del programa es:

[1]
[1, 2]
[1, 2, 3]

Esto se debe a que el valor predeterminado L se genera cuando se define la función, y las llamadas subsiguientes (que usan valores predeterminados, no pasan valores L) continuarán agregando elementos a la lista predeterminada generada en el momento de la definición.

Si quieres usar esta característica extraña, está bien, pero ten en claro qué es. Por lo general, no recomendamos valores predeterminados para objetos mutables, sino enteros inmutables, flotantes, cadenas, etc.

Parámetro de palabra clave

Al llamar a una función, podemos usar el "parámetro de palabra clave", que tiene la forma: kwarg=value . Por ejemplo, la llamada a la función say_hi anterior:

In [180]: say_hi(name='Tom')
Hi Tom 

In [181]: say_hi(name='Tom', greeting='Hello')
Hello Tom 

In [182]: say_hi(name='Tom', more='how are you')
Hi Tom how are you

In [183]: say_hi(more='good day', name='Tom', greeting='Hi')
Hi Tom good day

La última llamada anterior nos dice que el argumento de palabra clave es confirmar el argumento por palabra clave, por lo que no tiene que pasar el argumento en el orden en que se definió la función.

El parámetro de palabra clave es similar al parámetro predeterminado con el límite de posición del parámetro. El parámetro de palabra clave debe ir seguido del parámetro de palabra clave.
Las siguientes llamadas son inválidas:

say_hi()  # 缺少必须的参数name
say_hi(name='Tom', 'Hello')  # 关键字参数后面出现了非关键字参数
say_hi('Tom', name='Tim')  # 同样的参数传了两个值
say_hi(age=10)  # 函数定义中不存在的关键字参数

Si el último argumento de la definición de la función es dos asteriscos más el nombre: **name , entonces acepta un diccionario que contiene todos los argumentos de palabras clave. Este diccionario no incluye los argumentos normales declarados delante del nombre:

In [190]: def foo(a, **kwargs): 
     ...:     print(a) 
     ...:     for k, v in kwargs.items(): 
     ...:         print('%s : %s' % (k, v)) 
     ...:

In [191]: foo(1)
1

In [192]: foo(a=1)
1

In [193]: foo(a=1, b=2, c=3, d=4, e='a')
1
b : 2
c : 3
d : 4
e : a

Se puede ver que **kwargs ha recibido todos los parámetros de palabras clave después de a. Esto es muy útil cuando escribimos una gran cantidad de funciones en el futuro.

Lista de parámetros variables

La lista de argumentos variables es similar a la palabra clave argumento **kwargs porque no tiene clave y solo valor, por lo que es una secuencia (exactamente una tupla), que tiene la forma *args y tiene un asterisco * delante. Recibe un número indeterminado de parámetros. La función incorporada de print que utilizamos es una función de parámetro variable.
A continuación defino una función de parámetro variable:

In [197]: def foo(*args): 
     ...:     print(type(args)) 
     ...:     print('|'.join(args)) 
     ...:

In [198]: foo('a', 'b', 'c', 'd')
<class 'tuple'>
a|b|c|d

De forma similar, los parámetros variables deben ir seguidos de argumentos de palabras clave:

In [204]: def foo(*args, joiner='|'): 
     ...:     print(type(args)) 
     ...:     print(joiner.join(args)) 
     ...:

In [205]: foo('a', 'b', 'c', 'd')
<class 'tuple'>
a|b|c|d

In [206]: foo('a', 'b', 'c', 'd', joiner='/')
<class 'tuple'>
a/b/c/d

Desembalaje lista de parámetros

Esto es exactamente lo contrario de la lista de argumentos variables. Si el valor del argumento de la función a llamar ya está en la lista o tupla, podemos pasar el valor a la función desempaquetando la lista o tupla. Por ejemplo, la función de range() incorporada puede ingresar dos parámetros: iniciar y detener. Si están dentro de una lista o tupla, puede usar el operador * para descomprimir el valor:

In [207]: list(range(1, 8))
Out[207]: [1, 2, 3, 4, 5, 6, 7]

In [208]: args = [1, 8]

In [209]: list(range(*args))
Out[209]: [1, 2, 3, 4, 5, 6, 7]

Del mismo modo, dict puede pasar argumentos de palabras clave a través del operador ** :

In [212]: d = {'name':'Tom', 'greeting':'Hello', 'more':'good day'}

In [213]: say_hi(**d)
Hello Tom good day

Función lambda

Implementar una pequeña función anónima con la palabra clave lambda . Una función anónima devuelve un objeto de función que se puede pasar como un argumento de función a una función. Por ejemplo, el parámetro key en la función incorporada sortedacepta un objeto de función.

In [215]: func = lambda a, b: a * b

In [216]: func(1,2)
Out[216]: 2

In [217]: func(3,5)
Out[217]: 15

Echemos un vistazo al caso en el que la ordenación utiliza la función lambda, clasificando primero a los alumnos por su nombre y luego clasificándolos por edad:

In [218]: students = [ 
     ...: {'name': 'Tom', 'age': 12}, 
     ...: {'name': 'Jack', 'age': 13},  
     ...: {'name': 'Aby', 'age': 10},]

In [219]: sorted(students, key=lambda s: s['name'])
Out[219]: 
[{'name': 'Aby', 'age': 10},
 {'name': 'Jack', 'age': 13},
 {'name': 'Tom', 'age': 12}]

In [220]: sorted(students, key=lambda s: s['age'])
Out[220]: 
[{'name': 'Aby', 'age': 10},
 {'name': 'Tom', 'age': 12},
 {'name': 'Jack', 'age': 13}]

Ámbito y ciclo de vida de las variables.

Las variables en el programa no son visibles en ninguna parte, y tienen su propio alcance.

Variable local

Una variable definida dentro de una función solo es visible dentro de la función, es decir, es una variable local de la función.

In [1]: def func(): 
   ...:     x = 'hello' 
   ...:     print(x) 
   ...:

In [2]: func()
hello

In [3]: x
------------------------
NameError        Traceback (most recent call last)
<ipython-input-3-6fcf9dfbd479> in <module>
----> 1 x

NameError: name 'x' is not defined

x es una variable dentro de la func que es visible dentro de la función, por lo que la instrucción print(x) imprime el valor de x. Sin embargo, al acceder a x fuera de la función, se informa de un error: x no está definido.

Variable global

En relación con las variables locales, las variables globales se definen fuera de la función y tienen un alcance global.

In [4]: x = 'hello'

In [5]: def func2(): 
   ...:     print(x) 
   ...:

In [6]: func2()
hello

In [7]: x
Out[7]: 'hello'

Si desea modificar las variables globales dentro de una función, debe declarar la variable global con la palabra clave global :

In [8]: def func3(): 
   ...:     global x 
   ...:     x += 'world' 
   ...:     print(x) 
   ...:

In [9]: func3()
helloworld

In [10]: x
Out[10]: 'helloworld'

El ciclo de vida de una variable local comienza desde la llamada a la función hasta el final de la función, el ciclo de vida de la variable global es hasta el final del programa.

Función de borrado

En el capítulo anterior, usamos la palabra clave del para eliminar la lista o sus elementos, que también se puede usar para eliminar funciones:

In [11]: def func4(): 
    ...:     print('func4') 
    ...:

In [12]: func4()
func4

In [13]: del func4

In [14]: func4()
-------------------
NameError          Traceback (most recent call last)
<ipython-input-14-0e6ad11a93c1> in <module>
----> 1 func4()

NameError: name 'func4' is not defined

En Python, las funciones también son objetos, por lo que usar del eliminar funciones es como eliminar otros objetos.

Cadena de documento (cadena de documentación)

Un literal de cadena que aparece como la primera expresión dentro de una clase, función o módulo. Se ignora cuando se ejecuta el código, pero el intérprete lo reconoce y se coloca en el atributo doc de la clase, función o módulo. Debido a que se puede usar para la introspección de código, es la ubicación canónica donde los objetos almacenan documentos.

In [15]: def my_func(): 
    ...:     '''first line is summary of this function 
    ...:      
    ...:     the more lines are details of this function 
    ...:     ''' 
    ...:     pass 
    ...:

In [16]: print(my_func.__doc__)
first line is summary of this function

    the more lines are details of this function

Las reglas para escribir cadenas de documentación son generalmente así:
(1) La primera línea brinda una breve descripción de la función de la función o clase. (2) La segunda línea de espacios en blanco (3) Las siguientes líneas describen los parámetros, valores de retorno, etc. de la función en detalle.

Resumen

Al definir una función, el parámetro se denomina "parámetro de formulario", que expresa el tipo de parámetro; cuando se llama a la función, el parámetro es "parámetro real", que es el valor específico que se pasa a la función.

Al definir una función, puede especificar un valor predeterminado para el parámetro; cuando se llama a la función, se puede llamar con un argumento de palabra clave.

Para definir una función, puede especificar un parámetro como una lista de parámetros variables *args o **kwargs ; al llamar a una función, puede pasar argumentos desempaquetando listas, tuplas y dados.

Códigopara

搜尋此網誌