函数的嵌套 名称空间 作用域

函数
    什么是函数
        def 是定义函数的关键字
        函数名 命名规范与变量名的命名规范一致
                1.不能与关键字冲突
                2.尽量做到见名知意
        参数
            分为两大类
                形参:在函数定义阶段括号内写的变量名 称之为形参

                实参:在函数调用阶段括号内传入的具体的值 称之为实参
                形参与实参的关系
                    形参就是变量名
                    实参就是变量名指向的值
                    只有在调用函数的时候两者才有关系,一旦函数运行结束 关系自动解除
        函数的注释:推荐你写上
                    1.用来描述你这个函数的具体功能
                    2.诠释你写的函数的形参都表示什么意思
                    3.还可以诠释你这个函数的返回值有什么特点
        函数体代码:你这个函数到底能干嘛

        函数的返回值:关键字return
                    1.返回给调用者函数体代码执行之后得到的结果
                    2.只要函数体代码执行到return,整个函数立即结束

        def 函数名(参数1,参数2,参数3...):
            """
            函数的注释
            参数的解释
            返回值的解释
            """
            函数体代码1
            函数体代码2
            函数体代码3
            return 函数的返回值


函数的返回值
    1.不写return
        python所有的函数都有返回值,不写return的情况下默认返回None
    2.写return返回一个值
        1.return
            你想主动结束整个函数的运行
        2.return None(与上面的只写return是等价的)
            你想主动结束整个函数的运行
        3.return 值
            这个值可以是python任意数据类型
    3.写return返回多个值
        1.return 值1,值2,值3...
            return会自动将多个值组织成一个元组返回给调用者


            def func():
                return 'a','b','c'
            x,y,z = func()
            x,_,_ = func()
            x,*_ = func()  # _是一个元组类型

        2.return [值1,值2,值3...]
            你也可以自己的手动指定返回数据类型

函数的参数详解
    1.位置参数
        在定义函数的时候按照位置从左到右依次书写的变量名叫做位置形参
        位置形参在调用的时候必须为其传值

        在调用函数的时候,按照位置书写的实参 会一一对应的传给位置形参
    2.默认值参数
        在函数定义阶段就已经给形参赋值了
        注意如果默认值参数是可变类型的情况下,需要细心

    3.可变长参数(动态参数)
        *
        **

        * 站在形参的角度 可以接收多余的位置参数 将他们组织成一个元组 交给*后面的变量名
        * 站在实参的角度 可以将列表 元组 集合 字符串这些支持for循环的容器类型打散成位置参数

        ** 站在形参的角度 可以接收多余的关键字参数(什么=什么) 将他们组织成一个字典 交给**后面的变量名
        ** 站在实参的角度 可以将字典打散成key=value的形式 按照关键字参数传给函数


    函数可以接收调用者传入的任意个数的参数
    def func(*args,**kwargs):
        print(args)
        print(kwargs)

    定义函数的三种方式
        1.空函数:可以快速帮助你构建项目框架 使项目架构清晰明了
            应用频率非常高
                购物车功能
                    def register():
                        pass
                    def login():
                        pass
                    def shopping():
                        pass
                    def pay():
                        pass

            def func():
                pass
        2.无参函数
            def func():
                print('from func')
        3.有参函数
            def func(x,y,*args,**kwargs):
                pass

命名关键字参

# 命名关键字参数:在函数定义阶段 写在*与**可变长参数之间的形参
# 在给命名关键字参数传值的时候 只能用关键字为其传值
# 在定义阶段 给你感觉好像是z是默认值参数 放在了m这个位置参数的前面了 应该报错
# 其实z和m都是命名关键字参数 不是默认值参数和位置参数
def func(x,y=1,*args,z=3,m,**kwargs):
    print(x,y)
    print(args)
    print(z,m)
    print(kwargs)
func(1,2,1,2,3,4,5,6,7,78,8,9,0,z=69,m=999,o=666999,l = 999666)

函数对象（函数是第一类对象:函数名指向的值可以被当中参数传递）

1.函数名可以被传递

def func():
    print('from func')

f = func
func()
print(f)
f()  # 其实指向的也是函数func指向函数体代码的内存地址

>>>:  from func
>>>: <function func at 0x0000023E5EA68D90>
>>>:  from func

2.函数名可以被当做参数传递给其他函数

def func():
    print('from func')

def index(args):
    print(args)
    args()
    print('from index')
index(func)

 >>> <function func at 0x0000024B37998D90>
 >>> from func
 >>> from index

3.函数名可以被当做函数的返回值

def index():
    print('index')


def func():
    print('func')
    return index
res = func()
print(res)
res()


func
<function index at 0x000002407EBE8D90>
index

4.函数名可以被当做容器类型的参数

def func():
    print('func')
print(func())
l = [1,2,func,func()]
print(l)


func
None
func
[1, 2, <function func at 0x000001ACE51B8D90>, None]

2.函数的嵌套定义

 

def outer():
    x = 1
    print('outer')
    def inner():
        print('inner')
    return inner
res = outer()
res()

outer
inner

"""
写一个函数
该函数用户可以通过传参的不同控制函数执行不同的功能
"""

 

名称空间  详细解释:存放的是变量名与变量值的内存地址得绑定关系的地方 

要想访问一个变量的值 必须先去名称空间中拿到对应的名字 才能够访问变量的值

名称空间的分类
    1.内置名称空间:python解释器提前给你定义好的名字(已经存放到内置名称空间中了)
                len
                max
                min

    2.全局名称空间:文件级别的代码
                x = 1

                if 1 ==1 :
                    y = 2
                
                print(y)
                while True:
                    z = 3
                    
                x,y,z都会放到全局名称空间
                if for while 无论嵌套多少层 它们内部所创建的名字都是全局名称空间的
    3.局部名称空间:函数体内创建的名字都属于局部名称空间
            username
    
    
    
    生命周期:
        
        内置名称空间:只要python解释器已启动立马创建   关闭python解释器的时候内置名称空间自动销毁
        全局名称空间:只要你右键运行py文件会自动创建   py文件程序运行结束自动销毁 
        局部名称空间:函数被调用的时候自动创建  函数指向结束立即销毁(动态创建动态销毁)
        
    
    名字的查找顺序

　　　　名字的查找 (******)
   　　　　　1.需要先确定你当前在哪(大前提)
       　　 1.站在全局:  全局 >>> 内置
        　　2.站在局部:  局部 >>> 全局 >>> 内置

x=111
def outer():
    def inner():
        print('from inner',x)
        x = 66666666
    return inner
f=outer()
f()

函数在定义阶段查找名字的顺序就已经固定了 不会因为函数的调用位置变化而改变(******)

作用域

 全局作用域
 全局有效: 内置名称空间  全局名称空间

 局部作用域
 局部有效   局部作用域

 global nonlocal
"""
1.在局部修改全局的变量
"""
 global 在局部修改全局的不可变数据类型
 x = []  # 因为列表是可变类型
x = 1  # 不可变类型
username = 'jason'
def func():
    # x.append('嘿嘿嘿')
    global x,username  # 修改全局变量 而不是创建局部名称空间
    x = 999
    username = 'egon'
func()
print(x)
print(username)



# nonlocal  局部修改局部
def func():
    x = 1
    def index():
        nonlocal x
        x = 2
    index()
    print(x)
func()


"""
global:局部修改全局 如果想修改多个 逗号隔开
nonlocal:局部修局部 如果想修改多个 逗号隔开

"""