函数

函数

函数是对功能的封装

　　语法:

　　　　def 函数名(形参列表):

　　　　　　函数体(代码块,return)

　　调用

　　　　函数名(实参列表)

返回值

1.return:在函数执行的时候,如果遇到return.直接返回

2.如果函数什么都不写,不写return.得到的是None.

3.在函数中写return 值.返回一个值.

4.在函数中可以返回多个返回值,return 值1, 值2,  值3......, 接收的是元组.

参数

函数执行的时候给函数传递消息.

*形参:函数声明的位置的变量

*实参:函数调用的时候给的具体的值

传参:把实参交给形参的过程

#单行注释
'''多行注释'''
# 函数注释
def func(a, b):
    """
    这个函数是用来计算a和b的和
    :param a: 第一个数据
    :param b: 第二个数据
    :return: 返回的是两个数的和
    """
    return a + b

print(func.__doc__) # document文档

　　

　1.实参:

　　　1.位置参数,按照形参的参数位置,给形参传值

　　　2.关键字参数,按照形参的名字给形参传值

　　　3.混合参数.即用位置参数,也用关键参数

　2.形参:

　　　1.位置参数,按照形参的参数位置,给形参传值

　　　2.默认值参数  先位置后默认值

　　　3.动态传参　

　　　　1).*args　位置参数动态传参

def chi(*li):
    print(li)
chi('米饭', '面条', '粥')
chi('馒头', '盖浇饭')
chi('馒头')               #返回的是一个元组
输出结果:
('米饭', '面条', '粥')
('馒头', '盖浇饭')
('馒头',)

　　　　2).**kwargs　关键字参数动态传参

def chi1(**food):
    print(food)
chi1(good_food = '米饭', drink = '可乐')        #返回的是一个字典
输出结果:
{'good_food': '米饭', 'drink': '可乐'}

　　位置参数动态传参和关键字参数动态传参一起使用的顺序:　

　　　　顺序: 位置, *args, 默认值, **kwargs

def fun(a, *args, c="哈哈",  **kwargs):
    print(a, args, c, kwargs)
fun(1, 2, 3, 4,5, 6)
输出结果:
1 (2, 3, 4, 5, 6) 哈哈 {}

def func(*args, **kwargs):　　　　#无敌传参
    pass

　聚合:形参的位置*,**:聚合   聚合:把接收到的参数组合成一个元组

　　打散:  实参的位置*,**: 打散　　　打散:把序列按顺序打散

　　字典的打散和聚合需要两个**

def fun(*args):
    print(args)
lst = [1, 4, 7]
fun(lst)                        #直接输入列表,列表整体作为一个参数传入函数
fun(lst[0], lst[1], lst[2])     #输入列表的每一个元素,需要索引输入
fun(*lst)   # 可以使用*把一个列表按顺序打散
s = "臣妾做不到"
fun(*s)     # 字符串串也可以打散, (可迭代对象)
输出结果:
([1, 4, 7],)
(1, 4, 7)
(1, 4, 7)
('臣', '妾', '做', '不', '到')

　

def fun(*args, **kwargs):       #聚合
    print(args)
    print(kwargs)
list1 = [1, 2, 3, 4]
tuple1 = (1, 2, 3, 4)
list2 = ['alex', 'wusir', 1]
dic = {'name': 'alex', 'age': 18}
fun(*list1, *tuple1, *list2, **dic)     #打散
输出结果:
(1, 2, 3, 4, 1, 2, 3, 4, 'alex', 'wusir', 1)
{'name': 'alex', 'age': 18}

命名空间:

　　1.内置名称空间

　　2.全局名称空间

　　3.局部名称空间

　　作用域:

　　　　1.全局作用域:内置名称空间+全局名称空间

　　　　2.局部作用域: 局部(函数被调用)

　　　　globals() 查看全局中的内容

　　　　locals() 查看当前作用域中的内容

a = 110     # 全局
def fn():   #全局
    b = 20  # 局部
    def gn():   # 局部
        print(globals())  # 可以查看全局作用域中的内容
        print(locals())  # 查看当前作用域中的内容
    gn()
fn()
输出结果:
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0327DF50>, 
'__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 
'__file__': 'C:/Users/Desktop/python.py', '__cached__': None, 'a': 110, 'fn': <function fn at 0x032507C8>}

{}

　　

 函数嵌套:函数可以互相嵌套

　　　　global :在局部访问全局中的内容

def func():
    global a  # 1. 可以把全局中的内容引入到函数内部 , 2. 如果全局中没有这个内容,就在全局创建一个变量
    a = 20      #将20赋值给a,这个a是全局中的a,此时全局中的a为20
    a += 10     # a = a+10   此时a=30
    print(a)    #a=30
func()
print(a)
输出结果:
30
30

　　　　nonlocal:在局部寻找外层函数中离它最近的那个变量

a = 10
def outer():
    a = 1
    def inner(): # 在inner中改变a的值
        nonlocal a # 寻找外层函数中离他最近的那个变量
        print(a)    #在outer()函数中找到a,此时a=1
        a = 20       #将20赋值给a 
        print(a)        #此时a=20
    inner()
outer()
输出结果:
1
20

　　

a = 1
def fun_1():
    a = 2
    def fun_2():
        nonlocal a
        a = 3
        def fun_3():
            a = 4
            print(a)
        print(a)
        fun_3()
        print(a)
    print(a)
    fun_2()
    print(a)
print(a)
fun_1()
print(a)
输出结果:
1
2
3
4
3
3
1