Python Basics-08 Function Basics

o que é uma função

• Um monte de códigos preparados que podem ser chamados quando necessário
• Desvantagens representadas por código repetido: redundância, baixa capacidade de manutenção
• Portanto, para agrupar várias linhas de código em um todo: a função
• Em Python, use a palavra-chave def para declarar uma função

# def 函数名():
#   函数要执行的操作

• Depois que a função é definida, ela não será executada automaticamente
• Precisa usar o nome da função (parâmetro) para chamar
• Um nome de função também é um identificador
• Composto por números, letras e sublinhados, não pode começar com um número e diferencia maiúsculas de minúsculas; palavras-chave não podem ser usadas
• Obedeça à convenção de nomenclatura e use um sublinhado para conectar; como o nome indica: a lógica executada pela função deve ser preferencialmente consistente com o nome da função

parâmetros de função

• Quando uma função é declarada, os parâmetros entre parênteses são chamados de parâmetros formais, ou simplesmente parâmetros formais.
• O valor do parâmetro formal é indeterminado, é usado apenas como um espaço reservado
• Ao chamar uma função, você pode passar parâmetros formais
• Os parâmetros passados ​​quando a função é chamada são os dados reais envolvidos na operação, que chamamos de parâmetros reais
• Quando a função é chamada, os parâmetros reais serão passados ​​para os parâmetros formais em correspondência um a um.
• Você também pode especificar o nome da variável e passar o parâmetro real para o parâmetro formal

valor de retorno da função

• O valor de retorno é o resultado da execução da função, mas nem todas as funções devem ter um valor de retorno

def add(a,b):
    c = a+b  # 变量C在外部是不可见的,只能在函数内部使用
    return c  # return 表示一个函数的执行结果

result = add(1,2)
print(result ** 4)

• Se uma função não retornar um valor, ela retornará None

Documentação para a função

• Use um par de três aspas, no corpo da função, para indicar a descrição da função

def add(a,b):
    """
    a: 第一个参数
    b: 第二个参数
    该函数返回两个数字相加的结果
    """
    return a+b

• Ao escrever uma função, adicione: int após o parâmetro formal para especificar o tipo do parâmetro real que você deseja passar

def add(a:int,b:str):  # 希望a的类型是int,b的类型是str
    pass

função de chamada de função

• Na função 2, a função 1 pode ser chamada diretamente. Quando a função 2 for chamada, a função 1 será chamada de acordo com a posição da função 1 no código da função 2. A demonstração é a seguinte:

def function_1():
    print('函数1开始了')
    print('函数1结束了')

def function_2():
    print('函数2开始了')
    print('开始调用函数1')
    function_1()
    print('函数1调用结束')
    print('函数2结束了')

function_2()

# 函数2开始了
# 开始调用函数1
# 函数1开始了
# 函数1结束了
# 函数1调用结束
# 函数2结束了

# 求m阶乘的和
def fac(n):
    x = 1
    for i in range(1,n+1):
        x *= i
    return x

def sum(m):
    x = 0
    for i in range(1,m+1):
        x += fac(i)
    
    return x

print(sum(5))

Variáveis ​​globais e locais

• Python pode usar funções para separar escopos
• As variáveis ​​definidas fora da função são variáveis ​​globais e podem ser acessadas em todo o arquivo py
• A variável definida dentro da função é uma variável local, que é uma função local e só pode ser usada dentro da função
• A função interna globals() locals() pode imprimir as variáveis ​​globais e variáveis ​​locais na função

a = 100  # a是全局变量
word = 'hello'

def test():
    b = 80  # b是局部变量
    a = 10  
    print(a)
    # 如果在函数内部声明了一个与外部全局变量相同名称的变量,会新建一个函数内部的局部变量
    # 而不是修改外部的全局变量
    # 如果需要修改全局变量,可以使用global关键字
    global word
    word = 'thank'
    print(word)
    print('locals = {},globals = {}'.format(locals(),globals()))  # ocals = {'b': 80, 'a': 10},globals = {'__name__': '__main_........ 全局变量非常多

test()  # 10
print(a)  # 100

print(word)  # thank

Função de vários valores de retorno

