Python 基础之函数初识与函数参数

Posted 2021-11-29 hszstudypy

一:函数初识

定义:满足某一个方法 满足某一个功能
#(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