一、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
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所谓可变类型与不可变类型是指：
数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变
可变类型
列表
字典
集合
不可变类型
整型
浮点型
字符串
元组
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)
本文含有隐藏内容，请 开通VIP 后查看