Función de orden superior del parámetro real
1. Una función cuyo parámetro es una función es un parámetro real función de orden superior
def func4 (f):
print (f (10, 20) * 2) # print (func1 (10, 20) * 2)
def func1 (* nums):
return [1, 2]
func4 (func1)
- Aplicación de funciones de orden superior de los parámetros del sistema
max / min, ordenados, mapear, reducir
1) max, min
a. Uso común: max (secuencia) -encontrar el valor máximo de los elementos en la secuencia (los tipos de los elementos en la secuencia deben ser los mismos, y los elementos Debe soportar la operación de comparación en sí misma)
b. Parámetro real función de orden superior:
max (secuencia, tecla = función) -personalizar la forma de encontrar el valor máximo a través de la función.
Secuencia-necesidad de obtener la
función de secuencia correspondiente a un cierto valor máximo -tiene y solo un parámetro (Señale / represente cada elemento en la secuencia); hay un valor de retorno (el objeto de comparación cuando se busca el valor máximo)
nums = [93, 45, 67, 122]
Encuentra el elemento más grande
print (max (nums))
Encuentre el elemento con el
resultado de un solo dígito más grande = max (nums, key = lambda item: item% 10)
print (result) # 67
Encuentre el elemento con el dígito de decenas más grande
result = max (nums, key = lambda item: item // 10% 10)
print (result)
Encuentre el elemento con la mayor suma de dígitos
12, 15, 13, 5
nums = [930, 456, 67, 122]
方法 一 ：
def sum1 (elemento):
s = 0
para x en str (elemento):
s + = int (x)
return s
resultado = max (nums, key = sum1)
print (resultado)
方法 二 ：
resultado = max (nums, key = lambda item: sum ([int (x) for x in str (item)]))
print (resultado)
Ejercicio: Se conoce la siguiente lista:
estudiantes = [
{'nombre': 'estudiante1', 'edad': 20, 'puntaje': 67, 'sexo': 'Hombre'},
{'nombre': 'estudiante2', ' age ': 18,' score ': 82,' sex ':' 女 '},
{' name ':' stu3 ',' age ': 19,' score ': 54,' sex ':' 女 '},
{'name': 'stu4', 'age': 22, 'score': 77, 'sex': 'Male'},
{'name': 'stu5', 'age': 21, 'score': 56 , 'sexo': 'Hombre'},
{'nombre': 'estudiante6', 'edad': 18, 'puntuación': 78, 'sexo': 'Hombre'},
{'nombre': 'estudiante7', ' edad ': 16,' puntuación ': 100,' sexo ':' 女 '}
]
1) Busque la información del estudiante de mayor
edad en la lista result = max (estudiantes, clave = lambda elemento: elemento [' edad '])
imprimir ( 'El alumno de mayor edad:', resultado)
2) Busque la información del alumno con la puntuación más baja en la lista
result = min (estudiantes, clave = elemento lambda: elemento ['puntuación'])
print ('El estudiante con la puntuación más baja:', resultado)
3) Buscar información sobre el estudiante de mayor edad entre las niñas.
resultado = max ([x para x en estudiantes si x ['sexo'] == '女'], clave = lambda elemento: elemento ['edad'])
print ('La niña mayor:', resultado)
4) Encuentra información sobre el alumno más joven entre los chicos
nums = [10, 23, 30, 40, 51]
Caso de uso derivado 1: transformar todos o parte de los elementos en la secuencia original
1) Multiplicar todos los elementos por 2
nums2 = [2 * x para x en nums]
print (nums2) # [20, 46, 60, 80, 102]
2) Multiplica todos los números pares por 2
nums3 = [x if x & 1 else x * 2 for x in nums]
print (nums3) # [20, 23, 60, 80, 51]
Caso de uso inferido 2: Extraer (eliminar) algunos elementos
3) Obtener elementos impares
nums4 = [x para x en nums si x & 1]
print (nums4) # [23, 51]
2) ordenado
uso 1: ordenado (secuencia): ordena los elementos en la secuencia de pequeños a grandes de acuerdo con el tamaño de los elementos.
Uso 2:
ordenado (secuencia, tecla = función)
función tiene y solo un parámetro (apunta a / representa cada uno en la secuencia) Elementos); hay un valor de retorno (comparando el tamaño del valor de retorno para la clasificación; el valor de retorno es el criterio de clasificación)
nums = [115, 34, 62, 89, 102]
a. Ordenar por tamaño de elemento de secuencia
result = sorted (nums, key = lambda item: item)
print (result) # [34, 62, 89, 102]
b. Ordenar según el tamaño del dígito único del elemento de secuencia
result = sorted (nums, key = elemento lambda: elemento% 10)
print (resultado)
Ejercicio: Ordene los elementos en los datos según el valor numérico correspondiente
datas = [23, '78', 56, '34', '102', 79]
Resultado: [23, '34', 56, '78', 79 , '102']
result = sorted (datas, key = lambda item: int (item))
print (result) # [23, '34', 56, '78', 79, '102']
resultado = ordenado ([int (x) para x en datos])
print (resultado) # [23, 34, 56, 78, 79, 102]
Ordene la lista de estudiantes según sus puntajes de
mayor a menor resultado = ordenado (estudiantes, clave = elemento lambda: elemento ['puntaje'], reverso = Verdadero)
imprimir (resultado)
Ordene las puntuaciones de los estudiantes en la lista de estudiantes de pequeñas a grandes
puntuaciones_alumnos = [x ['puntuación'] para x en estudiantes]
resultado = ordenado ( puntuación_estudiantes )
imprimir (resultado)
Uso del mapa uno:
mapa (función, secuencia): genera una nueva secuencia después de la transformación especificada de los elementos en la secuencia original (el objeto devuelto es el mapa, que es esencialmente una secuencia)
a. Función: tiene y solo un parámetro (señalar / representar Elementos en la siguiente secuencia); hay un valor de retorno (elemento en la nueva secuencia)
Utilice dos
mapas (función, secuencia 1, secuencia 2): generar una nueva secuencia, los elementos de la secuencia son los elementos de la secuencia 1 y la secuencia 2 generados por la transformación especificada
a. Función: con y solo dos parámetros (los dos Los parámetros apuntan a los elementos en la secuencia 1 y los elementos en la secuencia 2 respectivamente);
hay un valor de retorno (elemento en la nueva secuencia)
Genere una nueva lista, la lista es el cuadrado de los elementos en
nums nums = [1, 2, 3, 4]
result = list (map (lambda item: item ** 2, nums))
print (result) # [1, 4, 9, 16]
Genere una nueva lista, los elementos de la lista son seq1 más elementos en seq2
seq1 = (1, 2, 3, 4)
seq2 = [5, 6, 7, 8]
result = list (map (lambda item1, item2: item1 + item2, seq1, seq2))
print (resultado) # [6, 8, 10, 12]
Ejercicio: agregue todos los números de teléfono en tels a cada diccionario en los estudiantes por turno y genere una nueva lista
estudiantes = [
{'nombre': 'stu1', 'edad': 20, 'puntaje': 67, ' sex ':' Male '},
{' name ':' stu2 ',' age ': 18,' score ': 82,' sex ':' Female '},
{' name ':' stu3 ',' age ' : 19, 'score': 54, 'sex': '女'},
{'name': 'stu4', 'age': 22, 'score': 77, 'sex': 'Male'},
{' name ':' stu5 ',' age ': 21,' score ': 56,' sex ':' 男 '},
{' name ':' stu6 ',' age ': 18,' score ': 78,' sex ':' Male '},
{' name ':' stu7 ',' age ': 16,' score ': 100,' sex ':' Female '}
]
tels = [' 110 ',' 120 ',' 114 ',' 119 ',' 12306 ',' 10086 ',' 10000 ']
Método 1:
def add_key (item1, item2):
item1 ['tel'] =
item2 return item1
resultado = lista (mapa (agregar_clave, estudiantes, tels))
imprimir (resultado)
Método 2:
resultado = lista (mapa (lambda x, y: eval (f '{str (x) [: - 1]}, "tel": "{y}"}}'), estudiantes, tels))
imprimir ('Método 2:', resultado)
方法 三 ：
print (list (map (lambda item1, item2: [item1.setdefault ('tel', item2), item1] [1], estudiantes, tels)))
Suplemento: el uso de la función
eval eval (secuencia de secuencia)
-convierte una cadena de una secuencia que satisface el formato de especificación en una secuencia dict1 = {'nombre': 'stu7', 'edad': 16, 'puntuación': 100, 'sexo ':' 女 '}
dict1_str = str (dict1) # “{' nombre ':' stu7 ',' edad ': 16,' puntuación ': 100,' sexo ':' 女 '}”
dict2 = eval (dict1_str)
print (dict2, type (dict2)) # {'nombre': 'stu7', 'edad': 16, 'puntuación': 100, 'sexo': '女'} <class'dict '>
list_str = “[1, 2, 3, 4]”
list1 = eval (list_str)
print (list1, type (list1)) # [1, 2, 3, 4] <class 'list'>
4)
Antes de usar reduce, debe importarlo desde el módulo de funciones.
Uso uno (entender):
reducir (función, secuencia) -fusionar los elementos de la secuencia en un solo dato de acuerdo con las reglas especificadas
a. Función-tiene y solo dos parámetros, el primero Cuando el parámetro se llama por primera vez, apunta al primer elemento de la secuencia. A partir de la segunda vez, apunta al resultado de la operación anterior; el segundo parámetro apunta a todos los elementos excepto al primer elemento; el
valor de retorno es cada vez El resultado de la fusión (utilizado para personalizar las reglas de fusión)
Uso dos (maestro):
reducir (función, secuencia, valor inicial)
a. Función: el
primer parámetro: el primer tiempo apunta al valor inicial; desde el segundo tiempo el parámetro apunta al resultado de la última combinación. El
segundo parámetro: apunta a la secuencia Todos los elementos del
valor devuelto: el resultado de cada combinación (utilizado para personalizar las reglas de combinación)
"" "
de las funciones de importación reducir
============== Uso uno (comprensión) ================= i
números = [10, 11, 12, 13, 14]
def func1(x, y):
print(f’x:{x}, y:{y}’)
return x+y
"" "
Primera vez: x = 10; y = 11; x = x + y,
segunda vez: x = 21; y = 12; x = x + y
tercera vez: x = 33; y = 13; x = x + y
cuarta vez: x = 46; y = 14; x = x + y
…
"" "
resultado = reducir (func1, nums)
imprimir (resultado)
Calcule la suma de un solo dígito de [29, 38, 90, 34, 67] elementos
nums = [29, 38, 90, 34, 67]
Método incorrecto:
resultado = reducir (lambda x, y: x% 10 + y% 10, nums)
imprimir (resultado)
Concatenar los dígitos individuales de todos los números en nums: "98047"
reduce (lambda x, y: str (x% 10) + str (y% 10), nums)
============== Uso 2 (Maestro) ================= i
números = [10, 11, 12, 13, 14]
def func2(x, y):
print(f’x:{x}, y:{y}’)
return x+y
resultado = reducir (func2, nums, 0)
imprimir (resultado)
Ejercicio: Calcule la suma de un solo dígito de [29, 38, 90, 34, 67]
nums = [29, 38, 90, 34, 67]
resultado = reduce (lambda x, y: x + y% 10, nums, 0)
imprimir (resultado)
Ejercicio: Concatenar los dígitos individuales de todos los números en nums: "98047"
resultado = reduce (lambda x, y: x + str (y% 10), nums, '')
print (resultado) # '98047'
Ejercicio: Encuentre la puntuación total de todos los estudiantes en el
resultado de estudiantes = reducir (lambda x, y: x + y ['puntuación'], estudiantes, 0)
imprimir (resultado) # 514
Decorador
Decorador es una función especialmente utilizada para agregar funciones a otras funciones
Agregue la función de contar el tiempo de ejecución a la función
Método 1: agregue directamente el código correspondiente a la nueva función en la función que debe agregarse (desventaja: el mismo código de función puede necesitar escribirse varias veces)
def func1 ():
start = time.time ( )
print ('¡hola mundo!')
end = time.time ()
print ('tiempo de ejecución:', end-start)
def func2 (x, y):
start = time.time ()
z = x + y
print ('y:', z)
end = time.time ()
print ('tiempo de ejecución:', end-start)
func1 ()
func2 (10, 20)
Método 2: Defina una función de orden superior con parámetros reales para agregar funciones a la función especificada (desventaja: inversión primaria y secundaria)
def count_time (func, * args, ** kwargs):
start = time.time ()
# ejecutar la función original
func (* args, ** kwargs)
end = time.time ()
print (' Tiempo de ejecución:', fin-inicio)
方式 三 ： 装饰 器
def add_time (func):
def test (* args, ** kwargs):
start = time.time ()
result = func (* args, ** kwargs)
end = time.time ()
print (' tiempo de acción: ', end-start)
return result
return test
@add_time
def func3 ():
print ('¿cómo estás?')
@add_time
def func4 (num):
print (num * 2)
func3 ()
count_time (func3)
func4 (10)
count_time (func4, 5)
Cómo escribir decorador sin argumentos decorador
= parámetro real función de orden superior + valor de retorno función de orden superior + sintaxis de azúcar
Rutina:
def nombre de función 1 (parámetro 1):
def nombre de función 2 (* args, ** kwarg):
resultado = parámetro 1 (* args, ** kwarg)
segmento de código para realizar la función agregada
retorno resultado
retorno nombre de función 2
Descripción:
nombre de la función 1-el nombre del decorador (nombrado de acuerdo con la función agregada por el decorador actual)
parámetro 1-este parámetro se usa para recibir la función de la función agregada (apuntando a la función original), generalmente nombrada directamente como: func
nombre de la función 2 -Significa una nueva función con funciones agregadas sobre la base de la función original, generalmente nombrada directamente como un nombre fijo: prueba, new_func
Use decorator: agregue antes de la definición de la función que debe agregarse: @decorator name
"" "
print ('======================== ================== ')
Ejemplo 1: escribir un decorador e imprimir después del final de la función originalFin de función= '
def end (func):
def new_func (* args, ** kwargs):
result = func (* args, ** kwargs)
print ('Fin de función= ')
devolver resultado
devolver new_func
@end
def func5 (x, y):
print (x + y)
@end
def func6 ():
print ('hola, decorador')
@end
def func7 (num):
result = reduce (lambda x, y: x * y, range (1, num + 1), 1)
return result
func5 (10, 30)
func6 ()
re = func7 (5)
print ('re:', re)
Ejemplo 2: Escribe un decorador. Si el valor de retorno de la función original es un entero, devuelve la expresión binaria de este número
def binary (func):
def new_func (* args, ** kwargs):
result = func (* args, ** kwargs)
if type (result)! = int:
return result
return bin (result)
return new_func
@binary
def func7 (x, y):
return x + y
print (func7 (20, 30)) # 0b110010
print (func7 (1.23, 2.34)) # 3.57
print (func7 ('abc', '123')) # abc123