初识函数

函数

• 为什么要用到函数呢？

  • 举个例子：函数就相当于一个可以重复利用的工具，例如xshell，下载一次后可以重复使用，而不是每次使用都要去下载，这样就节省了很多的时间

  • 这也就提到了函数的好处：

    • 可重复利用，减少代码量

    • 方便管理

• 函数的定义

  • 在python中函数的定义方式如下:

    >>> def 函数名(形式参数):
    ...     函数体
    ...     return 返回值

  • 定义一个求和的函数

    >>> def my_sum(x,y):    # 函数定义阶段
    ...     sum = x + y
    ...     return sum  # 两步并yibu  return x + y
    ...
    >>> my_sum(10,20)   # 函数调用阶段
    30

    # 一定要分清楚函数对象和函数调用
    函数对象: my_sum    # 会返回一个内存地址
    函数调用: my_sum()  # 执行函数体的代码

    • 函数名定义

      • 名称不可以和内置函数重名

      • 驼峰体: MySum

      • 地中海: my_sum

    • 函数的定义形式

      • 有参形式 : def (需要传递参数)
            当内部的函数体需要外部传递参数的时候，例如运算，
        
        无参形式:  def(不需要传递参数)
            当内部的函数体不需要明确的传递参数的时候，例如交互式操作
        
        空函数: def 函数名(): pass 
            什么都不做，作为一个空的函数，主要用于定义函数结构体，当你知道要写什么功能但是不知道具体怎么实现的时候，先定义空函数日后在写

         

    • 函数的执行原则
      
      • 函数调用一定要在函数定义之后

      • >>> my_sum(10+20)　　# 定义之前调用
        >>> def my_sum(x,y):
        ...     return x + y
        ...
        NameError: name 'my_sum' is not defined

• 函数参数

  • 形参、实参

    • 形参：函数定义定义时传递的参数，用于接收调用传递的参数

    • 实参：函数调用时传递的参数

      >>> def my_sum(x,y):
      ...     return x + y
      ...
      my_sum(10,20)
      ​
      x  y   就是形参
      10 20  就是实参
      # 传递实参的时候一定要从左到右对应形参的位置, 形参个数 = 实参个数，否则报错
      >>> def my_sum(x,y):
      ...     return x + y
      ... 
      >>> my_sum(1,2,3)
      ​
      TypeError: my_sum() takes 2 positional arguments but 3 were given
      # 我需要两个参数，而你却传给我三个参数

  • 关键字参数

    • 传递参数的时候指名道姓

      >>> def my_sum(x,y):
      ...     return x + y
      ...
      >>> my_sum(y=10,x=20)
      ​
      >>> def student(name,age):
      ...     return name,age # 返回多个值的时候，将多个值组成一个元组
      ...
      >>> student(age=18,name='dingh')
      ('dingh', 18)
      ​
      # 上段代码可以看出来传递参数的时候指定的形参的名字，而且不需要考虑形参的位置

  • 默认参数

    • 定义函数的时候指定默认参数，初始化了默认值，调用的时候可以不传值

      >>> def my_sum(x,y=20): # 定义y默认值为20
      ...     return x + y
      ...
      >>> my_sum(10)  
      30
      # 当然也可以传值，覆盖默认值
      >>> my_sum(20,30)  
      50

  • 可变长参数

    • 可变参数可以接收传递的多个值，也可以不传值

    • 可变长形参 (*args)

      # 当你有多个参数想要传入函数怎么办？就用*args,当然args也可以是任意其他的，但是约定俗成为这个
      

      >>> def num(*args):
      ...     print('args:',args)
      ...
      >>>> num(1,2,3,4,5,6,7,8,9) 
      args: (1,2,3,4,5,6,7,8,9)
      ​
      >>> def num(*args):
      ...    print(args)
      ...
      >>> num()
      ()
      ​
      # 求多个数的和
      >>> def my_sum(*args):
      ...     sum = 0
      ...     for num in args:
      ...         sum += num
      ...     return sum
      ...
      >>> my_sum(1,2,3,4,5,6,7,8,9,10)    
      55

    • 可变长关键字参数 (**keargs)

      # 接收多个关键字参数
      >>> def student(**kwargs):
      ...     print('kwargs:',kwargs)
      ...
      >>> student(name='dingh',age=18,sex='male')
      # 返回的是一个字典
      kwargs: {'name': 'dingh', 'age': 18, 'sex': 'male'}

    • 分解传入参数

      >>> L = [1,2,3,4,5]
      >>> def my_sum(*args):
      ...     sum = 0
      ...     for num in args:
      ...         sum += num
      ...     return sum
      ...
      # 将L列表分解传入
      >>> my_sum(*L)  # *L = *(1,2,3,4,5) --> for num in (1,2,3,4,5)
      15
      ​
      ​
      >>> dic = {'name': 'dingh','age': 18}
      >>> def student(**kwargs):
      ...     print(kwargs)
      ...
      >>> student(sex='male',**dic)
      {'sex': 'male', 'name': 'dingh', 'age': 18}

  • 命名关键字参数

    • 指定关键字，必须按照指定的关键字传值

      >>> def student(name,**kwargs):
      ...     print(name,kwargs)
      ...
      >>> student('dingh',sex=18,job='python')
      dingh {'sex': 18, 'job': 'python'}
      ​
      # **kwargs 可以接收任意关键字的值，如果想指定关键字呢？接下来请看
      >>> def student(name,*,sex,age):
      ...     print(name,sex,age)
          
      >>> student('dingh',sex=18,job='python')
      # 报错了，没有job这个key
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      TypeError: student() got an unexpected keyword argument 'job'
      ​
      # 传入指定的关键字就不会报错了
      >>> student('dingh',sex=18,age=18)
      dingh 18 18
      ​
      # 如果参数中有*号了后边就不用写了，例如这种
      >>> def student(name,*args,age,sex) # 当形参在可变参数后面就变成了命名关键字参数

  • 参数混用

    • 默认参数一定要在形参的后面，可变参数在默认参数的后面

      >>> def func(x,y,z,num=1,*args,**kwargs):
      ...     print(x,y,z)
      ...     print(num)
      ...     print(*args)
      ...     print(**kwargs)
      >>> func(1,2,3,4,'dingh','male',age=18)
      1 2 3
      4
      ('dingh', 'male')
      {'age': 18}

  • 函数的返回值

    • return 将函数的值返回，不会输出

      >>> def func(x):
      ...     return x
      ...
      >>> func(123)
      # 需要赋值打印出来
      >>> data = func(123)
      >>> print(data)     # 两步并作一步，print(func(123))
      123
      ​
      # 函数体当遇到return时退出函数
      >>> def func(x):
      ...     print(x)    # 111
      ...     return x    # 111 退出函数体
      ...     print('--------')   # 不会执行到这一步
      ...
      >>> print(func(111))
      111
      111

    • print 将值输出屏幕，返回None

      >>> def func(x):
      ...     print(x)
      ...
      >>> func(12345)
      12345
      >>> data = func(12345)
      # 因为值没有被返回而是被打印，所以返回None
      >>> print(data)
      None