Notas de estudo 6 do Python: o uso de funções e módulos e a discussão do escopo da variável

1. Uso da função

Hoje eu aprendi a postagem do blog de Luo Hao e resumi seus pontos de conhecimento relevantes, espero que seja útil para você.
Link original do GitHub

• 求解 ：$$C_M^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
encontra o valor = 35,0

1.1 O papel das funções

• Para o exemplo acima, usamos três loops for, o que fez com que o programa fosse repetido muitas vezes. O mestre da programação, Sr. Martin Fowler, disse uma vez: "O código tem muitos cheiros ruins, e a repetição é o pior deles!"
• Precisamos criar uma carta para encapsular essas mesmas funções nele

1.2 Definir funções

• Use a palavra-chave def para definir funções
• Depois que a função é executada, podemos usar a palavra-chave return para retornar um valor, que é equivalente à variável dependente da função em matemática

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 a função acima para definir tornará o programa mais conciso e simples

1.3 Parâmetros de função

• Os parâmetros da função podem ter valores padrão e também suportam o uso de parâmetros variáveis
• A configuração do parâmetro é flexível e há muitas maneiras de usá-lo

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 função (use a mesma função para completar funções diferentes)

• Definimos valores padrão para os parâmetros das duas funções acima, o que significa que se o valor do parâmetro correspondente não for passado quando a função for chamada, o valor padrão do parâmetro será usado, portanto, no código acima we A função __add__ pode ser chamada de várias maneiras diferentes, o que é consistente com o efeito da sobrecarga de função em muitas outras linguagens
• Na função __add__ acima, demos o número de parâmetros, mas se o número de parâmetros for desconhecido, o que devemos fazer?
  • Você pode adicionar um * na frente do parâmetro para indicar que o parâmetro é variável

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. Use funções de gerenciamento de módulo

• Para qualquer linguagem de programação, nomear identificadores, como variáveis ​​e funções, é uma dor de cabeça, porque encontraremos a situação embaraçosa de conflitos de nomenclatura. O cenário mais simples é definir duas funções com o mesmo nome no mesmo arquivo .py. Como o Python não tem o conceito de sobrecarga de função, a seguinte definição substituirá a anterior, o que significa que as duas funções com o mesmo nome na verdade só existe um
• O entendimento simples é que nomes de função repetidos serão substituídos pelo último

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

sayHi()

Olá Mundo!

2.1 Maneiras de resolver os problemas acima

• Crie um arquivo para cada módulo, como module1.py, module2.py ...
• Todos, em diferentes arquivos (módulos), funções com o mesmo nome são permitidas
• Ao usar, use a palavra-chave __import__ para importar o 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()

• Se o código for escrito como o seguinte, o último sayHi importado é chamado no programa, porque o sayHi importado posteriormente substitui o sayHi importado anteriormente

from module1 import sayHi
from module2 import sayHi

sayHi()# 输出hello

from module2 import sayHi
from module1 import sayHi

sayHi()# 输出hello, world!

Nota:

• Se o módulo que importamos tiver código executável além de definir funções, o interpretador Python executará esses códigos ao importar este módulo. Na verdade, podemos não querer isso, então se escrevermos a execução no módulo Código, é melhor para colocar esses códigos de execução nas condições mostradas abaixo, de modo que, a menos que o módulo seja executado diretamente, esses códigos sob a condição if não sejam executados, porque apenas o nome do módulo executado diretamente é "__ main __"

module3.py:

def foo():
    pass


def bar():
    pass


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

chamar foo ()
chamar barra ()

import module3

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

Caso 1: realize a função de cálculo do máximo divisor comum e mínimo múltiplo comum

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: implemente uma função para julgar se um número é um número de palíndromo

• Por exemplo: 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: realize uma função para julgar se um número é um 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:

• Pode-se ver a partir do programa acima que quando extraímos as funções repetitivas e relativamente independentes no código em funções, podemos usar essas funções em combinação para resolver problemas mais complexos, é por isso que definimos e usamos funções Um motivo muito importante.
  
  

3. Problemas sobre o escopo da variável em Python

• A ordem ao procurar variáveis:
  • Escopo local: c
  • Escopo aninhado: b
  • Escopo global: a
  • Escopo integrado, como alguns identificadores integrados, entrada, impressão, 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
olá
Verdadeiro
olá
35,0

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


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

Através do exemplo acima, sabemos que a saída final de a ainda é 100, pois, de acordo com a ordem de busca do python, quando a variável local for encontrada, ele não buscará mais por outras variáveis.

3.1. Se quiser usar o valor de uma variável local em uma variável global, você pode usar: palavra-chave global

3.2. Se você quiser que a função dentro da função seja capaz de modificar a variável no escopo aninhado, você pode usar: palavra-chave não local

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


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

Resumindo:

• No desenvolvimento real, devemos minimizar o uso de variáveis ​​globais, porque o escopo e a influência das variáveis ​​globais são muito amplos, e podem ocorrer modificações e uso inesperados. Além disso, as variáveis ​​globais têm mais do que as variáveis ​​locais O ciclo de vida pode causar a memória ocupados pelo objeto para não poderem ser coletados como lixo por muito tempo .
• Na verdade, reduzir o uso de variáveis ​​globais também é uma medida importante para reduzir o grau de acoplamento entre os códigos, e também é uma prática da lei de Dimit .
• Reduzir o uso de variáveis ​​globais significa que devemos tentar fazer o escopo das variáveis ​​na função do interior , mas se quisermos uma extensão do ciclo de vida da variável local, de modo que no final seja a definição de uma chamada de função que você ainda pode usar seu valor, desta vez você precisa usar encerramentos .