函数

【一】函数的定义

• 函数的使用必须遵循先定义，后调用的原则

def 函数名(参数1，参数2,...):
    函数体
    return 返回值
函数名()

（1）空函数

• 函数体为pass代表什么都不做，称之为空函数
• 定义空函数通常是有用的，因为在程序设计的开始，往往是先想好程序都需要完成什么功能，然后把所有功能都列举出来用pass充当函数体'占位符'

def login():
	pass # ...

（2）函数定义

[1]无参无返回值的函数

def login():
    username = input('用户名：>>>').strip()
    password = input('密码：>>>').strip()
    if username == 'heart' and password == '123':
        print(f'{username} 登陆成功！')
login() 

[2]有参无返回值的函数

def login(username, password):
        if username == 'heart' and password == '123':
                print(f'{username} 登陆成功！')
login('heart', '123')

[3]多个参数一个返回值

def add(x, y):
    result = x + y
    return result

result = add(1, 1)
print(result)

• 多个参数多个返回值

def index(x, y):
    return x + y, x * y

res_one, res_two = index(2, 4)
print(res_one)  # 6
print(res_two)  # 8

（3）函数的调用方式

def add(x,y):
    return x+y,x*y

[1]直接调用

def add(x,y):
    return x+y
res = add(4,7)
print(res)

[2]表达式调用

def add(x, y):
    print(x + y)
    return x + y

res = add
res(1, 9)

[3]作为参数

• 函数的返回值作为参数，给其他函数使用

def multy(j, k):
    return j * k

def add(x, y):
    return x + y

print(multy(add(1, 9), 8))

• 函数的内存地址可以作为参数给其他函数调用

def add():
    x=1
    y=9
    return x + y

def multy(func, k):
    return func() * k

print(multy(add,6))

[4]间接调用

def add(x,y):
    return x+y,x*y
res = add(4,7)
print(res)

（4）函数的参数类型

[1]形参和实参的介绍

• 函数的参数分为形参和实参
  • 在定义函数时，定义在函数名后面的(变量名)
    • 形参本质就是一个变量名，用来接受外部传来的值
  • 实参即在调用函数时，括号内传入的值
    • 值可以是常量、变量、表达式或三者的组合

def add(x,y):
    print(x+y)

• 如果我们想让其他人就传指定的类型的话，可以做一个弱声明

def add(x:int,y):
    print(x)
    print(y)
add('a',9)

[2]位置参数

• 按位置传参数：必须按照形参变量名的位置传参数

def add(name,age):
    print(f'my name is {name},my age is {age}')

add('heart',18)

• 按关键字传参数：必须按照形参变量名指定参数传参

def add(name, age):
    print(f'my name is {name},my age is {age}')

add(age=18, name='heart')

• 关键字参数和位置参数混合使用
  • 位置参数必须在关键字参数前面

def add(name, age, sex):
    print(f'my name is {name},my age is {age},my sex is {sex}')

add('heart', age=18, sex='男')

[3]默认参数

def func(name, age, sex='男'):
    print(f'my name is {name},my age is {age},my sex is {sex}')

func('heart', 18)
func('god', 18, '女')

[4]可变长参数

• 可变长位置参数：*args

def add(*args, **kwargs):
    print(args)
    print(kwargs)

add(1, 2, 3, 4, 5, name='heart', age='18')# (1, 2, 3, 4, 5) {'name': 'heart', 'age': '18'}

• 解包

def index(*args):
    print(args)
num_list = [1,2,3,4,5,6]
print(*num_list) # 1 2 3 4 5 6
index(*num_list) # (1,2,3,4,5,6)

• 可变长关键字参数：**kwargs key:word

def index(**kwargs):
    user_dict = {'name': 'heart'}
    if kwargs:
        user_dict.update(kwargs)
    return user_dict

res = index(age=18)
print(res)

• 解包 ** 将字典解压成键值传到函数内部

