[Python] gramática básica-6, design de funções

1.6 Design de funções

Conceito de função

As funções podem ser usadas para definir código reutilizável, organizar e simplificar o código

# 计算1~10的和
sum = 0
for i in range(1, 11):
    sum += i
print(sum)
​
# 计算2~22的和
sum = 0
for i in range(2, 23):
    sum += i
print(sum)
​
# 计算9~101的和
sum = 0
for i in range(9, 102):
    sum += i
print(sum)
​
# 封装
def getSum(a, b):
    result = 0
    for i in range(a, b + 1):
        result += i
    return result
​
sum = getSum(1,10)
print(sum)
​
sum = getSum(2,22)
print(sum)
​
sum = getSum(9,101)
print(sum)

Uma função é um conjunto de instruções montadas para implementar uma operação

Quais são os benefícios das funções:

• O uso de funções pode reutilizar código, eliminando a necessidade de escrita de código repetitiva e melhorando a reutilização de código

• A função pode encapsular a implementação interna, proteger os dados internos e obter transparência para os usuários

• As funções tornam o programa modular, com clara divisão de trabalho, o que é propício para leitura, depuração e modificação.

Definição de função

Os principais componentes da função são: nome da função, parâmetros, corpo da função e valor de retorno

def 函数名称(参数):
    函数体
    return 返回值

Os parâmetros são chamados de parâmetros formais ou parâmetros formais.Quando a função é chamada de fora, alguns dados são passados, e esses dados são recebidos pelos parâmetros formais. Os dados transmitidos são chamados de parâmetro real ou parâmetro real . O parâmetro é opcional.

num1 = 30;
num2 = 40;
sum = getSum(num1,num2)
print(sum)

Algumas funções têm valores de retorno e outras não. Não há retorno sem valor de retorno? Se não houver valor de retorno, o retorno será oculto.

def getSumPrint(a,b):
    result = 0
    for i in range(a, b + 1):
        result += i
    print(result)
    # return
​
getSumPrint(10,20)

O corpo da função contém um conjunto de instruções que definem o que a função faz.

Retorno significa apenas o fim da operação da função. Uma vez que o processo de execução da função encontra a instrução return, todo o código após a função é ignorado e o corpo da função é retirado diretamente e a função termina imediatamente, mesmo em um loop. E se a função não tiver valor de retorno, ela retornará Nenhum por padrão; se houver um valor de retorno, basta escrevê-lo após o retorno, encerrar a função e retornar o resultado ao chamador.

def func01(a):
    if a == 10:
        print("哈哈")
        return
    print("嘻嘻")
    return
​
func01(11)
res = func01(10)
print(type(res))
​
def func02(a):
    for i in range(1,11):
        if i == a:
            print(i)
            # break 跳出循环 接着向下运行
            return  # 直接结束函数
        print(i)
    print("啦啦")
    return
​
func02(11)
func02(4)

O que pode ser devolvido?

• Não devolva nada:return

• Qualquer tipo de dados:return 'hello'

• Uma expressão:return 1 + 2

• Uma declaração de julgamento:return 3 > 2

• Uma variável:return a

• Uma chamada de função:return func()

• Vários valores de retorno, separados por vírgulas:return a,1+2,'hello'

• Até mesmo volte a si mesmo:return self

As funções podem retornar quase todos os objetos de dados Python.

Passagem de parâmetros

As funções geralmente têm parâmetros, que são usados ​​para passar dados externos reais para a função para processamento. No entanto, ao processar parâmetros de diferentes tipos de dados, as duas coisas a seguir acontecerão:

• Quando uma função Python passa parâmetros, ela passa o endereço de memória do objeto real

• Os tipos de dados Python são divididos principalmente em objetos mutáveis ​​e objetos imutáveis

def func(a): # 局部变量
    print("函数内部没有修改前",id(a)) # 520
    a = 2
    print("函数内部修改后",id(a)) # 536
    print("函数内部修改后a=",a) # 2
    return
​
a = 1   # 全局变量
print("调用函数之前",id(a))   # 520
func(a)
print("调用函数之后",id(a))   # 520
print(a)

