python函数

pass语句

pass是个空语句，也被叫做占位符，是在构思代码框架阶段时用来占位，防止解释器运行时报错。

def a():

def b():
	pass

a()		#调用时会报语法错误
b()		#正常运行

它是一种空操作，解释器执行到它的时候，除了检查语法是否合法，什么也不做就直接跳过。除了占用一行代码行，不会改变程序的执行顺序，也不会产生任何影响。

函数

函数定义

把某给功能封装成函数块，在需要时直接调用函数块，简单快捷（函数相当于工具，把实现某个功能工具制造出来，更方便使用。函数名作用是工具的名字，像是用来砸钉子的工具叫锤子一样）

语法：def  函数名(参数):
				函数体
				return 返回值
				
原则：先定义，再执行     (在代码运行的顺序中)
1.定义函数的时候不会执行函数内部的代码

2.定义函数本质：
	第一步，先开辟一个内存空间
	第二步，把函数体的代码放进这个空间
	第三步，把这个空间的内存地址和函数名绑定
	
4.return 
	(1)return 可以是没有，也可以有无数个
	(2)return后面的值可以是0，也可以是无数个
	(3)如果没有return或者return后面没有值，则返回值会默认是None
	(4)函数代码执行时遇到return就会结束函数代码

函数的调用

3.调用函数本质：
	函数的内存地址()      （只要是函数内存地址加()就会调用这个函数）
	通过这个函数地址(),找到这个函数的空间，再执行内部的代码

def a():
    print('你好！我是小红，年龄14')

a()

运行结果
#你好！我是小红，年龄14

函数名绑定的是内存地址，调用函数必须是 函数名() 这种格式

def a(name, age):
    print(f'你好！我是{name}，年龄{age}')
    return '模板'	#设置返回值


b=a('小明', 12) #调用函数，并把return值返回给变量a
print(a)	#输出函数内存地址
print(b) 	#输出返回
#运行结果
#你好！我是小明，年龄12
#<function a at 0x0000023F18D7E040>
#模板

函数的注释

	1.使用三对引号进行注释的内容
	2.查看的方法 __doc__
	使用的的 '_' 是英文的下划线，需要连续两个

def a(name,age):
    """
    这个函数的功能是什么什么
    :param name: 这个参数是什么
    :param age: 这个参数是什么
    :return: 返回的值是什么
    """
    print(name,age)

print(a.__doc__)
#运行结果
# 这个函数的功能是什么什么
# :param name: 这个参数是什么
# :param age: 这个参数是什么
# :return: 返回的值是什么

函数参数顺序

1.函数的参数
		(1)设置函数的形参是为了接收外部的赋值形参
		(2)函数中的名称空间是局部作用的，只在该函数自己的内部有效
2.参数的设置顺序
	(位置参数，默认参数，可变长度位置参数，关键字参数，可变长度关键字参数)
			(1)位置参数是按照位置前后顺序对应赋值
			(2)关键字参数是通过字典的键值对的形式指定某个参数赋值
			(3)默认参数是值在定义形参的时候就赋予一个实参，可以通过传参修改
			(4)可变长度位置参数使用 *变量名 形式将接收到的多余位置实参放到放入以变量名绑定的元组中
			(5)可变长度关键字参数用 **变量名 形式将多余的关键字实参放入以变量名绑定的字典中

def a(a,b,c=3,*args,x,y,**kyargs):
    print('位置参数：',a,b)
    print('默认参数：',c)
    print('可变长度位置参数：',args)
    print('关键字参数：',x,y)
    print('可变长度关键字参数：',kyargs)

a(1,2,4,12,13,x=5,y=6,z=7,s=8)
#运行结果
#位置参数： 1 2
#默认参数： 4
#可变长度位置参数： (12, 13)
#关键字参数： 5 6
#可变长度关键字参数： {'z': 7, 's': 8}

函数的嵌套

和if循环一样，函数也可以嵌套函数
函数封装
为了隐藏数据保护内层函数数据不受到外部变化的影响，把他们从全局作用域中隐藏起来。

def a(n):	#封装函数
    def b(n):	#被封装的函数
        return n * 2

    nums = b(n)	#调用函数b
    print(nums)
a(5)# 运行结果 10
b(5)#报错，无法访问，被隐藏

函数闭包

函数的闭包

外部函数中定义一个函数，外部函数返回定义的函数，而不是一个具体的值，这种方式就叫闭包
闭包的作用：

闭包可以优先使用外函数中的变量，并对闭包中的值起到了封装包保护的作用，使外部无法访问。

函数闭包：

1. 函数嵌套
2. 内部函数对外部函数作用域里对象的引用
3. 外部函数返回内部函数对象

def a():	#外层函数
	num=1
    def b(num):	#闭包函数
        print("调用b函数",num)
        
    return b	#外层函数的return，返回内层函数b的内存地址
a()()	#a()返回的是b的内存地址，a()()相当于b()
#运行结果
# 调用b函数

变量作用域

内置变量
随着解释器的打开而创建，随着解释器的关闭而释放，变量存活周期为程序运行的期间
全局变量
随着文件的创建而创建，随着文件的关闭而释放，变量存活周期为文件使用的期间
局部变量
随着函数的调用而创建，随着函数调用结束而是释放，变量存活周期为函数的调用期间
查找规则
查找变量的顺序是 从自身的变量域里查找，找不到再到外部的变量域找，一层一层往外找，直到全局和内置作用域都不存在时，就会报错

x = 1  # 全局变量

def a():
    x = 2  # 局部变量，只在函数a()中有效
    print(x)  # 输出的是该函数中的变量x

a()
print(x)  # 输出全局变量x
运行结果
# 2
# 1

如果没有定义局部变量，函数会向函数外部获取

x = 1  # 全局变量

def a():
    print(x)

a()
print(x)  
运行结果
# 1
# 1

全局变量和局部变量是两个不同的内存空间，变量名可以一样，互不影响。
可以通过globa关键字和nonlocal关键字进行指向

global关键字

global关键字是用来声明变量的作用域是全局作用域

x = 1  # 全局变量

def a():
    global x  # 声明变量x为全局变量
    x = 2	#此时的变量x改变会覆盖x=1
    print(x)

a()
print(x)
运行结果
# 2
# 2

nonlocal关键字

nonlocal关键字是用来声明变量是外层局部变量，可以在内部函数中修改外部局部变量

• nonlocal关键字声明的变量一层一层的向外获取，最多只能获取到最外层函数的变量，无法获取到全局变量，如果没有获取到该变量，就算是全局变量中存在，也会报错

x = 1  # 全局变量

def a():
    x=2		#外层函数变量
    def b():
        nonlocal x  # 声明该变量是外层局部变量
        x=3			#可以修改使用外层的局部变量
        print(x)
    b()
a()
print(x)
运行结果
# 3
# 1