PYTHON DAY_10_20160606

PYTHON_DAY10_20160606


int()函数可以把其他数据类型转换为整数


函数名其实就是指向一个函数对象的引用，完全可以把函数名赋给一个变量，相当于给这个函数起了一个“别名”：
>>> a = abs # 变量a指向abs函数
>>> a(-1) # 所以也可以通过a调用abs函数
1


请注意，函数体内部的语句在执行时，一旦执行到return时，函数就执行完毕，并将结果返回。因此，函数内部通过条件判断和循环可以实现非常复杂的逻辑。
如果没有return语句，函数执行完毕后也会返回结果，只是结果为None。
return None可以简写为return。


数据类型检查可以用内置函数isinstance实现：
def my_abs(x):
    if not isinstance(x, (int, float)):
        raise TypeError('bad operand type')
    if x >= 0:
        return x
    else:
        return -x


定义默认参数要牢记一点：默认参数必须指向不变对象！


在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
定义可变参数和定义list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数。
Python允许你在list或tuple前面加一个*号，把list或tuple的元素变成可变参数传进去。


可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
def person(name, age, **kw):
    print 'name:', name, 'age:', age, 'other:', kw
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
和可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去：
>>> kw = {'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **kw)
name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}


参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数。


既然Python支持L[-1]取倒数第一个元素，那么它同样支持倒数切片
>>> L[-2:]
['Bob', 'Jack']
>>> L[-2:-1]
['Bob']
甚至什么都不写，只写[:]就可以原样复制一个list：
>>> L[:]
[0, 1, 2, 3, ..., 99]
tuple也是一种list，唯一区别是tuple不可变。因此，tuple也可以用切片操作，只是操作的结果仍是tuple：
>>> (0, 1, 2, 3, 4, 5)[:3]
(0, 1, 2)
字符串'xxx'或Unicode字符串u'xxx'也可以看成是一种list，每个元素就是一个字符。因此，字符串也可以用切片操作，只是操作结果仍是字符串：
>>> 'ABCDEFG'[:3]
'ABC'
>>> 'ABCDEFG'[::2]
'ACEG'


如果给定一个list或tuple，我们可以通过for循环来遍历这个list或tuple，这种遍历我们称为迭代（Iteration）.在Python中，迭代是通过for ... in来完成的
默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.itervalues()，如果要同时迭代key和value，可以用for k, v in d.iteritems()。
字符串也是可迭代对象.
如何判断一个对象是可迭代对象呢？方法是通过collections模块的Iterable类型判断：
>>> from collections import Iterable
>>> isinstance('abc', Iterable) # str是否可迭代
True
>>> isinstance([1,2,3], Iterable) # list是否可迭代
True
>>> isinstance(123, Iterable) # 整数是否可迭代
False
如果要对list实现类似Java那样的下标循环怎么办？Python内置的enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：
>>> for i, value in enumerate(['A', 'B', 'C']):
...     print i, value
...
0 A
1 B
2 C


上面的for循环里，同时引用了两个变量，在Python里是很常见的，比如下面的代码：
>>> for x, y in [(1, 1), (2, 4), (3, 9)]:
...     print x, y
...
1 1
2 4
3 9


列表生成式即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
举个例子，要生成list [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]可以用range(1, 11)，如果要生成[1x1, 2x2, 3x3, ..., 10x10]怎么做？
>>> [x * x for x in range(1, 11)]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
写列表生成式时，把要生成的元素x * x放到前面，后面跟for循环，就可以把list创建出来。
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']


运用列表生成式，可以写出非常简洁的代码。例如，列出当前目录下的所有文件和目录名，可以通过一行代码实现：
>>> import os # 导入os模块，模块的概念后面讲到
>>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录
['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace', 'XCode']


最后把一个list中所有的字符串变成小写：
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']


>>> L = ['Hello', 'World', 18, 'Apple', None]
>>> [s.lower() if isinstance(s,str) else s for s in L]
['hello', 'world', 18, 'apple', None]
列表生成式后面只能有if不能有else：
[process(x) for x in L if should_keep(x)]
因为这个if是说“要不要保留x”，加个else整个逻辑就没法解释了
但是for前面的process(x)是可以用if...else来写的：
[x if x > 0 else -x for x in L]
相当于：
def process(x):
    return x if x > 0 else -x
[process(x) for x in L]


如果列表元素可以按照某种算法推算出来，那我们是否可以在循环的过程中不断推算出后续的元素呢？这样就不必创建完整的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 0x104feab40>
定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator。
如果要一个一个打印出来，可以通过generator的next()方法，上面这种不断调用next()方法实在是太变态了，正确的方法是使用for循环，因为generator也是可迭代对象

这里，最难理解的就是generator和函数的执行流程不一样。函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。

闭包（closure）
使用闭包返回的函数，即使参数一模一样，它们也是不同的函数,它们之间的调用不会相互影响。
>>> func_1 == func_2
False


匿名函数：
lambda parameter: expression
匿名函数只能有一个表达式
你可以将匿名函数赋给一个变量，利用变量来进行操作函数
同样，也可以把匿名函数作为返回值返回，比如：
def build(x, y):
    return lambda: x * x + y * y


def build(x, y):
    def hello():
        print x, y
    return hello
这个函数是返回闭包，即hello函数使用了上层build函数的x,y参数，使用时写法是build(1,2)()。而：
def build(x, y):
    def hello(x,y):
        print x, y
    return hello
这个函数在hello函数中重新加入了参数x,y，就好像主动丢弃了使用上层函数内的数据一样，要使用自己的参数,写法是build(1,2)(3,4)。


装饰函数（decorator）
一个完整的装饰函数是这样写的：
import functools#导入模板


def log(text):
def decorator(func):#这一层的函数主要是方便装饰函数能够加入参数text。
@functools.wraps(func)#为了防止装饰后的函数__name__参数变为'wrapper'
def wrapper(*args, **kw):
print '%s %s():' %(text, func.__name__)
return func(*args, **kw)
return wrapper
return decorator#注意一层一层的往外返回，不要混淆


@log('the text')#这里的写法等同于now = log('the text)(now) 
def now():
print 'this function have been decorated'


偏函数：是functools模板中提供的方法，即通过设定函数参数的默认值来降低函数调用的难度，
import functools
int_2 = functools.partial(int, base = 16)#将int函数传入的字符串默认当作16进制数字处理
the_base = {"base":2}
int_3 = functools.partial(int, **the_base)#利用关键词参数对偏函数进行编辑
max_2 = functools.partial(max, 100)#默认加入100到max函数内进行比较
the_base = [1,2,3,4]
max_3 = functools.partial(max, *the_base)#利用可变参数对偏函数进行编辑