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__)<
9c37
br />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)#利用可变参数对偏函数进行编辑