函数、参数、局部函数and函数内变量修改、嵌套函数

一、函数

函数的定义：将一组语句的集合通过一个函数名封装起来，想要执行这个函数，只需要调用函数名即可。

函数的三种类型：1.无参函数，2.有参函数.（函数体需要外部传递进来信息的）3.空函数

函数的特性：1.减少重复的代码 2.使程序变得可扩展 3.使程序变得易维护

def sayhi(a,b):
    res = a + b
    print(res)
    
sayhi(5,10)

二、参数

2.1 形参(在函数定义时定义的参数，相当于变量名)和实参（在调用函数时传入的值，相当于变量值）

def sayhi(a,b):  # (a,b)形参（占位）
    res = a + b
    print(res)
    
sayhi(5,10)  # （5,10） 实参（实际存在的值）

2.2 默认参数（在函数定义阶段，就已经为形参赋值【本质上是内存地址】的参数），默认参数不要定义成可变类型！！！

默认参数可填可不填；但要按顺序传；但必须放在末尾！！！

def stu_infor(name,age,country=\'CN\'):
    print(name,age,country)

stu_infor(\'jake\',22,)
stu_infor(\'BOB\',24,\'JP\')
stu_infor(\'ASD\',12,\'KM\')

　可变长参数

如果形参中出现*变量名，传递的参数就可以不再是固定个数，传过来的参数都会打包成元组

方式一：
def stu_info(name,*args,):
    print(name,args)

stu_info(\'jake\',45,23,32,11)

>>>>jake (45, 23, 32, 11)  # 后面的数字都会传递给args

方式二：
def stu_info(name,*args,):
    print(name,args)

stu_info(\'jake\',*[45,23,32,11])

2.3关键参数（在定义函数时，*后定义的参数）

可以不按顺序传，这时就会用到关键参数，只需要指定参数名就可以，但是必须放在位置参数之后！

def stu_infor(name,age,country=\'CN\'):
    print(name,age,country)

stu_infor(name=\'jake\',age=23,country=\'JP\')

2.4 非固定参数

def stu_info(name,*args,**kwargs):
    print(name,args,kwargs)

stu_info(\'jake\',22,\'100w\',addr=\'北京\', num=1231214124212)

>>>>>>jake (22, \'100w\') {\'addr\': \'北京\', \'num\': 1231214124212}

def stu_info(name,*args,**kwargs):
    print(name,args,kwargs)

d = {\'addr\':\'北京\',\'num\':\'12312312424\'}
stu_info(\'jake\',22,\'100w\',**d)

# >>>>>>jake (22, \'100w\') {\'addr\': \'北京\', \'num\': \'12312312424\'}

三、函数的返回值

　　定义：函数外部的代码，想要获取函数的执行结果，使用return语句返回结果

　　　　　　return会结束函数，后面的代码不会运行；如果未指定return就返回None.

def stu_info(name,age,**kwargs):
    print(name,age,kwargs)
    if age > 22:
        return False
    else:
        return True
stu = stu_info(\'JAKE\',24,cuontry=\'JP\')
print(stu)

>>>>>>>>JAKE 24 {\'cuontry\': \'JP\'}
>>>>>>>>False

　　　　函数只能返回一个值；如果需要返回多个值，使用逗号分隔开，返回时回事一个元祖的类型，这个元祖代表的是一个值！

四、函数的局部变量

　　定义：在函数内部的变量，可以在函数内部修改（在局部创建）变量。

name = "jake"  # 函数外部，全局变量
def change_name():
    name = \'Bob\'  # 函数内部，局部变量
    print(name,id(name))
change_name()
print(name,id(name))

>>>>>>Bob 2448164753624
>>>>>>jake 2448163922360

　　1.在函数内部可以调用全局变量

　　2.如果同一个变量在全局和局部都有，那么调用的顺序应当是由内而外的

4.1 函数内部修改全局变量

name = "jake"  # 函数外部
def change_name():
    global name  # 不建议使用
    name = \'Bob\'  # 函数内部
    print(name,id(name))
change_name()
print(name,id(name))

>>>>>>Bob 2691644231896
>>>>>>Bob 2691644231896

4.2 在函数内部修改数据

　　列表，字典，集合，元祖是可以被修改的，而字符串这种是不可以被修改的。

name_list = ["jake",\'Bob\',\'rain\']
def change_name():
    del name_list[2]
    name_list[1] = \'Amy\'
    print(name_list,id(name_list))
change_name()
print(name_list,id(name_list))

>>>>[\'jake\', \'Amy\'] 1908083114504
>>>>[\'jake\', \'Amy\'] 1908083114504
# 整体的列表内存地址并没有被修改，修改的是列表内部元素的的内存地址！！！

五、嵌套函数

5.1.函数内部可以再次被定义，2.要想执行函数就需要被调用

def func1():
    print(\'JAKE\')
    def func2():
        print(\'Bob\')
    func2()
func1()

为函数传参的两种方式：

方式一：直接把函数需要的参数定义成形参

方式二：利用闭包函数传参

def func():
    x = 4
    def func2():
        print(x)
    return func2
res = func()
print(res)
res()

5.2函数之间调用的逻辑关系

（一层一层往外面找，函数内部没有的话，就会找全局变量！！！）

age = 11
def func1():
    age =22
    print(age)
    def func2():
        age = 33
        print(age)
    func2()
func1()

>>>22
>>>33

age = 11
def func1():
    age =22
    print(age)
    def func2():

        print(age)
    func2()
func1()

>>>22
>>>22

age = 11
def func1():

    print(age)
    def func2():

        print(age)
    func2()
func1()

>>>11>>>11

age = 11
def func1():
    def func2():
        print(age)
    age = 22
    func2()
func1()

>>>22

age = 11
def func1():
    global age
    def func2():
        print(age)
    func2()
    age = 22  # 此处修改了全局函数！！！
func1()
print(age)

>>>11
>>>22

age = 11
def func1():
    global age
    def func2():
        print(age)
    age = 22  # 修改了全局变量
    func2()
func1()
print(age)

>>>22
>>>22