def test(lst) :
    lst.append(4)
    print(id(lst))
    print(lst)
​
lst = [1,2,3] # 列表
print(id(lst))
test(lst)
print(id(lst))
print(lst)

Em relação à transferência de parâmetros, como Python é uma linguagem dinâmica, não há distinção de tipo de dados para variáveis, então a função não detectará o tipo de dados do parâmetro real, mas detectará o número; a detecção do tipo de dados só será detectada quando a função estiver em execução. sair.

def add(a, b):
    return a + b
​
add(1, 2)
add(1, 2, 3)
​
Traceback (most recent call last):
  File "C:/Users/HENG/Desktop/PythonCode/Day04/FunctionTest05.py", line 5, in <module>
    add(1, 2, 3)
TypeError: add() takes 2 positional arguments but 3 were given
    
add(1, "hello")
​
Traceback (most recent call last):
  File "C:/Users/HENG/Desktop/PythonCode/Day04/FunctionTest05.py", line 6, in <module>
    add(1, "hello")
  File "C:/Users/HENG/Desktop/PythonCode/Day04/FunctionTest05.py", line 2, in add
    return a + b
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Mecanismo de operação de função

Uma pilha é um contêiner do primeiro a entrar e último a sair.

As funções são executadas com base na pilha. Cada vez que uma função é chamada, o sistema cria automaticamente um espaço de memória para a função, também chamado de quadro de pilha, armazena seus parâmetros, variáveis ​​e instruções de execução e, em seguida, empurra o quadro de pilha para a pilha para iniciar a execução. Quando uma função chama outra nova função, então o sistema cria um novo quadro de pilha, empurra o quadro de pilha para a pilha e começa a ser executado, então a primeira função é suspensa até que todas as funções nela sejam executadas, a primeira A função continua a ser executada.

def multi(a, b, c):
    return a ** 2, b ** 2, c ** 2
​
def add(a, b, c):
    return a + b + c
​
def out(s):
    print(s)
​
def test(a, b):
    num1, num2, num3 = multi(a, b, a + b)
    out('hello')
    return add(num1, num2, num3)
​
num = test(2, 3)
print(num)

Escopo variável

As variáveis ​​definidas dentro da função são chamadas de variáveis ​​locais . Variáveis ​​locais só podem ser acessadas dentro da função. A função onde o escopo da variável local está localizado é colocada na pilha e executada até que a função termine e saia da pilha.

Também é possível definir variáveis ​​globais , que são definidas fora de todas as funções e podem ser acessadas por todas as funções.

Exemplo 1:

globalVar = 1
num1 = 3
num2 = 10
def f1():
    localVar = 2    # 局部变量 在该函数内创建
    print(globalVar)    # 全局变量
    print(localVar)     # 局部变量
    print(num1 + 3)      # num1 全局变量
    num2 = 20       # 局部变量 在该函数内创建
    print(num2)
    # 如果直接将全局变量，参与运算，直接打印 调用的就是全局变量
    # 如果是对全局变量进行修改，则为创建一个同名的局部变量
f1()
print(globalVar)
print(num2)
# NameError: name 'localVar' is not defined
# print(localVar)

Exemplo 2:

x = 1
def f2():
    global x    # 在函数内部将x标记为全局变量，如果存在则复用，不存在则创建全局变量
    x = 2
    print(x)
​
f2()
print(x)
==========================================
def f2():
    global x    # 在函数内部将x标记为全局变量，如果存在则复用，不存在则创建全局变量
    x = 2
    print(x)
​
f2()
print(x)

Exemplo 3:

x = int(input("Enter a number:"))
if x > 0:
    y = 4   # 全局变量 只有在x>0的条件下创建
print(y)
​
Enter a number:-10
Traceback (most recent call last):
  File "C:/Users/HENG/Desktop/PythonCode/Day04/FunctionTest05.py", line 52, in <module>
    print(y)
NameError: name 'y' is not defined

Exemplo 4:

sum = 0
for i in range(5): # i 全局变量
    sum += i
print(i) # --> 4