函数基础

目录

• 函数
• 函数的结构与调用
• 函数的返回值
• 函数的参数
  • 万能参数,仅限关键字参数
  • *的魔性用法。
  • 参数的最终顺序
• 名称空间作用域
  • 名称空间
  • 作用域
• 高阶函数之函数的嵌套
• 内置函数 globals locals
• global nonlocal
• 函数名的应用
• 默认参数的坑
• 局部作用域的坑

函数

1.以功能（完成一件事）为导向，登录，注册，len，一个函数就是一个功能。 随调随用。
2.减少代码的重复性。
3. 增强了代码的可读性。

函数的结构与调用

定义一个函数
def len_num(a):
    return len(a)
b=len_num([123,1,2])#函数名加括号就调用了 
print(b)

# 结构：
#def 关键字，定义函数。
#len_num 函数名：与变量设置相同，具有可描述性。
#函数体 ：缩进。函数中尽量不要出现print
# return后面是返回值（len(a)） 在函数中遇到return直接结束函数。
    # return 将数据返回给函数的执行者，调用者 len_num()。
    # return 返回单个元素 是返回原有数据类型的形式返回
    # return 返回多个元素 是以元组的形式返回给函数的执行者。

函数的返回值

1.return 将数据返回给函数的执行者，简单来说谁调用返回谁
2.return 返回单个元素 是返回原有数据类型的形式返回
3.return 返回多个元素 是以元组的形式返回给函数的执行者。

函数的参数

形参角度：
    1. 位置参数
    2. 默认参数  （经常使用的参数）

实参角度：
    1. 位置参数 按照顺序，一一对应
    2. 关键字参数， 一一对应
    3. 混合参数：位置参数一定要在关键字参数的前面。

# 写一个函数，只接受两个int的参数，函数的功能是将较大的数返回。
def compile(a,b): #行参  1.位置参数 2. 默认参数（经常使用的参数）
    c = 0
    if a > b:
        return c
    else:
        return c
compile(10,20)#实参 位置参数  关键字参数，

万能参数,仅限关键字参数

1.万能参数： *args, 约定俗称：args，
	函数定义时，*代表聚合。 他将所有的位置参数聚合成一个元组，赋值给了 args。
    
2.**kwargs 仅限关键字参数
	1.函数的定义时： ** 将所有的关键字参数聚合到一个字典中，将这个字典赋值给了kwargs.
	2.形参角度：仅限关键字参数 (了解) 可以在默认参数前也可以在后面 一定要传参数，不传报错
	3.形参角度最终的顺序：位置参数,*args,默认参数，仅限关键字参数，**kwargs
	
写一个函数：计算你传入函数的所有的数字的和。
def func(*args):
    count = 0
    for i in args:#args是元祖
        count += i
    return count
# print(func(1,2,3,4,5,6,7))

*的魔性用法。

1.*在函数的调用时，*代表打散。
    **{'name': '太白'}打散为name='太白' 
    *[1,2,3]打散为1,2,3
2.函数外：处理剩余元素
    a,b,*c = [1,2,3,4,5]
    a,*c,b, = [1,2,3,4,5]
    a,*c = range(5)·
    a,*c,b = (1,2,3,4,5,6)

参数的最终顺序

形参的最终顺序为：**位置参数，*args，默认参数，仅限关键字参数，**kwargs

名称空间作用域

名称空间

# 内置名称空间：python源码给你提供的一些内置的函数，print input
python分为三个空间：
    1.内置名称空间（builtins.py）
    2.全局名称空间（当前py文件）
    3.局部名称空间（函数，函数执行时才开辟）

加载顺序：
内置名称空间 ---> 全局名称空间  ----> 局部名称空间（函数执行时）

取值顺序（就近原则） 单向不可逆
从局部找时）局部名称空间  ---> 全局名称空间  --->  内置名称名称空间

作用域

两个作用域：
    1.全局作用域 ：内置名称空间 全局名称空间
    2.局部作用域：局部名称空间（函数等）
注意
1.局部作用域可以引用全局作用域的变量
2.局部作用域不能改变全局变量。 可以使用，不能改变
3.注意 python中不可以先引用 后定义

高阶函数之函数的嵌套

# 例1：
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    print(4)

func1()
print(1)
func2()
print(2)
# in func1 3 1 in func2 4 2



# 例2：
def func1():
    print('in func1')
    print(3)

def func2():
    print('in func2')
    func1()
    print(4)

print(1)
func2()
print(2)


# 例3：
def fun2():
    print(2)

    def fun3():
        print(6)

    print(4)
    fun3()
    print(8)

print(3)
fun2()
print(5)

内置函数 globals locals

globals()
	返回的是字典：字典里面的键值对：全局作用域的所有内容。
locals()
	返回的是字典：字典里面的键值对：当前作用域的所有的内容。

举例

a = 1
b = 2
def func():
    name = 'alex'
    age = 73
    print(globals()) 
    print(locals())  
# print(globals()) 
# print(locals())  
func()

global nonlocal

global
	1, 在局部作用域声明一个全局变量 声明后就可以修改全局变量
	
nonlocal 存在于双层嵌套中
    1. 不能够操作全局变量。
    2. 作用局部作用域：内层函数对外层函数的局部变量进行修改。

函数名的应用

1.函数名是一个特殊的变量。
2.函数名指向的是函数的内存地址,加上()就执行这个函数。
3. 函数名可以作为容器类类型的元素。
4. 函数名可以作为函数的实参。
5. 函数名可以作为函数的返回值。

默认参数的坑

1.陷阱只针对于默认参数是可变的数据类型：
2.如果你的默认参数指向的是可变的数据类型，那么你无论调用多少次这个默认参数，都是同一个。
3.本质是闭包

举例

def func(name,alist=[]):
    alist.append(name)
    return alist
ret1 = func('alex')
print(ret1,id(ret1))  # ['alex']
ret2 = func('太白金星')
print(ret2,id(ret2))  # ['太白金星']

局部作用域的坑

1.在函数中，如果你定义了一个变量，但是在定义这个变量之前对其引用了，那么解释器认为：语法问题。
2.你应该在使用之前先定义。

举例

列题
count = 1
def func():
    count += 1
    print(count)
func()