Notas de estudio de Python 6: el uso de funciones y módulos, y la discusión del alcance variable

1. Uso de funciones

Hoy me enteré de la publicación del blog de Luo Hao y resumí sus puntos de conocimiento relevantes, espero que te sea útil.
Enlace original de GitHub

• 求解 ：$$C_{METRO}^N=\frac{M!}{¡N!(M-N)!},\text{(M = 7, N = 3)}$$

m = int(input('m = '))
n = int(input('n = '))
fm = 1
for num in range(1, m + 1):
    fm *= num
fn = 1
for num in range(1, n + 1):
    fn *= num
fmn = 1
for num in range(1, m - n + 1):
    fmn *= num
    
print("求得值为 = {}".format(fm/fn/fmn))

m = 7
n = 3
encuentra el valor = 35.0

1.1 El papel de las funciones

• Para el ejemplo anterior, usamos tres bucles for, lo que hizo que el programa se repitiera demasiadas veces. El maestro de programación, el Sr. Martin Fowler, dijo una vez: "El código tiene muchos malos olores, ¡y la repetición es la peor!"
• Necesitamos crear una letra para encapsular estas mismas funciones en ella

1.2 Definir funciones

• Use la palabra clave def para definir funciones
• Después de que se ejecuta la función, podemos usar la palabra clave return para devolver un valor, que es equivalente a la variable dependiente de la función en matemáticas.

def factorial(num): # factorial：阶乘
    result = 1
    for n in range(1, num + 1):
        result *= n
    return result

m = int(input("m = "))
n = int(input("n = "))

print(factorial(m)/factorial(n)/factorial(m - n))

# 在Python的math模块中已经有一个factorial函数
# 就不需要自己定义函数了

import math

m = int(input("M = "))# 注意要将str强制转换为int
n = int(input("N = "))

c = math.factorial(m)/ \
    math.factorial(n)/ \
    math.factorial(m - n)
print(c)

m = 7
n = 3
35,0
M = 7
N = 3
35,0

Usar la función anterior para definir hará que el programa sea más conciso y simple

1.3 Parámetros de función

• Los parámetros de la función pueden tener valores predeterminados y también admitir el uso de parámetros variables
• La configuración de parámetros es flexible y hay muchas formas de usarla

from random import randint

def rollDice(n = 2):
    """摇色子"""
    total = 0
    for i in range(n):
        total += randint(1, 6)
    return total

def add(a=0, b=0, c=0):
    """三个数相加"""
    return a + b + c

# 如果没有指定参数那么使用默认值摇两颗色子
print(rollDice()) # 4

# 摇三颗色子
print(rollDice(3)) # 14
print(add())       # 0
print(add(1))      # 1
print(add(1, 2))   # 3
print(add(1, 2, 3))# 6

# 传递参数时可以不按照设定的顺序进行传递
print(add(c=50, a=100, b=200))   # 350

1.4 Sobrecarga de funciones (use la misma función para completar diferentes funciones)

• Establecemos valores predeterminados para los parámetros de las dos funciones anteriores, lo que significa que si el valor del parámetro correspondiente no se pasa cuando se llama a la función, se utilizará el valor predeterminado del parámetro, por lo que en el código anterior we La función __add__ se puede llamar de varias formas diferentes, lo cual es consistente con el efecto de la sobrecarga de funciones en muchos otros lenguajes
• En la función __add__ anterior, hemos dado el número de parámetros, pero si se desconoce el número de parámetros, ¿qué debemos hacer?
  • Puede agregar un * delante del parámetro para indicar que el parámetro es variable

def add(*args):
    total = 0
    for i in args:
        total += i
    return total


# 在调用add函数时可以传入0个或多个参数
print(add())          	# 0
print(add(1))			# 1
print(add(1, 2))		# 3		
print(add(1, 2, 3))		# 6

2. Utilizar funciones de gestión de módulos

• Para cualquier lenguaje de programación, nombrar identificadores como variables y funciones es un dolor de cabeza, porque nos encontraremos con la situación embarazosa de los conflictos de nombres. El escenario más simple es definir dos funciones con el mismo nombre en el mismo archivo .py. Dado que Python no tiene el concepto de sobrecarga de funciones, la siguiente definición anulará la definición anterior, lo que significa que las dos funciones con el mismo nombre en realidad solo existe uno
• El simple entendimiento es que los nombres de funciones repetidos serán sobrescritos por este último.

def sayHi():
    print("hello")
    return None
    
def sayHi():
    print('hello,world!')
    return None

sayHi()

¡Hola Mundo!

2.1 Formas de resolver los problemas anteriores

• Cree un archivo para cada módulo, como module1.py, module2.py ...
• Todas, en diferentes archivos (módulos), se permiten funciones con el mismo nombre
• Al usar, use la palabra clave __import__ para importar el módulo especificado

from module1 import sayHi

sayHi()

from module2 import sayHi

sayHi()


# 也可以使用下面的方法来区分使用了哪个 sayHi 函数
import module1 as m1
import module2 as m2

m1.sayHi()
m2.sayHi()

