函数

函数的定义

对功能或动作的封装

语法: def 函数名(形式参数):

　　　　函数体(代码块)

调用方式: 函数名(实参)

形参:在函数申明的地方定义的是实参 也就是括号里写的就是定义一个变量.

实参: 在函数调用的时候给函数的形参传递的信息(值)

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

返回值:

return 可以终止一个函数的运行
1. 什么都不写. 不写return. 返回None
2. 写了return, 返回None
3. return 值. 有一个返回值.
4. return 值1, 值2, 值3...多个返回值. 接收的是元组(不可变)
参数: 

def func(*args):
    print(args)
s = "123456"
func(s)


运行结果为  ('123456',)

形参:
1. 位置参数
2. 默认值参数
3. 动态传参
实参:
1. 位置参数, 记住位置
2. 关键字参数, 记住名字
3. 混合参数, 顺序: 先位置后关键字

1. 函数的动态参数
1. *args 位置参数动态传参
2. **kwargs 关键字参数动态传参
顺序:位置参数, *args, 默认值, **kwargs

def func(*args, **kwargs):
pass

形参的位置*,**: 聚合
实参的位置*,**: 打散
2. 命名空间
1. 内置名称空间
2. 全局名称空间
3. 局部名称空间

在python解释器开始执行之后,会在内存中开辟一个空间,每当遇到一个变量的时候,就把变量名和值之间的关系记录下来,但是当遇到函数定义的时候,

解释器只把函数名读入内存,表示这个函数存在了,至于函数内部的变量和逻辑,解释器是不关心的,也就是说,开始的时候函数只是加载进来,经此而已.

只有当函数被调用和访问的时候,解释器才会根据函数内部申明的变量来进行开辟变量的内部空间,

随着函数执行完毕,这些函数内部变量占用的空间也会随着函数执行完毕被清空

def fun():
 a = 10
 print(a)
fun()
print(a) # a不存在了已经.

def outer():
    print("哈哈")
    def inner_1():
        print("呵呵")
        def inner_1_1():
            print("嘻嘻")
        inner_1_1()
        print("吼吼")
    def inner_2():
        print("嘿嘿")
    inner_2()
    inner_1()
outer()
##
结果为 >>>>>>
哈哈
嘿嘿
呵呵
嘻嘻
吼吼

加载顺序:

内置命名空间

全局命名空间

局部命名空间(函数执行的时候)

取值顺序:

局部命名空间

全局命名空间

内置命名空间

作用域:
1. 全局作用域: 内置+全局
2. 局部作用域: 局部(函数被调用)
globals() 查看全局中的内容
locals() 查看当前作用域中的内容

a = 10
def func():
 a = 40
 b = 20
 def abc():
 print("哈哈")
 print(a, b) # 这⾥使⽤的是局部作⽤域
 print(globals()) # 打印全局作⽤域中的内容
 print(lglobals()) # 打印局部作⽤域中的内容
func()

# a = 10 # 全局名称空间中的内容
# def fn(): # fn也在全局名称空间
#     b = 20 # 局部名称空间
#     print(a)
# def gn():
#     print(a)
# fn()
# gn()
运行结果为>>>>>
10
10

3. 函数嵌套
函数可以互相的嵌套
4. global和nonlocal关键
global: 在局部访问全局中的内容

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

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