• return indica o fim de uma função
• Em circunstâncias normais, uma função só executará no máximo uma instrução de retorno
• Em casos especiais (instrução final), a próxima função pode executar várias instruções de retorno

def test(a,b):
    x = a // b
    y = a % b

    # return x 
    # return y
    # 以上代码只会执行一个return

    # return {'x':x,'y':y}  # 以字典的形式返回
    # return [x,y]  # 以列表的形式返回
    # return (x,y)  # 以元组的方式返回
    return x,y  # 返回的本质实际上就是返回一个元组

print(test(12,5))  # (2, 2)

Uso de parâmetros padrão

• Os parâmetros de algumas funções, se passar parâmetros, use os parâmetros passados, se não passar parâmetros, use o valor padrão

# print函数中,end就是一个缺省参数
print('hello',end = '')
print('你好')
# hello你好

• Como definir o valor padrão de um parâmetro formal: Ao definir uma função, forneça diretamente um valor ao parâmetro formal no parâmetro formal que precisa de um valor padrão
• Se nenhum parâmetro for passado, o valor padrão será usado. Se o parâmetro for passado, o parâmetro passado será usado, conforme a seguir

def say_hello(name,age,city='hangzhou'):
    print('大家好,我叫{},我今年{}岁了,我来自{}'.format(name,age,city))

say_hello('lzh',18)  # 大家好,我叫lzh,我今年18岁了,我来自hangzhou

• Um único parâmetro pode ser passado diretamente ou pode ser passado na forma de atribuição de variável
• Se houver parâmetros posicionais e parâmetros de palavra-chave, os parâmetros de palavra-chave devem ser colocados após os parâmetros posicionais

def say_hello(name,age,city='hangzhou'):
    print('大家好,我叫{},我今年{}岁了,我来自{}'.format(name,age,city))

say_hello(name ='lzh',city ='sichuan',age =18)  # 大家好,我叫lzh,我今年18岁了,我来自sichuan

O uso de parâmetros variáveis

• Use *args para representar parâmetros posicionais variáveis ​​--> salve na forma de tuplas
• Use **kwargs para representar parâmetros variáveis ​​de palavra-chave --> salve na forma de um dicionário

def add (a,b,*args):  # args 表示可变参数,必须有两个参数
    pass
add(1,4,65,7,8,43)  # 多出来的可变参数会以元组的形式保存到args中

def add(*args):  # 仅有可变参数
    pass

def add(a,b,*args,mul=2):  # 如果有关键字参数,需要放在可变参数之后
    pass

def add(a,b,*args,mul=2,**kwargs):  # 可以用 ** kwargs 来接受多余的关键字阐述
    pass

Notas sobre funções

• Os três elementos de uma função
  • Nome da função
  • parâmetro
  • valor de retorno
• Em algumas linguagens de programação, a duplicação de função é permitida, mas a duplicação de função não é permitida em Python
• Se a função tiver o mesmo nome, a última função substituirá a anterior
• Em Python, um nome de função também pode ser entendido como um nome de variável
• Portanto, ao definir uma função, não tenha o mesmo nome da função interna

recursão de função

• Simplificando, recursão significa que a própria função chama a si mesma
• A coisa mais importante sobre a recursão é encontrar a saída (condição de parada)

# 使用函数递归求1-n的和
x = 0
def get_sum(n):
    global x
    x += n
    n -= 1
    if n >= 1:
        get_sum(n)
    return x

print(get_sum(100)) # 5050

# 递归方法2
def get_sum2(n):
    if n == 0:
        return n
    return n + get_sum2(n-1)

print(get_sum2(100))  # 5050

# 使用函数递归求n!
def get_num(n):
    if n == 0:
        return 1 
    return  n * get_num(n-1)

print(get_num(0))  # 1

# 斐波那契数列的第N个数字
def get_fi(n):
    if n == 2 or n == 1:
        return 1
    return get_fi(n-2) + get_fi(n-1)

print(get_fi(8))  # 21

função anônima

def add(a,b):
    return a+b

x = add(1,2)  # 函数名(实参)作用是调用函数,获取到行数的执行结果并赋值给变量 x