• Si el código está escrito como el siguiente, entonces el último sayHi importado se llama en el programa, porque el sayHi importado más tarde sobrescribe el sayHi importado

from module1 import sayHi
from module2 import sayHi

sayHi()# 输出hello

from module2 import sayHi
from module1 import sayHi

sayHi()# 输出hello, world!

Nota:

• Si el módulo que importamos tiene código ejecutable además de definir funciones, entonces el intérprete de Python ejecutará estos códigos al importar este módulo. De hecho, es posible que no queramos esto, así que si escribimos la ejecución en el código del módulo, es mejor poner estos códigos de ejecución en las condiciones que se muestran a continuación, de modo que a menos que el módulo se ejecute directamente, estos códigos bajo la condición if no se ejecutarán, porque solo el nombre del módulo ejecutado directamente es "__ principal __"

module3.py:

def foo():
    pass


def bar():
    pass


# __name__是Python中一个隐含的变量它代表了: 模块的名字
# 只有被Python解释器直接执行的模块的名字才是: __main__
if __name__ == '__main__':
    print('call foo()')
    foo()
    print('call bar()')
    bar()

llamar a foo ()
llamar a la barra ()

import module3

# 导入module3时, 不会执行模块中if条件成立时的代码 
# 因为模块的名字是module3而不是__main__

Caso 1: darse cuenta de la función de calcular el máximo común divisor y el mínimo común múltiplo

def gcd(x, y):
    
    # 求最大公约数:两个或多个整数共有约数中最大的一个
    # (x, y) = (y, x) if x > y else (x, y)
    for factor in range(y, 0 , -1):
        if x % factor == 0 and y % factor == 0:
            return factor

        
def lcm(x, y):
    # 求最小公倍数
    return x * y // gcd(x, y)


gcd(200, 45)
lcm(7, 7)

Caso 2: implementar una función para juzgar si un número es un número palíndromo

• Por ejemplo: 1234321

def isPal(num):
    temp = num
    total = 0
    while temp > 0:
        total = total * 10 + temp % 10
        temp //= 10
    return total == num

isPal(1234321)

Caso 3: Realice una función para juzgar si un número es un número primo

def isPrime(num):
    # 判断一个数是不是素数
    for factor in range(2, num):
        if num % factor == 0:
            return False
    return True if num != 1 else False

Nota:

• Se puede ver en el programa anterior que cuando extraemos las funciones repetitivas y relativamente independientes en el código en funciones, podemos usar estas funciones en combinación para resolver problemas más complejos, razón por la cual definimos y usamos funciones. Una razón muy importante.
  
  

3. Problemas sobre el alcance de la variable en Python

• El orden al buscar variables:
  • Alcance local: c
  • Alcance anidado: b
  • Alcance global: a
  • Alcance integrado, como algunos identificadores integrados, entrada, impresión, int, etc.

def foo():
    b = 'hello'  # 局部变量，在foo函数的外部并不能访问到它
                 # 对于foo函数内部的bar函数来说，变量b属于嵌套作用域
                 # 在bar函数中，可以访问到它
    
    # Python中可以在函数内部再定义函数
    def bar():
        
        #nonlocal b
        #b = "nonlocal" # 修改嵌套变量的值
        
        c = True # 局部作用域，在bar函数之外是无法访问
        print(a)
        print(b)
        print(c)

    bar()
    print(b)  
    print(c)     # NameError: name 'c' is not defined

if __name__ == '__main__':
    a = 100      # 全局变量，属于全局作用域
    foo()
    # print(b)   # NameError: name 'b' is not defined

100
hola
verdadera
hola
35,0

# 案例1：
def foo():
    a = 200
    print(a)         # 200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)         # 100

A través del ejemplo anterior, sabemos que la salida final de a sigue siendo 100, porque, según el orden de búsqueda de Python, cuando se encuentra la variable local, ya no buscará otras variables.

3.1. Si desea utilizar el valor de una variable local en una variable global, puede utilizar: palabra clave global

3.2. Si desea que la función dentro de la función pueda modificar la variable en el ámbito anidado, puede usar: palabra clave nonlocal

# 案例2：
def foo():
    global a
    a = 200
    print(a)  # 200


if __name__ == '__main__':
    a = 100
    foo()
    print(a)  # 200
    

para resumir:

• En el desarrollo real, debemos minimizar el uso de variables globales, porque el alcance y la influencia de las variables globales son demasiado amplios y pueden ocurrir modificaciones y usos inesperados. Además, las variables globales tienen más tiempo que las variables locales El ciclo de vida puede causar que la memoria ocupada por el objeto para que no pueda ser recolectada la basura durante mucho tiempo .
• De hecho, reducir el uso de variables globales también es una medida importante para reducir el grado de acoplamiento entre códigos, y también es una práctica de la ley de Dimit .
• Reducir el uso de variables globales significa que deberíamos intentar hacer el alcance de las variables en la función del interior , pero si queremos una extensión del ciclo de vida de la variable local, de modo que al final sea la definición de una llamada de función que aún pueda usar su valor, esta vez es necesario utilizar cierres .