接上篇~ 函数相关知识以及模块的使用等

函数

  1. 高级函数

    1
    2
    3
    4
    5
    def add(x, y, f):
    return f(x) + f(y)

    >>> add(2, -5, abs);
    7

    可以将函数abs当做变量传入add函数参与运算。

    • map:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      >>> def f(x):
      ... return x * x
      ...
      >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
      >>> list(r)
      [1, 4, 9, 16, 25, 36, 49, 64, 81]

      >>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
      ['1', '2', '3', '4', '5', '6', '7', '8', '9']

      作为键值对,以后者的Iterator作为底数进行前者的迭代运算并输出。

    • reduce:

      1
      2
      3
      4
      5
      6
      >>> from functools import reduce
      >>> def fn(x, y):
      ... return x * 10 + y
      ...
      >>> reduce(fn, [1, 3, 5, 7, 9])
      13579

      抽取后者的Iterator的前两个元素进行前者的运算并迭代输出。

    • filter:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      def is_odd(n):
      return n % 2 == 1
      list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
      # 结果: [1, 5, 9, 15]

      def not_empty(s):
      return s and s.strip()
      list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))
      # 结果: ['A', 'B', 'C']

      第二个判断为s为空则返回s.strip()(去除空格),s不为空返回s。

    • sorted:

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      # 1. 正常排序
      >>> sorted([36, 5, -12, 9, -21])
      [-21, -12, 5, 9, 36]

      # 2. 依照绝对值排序
      >>> sorted([36, 5, -12, 9, -21], key=abs)
      [5, 9, -12, -21, 36]

      # 3. 忽略大小写并反向排序
      >>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)
      ['Zoo', 'Credit', 'bob', 'about']
  2. 返回函数

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    def lazy_sum(*args):
    def sum():
    ax = 0
    for n in args:
    ax = ax + n
    return ax
    return sum

    >>> f = lazy_sum(1, 3, 5, 7, 9)
    >>> f
    <function lazy_sum.<locals>.sum at 0x101c6ed90>

    >>> f()
    25

    当调用lazy_sum时sum函数并不会立即运行,此时的f即是sum函数,调用f()时才开始运行内部,以此实现延时运行的效果。

  3. 闭包

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    def count():
    fs = []
    for i in range(1, 4):
    def f():
    return i*i
    fs.append(f)
    return fs

    f1, f2, f3 = count()

    def count():
    def f(j):
    def g():
    return j*j
    return g
    fs = []
    for i in range(1, 4):
    fs.append(f(i)) # f(i)立刻被执行,因此i的当前值被传入f()
    return fs

    第一种方式在调用时返回值都为9,因为内部i在第一次被调用之后被作为返回值返回,所以函数并未被清理,i的值依旧为上一次运行结果。而第二种在返回函数的内部单独传入一个临时变量,这个临时变量的作用域止于f函数,并在每一次运行时都重新传入新的j,所以运行结果为1,4,9.闭包原则。

  4. 匿名函数
    python的匿名函数即为lambda表达式:

    1
    2
    >>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
    [1, 4, 9, 16, 25, 36, 49, 64, 81]
  5. 装饰器

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    def log(text):
    def decorator(func)
    def wrapper(*args, **kw):
    print('%s %s():' % (text, func.__name__))
    return func(*args, **kw)
    return wrapper
    return decorator

    @log('execute')
    def now():
    print('2015-3-25')

    >>> now()
    execute now():
    2015-3-25

    定义log函数,对now函数进行标记。运行时也同时运行log方法。相当于运行了
    now = log('execute')(now)

    最后写法:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    #1. 带参数
    import functools

    def log(text):
    def decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
    print('%s %s():' % (text, func.__name__))
    return func(*args, **kw)
    return wrapper
    return decorator
    1
    2
    3
    4
    5
    6
    7
    8
    9
    #2. 不带参数
    import functools

    def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
    print('call %s():' % func.__name__)
    return func(*args, **kw)
    return wrapper
  6. 偏函数

    1
    2
    3
    max2 = functools.partial(max, 10)

    int2 = functools.partial(int, base=2)

    偏函数的作用:固定一些参数,简化需要传入的参数数量。
    此时int2('10010')相当于

    1
    2
    kw = { 'base': 2 }
    int('10010', **kw)

    以及max2(5,6,7)相当于

    1
    2
    3
    args = (10, 5, 6, 7)
    max(*args)
    #结果为10

模块

  1. 使用:
    栗:

    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
    27
    28
    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-

    # 1. 文档注释,所有模块代码的第一个字符串都被视为文档注释
    ' a test module '

    # 2. 标记作者(廖雪峰)
    __author__ = 'Michael Liao'

    # 3. 导入内建的sys模块,sys模块有一个argv变量,用list存储了命令行的所有参数,其第一个参数永远是模块的文件名
    import sys

    def test():
    args = sys.argv
    if len(args)==1:
    print('Hello, world!')
    elif len(args)==2:
    print('Hello, %s!' % args[1])
    else:
    print('Too many arguments!')

    # 4. 标记作用域
    if __name__=='__main__':
    test()

    # 5. 结果
    $ python hello.py Michael
    Hello, Michael!
  2. 第三方模块

    1
    2
    3
    4
    5
    6
    # 生成图片的缩略图
    from PIL import Image
    im = Image.open('test.png')
    print(im.format, im.size, im.mode)
    im.thumbnail((200,100))
    im.save('thumb.jpg', 'JPEG')

待续~