fn = add  # 相当于给函数add起了一个别名叫fn

• Usando a palavra-chave lambda pode ser usado para definir uma função
• Função anônima, usada para expressar uma função simples
• Como chamar uma função anônima:
  • A primeira: definir um nome para ele (raramente usado assim)
  • A segunda: passar esta função como parâmetro para outra função usar

lambda a,b: a+b  
fn2 = lambda a,b: a+b  # 第一种调用方法

def calc(a,b,fn):
    c= fn(a,b)
    return c

x3 = calc(1,3,lambda x,y: x+y)  # 第二种调用方法:借用回调函数
print(x3)

Uso do método sort

• Lista parcial de funções internas e classes internas, usando funções internas

# 列表的 sort 内置方法会直接对列表进行排序
# sorted 内置函数,不会改变原有的数据,而是生成一个新的结果
students = [
    {
    
    'name':'zhoujielun','age':18,'sorce':97,'height':180},
    {
    
    'name':'linjunjie','age':22,'sorce':65,'height':177},
    {
    
    'name':'caiyilin','age':20,'sorce':88,'height':185}
]

# 字典和字典之间不能使用比较运算
# students.sort()  # '<' not supported between instances of 'dict' and 'dict'

# 需要传递一个 key 参数,指定比较的规则
# key 的参数类型是一个函数
# def foo(ele):
#     return ele['age']  # 在foo方法中,指定按照年龄进行排序

# students.sort(key=foo)  
# 在sort方法中,会调用key中给定的函数,并且传入参数,参数是列表中的元素
# [{'name': 'zhoujielun', 'age': 18, 'sorce': 97, 'height': 180},
#  {'name': 'caiyilin', 'age': 20, 'sorce': 88, 'height': 185}, 
# {'name': 'linjunjie', 'age': 22, 'sorce': 65, 'height': 177}]

# 简化sort函数
students.sort(key= lambda ele:ele['height'])
# [{'name': 'linjunjie', 'age': 22, 'sorce': 65, 'height': 177}, 
# {'name': 'zhoujielun', 'age': 18, 'sorce': 97, 'height': 180}, 
# {'name': 'caiyilin', 'age': 20, 'sorce': 88, 'height': 185}]

print(students)

O uso do mapa de filtro reduz classes internas

• filtro pode filtrar objetos iteráveis ​​e obter um objeto de filtro
• Em Python2, é uma função interna, em Python3, é modificada em uma classe interna

# fliter 可以给定两个参数
# 第一个参数是一个函数
# 第二个参数是可迭代对象
# filter返回的结果是一个fiilter类型的对象
# filter对象本身也是一个可迭代的对象

x = filter(lambda a: a%2 == 0,range(1,10))
print(x)  # <filter object at 0x0000024ED08E9FA0>
print(list(x))  # [2, 4, 6, 8]
for i in x:
    print(i,end='')  # 2468

# map 内置方法,将可迭代对象中所有的元素按照map指定的方法处理
# 返回一个map类型的可迭代对象
ages = [10,11,25,16,8,14,46,547]

m = map(lambda a: a+2,ages)
for x in m:
    print(x,end=' ')  # 12 13 27 18 10 16 48 549

# reduce 以前是一个内置函数,现在在functools模块中
# 内置函数和内置类都在 builtin.py 文件中定义
from functools import reduce
def foo(x,y):
    return x + y 

scores = [100,154,1564,4684]

print(reduce(foo,scores))  # 6502

# 使用内置方法,求students中所有的age相加
from functools import reduce

students = [
    {
    
    'name':'zhoujielun','age':18,'sorce':97,'height':180},
    {
    
    'name':'linjunjie','age':22,'sorce':65,'height':177},
    {
    
    'name':'caiyilin','age':20,'sorce':88,'height':185}
]

# 使用map函数先处理获取age,再使用reduce进行相加
print(reduce(lambda x1,x2:x1+x2,map(lambda a: a['age'],students)))  # 60

# 或者直接给定reduce的初始值为0,那么第一轮运算时,给的第一个x的值就是0
print(reduce(lambda x1,x2:x1+x2['age'],students,0))  # 60