Python3.6学习笔记（二）

Python 的高级特性

切片

对于指定索引范围取值的操做，Python提供了slice方法，相似于Excel中数据透视表的切片器。

>>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack’]    #声明一个List，取前三个值
>>> L[0:3]    #表示从0开始，到3为止，可是不包括3，后面还能够再接:加上步长
['Michael', 'Sarah', 'Tracy’]
>>> S=list(range(100))    #声明一个0-99的list
>>> S[0:100:9]            #取9的倍数
[0, 9, 18, 27, 36, 45, 54, 63, 72, 81, 90, 99]

tuple也是一种list，惟一区别是tuple不可变。所以，tuple也能够用切片操做，只是操做的结果还是tuple。

迭代 Iteration

给定一个list或tulp，能够经过for循环来遍历，这称之为迭代。Python中的迭代相似于Javascript，而与PHP或Java采用下标迭代的方式不一样。对于Python来讲，dict、set、字符串等都是可迭代对象，均可以使用for循环。只要做用于一个可迭代对象，for循环就能够正常运行，而咱们不太关心该对象到底是list仍是其余数据类型。

判断一个对象是否可迭代，经过collections模块的Iterable类型判断。

>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False

Python内置的enumerate函数能够把一个list变成索引-元素对，这样就能够在for循环中同时迭代索引和元素自己。

列表生成式

列表生成式即List Comprehensions，是Python内置的很是简单却强大的能够用来建立list的生成式。写列表生成式时，把要生成的元素放到前面，后面跟for循环，就能够把list建立出来，十分有用，多写几回，很快就能够熟悉这种语法。

tiangan = '甲乙丙丁戊己庚辛壬癸'
dizhi = '子丑寅卯辰巳午未申酉戌亥'

jiazi = [tiangan[x % len(tiangan)] + dizhi[x % len(dizhi)] for x in range(60)]

for循环后面还能够加上if判断。

>>> [x * x for x in range(1, 11) if x % 2 == 0]
[4, 16, 36, 64, 100]

还可使用两层循环，能够生成全排列。

>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', ‘CZ']

生成器

经过列表生成式，咱们能够直接建立一个列表。可是，受到内存限制，列表容量确定是有限的。并且，建立一个包含100万个元素的列表，不只占用很大的存储空间，若是咱们仅仅须要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了。

因此，若是列表元素能够按照某种算法推算出来，那咱们是否能够在循环的过程当中不断推算出后续的元素呢？这样就没必要建立完整的list，从而节省大量的空间。在Python中，这种一边循环一边计算的机制，称为生成器：generator。

生成generator有两个办法。

一、只要把一个列表生成式的[]改为()，就建立了一个generator。

>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。一般，可使用for循环来遍历生成器中的内容。

二、若是算法比较复杂，可使用函数来实现。

def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'

若是一个函数定义中包含yield关键字，那么这个函数就再也不是一个普通函数，而是一个generator。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

迭代器

这里主要区分 Iterable 和 Iterator 。

对于 Iterable 的数据类型，称之为可迭代对象，可使用for循环遍历，包括list、tuple、dict、set、str、生成器以及带yield的Generator Function。可使用 isinstance() 函数判断是否为 Iterable 。

迭代器不只可使用for循环，还可使用next()函数不断调用返回下一个值，直到最后抛出StopIteration错误表示没法继续返回下一个值了。这样，就能够把数据流看做一个有序序列，咱们不知道序列的长度，可是能够经过不断的计算获取下一个值。

可使用 iter() 函数把 list、dict、str等Iterable变成Iterator。

函数式编程

我以前熟悉的PHP、C，编写程序可能是经过将任务分解为一个个Function，而后组合起来解决问题的，这种分解称为面向过程的程序设计，而函数是面向过程的程序设计的基本单元。

函数式编程（Functional Programming）其思想更接近数学计算。函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，所以，任意一个函数，只要输入是肯定的，输出就是肯定的，这种纯函数咱们称之为没有反作用。而容许使用变量的程序设计语言，因为函数内部的变量状态不肯定，一样的输入，可能获得不一样的输出，所以，这种函数是有反作用的。

Python对函数式编程提供部分支持。

高阶函数 High order function

变量能够指向函数

这个对我真是有点颠覆，看下面的例子。

>> abs(-10)
10
>>> abs
<built-in function abs>
>>> f = abs
>>> f(-10)
10

函数名也是变量

Python中函数名其实就是指向函数的变量。

>>> abs=10
>>> abs
10
>>> abs(-10)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not callable
>>> f(-10)
10

传入函数

函数的参数若是接收一个指向函数的变量，就变成了一个函数接收另外一个函数做为参数，这种函数称为高阶函数。函数式编程就是指这种高度抽象的编程范式

map / reduce

Python内建了map()和reduce()函数。map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次做用到序列的每一个元素，并把结果做为新的Iterator返回。

>>> 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]

reduce把一个函数做用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素作累积计算，其效果就是reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)。

filter

Python内建的函数filter()用于过滤序列，其接收一个函数和一个序列，并把传入的函数做用于每一个元素，而后根据返回值是True仍是False决定是保留仍是丢弃该元素。

def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))

