一、Python中的函数
1、函数--入门
函数：
1、函数就是将经常使用的代码进行一个封装，封装之后给这段代码起个名字
2、以后使用者只需要用这个函数名字就可以实现同样的功能，而内部代码不需要再重写
函数的语法：
def 函数名（参数）：
函数体
....
return 返回值
def 果汁机(水果):
榨果汁
...
return 果汁
调用函数：
函数名(要传入的参数)
# 需求一：定义一个函数，要求传入两个数字，返回这两个数字的和 def add(a, b): # 形式参数 sum1 = a + b return sum1 # 调用函数 result = add(10, 20) # 实际参数 print(f'result = {result}') # 合并 def add(a, b): # 形式参数 return a + b print(add(10, 20))
2、函数--四种类别
def func1(a, b): # 形式参数 """ 该函数用来实现两个数的和 :param a: 第一个数 :param b: 第二个数 :return: 两个数的和 """ return a + b def func2(): print('hello world') def func3(my_str): print('hello world' + my_str) def func4(): return 'helloworld' # 函数的调用 print(func1(10, 20)) func2() # 对于没有返回值的方法不能放在print语句中 func3('xxxx') print(func4())
3、函数--案例
# 尽量改参 不要改源码 def yang(rows, cols): for i in range(rows): for j in range(cols): print('*', end='') print() yang(8, 17)
4、函数--嵌套
def kao_jia_zhao(): print('考驾照！----1') print('考驾照！----1') print('考驾照！----1') def shi_xi_drive(): print('实习开车!----2') print('实习开车!----2') print('实习开车!----2') def drive(): #开车 kao_jia_zhao() shi_xi_drive() print('正常驾驶！-----3') print('正常驾驶！-----3') print('正常驾驶！-----3') drive()
5、函数--作用域
a = 123 # 全局变量 def func1(): global a a = 888 # 局部变量 global b # 将局部变量升级为全局变量 b = 999 print(f'我是func1函数={a}') # 就近原则 print(f'我是func1函数={b}') # 就近原则 print(a) # 因为函数还没有执行，这个的全局变量还没有声明 func1() # 在函数中使用global，一定要调用函数，才可以升级为全局变量 print(a) # 888 print(b) # 999
二、函数的进阶
1、函数的进阶--函数返回多个值
""" 1:函数的进阶 1)一个函数如何返回多个值 如果一个函数返回多个值，则将返回的多个值封装成元组 """ def func1(): return 1, 2 # 获取结果-方式1 print('-------------') result = func1() print(result[0]) print(result[1]) # 获取结果-方式2 print('-------------') r1, r2 = func1() print(r1) print(r2)
2、函数的进阶--位置参数和关键字参数
""" 1、位置参数，通过传递参数的先后顺序来决定哪个实参给哪个形参 2、关键字参数：函数调用时通过“键=值”形式传递参数. """ def func1(name, age, sex): print(f'名字是{name},年龄是{age},性别是{sex}') # 位置参数 func1('张三', 18, '男') # 关键字参数 func1(name='张三', age=18, sex='男') func1('张三', age=18, sex='男') # 可以 # func1(name='张三',age=18,'男') #不可以，位置参数必须在关键字参数的前边 func1(sex='男', age=18, name='张三')
3、函数的进阶--默认参数
""" 3、默认参数:默认参数必须放在最后 """ def func1(name, age, sex='女'): print(f'名字是{name},年龄是{age},性别是{sex}') func1('张三', 18) # 如果默认参数不给值，则使用默认参数 func1('张三', 18, '男') # 如果默认参数给值，则使用实参的值 func1(name='张三', age=18) # 如果默认参数不给值，则使用默认参数 func1(name='张三', age=18, sex='男') # 如果默认参数不给值，则使用默认参数 print('-------------------------------------------') # # def func1(name='张三',age,sex): # 默认参数: 默认参数必须放在最后 # print(f'名字是{name},年龄是{age},性别是{sex}') # # # func1('xxx','yyy')
4、函数的进阶--不定长参数
""" 不定长参数 形参的个数是不确定的，你想传入多少就传入多少 """ def add1(a, b): return a + b def add2(a, b, c): return a + b + c def add3(a, b, c, d): return a + b + c + d def func(*args): # 这个参数名字随便写 args = (1,2,3,4,5,6,7,8) print(type(args)) # 可变参函数本质上就是元组 sum = 0 for num in args: sum += num return sum print(func()) print(func(1)) print(func(1, 2)) print(func(1, 2, 3)) print(func(1, 2, 3, 4, 5, 6, 7, 8))
""" 不定长参数 *args: 1、形参的个数是不确定的，你想传入多少就传入多少 2、必须以位置参数传入，传入的参数会变成元组 **kargs: 1、形参的个数是不确定的，你想传入多少就传入多少 2、必须以关键字的参数传入，传入之后，转为字典 """ def func(**args): # 这个参数名字随便写 args = {'a'=1,'b'=2} print(type(args)) # 可变参函数本质上就是元组 sum = 0 for k, v in args.items(): sum += v return sum # func(1,2) #报错 print(func(a=1, b=2)) # 不报错 print(func(a=1, b=2, c=3)) # 不报错
5、函数的进阶--拆包
1. """ """ 拆包 """ #拆包-1 my_tuple1 = (1,2,3) n1,n2,n3 = my_tuple1 print(n1) print(n2) print(n3) #拆包-2 def func(): return 1,2 r1,r2 = func() print(r1) print(r2)
6、函数的进阶--引用
#引用：就是门牌号，也被称为地址 a = 10 #该语句的本质是；将10这个数字所在空间的地址赋给了a b = a c = a a = 20 #这里的id函数获取的是变量指向的空间的地址（门牌号） print(id(a)) #140716035397568 print(id(b)) #140716035397568 print(id(c)) #140716035397568 2.
所谓可变类型与不可变类型是指：
数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变
可变类型
列表
字典
集合
不可变类型
整型
浮点型
字符串
元组
7、函数的进阶--匿名函数
""" 匿名函数： """ def add2(a ,b): return a + b print(add2(10 ,20)) add = lambda a ,b : a +b print(add(10 ,20)) # def yunsuan(a,b,func): #func = lambda a,b:a+b # return func(a,b) # # result1 = yunsuan(10,20,lambda a,b:a+b) # result2 = yunsuan(10,20,lambda a,b:a-b) # result3 = yunsuan(10,20,lambda a,b:a*b) # result4 = yunsuan(10,20,lambda a,b:a/b) # # print(result1) # print(result2) # print(result3) # print(result4)
