Resumen de varios principios de diseño de métodos de funciones de Python

En cualquier lenguaje de programación, la aplicación de funciones se debe principalmente a las dos situaciones siguientes:

1. Los bloques de código se repiten. En este momento se debe considerar el uso de funciones. para reducir la redundancia del programa.

2. Cuando el bloque de código es complejo, puede considerar el uso de funciones para mejorar la legibilidad del programa.

Cuando el proceso es lo suficientemente complejo. , debes considerar las funciones y cómo usarlas. Al diseñar funciones en Python, consideramos principalmente tres aspectos: tamaño de función, agregación y acoplamiento. Estos tres aspectos deben atribuirse al alcance de la planificación y el diseño. Alta cohesión y bajo acoplamiento son los principios generales del diseño de funciones en cualquier idioma.

1. Cómo descomponer las tareas en funciones más específicas, lo que conduce a la agregación

2. Cómo diseñar la comunicación entre funciones también implica el acoplamiento

3. diseñar el tamaño de una función para fortalecer su agregación y reducir su acoplamiento

Agregación

Cada función solo hace una cosa

Programación perfecta, cada función solo debe haz una cosa.

Por ejemplo: Meter un elefante en el frigorífico implica tres pasos: abrir la puerta, meter el elefante dentro y cerrar la puerta.

De esta manera, debes escribir tres funciones en lugar de una función para hacer todo. De esta manera, la estructura es clara y en capas, ¡lo que la hace fácil de entender!

Tamaño

Mantenlo simple, mantenlo breve

Python es un lenguaje orientado a procesos y un lenguaje orientado a objetos, pero sirve más como un Rol del lenguaje de scripting.

Para la misma función, la longitud del código usando Python puede ser 1/3 de la de C/C/Java y otros lenguajes. ¡Unos pocos cientos de líneas de código pueden lograr bastantes funciones!

Si una función diseñada en el proyecto requiere pasar páginas para leerse, considere dividir la función.

Entre los más de 200 módulos que vienen con Python, es raro ver una función con dos o tres páginas.

El código Python es conocido por su simplicidad y claridad, y una función que es demasiado larga o profundamente anidada es a menudo un signo de un defecto de diseño.

Acoplamiento

Utilice parámetros para la entrada y declaraciones de retorno para la salida.

Esto puede hacer que la función sea independiente de elementos externos a ella. Los parámetros y las declaraciones de retorno son la mejor manera de aislar las dependencias externas.

Utilice las variables globales con precaución

Primera consideración: las variables globales suelen ser una forma deficiente de comunicarse entre funciones.

Causará problemas de dependencia y sincronización, lo que dificultará la depuración y modificación del programa.

La segunda consideración: desde la perspectiva del código y la optimización del rendimiento, las variables locales son mucho más rápidas que las variables globales.

Según el orden de búsqueda de variables de Python: Variables de función local==》Variables de función de nivel superior==》Variables globales==》Variables integradas

Como puede ser Como se ve en lo anterior, primero se buscan las variables locales y, una vez encontradas, se detiene.

Se prueba específicamente a continuación y los resultados de la prueba son los siguientes:

importar perfil

A = 5

def param_test():

B = 5

res = 0

para i en el rango (100000000):

res = B i

devolver res

if __name__=='__main__':

perfil.run('param_test()')

gt;gt;gt; === ==== ============================== REINICIAR =============== ==== ==================

gt;gt;gt;

5 llamadas a funciones en 37.012 segundos #Global resultados de prueba variables: 37 segundos

Ordenado por: nombre estándar

ncalls tottime percall cumtime percall nombre de archivo: lineno(función)

1 19.586 19.586 19.586 19.586 : 0 (rango)

1 1.358 1.358 1.358 1.358: 0(setprofile)

1 0.004 0.004 35.448 35.448: 1()

1 15.857 15.857 35.443 35.443 Aprender. py: 5( param_test)

1 0.206 0.206 37.012 37.012 perfil: 0 (param_test())

0 0.000 0.000 perfil: 0 (perfilador)

gt ;gt;gt ; ===================================== REINICIAR ======= ==== ==========================

gt；gt；gt; 5 llamadas a funciones en 11,504 segundos #Resultado de la prueba de variable local: 11 segundos

Ordenado por: nombre estándar

ncalls tottime percall cumtime percall nombre de archivo: lineno(función)

1 3,135 3,135 3,135 3,135 :0(rango)

1 0,006 0,006 0,006 0,006 :0(setprofile)

1 0,000 0,000 11,497 11,497 :1()

1 8,362 8,362 11,497 11,497 Learn.py：5(param_test)

1 0,000 0,000 11,504 11,504 perfil：0(param_test())

0 0,000 0,000 perfil

:0 (perfilador)

Evite cambiar los parámetros de tipo de variable

Los tipos de datos de Python, como listas y diccionarios, son objetos mutables. Cuando se pasan como argumentos a funciones, a veces se modifican como variables globales.

La desventaja de esto es que mejora el acoplamiento entre funciones, haciendo que las funciones sean demasiado especiales y poco amigables. También es difícil de mantener.

En este momento, deberías considerar usar el segmento S[:] y las funciones copy() y deepcopy() en el módulo de copia para hacer una copia y evitar modificar el objeto variable.

Específico Consulte este artículo: Explicación detallada de copias profundas y superficiales en Python

Evite cambiar variables directamente en otro módulo

Por ejemplo, importe un módulo en el archivo b.py y hay variables en un PI = 3.14, pero b.py quiere cambiarlo a: PI = 3.14159 Aquí no puedes averiguar cuál es el valor original de la variable PI. Cuando se encuentre con esta situación, puede considerar el uso de nombres de funciones fáciles de entender:

#Module a.py

PI = 3.14

def setPi(new ):

PI = nuevo

devuelve PI

De esta manera tienes el valor de PI que deseas sin cambiar el valor de PI en el módulo a< / p>

importar un

PI = a.setPi(3.14159)

imprimir PI