python基础-函数

函数

什么是函数

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

为什么要使用函数

防止代码冗余；不使用函数，代码的可读性差

如何使用函数

• 函数的定义

  关键字(def) 函数名(index) 小括号():
  """函数描述：用于描述函数代码体的功能"""

  def index():
      """打印一句话
      :return:
      """
      print("这是一个函数")

• 函数名的命名规范与变量是一样

• 函数的种类

  • 无参函数

    def index():
        """打印一句话
        :return:
        """
        print("这是一个无参函数")

  • 空函数(只有函数名)

    def index():
        pass

  • 有参函数

    def login(username,password):
        print(username,password)

• 函数的调用

  • 直接调用

    # 定义register 函数 
    def register():
        """打印姓名，年龄
        :return:
        """
        print("注册用户：\n姓名：dawn\n年龄：37\n")
    # 直接调用register 函数
    register()

  • 定义变量接收

    # 定义register 函数
    def register():
        """打印姓名，年龄
        :return:
        """
        print("注册用户：\n姓名：dawn\n年龄：37\n")
    # 定义变量res ，给res 赋值为register
    per = register
    # 使用res调用函数
    per()

  • 将函数当作参数使用

    # 定义max 函数
    def max(num1,nmu2):
        """
        比较两个数的大小,返回最大数
        :param num1:
        :param nmu2:
        :return: max
        """
        # 如果num1 > num2，那么返回num1，否则返回num2，再将结果赋值给max变量。相当于if…else…的缩写
        max = num1 if num1 > nmu2 else nmu2
        return max
    # 使用了函数嵌套,将max() 当作一个参数再次传入了max() 中
    print(max(187,max(89,233)))

• 函数的返回值

  返回用关键字return表示。return是函数结束的标志，函数体代码只要执行到return，函数执行结束

  函数的返回值分为5种情况：

  • 不写return：也就是没有返回值，默认返回none

    def foo():
        """用于演示没有return的函数
        :return:
        """
        name = "dawn"
        age = 37
    
    print(foo())        # 打印结果：none

  • 只写return：只有结束函数体代码的效果，返回none

    def foo():
        """
        用于演示只写return
        :return: none
        """
        for i in range(2):
            while true:
                i += 1
                print(i)
                if i == 1:
                    return
    
    print(foo())        # 打印结果：1和none 1是函数打印出来的记录

  • return none：这种情况跟只写return none的效果相同

    def foo():
        """
        用于演示return none
        :return: none
        """
        for i in range(3,0,-1):
            for j in range(i-1,-1,-1):
                if j == 1:
                    return none
                print(j)
    
    print(foo())        # 打印结果：2和none 2是函数打印出来的记录

  • return 单个值：可将返回的结果当作变量或赋值给变量使用

    def foo():
        """
        用于演示return 一个值
        :return: min
        """
        min = 0
        num1 = 123.04
        num2 = 233.333
        min = num1 if num1 < num2 else num2
        return min
    
    print(f"123.04和233.333之间，比较小的是{foo()}")

  • return 多个值：将返回的多个值，存入元组中返回（默认），也可自行指定返回的数据类型。存储在元组中，是不想返回值被修改

    # 默认返回元组
    def foo():
        """
        用于演示return 多个值时，默认将多个值存储在元组中返回
        :return: (name,age,hobby,animals)
        """
        name = "dawn"
        age = 37
        hobby = ["study","read","music"]
        animals = {"cat":"星期天","dog":"饭团"}
        return name,age,hobby,animals
    
    print(foo())            # 打印结果元组类型记录：('dawn', 37, ['study', 'read', 'music'], {'cat': '星期天', 'dog': '饭团'})
    
    # 自定义返回值为字典
    def foo1():
        """
        用于演示return 多个值时，设置以字典的形式返回多个值
        :return: {"name":name,"age":age,"hobby":hobby,"animals":animals}
        """
        name = "dawn"
        age = 37
        hobby = ["study", "read"]
        animals = {"cat": "星期天"}
        return {"name":name,"age":age,"hobby":hobby,"animals":animals}
    
    print(foo1())   # 打印结果字典类型：{'name': 'dawn', 'age': 37, 'hobby': ['study', 'read'], 'animals': {'cat': '星期天'}}

