函数
1. 函数是什么？
定义：
1. 一组语句通过一个名字（函数名）封装
2. 通过调用函数名执行
3.函数可以带参数
def test(): # 定义一个函数 print('test') test() # 调用一个函数
def abc(a, b): # 定义一个abc函数,可以带参数 c = a+b return c # 代表函数的结束并返回计算结果 print('结果是',c) #这句不会执行 resu = abc(3, 4) # 调用函数abc 函数返回的结果赋给参数 print(resu)
特性：
1.减少重复代码
2.程序变得可扩展
3.变得易维护
2. 函数参数
1. 形参
1.调用时分配内存单元，结算时释放内存单元。 ——》如下：当函数执行完时str的值就不能在函数外面使用了
2.函数内部有效，函数执行完结束后主函数不能使用这个参数。 ——》str只有在test函数里有效
2. 实参
1.可以是常量、变量、表达式、函数。 ——》a是变量
2.调用函数时，要预先赋值。 ——》a要先赋值，才能进行传进函数里进行运算。
def test(str): # str——》形参 print('test', str) a = '哈哈' test(a) # a——》实参
3. 默认
在定义函数时指定。
调用函数时有值传入，使用函数的值。
调用函数时没有值传入，使用默认参数的值
4. 关键
位置参数——函数传参时必须按照函数定义的位置填。
关键参数——使用关键参数,传参时可以不按位置填。
def test(str, age, county='CN'): # county='CN'默认参数， print('test', str, age, county) # county 有传值——》用函数的值 ；没传值——》用定义的值 a = '哈哈' test(a, 22, county='JP') # a：位置参数 test(a, age=22) # age=22 关键参数；关键参数必须放在位置参数后
5. 非固定
不确定用户传入多少个参数。
1.*args——》返回元组
2.**kwargs——》返回字典
def func(*args, **kwargs): # *args和**kwargs这个就是非固定参数 name = args[0] # args 返回的是一个元组 password = kwargs['password'] # kwargs返回的是一个字典 print(type(args), type(kwargs)) print(name, password) func('abc', password='123') # 非固定参数值传入方式 'abc'=>args ,'password=123'=>kwargs
输出：
<class 'tuple'> <class 'dict'>
abc 123
3. 函数返回
1.类型
1.函数里可以没有return语句
2. 函数没return——函数返回值为None
3. 函数有return——函数执行结果
2. 值的数量
1.一个——可以为一个变量
2.多个——可以为多个变量，每个变量用逗号分隔，以元组方式返回
3. 状态
1.遇到return语句，函数停止执行，并返回执行结果。
2.return指定函数的结束
3.可以返回任意数据类型
def abc(a, b): c = a+b return a, b, c # 返回多个变量 num1, num2, resu = abc(3, 2) # 返回几个要接几个 print(num1, num2, resu)
4. 变量
1. 全局
定义在函数外部，变量全局有效
2. 局部
定义在函数内部，函数执行时分配内存空间，执行完释放。
函数外面不能调用局部变量
name = "全局变量" # name 在函数外，哪里都有他份 def in_or_out(): name = "局部变量" print("这是in", name) # name 在函数内部有效执行完不关他的事 in_or_out() print("这是out", name)
output:
这是in 局部变量
这是out 全局变量
3. 作用域
程序变量可用的范围
5. 其他函数
1.嵌套
函数里嵌套一个函数
#嵌套函数 name = "123" def change_name(): name = "456" def change_name2(): name = "789" print("第3层打印", name) change_name2() # 调用内层函数 print("第2层打印", name) change_name() print("最外层打印", name)
2. 匿名
不需要显式的指定函数名
#1.这段代码 显式函数 def calc(x, y): return x**y print(calc(2, 5)) #2.换成匿名函数 calc2 = lambda x, y: x**y print(calc2(2, 5))
2. 高阶
2.1一个函数，它的参数接收了另一个函数作为其参数
# 第一种情况：函数名可以用作参数 def func(): print('func') def func2(f): # 1.定义一个函数 3.func2这个函数称高阶函数 f() print('func2') func2(func) # 2. func2的参数是函数名func
def add(x, y, f): # 1、一个函数 add()。 return f(x) + f(y) # 3、这个add()函数称为高阶函数。 res = add(3, -6, abs) # 2、add()它的参数接收了另一个函数abs作为其参数。 print(res)
2.2一个函数，它的返回值是另一个函数。
# 第二种情况：函数的返回值是另一个函数 def func(): # 1.定义一个函数 3.func这个函数称高阶函数 def func3(): return 'a' return func3 # 2.这个函数的返回值是另一个函数 func3 = func() print(func3())
3. 递归
一个函数在内部调用自身本身，这个函数就是递归函数。
def calc(n): print(n) if int(n/2) == 0: return n return calc(int(n/2)) # 在函数的内部调用自身 calc(10)
#递归应用1： #现有一个需求：需要把一个数除5次并把第5次结果的值返回 #递归的返回值： def calc2(n, count): print(n, count) if count < 5: return calc2(n/2, count+1) # 返回前面几层数据 else: return n # 返回最里层数据 res = calc2(188, 1) print(res)
4. 内置
Python预先加载好的
