day--函数

函数

  • 什么是函数

    函数是一种工具,可以重复调用

  • 为什么要用函数

    1.防止代码冗余。

    2.代码的可读性差

  • 怎么用函数

    1.定义函数-->制造工具

    2.调用函数-->使用工具

  • 函数的分类:

    1.无参函数:

    def  index():

    print("ok")

    2.空函数:

    def  login():

    pass

    3.有参函数:

    def login(username):

    print(username)

    def index(a,b):
      if a > b:
          return a
      else:
          return b
    print(index(3 , 4))

     

    返回值:

        1、不写return:默认返回None   

    2、只写return:只有结束函数体代码的效果,返回None   

    3、写return None :与只写return的效果相同   

    4、return返回一个值: 可以将返回的结果,当做一个变量值来使用   

    5、return返回多个值:       

    1、将返回的多个值,默认存入元组返回       

    2、函数的返回值不想被修改       

    3、可以自己指定返回的数据类型

    return 是一个函数结束的标志,函数体代码只要执行到return ,代码就会被结束执行。

    l1 = [1, 3, 6, 9, 3, 5, 7]
    # 求9的索引值

    def my_len():
      count = 0
      while True:
          for i in l1:
              if i == 9:
                  print(count)
                  return
              count += 1
    print(my_len())

    a = 1
    b = 5
    c = '2'
    d = [2, 3, 4]
    e = {'name', 'sean'}


    def yuan(a, b, c, d, e):
      return a, b, c, d, e
    print(yuan(a, b, c, d, e)) # 可以接受任意的类型,返回是一个元组

     

     

    函数的参数:

    函数定义时只检查语法,不执行任何代码

    参数的类型:

            形参:在函数定义阶段就规定的参数,相当于变量的变量名

            实参:在函数调用阶段传入的参数,相当于定义变量时的变量值。

    传参方式:

    位置参数 :通过位置传参数

    关键字参数:指定参数传参

    PS:位置参数要在关键字参数前面
    def foo(a, b, c, d):
      print(a, b, c, d)
       
    foo(1, 2, c=1, d=2)

     

    默认参数:

    在定义函数阶段就已经传入函数

    如果说在实参的时候传入了一个新的参数,就会使用新参数

    默认参数再传值时不要将可变类型当作参数传入

    当参数对应值重复出现的情况下,可以使用默认参数
    def rag(username, age,gender):
      print(f'名字:{username},年龄:{age},性别:{gender}')
    rag('egon',73,'male')
    rag('jason', 66, 'male')       #里面性别gender都是一样的

    def rag(username, age, gender="male"):
      print(f'名字:{username},年龄:{age},性别:{gender}')
    rag('egon', 73)
    rag('jason', 66)             #重复部分我们在定义时可以写成默认参数
    rag('blose', 22, 'female')   #传入新的参数,会使用新的参数

     

    可变长参数:

            *args:

    在形参中:接收所有溢出的位置参数 , 接收的值都被存入一个元组。

    在实参中:*打散传入的容器类型。

            **kwargs:接收所有溢出的关键字参数, 关键字参数接收的值都被存入一个字典。

    def index(a, b, c, d, *rangs):   #*rangs接收溢出的位置参数。形参
      print(a, b, c, d)   #只打印4个参数

    #
    index(1, 2, *(3, 4, 5)) #实参 *在实参中会打散传入的容器类型。
                              变成3,4,5。index就会有了5个参数
                             
                             
    def index(a, b, c, d, *rangs):
      print(a, b, c, d,rangs)# 打印时rangs返回的是一个元组。


    index(1, 2, *(3, 4, 5))

    结果:1 2 3 4 (5,)

    实参中有字典
    def index(a, b, c, d, e, *rangs):
      print(a, b, c, d, e, rangs)


    index(1, 2, 3, 4, *{'a =1', 'b = 2'})

    结果:1 2 3 4 a =1 ('b = 2',)

    # **kwargs接受溢出的关键字参数。,如果接受的是字典类型的参数。**kwargs可以把所有的值都接收到,*kwargs的话就只能接收到key值。
    def foo(a, b, c, d, e):
      print(a, b, c, d, e)

    def bar(*args, **kwargs):
      foo(*args, **kwargs)

    bar(1, 2, c=12, d=22, e=33)
原文地址:https://www.cnblogs.com/lishuangjian/p/11830961.html