• 函数的参数

  从类型来讲，参数分为形参和实参。

  形参：函数定义阶段就规定的参数。相当于定义变量时的变量名

  实参：函数调用阶段传入的参数。相当于赋值给变量的变量值

  # 这里的username 和password 就是形参
  def get_xspar(username,password):
      """
        用于演示形参和实参
      :param username:姓名
        :param 和password:密码
      :return:
        """
      print(f"姓名：{username}\t密码：{password}")
  
  # 这里传入login 函数中的"dawn"和"123"就是实参
  get_xspar("dawn","123")

  从传参方式来说，分为四种。分别是：位置参数、关键字参数、默认参数、可变长参数

  • 位置参数：在调用函数时，直接通过函数中参数列表顺序传参的参数

    def w_par(name,pwd):
            """
            用于演示位置参数
            :param name:姓名
            :param pwd:密码
            :return:
            """
            print(f"用户名：{name}\t登录密码：{pwd}")
        w_par("dawn","123")  # "dawn","123"根据参数列表依次传参，就是位置参数

  • 关键字参数：在调用函数时，指定参数名进行传参的参数

      def g_par(name,pwd,age):
        """
        用于关键字参数
        :param name:姓名
        :param pwd:密码
        :param age:年龄
        :return:
        """
        print(f"姓名：{name}\t密码：{pwd}\t年龄：{age}")
    g_par(age=18,name="dawn",pwd="123") # 将值传给指定参数的这种，就是关键字参数

    注意：

    位置参数和关键字参数可以混用，位置参数一定要在关键字参数之前，混用的时候，不要对同一个形参重复赋值

    def g_par(name,pwd,age):
        """
        用于演示位置参数和关键字参数的混用
        :param name:姓名
        :param pwd:密码
        :param age:年龄
        :return:
        """
        print(f"姓名：{name}\t密码：{pwd}\t年龄：{age}")
    
    g_par(name="dawn","123",age=18)     # 错误示例，位置参数一定要在关键字参数之前
    g_par("123",name="dawn",age=18)     # 错误示例，程序运行时，默认将"123",name="dawn"都当作参数[name]的值
    g_par("dawn","123",age=18)          # 正确示例

  • 默认参数：在定义函数阶段，对形参进行赋值（也就是设置了参数值）的参数。在调用时，如果不对这个参数传值，系统会自动使用默认值；如果对这个参数，重新传了参数，默认值将会被修改。请不要将可变类型当作参数传递

    def defult_par(name,age,gender="男"):
        """
        用于演示返回默认值参数
        :param name: 姓名
        :param age: 年龄
        :param gender: 性别，默认值为[男]
        :return:
        """
        print(f"姓名：{name}，年龄：{age}，性别：{gender}")
    
    defult_par("egon",73)       # 没有传入[gender]参数，打印结果：姓名：egon，年龄：73，性别：男
    defult_par("dawn",37,"女")   # 传了[gender]参数，打印结果：姓名：dawn，年龄：37，性别：女

  • 可变长参数：函数中参数列表数量可以不固定

    *args：接收所有溢出的位置参数，接收的值都被存入一个元组中。

    其实，*args 是官方认证的表示，***** 后面的名称可以修改，**形参中只要有*就有可变长参数的效果**。

    def args_par(name,age,*args):
        """
        用于演示*args 的作用
        :param name:姓名
        :param age:年龄
        :param args:溢出参数
        :return:
        """
        print(f"姓名：{name}，年龄：{age}。溢出的参数：{args}")
    
    args_par("egon",73)         # 正常输入参数，打印结果：姓名：egon，年龄：73。溢出的参数：()
    args_par("sean",18,"male","烫头")     # 多传了2个参数，打印结果：姓名：sean，年龄：18。溢出的参数：('male', '烫头')

    需要注意的是：

    *****在形参中表示接收溢出参数，在实参中的表示将容器类型的数据打散。# 函数有几个参数，实参的长度就是几位，否则报错。字典传入的是key值

    def s_par(name,age,str):
        """
        用于演示在实参中，* 表示打算的意思
        :param str: 传入的容器类型数据，str,list,tuple,dict,set
        :return:
        """
        print(name,age,str)
    
    s_par(*"sea")       # 打印结果：s e a
    s_par(*['sean','18','male'])  # 打印结果：sean 18 male
    s_par(*('a',1,'c'))           # 打印结果：a 1 c
    s_par(*{"name":"sean","age":18,"gender":"male"}) # 字典传入的是key 打印结果：name age gender
    s_par(*{'1','a',233})         # 打印结果：a 233 1

    ** kwargs：接收所有溢出的关键字参数，接收的值都被存入一个字典中。输出时，直接使用kwargs；如果是 *kwargs，表示打算输出字典中的所有的key值

    def kwargs_par(name,age,**kwargs):
        """
        用于演示**kwargs 的作用
        :param name: 姓名
        :param age: 年龄
        :param kwargs: 溢出的关键字参数字典
        :return:
        """
        print(f"姓名：{name}，年龄：{age}，溢出的位置参数字典：{kwargs}")
        print(f"打散后的溢出位置参数：",end="")
        print(*kwargs)
    
    kwargs_par(age=18,gender="male",hobby="['study','read']",name="sean")
    # 打印结果：
    # 姓名：sean，年龄：18，溢出的位置参数字典：{'gender': 'male', 'hobby': "['study','read']"}
    # 打散后的溢出位置参数：gender hobby