def index(**kwargs):
    user_dict={'name':'heart'}
    if kwargs:
        user_dict.update(kwargs)
    return user_dict

user_data={'age':18,'gender':'男'}
res=index(**user_data)
print(res)

[5]命名关键字参数

• 在定义形参时，用*作为一个分隔符号，*号之后的形参成为命名关键字参数
  • 对于这类参数，在函数调用时，必须按照key=value的形式为其传值，且必须被传值

def add(name,age,*,sex,height):
    print()

• 默认参数 --- 如果是命名关键字参数，我的默认参数就可以不区分位置

def add(name,age,*,sex='男',height)
	print()

（5）名称空间

• 定义变量名和变量值，变量名其实就是指向变量值的引用

[1]内建名称空间

• 随着python解释器的启动而自动加载的名称空间

print(max([1,2,3]))

[2]全局名称空间

• 全局名称空间 （内建 + 我们自己定义的）
• 我们自己的在文件中定义的变量名`/函数名/类名...

name='heart'
import random

[3]局部名称空间

• 定义在函数内部/定义在类内部加载出来的名称空间

# 内建
print(max([1,2,3]))

# 全局
num =1

# 局部
def add():
	print(num)

• 局部可以使用全局的变量，全局不能使用局部的变量

[4]名称空间的加载顺序是

• 内建名称空间 ->全局名称空间 ->局部名称空间
• 而查找一个变量名，查找顺序为：
• 局部名称空间->全局名称空间->内置名称空间。

（6）作用域

[1]内置 --- 内建

• python自带或导入第三方包

[2]全局作用域

a = 2

def index():
    print('这是func1打印的', a)

index()

[3]局部作用域

num =2
print(num)
def outer():
    # 局部修改全局变量需要在函数内部用global声明
    global num
    print(num)
    num += 1
    print(num)
outer()
print(num) # 2 2 3 3 

[4]嵌套作用域

• nonlocal

def outer():
    # 局部修改全局变量需要在函数内部用global声明
    num_inner =99
    def inner():
        #局部引用内函数 要用nonlocal
        nonlocal num_inner
        num_inner +=99
    inner()
    print(num_inner)
outer()

（7）global和nonlocal

（1）global

• 如果想要修改全局的不可变数据类型就需要global关键字将内部需要修改的变量名提高成全局的才能生效

is_admin=False
def login():
    global is_admin
    is_admin=True
    print(is_admin)

login()
print(is_admin)

（2）nonlocal

• 修改外层函数变量
• 在函数中嵌套函数时，嵌套在里面的函数创建的作用域内一般也是不允许改变外层函数变量
  • 除非是nonlocal关键字声明

	def fun1():
    a = 1

    def fun2():
        nonlocal a
        a += 1
        print(a)

    return fun2

fun2 = fun1()
fun2()

（8）闭包函数

• 基于函数对象的概念，可以将函数返回到任意为止去调用

• 闭包函数就是内嵌函数包含对外部函数作用域（而非全局作用域）中变量的引用

• 无论是在何处调用闭包函数，使用的仍然是包裹在其外层的变量

x = 1

def outer():
    x = 2

    def inner():
        print(x)

    return inner

func = outer()
func()

（9）函数对象

• 函数对象指的是函数可以被当做数据来处理，，具体可以分为四个方面的使用

[1]函数可以被引用

def add(x, y):
    return x + y


func = add
res = func(1, 2)
print(res) # 3

[2]函数可以作为容器类型的元素

def add(x, y):
    return x + y


dic = {'add': add, 'max': max}
res = dic['add'](1, 2)
print(res)

[3]函数可以作为参数传入另外一个参数

def add(x, y):
    return x + y


def foo(x, y, func):
    return func(x, y)


res = foo(1, 2, add)
print(res)

[4]函数的返回值可以是一个函数

def add(x, y):
    return x + y


def bar():
    return add


func = bar()
res = func(1, 2)
print(res)