一:函数初识
定义:满足某一个方法 满足某一个功能
#(1)功能(包裹一部分代码 实现某一个功能 达成某一个目的)
#(2)可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
#(3)函数的基本格式:
#定义一个函数
def 函数名():
code1
code2
#调用函数
函数名()
#例子:(最简单的一个函数)
#函数的定义处
def func():
print("我是一个大帅哥")
#函数的调用处
func()
#(4) 函数的命名规则
字母数字下划线 首字符不能为数字
严格区分大小写 且不能使用关键字
函数命名有意义 且不能使用中文哦
这样方便记忆
#小记:
驼峰命名法:
(1)大驼峰命名法 : myfunc => MyFunc 应用在面向对象程序当中的类名
(2)小驼峰命名法 ： myfunc => myFunc 用在函数上(不做强制要求)
(3)下划线命名法 : myfunc => my_func (推荐)
#函数的定义处 def
def Multiplication_table():
for i in range(1,10):
for j in range(1,i+1):
print("%d*%d=%2d " % (i,j,i*j),end="")
print()
#函数调用处
Multiplication_table()
for k in range(1,10):
Multiplication_table()
k+=1
二:函数的参数
参数: 形参 + 实参
形参: 形式参数 在函数的一定处
实参: 实际参数 在函数的调用处
形参: 普通形参(位置形参),默认形参,普通收集形参,命名关键字形参,关键字收集形参
实参: 普通实参,关键字实参
形参 和 实参 要一一对应
#1.带有参数的函数:普通形参(位置形参)
#例:
#函数的定义处 hang lie 叫做普通形参 或者 叫做 位置形参
def small_star(hang,lie):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
#函数的调用处 10,10 叫普通实参
small_star(10,10)
print("===============")
small_star(5,8)
#2.默认参数
如果不写任何的实参,那么使用默认形参的值
如果写了自定义的实参,那么使用实际参数
#例:
#函数的定义处 hang = 10 lie = 10 默认形参
def small_star(hang=10,lie=10):
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
#函数的调用处 3 4 普通实参
small_star()
small_star(3)
small_star(3,4)
#3.普通实参 + 默认形参
普通形参 必须 放在默认形参的前面
#例:
print('---------------')
def small_star(hang,lie=10): #就是hang要放在lie=10之前
i = 0
while i < hang:
j = 0
while j < lie:
print("*",end="")
j+=1
print()
i+=1
small_star(3,4)
#4.关键字实参
(1)如果是用来关键字实参进行调用,顺序随意
(2)如果定义时是普通形参,但调用时是使用了关键字实参调用,
那么这个参数的后面所有参数都必须使用关键字实参
#例:
def small_star(hang,a,b,c,lie=10):
print(hang,a,b,c,lie)
i = 0
while i<hang:
j = 0
while j<lie:
print("*",end="")
j+=1
print()
i+=1
#small_star(3,b=5,lie=90,a=4,c=6)
small_star(3,a=4,b=5,c=6,lie=12)
#默认形参 与 关键字实参的区别
# 函数的定义处 top middle bottom ..默认形参
def five_class_xiongda_team(top="皇子",middle="狐狸",bottom="寒冰",jungle="瞎子",support="琴女"):
print("top上单选手:{top}".format(top=top))
print("middle中单选手:{middle}".format(middle=middle))
print("bottom下路选手:{bottom}".format(bottom=bottom))
print("jungle打野选手:{jungle}".format(jungle=jungle))
print("support辅助选手 最后的希望vip:{support}".format(support=support))
#函数的调用处
# five_class_xiongda_team() top middle bottom ... 关键字实参
five_class_xiongda_team(top="奥拉夫",middle="亚索",bottom="德莱文",jungle="蜘蛛")
#在函数的调用处给参数赋值 top = '' middle = '' 等
#关键字实参的内容可以将默认形参进行修改,如果关键字实参没有,那么函数内的参数就使用默认形参
#5.收集参数
收集参数:
(1)普通收集参数
(2)关键字收集参数
#(1)普通收集参数(可变参数)
语法:
def func(*参数):
pass
参数前面加一个* 的就是普通收集参数;
普通收集参数专门用于收集多余的,没人要的普通实参,形成一个元组
#例:
def func(a,b,c,*arg):
print(a,b,c) #1,2,3
print(arg) #()
func(1,2,3,4,5,6)
arg => argument 参数
# 计算任意长度的累加和
# 函数的定义处
def mysum(*arg): #*args接受了三个参数
total = 0
print(arg)
for i in arg:
total +=i
print(total)
mysum(1,5,7,1000)
#(2) 关键字收集参数
#语法
def func(**参数):
pass
参数前面加上**的就是关键字收集参数
关键字收集参数:用于收集多余的,没人要的关键字实参,形成一个字典
def func(a,b,c,**kwargs):
pass
kwargs => keyword 关键字 arguments 多个参数
#例1:
def func(a,b,c,**kwargs):
print(a,b,c)
print(kwargs)
func(1,2,3,f=11,d=13,zz=19) #将关键字实参形成一个字典
"""
输出结果为:
1 2 3
{'f': 11, 'd': 13, 'zz': 19}
#例2:
#打印任意长度的字符
# 班长:one
# 班花:two
def func(**kwargs):
dictvar = {"monitor":"班长","class_flower":"班花"}
strvar1 = ''
strvar2 = ''
print(kwargs) #这个kwargs是一个字典
for a,b in kwargs.items():
if a in dictvar:
strvar1 += dictvar[a] + ":" + b + "\n"
else:
strvar2 += "吃瓜群众:" + b + "\n"
print(strvar1)
print(strvar2)
func(monitor="one",class_flower="two",people1="three",people2="four")
运行后的结果为:
{'monitor': 'one', 'class_flower': 'two', 'people1': 'three', 'people2': 'four'}
班长:one
班花:two
吃瓜群众:three
吃瓜群众:four
#6.命名关键字
#语法:
def func(参数1,参数2,*,参数3,参数4):
pass
#(1)在函数的定义处,*号后面的参数就是命名关键字参数
#(2)在函数的定义处,在普通收集参数和关键字收集参数之间的命名关键字参数
def func(*args,命名关键字参数,**kwargs)
命名关键字必须使用关键字实参的形式进行调用
#形式1:
def func(a,b,*,c):
print(a,b,c)
func(1,2,c=4)
结果为: 1 2 4
#形式2:
如果命名关键字指定了默认值,那么在调用时,
可以不指定实参,默认使用自己的值
def func(a,b,*,c=5):
print(a,b,c)
func(1,2,c=6) #有实参先用实参,没有实参才使用默认形参
结果: 1 2 6
#形式3:
def func(*args,d,**kwargs):
print(args) # 1 2 23
print(kwargs) # {'c':1,'f':2}
print(d) # 3
func(1,2,23,c=1,f=2,d=3)
结果:写在每行输出的#后面了
#(3)* 和**的魔术用法
*和**在函数的定义处,负责打包(把实参都收集过来,放在元组或字典中)
#例1:
def func(a,b,c):
print(a,b,c)
listvar = [1,2,3]
# * 一般修饰列表更多一些(负责把列表里面的元素一个个拿出来的进行函数调用)
func(*listvar) #<==> func(1,2,3)
#结果输出: 1 2 3
#可以这样用func(*(1,2,3))
#例2:
def func(a,b,c,*,d,e,f):
print(a,b,c)
print(d,e,f)
listvar = [1,2,3]
dic = {"d":4,"e":5,"f":6} #func(d=4,e=5,f=6)
# ** 一般修饰字典,(负责把字典里面的键值对变成d=4,e=5的形式,进行函数调用)
func(1,2,3,**dic) #<===>d = 4,e = 5,f = 6
#* 和 **的解包操作
func(*listvar,**dic)
#函数参数的默认顺序:
必须按照如下的参数顺序进行定义:
普通形参(位置形参) -> 默认形参 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数
#例:
def f1(a,b,c=0,*args,**kw):
print('a =',a,'b =',b,'c =',c,'args =',args,'kw =',kw)
def f2(a,b,c=0,*,d,**kw):
print('a =',a,'b =',b,'c =',c,'d =',d,'kw =',kw)
print("=============分隔=============")
#(一)
f1(1,2) #a=1 b=2 c=0 args=() kw={}
f1(1,2,c=3) #a=1 b=2 c=3 args=() kw={}ffffffffffffff
f1(1,2,3,'a','b')#a=1 b=2 c=3 args=('a','b') kw={}
#f1(1,2,3,'a','b',x=99) #a=1 b=2 c=3 args=('a','b') kw={'x':99}
#f2(1,2,d=99,ext=None) #a=1 b=2 c=0 d=99 kw={'ext':None}
#(二)
print("=============分隔=====二========")
args = (1,2,3,4)
kw = {'d':99,'x':'#'}
f1(*args,**kw) #a=1 b=2 c=3 d=99 args=(4,) kw={'x':'#'}
#*args ==> f1(1,2,3,4)
#**kwargs ==> f1(d=99,x="#")
#(三)
print("=============分隔=====三========")
def f2(a, b, c=0, *, d, **kw):
print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
myargs = (1,2,3)
mykw ={'d':88,'x':'#'}
f2(*myargs,**mykw) #a=1 b=2 c=3 d=88 kw={'x':'#'}
#(四)
#定义处
print("=============分隔=====四========")
def f1(a,b,c=0,*args,d,**kw):
print('a =',a,'b =',b,'c =',c,'args =',args,'kw = ',kw)
print('d=',d)
#调用处
f1(1,2,3,'a','b',d=67,x=99,y=77)
#a=1 b=2 c=3 args=('a','b') kw={'x':99,'y':77}
#d=67
#普通收集形参 和 关键字收集形参 可以接受到所有种类的参数
# *args,**kwargs 都是可变长参数,参数的长度不限制
def func(*args,**kwargs):
pass