重新认识函数

• 内置函数

  • 认识Python自带的, 可全局调用的函数, 避免我们命名冲突导致了函数性状发生改变

  • 查看Python携带的内置函数

    from pprint import pprint
    # 格式化输出的库
    pprint(dir(__builtins__))

  • 常见的内置函数

    • str

      >>> str(1.0)
      '1.0'

    • int

      >>> int(1.0)
      1
      >>> int("1.0")
      Traceback (most recent call last):
        File "<stdin>", line 1, in <module>
      ValueError: invalid literal for int() with base 10: '1.0'
      >>> int("1")
      1
      >>>

    • float

      >>> float("1.0")
      1.0
      >>> float(1)
      1.0
      >>> float('1')
      1.0

    • bytes

      >>> bytes('a'.encode("utf-8"))
      b'a'

    • bool

      >>> bool(0)
      False
      >>> bool(1)
      True
      >>> bool(2)
      True
      >>> bool('0')   *****
      True
      >>> bool(0.0)
      False

    • list

      只要是序列都可以转换成list

      >>> list("qwe")
      ['q', 'w', 'e']

    • tuple

      >>> tuple("qwe")
      ('q', 'w', 'e')
      >>> tuple([1,2])
      (1, 2)

    • dict

      >>> dict(a=1)
      {'a': 1}

    • set

      >>> set([1,2,2])
      {1, 2}
      >>> set("qweqweqwe")  ****
      {'q', 'w', 'e'}

    • id

      查看当前对象的内存地址

      >>> a = "1"
      >>> id(a)
      26114944

    • dir

      • 当前对象下的所有方法和属性
      • 在Python中一切皆为对象

      dir(__builtins__)

    • max

      返回一个序列中的最大值

      >>> max([2, 4,67,1])
      67

    • min

      返回一个序列中的最小值

      >>> min([2, 4,67,1])
      1

    • range

      返回一组数字区间的可迭代对象

      >>> r = range(100)
      >>> r
      range(0, 100)
      
      >>> for i in range(10):
      ...     print(i)

• 函数的形参和实参

  • 形参

    形式参数, 简单地说就是还没接受到实际值的参数. 函数未调用时就是形参

    def my_power(a, b):
        return a ** b

  • 实参

    实际传入的参数, 函数调用时传入的值就叫实参

    print(my_power(2, 3))

• 函数的返回值

  • 返回值的类型

    任意类型, 包括函数本身

  • 如何接受返回值

    • 接收单个值

    • 一个变量接受返回的多个值

      实际上返回的是个tuple

      >>> def foo(a, b):
      ...     return a*2, b*2
      ...
      >>> result = foo(1, 2)
      >>> result
      (2, 4)

    • 多个变量按顺序接收

      实现原理是元组解包(unpack)

      >>> a,b = foo(1,2)
      >>> a
      2
      >>> b
      4
      # 等同于
      >>> result = foo(1,2)
      >>> a, b = result

    • 不定长变量接收

      >>> result
      (1, 2, 3, 4, 5, 6, 7)
      >>> a, *b, c = result
      >>> a
      1
      >>> c
      7
      >>> b
      [2, 3, 4, 5, 6]

匿名函数

顾名思义匿名函数就是没有名字的函数, 一般都是提供给高阶函数调用.

• 通过lambda关键字来声明匿名函数

  >>> lambda x: x **2
  # 返回的是一个匿名函数对象
  <function <lambda> at 0x018BB660>

• 函数体是纯表达式

  • 不能有复杂的逻辑判断语句

    • 唯一例外的例子:

      lambda x: 返回值 if 纯表达式 else 返回值
      
      lambda x: True if  x % 2==0 else False

• 不能有循环语句
• 不能有异常捕获
• 不能有赋值语句

• 不能有return

  • 默认表达式运行的结果就是返回值

    >>> lambda x: x **2
    返回值就是 x**2

• 例子

  l = [[1,2], [2,1], [6,4], [3,5]]
  l.sort(key=lambda x: x[1])
  print(l)

高阶函数

接受函数作为参数, 或者把函数作为结果返回

• map(映射)

  对一个序列每个元素进行相同的操作, 这个过程就叫映射

  >>> l = [1,2,3]
  >>> m = map(lambda x: x**2, [1,2,3])
  
  # 获得返回结果是一个map对象
  >>> m
  <map object at 0x03545C10>
  >>> l
  [1, 2, 3]
  
  # map对象是一个可迭代对象, 需要驱动可迭代对象返回值, list就有这样的功能. 暂时不要太纠结
  >>> list(m)
  [1, 4, 9]
  >>> l
  [1, 2, 3]

  • 等同于以下:

    def my_powser_2(a):
        return a ** 2
    
    # 匿名函数只是图方便, 所有的匿名都可以通过正常函数替换
    >>> m = map(my_powser_2, [1,2,3])
    >>> list(m)
    [1, 4, 9]

  • 多用于和math库进行运算操作

    >>> m = map(math.sqrt, [1, 4, 9, 16, 25])
    >>> list(m)
    [1.0, 2.0, 3.0, 4.0, 5.0]

• filter(过滤)

  filter(函数, 可迭代对象)
  函数中的表达式返回结果为False, 就会被过滤

  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  # 过滤偶数
  >>> f = filter(lambda x: x%2, l)
  >>> list(f)
  [1, 3, 5, 7, 9]
  
  # 过滤奇数
  >>> f = filter(lambda x: False if x%2 == 1 else True, l)
  >>> list(f)
  [0, 2, 4, 6, 8]

递归函数

在函数中调用自身的函数就叫递归函数

• 核心思想

  将大的任务拆分为子任务来解决复杂问题, 只要大任务能拆分成子任务, 就可以使用递归

  F(n) = F(F(n-1))

• 声明一个递归函数(阶乘)

  • 一定要有退出机制

  F(n) = n * F(n-1)
  
  def fact(n):
      if n == 1:
          return 1
      return n * fact(n-1)