注意到filter()函数返回的是一个Iterator，也就是一个惰性序列，因此要强迫filter()完成计算结果，须要用list()函数得到全部结果并返回list。

sorted 排序算法

排序是程序中常常用到的算法。不管使用冒泡排序仍是快速排序，排序的核心是比较两个元素的大小。Python内置的sorted()函数就能够对list进行排序。sorted()函数也是一个高阶函数，它还能够接收一个key函数来实现自定义的排序，例如按绝对值大小排序。key指定的函数将做用于list的每个元素上，并根据key函数返回的结果进行排序。要进行反向排序，没必要改动key函数，能够传入第三个参数reverse=True。

>>> sorted([36, 5, -12, 9, -21])
[-21, -12, 5, 9, 36]
>>> sorted([36, 5, -12, 9, -21], key=abs)
[5, 9, -12, -21, 36]

函数做为返回值

高阶函数除了能够接受函数做为参数外，还能够把函数做为结果值返回。以下示例，调用lazy_sum时，返回的并非求和结果，而是求和函数。这种结构称为闭包 Closure。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

匿名函数

在Python中，对匿名函数提供了有限支持。仍是以map()函数为例，计算f(x)=x2时，除了定义一个f(x)的函数外，还能够直接传入匿名函数。关键字lambda表示匿名函数，冒号前面的x表示函数参数。匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

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

用匿名函数有个好处，由于函数没有名字，没必要担忧函数名冲突。此外，匿名函数也是一个函数对象，也能够把匿名函数赋值给一个变量，再利用变量来调用该函数。

装饰器

函数对象有一个__name__属性，能够拿到函数的名字。如今，假设咱们要加强now()函数的功能，好比，在函数调用先后自动打印日志，但又不但愿修改now()函数的定义，这种在代码运行期间动态增长功能的方式，称之为“装饰器”（Decorator）。

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

借助Python的@语法，把decorator置于函数的定义处。

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

>>> now()
call now():    #调用now()函数，不只会运行now()函数自己，还会在运行now()函数前打印一行日志
2015-3-25

把@log放到now()函数的定义处，至关于执行了语句:now = log(now)

对于上面这种写法，若是调用__name__方法，返回的函数名为 wrapper ，须要用Python内置的 functools.wraps 来解决。

import functools

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

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

偏函数

Python 的 functools 提供了不少有用的功能，其中一个就是偏函数（Partial function）。

def int2(x, base=2):
    return int(x, base)

>>> int2('1000000')
64
>>> int2('1010101')
85

如上例子，经过使用偏函数，咱们至关于对函数作了一个包装，默认输入了一些函数参数，减小了后续调用时输入的参数个数。实现这个功能，能够借助 functools。

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('1000000')
64
>>> int2('1010101')
85
>>> int2('1000000', base=10)
1000000

模块

任何语言要实现一个项目，都离不开文件组织管理。在Python中，一个.py文件就称之为一个模块（Module）。使用模块能够提升代码的可维护性，也能够避免函数名和变量名冲突。可是也要注意，尽可能不要与内置函数名字冲突。为了不模块名冲突，Python又引入了按目录来组织模块的方法，称为包（Package）。

引入了包之后，只要顶层的包名不与别人冲突，那全部模块都不会与别人冲突。每个包目录下面都会有一个__init__.py的文件，这个文件是必须存在的，不然，Python就把这个目录当成普通目录，而不是一个包。init.py能够是空文件，也能够有Python代码，由于__init__.py自己就是一个模块。相似的，能够有多级目录，组成多级层次的包结构。

本身建立模块时要注意命名，不能和Python自带的模块名称冲突。例如，系统自带了sys模块，本身的模块就不可命名为sys.py，不然将没法导入系统自带的sys模块。

使用模块

看一段代码，引用了sys模块，定义了hello模块。

#!/usr/bin/env python3    #标准注释
# -*- coding: utf-8 -*-   #表示.py文件自己使用标准UTF-8编码

' a test module '

__author__ = 'Michael Liao'

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!')

if __name__=='__main__':
    test()

导入sys模块后，咱们就有了变量sys指向该模块，利用sys这个变量，就能够访问sys模块的全部功能。

做用域

正常的函数和变量名是公开的（public），能够被直接引用，好比：abc，x123，PI等。相似__xxx__这样的变量是特殊变量，能够被直接引用，可是有特殊用途。相似_xxx和__xxx这样的函数或变量就是非公开的（private），不该该被直接引用。之因此咱们说，private函数和变量“不该该”被直接引用，而不是“不能”被直接引用，是由于Python并无一种方法能够彻底限制访问private函数或变量，可是，从编程习惯上不该该引用private函数或变量。

安装第三方模块

在Python中，安装第三方模块，是经过包管理工具pip完成的。在命令提示符窗口下尝试运行pip，若是Windows提示未找到命令，能够从新运行安装程序添加pip。

注意：Mac或Linux上有可能并存Python 3.x和Python 2.x，所以对应的pip命令是pip3。

通常来讲，第三方库都会在Python官方的pypi.python.org网站注册，要安装一个第三方库，必须先知道该库的名称，能够在官网或者pypi上搜索，好比Pillow的名称叫Pillow，所以，安装Pillow的命令就是

pip install Pillow