######################函数定义和分类
"""没有函数会有什么问题?
1.无组织无结构,代码冗余
2.可读性差
3.无法统一管理且维护成本高
"""
# 在python中函数分两类:内置函数,自定义函数
#内置函数
# sum
# max
# min
#
# a=len('hello')
# print(a)
#
# b=max([1,2,3])
# print(b)
#自定义函数
# # ******
# # ******
# # ******
# # hello world
# # ******
# # ******
# # ******
#
def print_star():
print('#'*6)
def print_msg():
print('hello world')
print_star()
print_star()
print_star()
print_msg()
print_star()
print_star()
print_star()
######自定义函数#####
#为什么要定义函数?:先定义后使用,如果没有定义而直接使用,就相当于引用了一个不存在的变量名
foo()
def foo():
print('from foo')
print(foo)
#函数的使用包含两个阶段:定义阶段和使用阶段
# 语法
# def 函数名(参数1,参数2,...):
# """文档注释"""
# 函数体
# return 值
x=len('hello')
print(x)
#定义函数的三种形式
#一:无参数函数:如果函数的功能仅仅只是执行一些操作而已,就定义成无参函数,无参函数通常都有返回值
def print_star():
print('#'*6)
#二:定义有参函数:函数的功能的执行依赖于外部传入的参数,有参函数通常都有返回值
def my_max(x, y):
res=x if x >y else y
return res
# 三元表达式
x=10
y=2
if x > y:
print(x)
else:
print(y)
res=x if x > y else y
print(res)
#三:空函数
def auth():
"""认证功能"""
pass
auth()
def insert():
"""插入功能"""
pass
def select():
"""查询功能"""
pass
def delete():
"""删除功能"""
pass
def update():
"""更新功能"""
pass
########函数调用########
def foo():
print('from foo')
def bar(name):
print('bar===>',name)
# 按照有参和无参可以将函数调用分两种
foo() # 定义时无参,调用时也无需传入参数
bar('egon') # 定义时有参,调用时也必须有参数
#按照函数的调用形式和出现的位置,分三种
# 1. 调用函数的语句形式
foo()
# 2. 调用函数的表达式形式
def my_max(x, y):
res=x if x >y else y
return res
res=my_max(1,2)*10000000
print(res)
# 3. 把函数调用当中另外一个函数的参数
res=my_max(my_max(10,20),30)
print(res)
#########函数返回值######
def foo():
print('from foo')
return None
res=foo()
print(res)
"""以下三种情况返回值都为None:
没有return
return 什么都不写
return None
"""
# return 一个值 函数调用返回的结果就是这个值
def foo():
print('from foo')
x=1
return x
res=foo()
print(res)
# return 值1,值2,值3,... 返回结果:(值1,值2,值3,...)
def foo():
print('from foo')
x=1
return 1,[2,3],(4,5),{}
res=foo()
print(res) #打印结果:(1,[2,3],(4,5),{})
a,b,c,d=foo()
print(d)
# 多个变量接收多个值的方法
t=(1,2,3)
a,_,_=t
print(a)
t=(1,2,3,4,5,6,7,8,9)
a,*_,c=t
print(a)
print(c)
############函数参数######
#从大的角度去看,函数的参数分两种:形参(变量名),实参(值)
#定义阶段
def foo(x,y): #x=1,y=2
print(x)
print(y)
#调用阶段
foo(1,2)
#详细的区分函数的参数分为五种:
# 位置参数,关键字参数,默认参数,可变长参数(*args,**kwargs),命名关键字参数
# 1. 位置参数
def foo(x, y, z):# 位置形参:必须被传值的参数
print(x, y, z)
foo(1,2,3) #位置实参数:与形参一一对应
# 2. 关键字参数:key=value
def foo(x, y, z):
print(x, y, z)
foo(z=3,x=1,y=2)
#关键字参数需要注意的问题:
# 1:关键字实参必须在位置实参后面
# 2: 不能重复对一个形参数传值
foo(1, z=3, y=2) # 正确
foo(x=1, 2, z=3) # 错误
foo(1,x=1,y=2,z=3) # 错误
# 3. 默认参数
def register(name, age, sex='male'): # 形参:默认参数
print(name, age, sex)
register('asb', age=40)
register('a1sb', 39)
register('钢蛋', 20,' female')
register('钢蛋', sex='female', age=19)
#默认参数需要注意的问题:
#一:默认参数必须跟在非默认参数后
def register(sex='male',name,age): #在定义阶段就会报错
print(name,age,sex)
#二:默认参数在定义阶段就已经赋值了,而且只在定义阶段赋值一次
a=100000000
def foo(x, y=a):
print(x, y)
a=0
foo(1) # 最终结果 y = 100000000
#三:默认参数的值通常定义成不可变类型
#4. 可变长参数
def foo(x, y, *args): #*会把溢出的按位置定义的实参都接收,以元组的形式赋值给args
print(x,y)
print(args)
foo(1,2,3,4,5)
def add(*args):
res = 0
for i in args:
res+=i
return res
print(add(1, 2, 3, 4))
print(add(1, 2))
def foo(x, y, **kwargs): # **会把溢出的按关键字定义的实参都接收,以字典的形式赋值给kwargs
print(x, y)
print(kwargs)
foo(1, 2, a=1, name='egon', age=18)
def foo(name, age, **kwargs):
print(name, age)
if 'sex' in kwargs:
print(kwargs['sex'])
if 'height' in kwargs:
print(kwargs['height'])
foo('egon', 18, sex='male', height='185')
foo('egon', 18, sex='male')
# 5. 命名关键字参数(了解)
def foo(name, age, *, sex='male', height):
print(name, age)
print(sex)
print(height)
# #*后定义的参数为命名关键字参数,这类参数,必须被传值,而且必须以关键字实参的形式去传值
foo('egon', 17 ,height='185')
## 各种参数混合使用
def foo(name,age=10,*args,sex='male',height,**kwargs):
print(name)
print(age)
print(args)
print(sex)
print(height)
print(kwargs)
foo('alex',1,2,3,4,5,sex='female',height='150',a=1,b=2,c=3)
###一些示例
def foo(*args):
print(args)
foo(1,2,3,4) # 1,2,3,4 <=====>*(1,2,3,4)
#*['A','B','C','D'],=====>'A','B','C','D'
foo(*['A','B','C','D']) # ('A','B','C','D')
foo(['A','B','C','D']) # (['A', 'B', 'C', 'D'],)
######
def foo(x,y,z):
print(x,y,z)
foo(*[1,2,3]) #foo(1,2,3)
foo(*[1,2]) #foo(1,2) 报错
####
def foo(**kwargs):
print(kwargs)
# x=1,y=2 <====>**{'y': 2, 'x': 1}
foo(x=1,y=2)
foo(**{'y': 2, 'x': 1,'a':1}) #foo(a=1,y=2,x=1)
###
def foo(x,y,z):
print(x,y,z)
# foo(**{'z':3,'x':1,'y':2}) #foo(x=1,z=3,y=2)
foo(**{'z':3,'x':1}) #foo(x=1,z=3)
##############
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
print(args)
print(kwargs)
wrapper(1,2,3,a=1,b=2)
####
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
print(args) #args=(1,2,3)
print(kwargs) #kwargs={'a':1,'b':2}
foo(*args,**kwargs) #foo(*(1,2,3),**{'a':1,'b':2}) #foo(1,2,3,b=2,a=1)
# wrapper(1,2,3,a=1,b=2)
wrapper(1,z=2,y=3)
####
def foo(x,y,z):
print('from foo',x,y,z)
def wrapper(*args,**kwargs):
# print(args) #args=(1,)
# print(kwargs) #kwargs={'y':3,'z':2}
foo(*args,**kwargs) #foo(*(1,),**{'y':3,'z':2}) #foo(1,z=2,y=3)
# wrapper(1,2,3,a=1,b=2)
wrapper(1,z=2,y=3)
#补充:函数定义阶段,只检测函数体的语法,并不会执行