函数的定义和调用

1
2
3
4
5
6
def printInfo():
    '''打印信息'''
    print('Life is short, you need python :)')

printInfo()
help(printInfo)

函数的参数

  • 位置参数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    def power(x, n=3):  # x和n都是位置参数
        s = 1
        while n > 0:
            s = s * x
            n -= 1
        return s

    print(power(2))  # 2传给x，n使用默认参数3
    print(power(2, 1))  # 2传给x，1传给n
    print(power(1, 2))  # 1传给x，2传给n

  • 不定长参数

    使用*args定义，传入的是一个元组，可包含任意多个元素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def cal(*args):
        sum = 0
        print(type(args))
        for n in args:
            sum += n
        return sum

    print(cal(1, 2, 3))
    nums = [1, 2, 3]
    print(*nums)  # 使用`*`将列表或元组拆成单独的元素，作为不定长参数传入
    print(cal(*nums))

  • 关键字参数

    • 不定长关键字参数：使用**kwargs定义，传入的是一个字典

      1
      2
      3
      4
      5
      def info(**kwargs):
          print(type(kwargs))
          print(kwargs)

      info(name='Li Lei', age=28)

    • 指定关键字参数：用*分隔位置参数和关键字参数，位置参数在前

      1
      2
      3
      4
      def info(name, age, *, title='Dr.', gender):
          print(name, age, title, gender)

      info('Li Lei', 28, gender='Male')

    • 如果已有不定长参数，后面的关键字参数不需要*分隔

      1
      2
      3
      4
      5
      def info(name, age, *args, title, gender):
          print(name, age, args, title, gender)
          print(name, age, *args, title, gender)

      info('Li Lei', 28, '010-65190389', title='Dr.', gender='Male')

  • 参数定义的顺序

    必选位置参数、默认位置参数、不定长位置参数、必选关键字参数、默认关键字参数、不定长关键字参数

函数的返回值

  • 多个return语句

    一个函数可以有多个return语句，执行到任意一个时，函数的调用就结束了

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
        def check_return():
            print('This is the first return clause.')
            return 1
            # 以下代码将不会被执行
            print('This is the second return clause.')
            return 2

        print(check_return())
        ```    

    * 返回多个值

        元组、列表、字典等能够存储多个数据的变量类型都可以用于返回多个数据，默认返回一个元组

        ```python
        def multi_return(a, b, *, type):
            if type == 'tuple':
                return a, b
            if type == 'dict':
                return {'a': a, 'b': b}
            if type == 'list':
                return [a, b]

        print(multi_return(1, 2, type='tuple'))
        print(multi_return(2, 3, type='dict'))
        print(multi_return(3, 4, type='list'))

  • 返回一个函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    def sort(method):
        # 冒泡算法
        if method == 'bubble':
            def sort_inner(l):
                for i in range(len(l)-1):
                    for j in range(len(l)-1-i):
                        if l[j] > l[j+1]:
                            l[j+1], l[j] = l[j], l[j+1]
                return l
        # 快速排序算法
        if method == 'quick':
            def sort_inner(l):
                if l == []:
                    return []
                else:
                    pivot = l[0]
                    # 使用递归函数，即在函数内部调用函数自身
                    left = sort_inner([m for m in l[1:] if m < pivot])
                    right = sort_inner([n for n in l[1:] if n >= pivot])
                    return left+[pivot]+right
        # 返回一个函数时，函数名后面不可加`()`
        return sort_inner

    my_list = [2, 5, 10, 34, 6, 27, 9]
    print(sort('bubble')(my_list))
    print(sort('quick')(my_list))