函数

函数类型

1 内置函数

• sum() 和
• max() 最大值
• min() 最小值
• len() 长度
• 等等等等

2自定义函数

    #制造自定义函数
    #def 是参数, print_star()是函数名, print("hello")是函数值
     
    def print_star():
    print("#"*6)
    def print_msg():
    print("hello")
    #使用自定义函数
    print_star()
    print_msg()
    print_star()

 

函数的使用:

    先定义后使用,(先使用后调用, 会报错找不到)
    def 函数名 (参数1,参数2,....):
       """文档注释"""
       函数体(代码)
        renturn值(定义返回值)

 

函数定义方式:

 

1.无参数函数:

    #无参函数: 函数的功能仅仅只是执行一些操作
    def foo():
    print("from foo")
    foo() #定义时无参,调用时也无参函数

2 有参函数：

    #定义时有参,调用时也必须有参数
    方法1
        def bar(name):
        print('bar===>>',name)
        bar("egon")
        #显示:bar===>> egon
    方法2
        def my_max(x,y):
        res= x if x >y else y
        return res
        res=my_max(1,2)*1000
        print(res)
        #显示2000
    方法3
        def my_max(x,y):
        res= x if x >y else y
        return res
        res=my_max(my_max(10,20),30)
        print(res)
        #显示:30

    三元运算

        #if条件成立执行 res=x x可改
        x = 10
        y = 2
        res = x if x > y else y
        print(res)

3 空函数:

    def auth():
    """认证功能"""
    pass
    auth()

return

    def foo():
    print("from foo")
    res=foo()
    print(res) #返回None,None表示什么都没有
    # 以下3种都返回None
    # 没有return
    # return 什么都不写
    # return None
    def foo():
    print("from foo")
    x = 1
    #return x #返回1,x定义是1
    #return 1,2,3,4 #返回结果是元组形式
    return 1,[2,3],(4.5),{} #返回指定的值
    res=foo()
    print(res)

 

数值读取和增加

    读取t下的每个元素
        t=(1,2,3)
        a,b,c = t
        #显示每个元素
        print(a)
        print(b)
        print(c)
        t=c,a,b,b        #调顺序并增加b
        print(t)
        #(3, 1, 2, 2)
    显示1个数其他都用站位表示
    t=(1,2,3)
    a,_,_=t #_站位
    print(a)
    #显示1
     
    #显示第一个和最后一个值
    test=(1,2,3,4,5,6)
    a,*_,c =test #*表示所有值, _站位, a第一值,c最后一个值
    print(a)
    print(c)
    # 1
    # 6

 

 

函数的参数: 

 

函数2个阶段:                    定义阶段     调用阶段

 

广义上函数的参数分两种:    形参            实参

    #实参的值要传给形参
     
    #定义阶段:只检测函数体的语法,并不会执行,不占用内存空间
    def foo(x,y): #形参(变量名), 形式参数
    print(x)
    print(y)
    #调用阶段    
    foo(1,2) #实参(变量值),实际参数

位置参数

    def foo(x,y,z):    #位置形参,必须被传值的参数
    print(x,y,z)
    foo(1,2,3)    #位置实参,与形参一一对应
    #显示1 2 3

关键字参数 key=value

    def foo(x,y,z):#必须被传值的参数
    print(x,y,z)
    foo(z=3,x=1,y=2) #关键字传参,指定传参,不需要按顺序
    #显示1 2 3
    foo(1,z=3,y=2) #位置参数和关键字,执行传参
    #显示1 2 3
    #foo(x=1,2,z=3) 错误实例 注:关键字参数必须在位置参数后边
    #foo(1,x=1,y=2,z=3) 错误实例 注:不能重复对一个形参传值

默认参数

    def register(name,age,sex="male"):    #age,sex="male"是默认参数
    print(name,age,sex)
    register("root",39) #male是默认实参,不指定则添加
    #显示 root 39 male
    register("三",20,"female") #改变默认实参sex="male"为sex="female"
    #显示 三 20 female
    register("四",sex="female",age=19) #改变实参位置,必须指定变量
    #显示 四 19 famale
    #默认参数注意问题:
    # 1.默认参数必须在非默认参数后边,
     
    #如下是错误实例,定义阶段就报错
    #def register(sex="male",name,age):
    # print(sex,name,age)
    # 2.默认参数在定义阶段就已经赋值了,而且只在定义阶段赋值一次
    a=100
    def foo(x,y=a):
    print(x,y)
    a = 0
    foo(1) #只在定义阶段赋值,所有a=100 而不是a=1
    #显示100
    # 3.默认参数的值通常定义成不可变类型,不能用于可变类型(字典,列表),常用:变化比较少的参数, 用默认参数

 

可变长参数,(*args,**kwargs)

    实参和形参的变化:按位置定义和按关键字定义
    在调用函数时,实参的长度是可变
    在形参角度,去声明这种参数,能够接受任意长度的实参

*args 是位置参数
*args     *把溢出的按位置参数定义的实参都接受,以元组的形式赋值给args

    #针对按位置定义的溢出的实参
    def foo(x,y,*args):     #x和y是位置形数, *args是所有溢出的形参
    print(x,y)             #x和y是位置形数,
    print(args)       #溢出的形参
    foo(1,2,3,4,5)       #1,2是位置实参,3,4,5是溢出的实参
    #普通求和函数
    def add(x,y):
    res=x+y
    return res
    print(add(1,2))
    #显示3
    #*args求和函数
    def add(*args):
    res=0
    for i in args:
    res+=i #res=0+1>>1+2>>3+3>>6+4
    return res
    print(add(1,2,3,4)) #显示数字相加的值
    #显示10
    *args特殊用法
        def foo(*args): #*后边跟的值 都是位置参数
        print(args)
        foo("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'],)
     

 
**kwargs是关键字参数
**kwargs     **把溢出的按关键字定义的实参都接受,以字典的形式赋值给kwargs

     
    def foo(x,y,**kwargs): #x和y是位置形数, **kwargs是所有溢出的形参
    print(x,y) #x和y是位置形数,
    print(kwargs) #**kwargs是所有溢出的形参
    foo(y=2,x=1,a=1,name="guolm",age=18)    #和下边一样
    foo(1,2,a=1,name="guolm",age=18) #和上边的foo...相同,位置实参,可用位置实参或关键字实参, 但溢出实参必须用关键字实参
     
    #显示
    # 1 2
    #{'a': 1, 'name': 'guolm', 'age': 18}
    生成字典

    def foo(**kwargs):
        print(kwargs)
    foo(x=1,y=2)         #实现效果和下边一样    #这是用户参照
    #{'x': 1, 'y': 2}
    foo(**{"x":1,"y":2}) #foo(y=2,x=1)        #这是用户参照

    #{'y': 2, 'x': 1}
    函数调用函数
        *args+**kwargs组合
        def foo(x,y,z):
        print("from foo",x,y,z)
        def wrapper(*args,**kwargs):
        #print(args) #(1,)
        #print(kwargs) #{'z': 2, 'y': 3}
        foo(*args,**kwargs)
        wrapper(1,z=2,y=3)
        #from foo 1 3 2          #1是元组 3和2是字典{'z': 2, 'y': 3} ,是z和y的value

 

 

命名关键字参数

*后的参数全为命名关键字参数,但是拥有其他参数的功能(看方法2)

    *后定义的参数为命名关键字参数,这类参数.必须被传值,而且必须以关键字实参的形式去传值
方法1
    def foo(name,age,*,sex,height):    
    # name是位置参数,age是位置参数, *,sex,height (*后边的sex,height,都是命名关键字参数)
    print(name)
    print(age)
    print(sex)
    print(height)
    foo("egon",18,height="185",sex="male")
    #egon #18 #male #185
　　 

方法2    def foo(name,age,*,sex="male",height):    这里sex="male"是命名关键字,用于默认参数的功能
    print(name)
    print(age)
    print(sex)
    print(height)
    foo("egon",18,height="185")                #这么不需要输入sex的值,因为有默认参数的功能
    # egon
    # 18
    # male
    # 185