python 一行代码(不包含导包)实现1到10的累加_【python】《Python进阶（Intermediate Python）》笔记...

1.0 *args 和 **kwargs

用法

*args 和 **kwargs 主要用于函数定义。 你可以将不定数量的参数传递给一个函数。

其中，**kwargs 允许你将不定长度的键值对, 作为参数传递给一个函数。 如果你想要在一个函数里处理带名字的参数, 你应该使用**kwargs。

这里的不定的意思是：预先并不知道, 函数使用者会传递多少个参数给你, 所以在这个场景下使用这两个关键字。 *args 是用来发送一个非键值对的可变数量的参数列表给一个函数.

示例

def test_var_args(f_arg, *argv):

print("first normal arg:", f_arg)

for arg in argv:

print("another arg through *argv:", arg)

test_var_args('yasoob', 'python', 'eggs', 'test')

def greet_me(**kwargs):

for key, value in kwargs.items():

print("{0} == {1}".format(key, value))

greet_me(var1="arg1", var2="arg2")

def test_args_kwargs(arg1, arg2, arg3):

print("arg1:", arg1)

print("arg2:", arg2)

print("arg3:", arg3)

args = ("two", 3, 5)

test_args_kwargs(*args)

kargs = {"arg3": 3, "arg2": "two", "arg1": 5}

test_args_kwargs(**kargs)

标准参数与args、*kwargs在使用时的顺序

那么如果你想在函数里同时使用所有这三种参数， 顺序是这样的：

some_func(fargs, *args, **kwargs)

什么时候用他们

最常见的用例是在写函数装饰器的时候

此外它也可以用来做猴子补丁(monkey patching)。猴子补丁的意思是在程序运行时(runtime)修改某些代码。 打个比方，你有一个类，里面有个叫get_info的函数会调用一个API并返回相应的数据。如果我们想测试它，可以把API调用替换成一些测试数据。例如：

import someclass

def get_info(self, *args):

return "Test data"

someclass.get_info = get_info

猴子补丁：monkey patch指的是在运行时动态替换,一般是在startup的时候.

用过gevent就会知道,会在最开头的地方gevent.monkey.patch_all();把标准库中的thread/socket等给替换掉.这样我们在后面使用socket的时候可以跟平常一样使用,无需修改任何代码,但是它变成非阻塞的了.

例如，想把json 替换为ujson(ujson效率更高)，不需要把每个文件的import json 修改为import ujson as json

其实只需要在进程startup的地方monkey patch就行了.是影响整个进程空间的.

同一进程空间中一个module只会被运行一次.

下面是代码main.py：

import json

import ujson

def monkey_patch_json():

json.__name__ = 'ujson'

json.dumps = ujson.dumps

json.loads = ujson.loads

monkey_patch_json()

print 'main.py',json.__name__

2.0 调试

从命令行运行

你可以在命令行使用Python debugger运行一个脚本:

这会触发debugger在脚本第一行指令处停止执行。这在脚本很短时会很有帮助。你可以通过(Pdb)模式接着查看变量信息，并且逐行调试。

从脚本内部运行

同时，你也可以在脚本内部设置断点，这样就可以在某些特定点查看变量信息和各种执行时信息了。这里将使用pdb.set_trace()方法来实现。

import pdb

def make_bread():

pdb.set_trace()

return "I don't have time"

print(make_bread())

命令列表：

c: 继续执行

w: 显示当前正在执行的代码行的上下文信息

a: 打印当前函数的参数列表

s: 执行当前代码行，并停在第一个能停的地方(相当于单步进入)

n: 继续执行到当前函数的下一行，或者当前行直接返回(单步跳过)

3.0 生成器(Generators)

迭代器：

迭代器是一个让程序员可以遍历一个容器(特别是列表)的对象。然而，一个迭代器在遍历并读取一个容器的数据元素时，并不会执行一个迭代。

可迭代对象(Iterable)

Python中任意的对象，只要它定义了可以返回一个迭代器的iter方法，或者定义了可以支持下标索引的getitem方法(这些双下划线方法会在其他章节中全面解释)，那么它就是一个可迭代对象。简单说，可迭代对象就是能提供迭代器的任意对象。

迭代器(Iterator)

任意对象，只要定义了next(Python2) 或者next方法，它就是一个迭代器

迭代(Iteration)

用简单的话讲，它就是从某个地方(比如一个列表)取出一个元素的过程。当我们使用一个循环来遍历某个东西时，这个过程本身就叫迭代。现在既然我们有了这些术语的基本理解，那我们开始理解生成器吧。

生成器(Generators)：

生成器也是一种迭代器，但是你只能对其迭代一次。这是因为它们并没有把所有的值存在内存中，而是在运行时生成值。你通过遍历来使用它们，要么用一个“for”循环，要么将它们传递给任意可以进行迭代的函数和结构。大多数时候生成器是以函数来实现的。然而，它们并不返回一个值，而是yield(暂且译作“生出”)一个值。

生成器函数的例子：

def generator_function():

for i in range(10):

yield i

for item in generator_function():

print(item)

# Output: 0

# 1

# 2

# 3

# 4

# 5

# 6

# 7

# 8

# 9

这个案例并不是非常实用(这样做会消耗大量资源)。生成器最佳应用场景是：你不想同一时间将所有计算出来的大量结果集分配到内存当中，特别是结果集里还包含循环。

下面是一个计算斐波那契数列的生成器：

# generator version

def fibon(n):

a = b = 1

for i in range(n):

yield a

a, b = b, a + b

函数使用方法如下：

for x in fibon(1000000):

print(x)

用这种方式，我们可以不用担心它会使用大量资源。然而，之前如果我们这样来实现的话：

def fibon(n):

a = b = 1

result = []

for i in range(n):

result.append(a)

a, b = b, a + b

return result

这也许会在计算很大的输入参数时，用尽所有的资源。我们已经讨论过生成器使用一次迭代，但我们并没有测试过。在测试前你需要再知道一个Python内置函数：next()。它允许我们获取一个序列的下一个元素。那我们来验证下我们的理解：

def generator_function():

for i in range(3):

yield i

gen = generator_function()

print(next(gen))

# Output: 0

print(next(gen))

# Output: 1

print(next(gen))

# Output: 2

print(next(gen))

# Output: Traceback (most recent call last):

# File "", line 1, in

# StopIteration

结果验证：

我们可以看到，在yield掉所有的值后，next()触发了一个StopIteration的异常。基本上这个异常告诉我们，所有的值都已经被yield完了。你也许会奇怪，为什么我们在使用for循环时没有这个异常呢？啊哈，答案很简单。for循环会自动捕捉到这个异常并停止调用next()。

Python中一些内置数据类型也支持迭代:

my_string = "Yasoob"

next(my_string)

# Output: Traceback (most recent call last):

# File "", line 1, in

# TypeError: str object is not an iterator

好吧，这不是我们预期的。这个异常说那个str对象不是一个迭代器。对，就是这样！它是一个可迭代对象，而不是一个迭代器。这意味着它支持迭代，但我们不能直接对其进行迭代操作。那我们怎样才能对它实施迭代呢？是时候学习下另一个内置函数，iter。它将根据一个可迭代对象返回一个迭代器对象。这里是我们如何使用它：

my_string = "Yasoob"

my_iter = iter(my_string)

next(my_iter)

# Output: 'Y'

4.0 Map,Filter和Reduce

5.0 set(集合)数据结构

set(集合)是一个非常有用的数据结构。它与列表(list)的行为类似，区别在于set不能包含重复的值。

交集

可以对比两个集合的交集(两个集合中都有的数据)，如下：

valid = set(['yellow', 'red', 'blue', 'green', 'black'])

input_set = set(['red', 'brown'])

print(input_set.intersection(valid))

### 输出: set(['red'])

差集

你可以用差集(difference)找出无效的数据，相当于用一个集合减去另一个集合的数据，例如：

valid = set(['yellow', 'red', 'blue', 'green', 'black'])

input_set = set(['red', 'brown'])

print(input_set.difference(valid))

### 输出: set(['brown'])

6.0 三元运算符

三元运算符通常在Python里被称为条件表达式，这些表达式基于真(true)/假(not)的条件判断，在Python 2.4以上才有了三元操作..

例子：

is_fat = True

state = "fat" if is_fat else "not fat"

或使用元组：

fat = True

fitness = ("skinny", "fat")[fat]

print("Ali is ", fitness)

#输出: Ali is fa

7.0 装饰器

装饰器(Decorators)是Python的一个重要部分。简单地说：他们是修改其他函数的功能的函数。他们有助于让我们的代码更简短，也更Pythonic(Python范儿)。

一切皆对象

首先我们来理解下Python中的函数

def hi(name="yasoob"):

return "hi " + name

print(hi())

# output: 'hi yasoob'

# 我们甚至可以将一个函数赋值给一个变量，比如

greet = hi

# 我们这里没有在使用小括号，因为我们并不是在调用hi函数

# 而是在将它放在greet变量里头。我们尝试运行下这个

print(greet())

# output: 'hi yasoob'

# 如果我们删掉旧的hi函数，看看会发生什么！

del hi

print(hi())

#outputs: NameError

print(greet())

#outputs: 'hi yasoob'

在函数中定义函数

刚才那些就是函数的基本知识了。我们来让你的知识更进一步。在Python中我们可以在一个函数中定义另一个函数：

def hi(name="yasoob"):

print("now you are inside the hi() function")

def greet():

return "now you are in the greet() function"

def welcome():

return "now you are in the welcome() function"

print(greet())

print(welcome())

print("now you are back in the hi() function")

hi()

#output:now you are inside the hi() function

# now you are in the greet() function

# now you are in the welcome() function

# now you are back in the hi() function

# 上面展示了无论何时你调用hi(), greet()和welcome()将会同时被调用。

# 然后greet()和welcome()函数在hi()函数之外是不能访问的，比如：

greet()

#outputs: NameError: name 'greet' is not defined

那现在我们知道了可以在函数中定义另外的函数。也就是说：我们可以创建嵌套的函数。现在你需要再多学一点，就是函数也能返回函数。

从函数中返回函数

其实并不需要在一个函数里去执行另一个函数，我们也可以将其作为输出返回出来：

def hi(name="yasoob"):

def greet():

return "now you are in the greet() function"

def welcome():

return "now you are in the welcome() function"

if name == "yasoob":

return greet

else:

return welcome

a = hi()

print(a)

#outputs:

#上面清晰地展示了`a`现在指向到hi()函数中的greet()函数

#现在试试这个

print(a())

#outputs: now you are in the greet() function

再次看看这个代码。在if/else语句中我们返回greet和welcome，而不是greet()和welcome()。为什么那样？这是因为当你把一对小括号放在后面，这个函数就会执行；然而如果你不放括号在它后面，那它可以被到处传递，并且可以赋值给别的变量而不去执行它。

你明白了吗？让我再稍微多解释点细节。

当我们写下a = hi()，hi()会被执行，而由于name参数默认是yasoob，所以函数greet被返回了。如果我们把语句改为a = hi(name = "ali")，那么welcome函数将被返回。我们还可以打印出hi()()，这会输出now you are in the greet() function。

将函数作为参数传给另一个函数

def hi():

return "hi yasoob!"

def doSomethingBeforeHi(func):

print("I am doing some boring work before executing hi()")

print(func())

doSomethingBeforeHi(hi)

#outputs:I am doing some boring work before executing hi()

# hi yasoob!

现在你已经具备所有必需知识，来进一步学习装饰器真正是什么了。装饰器让你在一个函数的前后去执行代码。

你的第一个装饰器

在上一个例子里，其实我们已经创建了一个装饰器！现在我们修改下上一个装饰器，并编写一个稍微更有用点的程序：

def a_new_decorator(a_func):

def wrapTheFunction():

print("I am doing some boring work before executing a_func()")

a_func()

print("I am doing some boring work after executing a_func()")

return wrapTheFunction

def a_function_requiring_decoration():

print("I am the function which needs some decoration to remove my foul smell")

a_function_requiring_decoration()

#outputs: "I am the function which needs some decoration to remove my foul smell"

a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

#now a_function_requiring_decoration is wrapped by wrapTheFunction()

a_function_requiring_decoration()

#outputs:I am doing some boring work before executing a_func()

# I am the function which needs some decoration to remove my foul smell

# I am doing some boring work after executing a_func()

我们刚刚应用了之前学习到的原理。这正是python中装饰器做的事情！它们封装一个函数，并且用这样或者那样的方式来修改它的行为。现在你也许疑惑，我们在代码里并没有使用@符号？那只是一个简短的方式来生成一个被装饰的函数。这里是我们如何使用@来运行之前的代码：

@a_new_decorator

def a_function_requiring_decoration():

"""Hey you! Decorate me!"""

print("I am the function which needs some decoration to "

"remove my foul smell")

a_function_requiring_decoration()

#outputs: I am doing some boring work before executing a_func()

# I am the function which needs some decoration to remove my foul smell

# I am doing some boring work after executing a_func()

#the @a_new_decorator is just a short way of saying:

a_function_requiring_decoration = a_new_decorator(a_function_requiring_decoration)

希望你现在对Python装饰器的工作原理有一个基本的理解。如果我们运行如下代码会存在一个问题：

print(a_function_requiring_decoration.__name__)

# Output: wrapTheFunction

这并不是我们想要的！Ouput输出应该是“a_function_requiring_decoration”。这里的函数被warpTheFunction替代了。它重写了我们函数的名字和注释文档(docstring)。幸运的是Python提供给我们一个简单的函数来解决这个问题，那就是functools.wraps。我们修改上一个例子来使用functools.wraps：

from functools import wraps

def a_new_decorator(a_func):

@wraps(a_func)

def wrapTheFunction():

print("I am doing some boring work before executing a_func()")

a_func()

print("I am doing some boring work after executing a_func()")

return wrapTheFunction

@a_new_decorator

def a_function_requiring_decoration():

"""Hey yo! Decorate me!"""

print("I am the function which needs some decoration to "

"remove my foul smell")

print(a_function_requiring_decoration.__name__)

# Output: a_function_requiring_decoration

现在好多了。我们接下来学习装饰器的一些常用场景。

蓝本规范:

from functools import wraps

def decorator_name(f):

@wraps(f)

def decorated(*args, **kwargs):

if not can_run:

return "Function will not run"

return f(*args, **kwargs)

return decorated

@decorator_name

def func():

return("Function is running")

can_run = True

print(func())

# Output: Function is running

can_run = False

print(func())

# Output: Function will not run

注意：@wraps接受一个函数来进行装饰，并加入了复制函数名称、注释文档、参数列表等等的功能。这可以让我们在装饰器里面访问在装饰之前的函数的属性。

使用场景

授权

装饰器能有助于检查某个人是否被授权去使用一个web应用的端点(endpoint)。它们被大量使用于Flask和Django web框架中。这里是一个例子来使用基于装饰器的授权：

from functools import wraps

def requires_auth(f):

@wraps(f)

def decorated(*args, **kwargs):

auth = request.authorization

if not auth or not check_auth(auth.username, auth.password):

authenticate()

return f(*args, **kwargs)

return decorated

日志

日志是装饰器运用的另一个亮点。这是个例子：

from functools import wraps

def logit(func):

@wraps(func)

def with_logging(*args, **kwargs):

print(func.__name__ + " was called")

return func(*args, **kwargs)

return with_logging

@logit

def addition_func(x):

"""Do some math."""

return x + x

result = addition_func(4)

# Output: addition_func was called

带参数的装饰器

来想想这个问题，难道@wraps不也是个装饰器吗？但是，它接收一个参数，就像任何普通的函数能做的那样。那么，为什么我们不也那样做呢？

这是因为，当你使用@my_decorator语法时，你是在应用一个以单个函数作为参数的一个包裹函数。记住，Python里每个东西都是一个对象，而且这包括函数！记住了这些，我们可以编写一下能返回一个包裹函数的函数。

在函数中嵌入装饰器

我们回到日志的例子，并创建一个包裹函数，能让我们指定一个用于输出的日志文件。

from functools import wraps

def logit(logfile='out.log'):

def logging_decorator(func):

@wraps(func)

def wrapped_function(*args, **kwargs):

log_string = func.__name__ + " was called"

print(log_string)

# 打开logfile，并写入内容

with open(logfile, 'a') as opened_file:

# 现在将日志打到指定的logfile

opened_file.write(log_string + '\n')

return func(*args, **kwargs)

return wrapped_function

return logging_decorator

@logit()

def myfunc1():

pass

myfunc1()

# Output: myfunc1 was called

# 现在一个叫做 out.log 的文件出现了，里面的内容就是上面的字符串

@logit(logfile='func2.log')

def myfunc2():

pass

myfunc2()

# Output: myfunc2 was called

# 现在一个叫做 func2.log 的文件出现了，里面的内容就是上面的字符串

装饰器类

现在我们有了能用于正式环境的logit装饰器，但当我们的应用的某些部分还比较脆弱时，异常也许是需要更紧急关注的事情。比方说有时你只想打日志到一个文件。而有时你想把引起你注意的问题发送到一个email，同时也保留日志，留个记录。这是一个使用继承的场景，但目前为止我们只看到过用来构建装饰器的函数。

幸运的是，类也可以用来构建装饰器。那我们现在以一个类而不是一个函数的方式，来重新构建logit。

from functools import wraps

class logit(object):

def __init__(self, logfile='out.log'):

self.logfile = logfile

def __call__(self, func):

@wraps(func)

def wrapped_function(*args, **kwargs):

log_string = func.__name__ + " was called"

print(log_string)

# 打开logfile并写入

with open(self.logfile, 'a') as opened_file:

# 现在将日志打到指定的文件

opened_file.write(log_string + '\n')

# 现在，发送一个通知

self.notify()

return func(*args, **kwargs)

return wrapped_function

def notify(self):

# logit只打日志，不做别的

pass

这个实现有一个附加优势，在于比嵌套函数的方式更加整洁，而且包裹一个函数还是使用跟以前一样的语法：

@logit()

def myfunc1():

pass

现在，我们给logit创建子类，来添加email的功能(虽然email这个话题不会在这里展开)。

class email_logit(logit):

'''

一个logit的实现版本，可以在函数调用时发送email给管理员

'''

def __init__(self, email='[email protected]', *args, **kwargs):

self.email = email

super(logit, self).__init__(*args, **kwargs)

def notify(self):

# 发送一封email到self.email

# 这里就不做实现了

pass

从现在起，@email_logit将会和@logit产生同样的效果，但是在打日志的基础上，还会多发送一封邮件给管理员。

8.0 slots魔法

在Python中，每个类都有实例属性。默认情况下Python用一个字典来保存一个对象的实例属性。这非常有用，因为它允许我们在运行时去设置任意的新属性。

然而，对于有着已知属性的小类来说，它可能是个瓶颈。这个字典浪费了很多内存。Python不能在对象创建时直接分配一个固定量的内存来保存所有的属性。因此如果你创建许多对象(我指的是成千上万个)，它会消耗掉很多内存。

不过还是有一个方法来规避这个问题。这个方法需要使用slots来告诉Python不要使用字典，而且只给一个固定集合的属性分配空间。

这里是一个使用与不使用slots的例子：

不使用 __slots__:

class MyClass(object):

def __init__(self, name, identifier):

self.name = name

self.identifier = identifier

self.set_up()

# ...

使用 __slots__:

class MyClass(object):

__slots__ = ['name', 'identifier']

def __init__(self, name, identifier):

self.name = name

self.identifier = identifier

self.set_up()

# ...

第二段代码会为你的内存减轻负担。通过这个技巧，有些人已经看到内存占用率几乎40%~50%的减少。

9.0 容器(Collections)

Python附带一个模块，它包含许多容器数据类型，名字叫作collections。我们将讨论它的作用和用法。

我们将讨论的是：

defaultdict

counter

deque

namedtuple

enum.Enum (包含在Python 3.4以上)

defaultdict

与dict类型不同，你不需要检查key是否存在，所以我们能这样做：

from collections import defaultdict

colours = (

('Yasoob', 'Yellow'),

('Ali', 'Blue'),

('Arham', 'Green'),

('Ali', 'Black'),

('Yasoob', 'Red'),

('Ahmed', 'Silver'),

)

favourite_colours = defaultdict(list)

for name, colour in colours:

favourite_colours[name].append(colour)

print(favourite_colours)

输出：

# defaultdict(,

# {'Arham': ['Green'],

# 'Yasoob': ['Yellow', 'Red'],

# 'Ahmed': ['Silver'],

# 'Ali': ['Blue', 'Black']

# })

另一种重要的是例子就是：当你在一个字典中对一个键进行嵌套赋值时，如果这个键不存在，会触发keyError异常。 defaultdict允许我们用一个聪明的方式绕过这个问题。 首先我分享一个使用dict触发KeyError的例子，然后提供一个使用defaultdict的解决方案。

问题：

some_dict = {}

some_dict['colours']['favourite'] = "yellow"

异常输出：KeyError: 'colours'

解决方案：

import collections

tree = lambda: collections.defaultdict(tree)

some_dict = tree()

some_dict['colours']['favourite'] = "yellow"

运行正常

你可以用json.dumps打印出some_dict，例如：

import json

print(json.dumps(some_dict))

## 输出: {"colours": {"favourite": "yellow"}}

counter

Counter是一个计数器，它可以帮助我们针对某项数据进行计数。比如它可以用来计算每个人喜欢多少种颜色：

from collections import Counter

colours = (

('Yasoob', 'Yellow'),

('Ali', 'Blue'),

('Arham', 'Green'),

('Ali', 'Black'),

('Yasoob', 'Red'),

('Ahmed', 'Silver'),

)

favs = Counter(name for name, colour in colours)

print(favs)

## 输出:

## Counter({

## 'Yasoob': 2,

## 'Ali': 2,

## 'Arham': 1,

## 'Ahmed': 1

## })

我们也可以在利用它统计一个文件，例如：

with open('filename', 'rb') as f:

line_count = Counter(f)

print(line_count)

deque

deque提供了一个双端队列，你可以从头/尾两端添加或删除元素。要想使用它，首先我们要从collections中导入deque模块：

它的用法就像python的list，并且提供了类似的方法，例如：

from collections import deque

d = deque()

d.append('1')

d.append('2')

d.append('3')

print(len(d))

## 输出: 3

print(d[0])

## 输出: '1'

print(d[-1])

## 输出: '3'

你可以从两端取出(pop)数据：

d = deque(range(5))

print(len(d))

## 输出: 5

d.popleft()

## 输出: 0

d.pop()

## 输出: 4

print(d)

## 输出: deque([1, 2, 3])

对象自省

自省(introspection)，在计算机编程领域里，是指在运行时来判断一个对象的类型的能力。它是Python的强项之一。Python中所有一切都是一个对象，而且我们可以仔细勘察那些对象。Python还包含了许多内置函数和模块来帮助我们。

dir

返回一个列表，列出了一个对象所拥有的属性和方法。这里是一个例子：

my_list = [1, 2, 3]

dir(my_list)

# Output: ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',

# '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',

# '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__',

# '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__',

# '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__',

# '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__',

# '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop',

# 'remove', 'reverse', 'sort']

上面的自省给了我们一个列表对象的所有方法的名字。当你没法回忆起一个方法的名字，这会非常有帮助。如果我们运行dir()而不传入参数，那么它会返回当前作用域的所有名字。

type和id

print(type(''))

# Output:

print(type([]))

# Output:

print(type({}))

# Output:

print(type(dict))

# Output:

print(type(3))

# Output:

id()函数返回任意不同种类对象的唯一ID，举个例子：

name = "Yasoob"

print(id(name))

# Output: 139972439030304

inspect模块

inspect模块也提供了许多有用的函数，来获取活跃对象的信息。比方说，你可以查看一个对象的成员，只需运行：

import inspect

print(inspect.getmembers(str))

# Output: [('__add__',

10.0 列表推导室

推导式(又称解析式)是Python的一种独有特性，如果我被迫离开了它，我会非常想念。推导式是可以从一个数据序列构建另一个新的数据序列的结构体。 共有三种推导，在Python2和3中都有支持：

列表(list)推导式

字典(dict)推导式

集合(set)推导式

列表(list)推导式

列表推导式(又称列表解析式)提供了一种简明扼要的方法来创建列表。

它的结构是在一个中括号里包含一个表达式，然后是一个for语句，然后是0个或多个for或者if语句。那个表达式可以是任意的，意思是你可以在列表中放入任意类型的对象。返回结果将是一个新的列表，在这个以if和for语句为上下文的表达式运行完成之后产生。

规范

variable = [out_exp for out_exp in input_list if out_exp == 2]

这里是另外一个简明例子:

multiples = [i for i in range(30) if i % 3 is 0]

print(multiples)

# Output: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

这将对快速生成列表非常有用。

有些人甚至更喜欢使用它而不是filter函数。

列表推导式在有些情况下超赞，特别是当你需要使用for循环来生成一个新列表。举个例 子，你通常会这样做：

squared = []

for x in range(10):

squared.append(x**2)

你可以使用列表推导式来简化它，就像这样：

squared = [x**2 for x in range(10)]

字典推导式(dict comprehensions)

字典推导和列表推导的使用方法是类似的。这里有个我最近发现的例子：

mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}

mcase_frequency = {

k.lower(): mcase.get(k.lower(), 0) + mcase.get(k.upper(), 0)

for k in mcase.keys()

}

# mcase_frequency == {'a': 17, 'z': 3, 'b': 34}

在上面的例子中我们把同一个字母但不同大小写的值合并起来了。

就我个人来说没有大量使用字典推导式。你还可以快速对换一个字典的键和值：

{v: k for k, v in some_dict.items()}

集合推导式(set comprehensions)

它们跟列表推导式也是类似的。 唯一的区别在于它们使用大括号{}。 举个例子：

squared = {x**2 for x in [1, 1, 2]}

print(squared)

# Output: {1, 4}

11.0 异常

异常处理是一种艺术，一旦你掌握，会授予你无穷的力量。我将要向你展示我们能处理 异常的一些方式。

最基本的术语里我们知道了try/except从句。可能触发异常产生的代码会放到try语句块里，而处理异常的代码会在except语句块里实现。这是一个简单的例子：

try:

file = open('test.txt', 'rb')

except IOError as e:

print('An IOError occurred. {}'.format(e.args[-1]))

上面的例子里，我们仅仅在处理一个IOError的异常。大部分初学者还不知道的是，我们可以处理多个异常。

处理多个异常

我们可以使用三种方法来处理多个异常。

第一种方法需要把所有可能发生的异常放到一个元组里。像这样：

try:

file = open('test.txt', 'rb')

except (IOError, EOFError) as e:

print("An error occurred. {}".format(e.args[-1]))

另外一种方式是对每个单独的异常在单独的except语句块中处理。我们想要多少个except语句块都可以。这里是个例子：

try:

file = open('test.txt', 'rb')

except EOFError as e:

print("An EOF error occurred.")

raise e

except IOError as e:

print("An error occurred.")

raise e

现在，最后一种方式会捕获所有异常：

try:

file = open('test.txt', 'rb')

except Exception:

# 打印一些异常日志，如果你想要的话

raise

finally从句

我们把我们的主程序代码包裹进了try从句。然后我们把一些代码包裹进一个except从句，它会在try从句中的代码触发异常时执行。

在下面的例子中，我们还会使用第三个从句，那就是finally从句。包裹到finally从句中的代码不管异常是否触发都将会被执行。这可以被用来在脚本执行之后做清理工作。这里是个简单的例子：

try:

file = open('test.txt', 'rb')

except IOError as e:

print('An IOError occurred. {}'.format(e.args[-1]))

finally:

print("This would be printed whether or not an exception occurred!")

# Output: An IOError occurred. No such file or directory

# This would be printed whether or not an exception occurred!

try/else从句

try:

print('I am sure no exception is going to occur!')

except Exception:

print('exception')

else:

# 这里的代码只会在try语句里没有触发异常时运行,

# 但是这里的异常将 *不会* 被捕获

print('This would only run if no exception occurs. And an error here '

'would NOT be caught.')

finally:

print('This would be printed in every case.')

# Output: I am sure no exception is going to occur!

# This would only run if no exception occurs.

# This would be printed in every case.

12.0 lambda表达式

lambda表达式是一行函数。

它们在其他语言中也被称为匿名函数。如果你不想在程序中对一个函数使用两次，你也许会想用lambda表达式，它们和普通的函数完全一样。

原型：

lambda 参数:操作(参数)

例子：

add = lambda x, y: x + y

print(add(3, 5))

# Output: 8

这还有一些lambda表达式的应用案例，可以在一些特殊情况下使用：

列表排序:

a = [(1, 2), (4, 1), (9, 10), (13, -3)]

a.sort(key=lambda x: x[1])

print(a)

# Output: [(13, -3), (4, 1), (1, 2), (9, 10)]

列表并行排序:

data = zip(list1, list2)

data.sort()

list1, list2 = map(lambda t: list(t), zip(*data))

13.0 一行式

一行式

本章节,我将向大家展示一些一行式的Python命令，这些程序将对你非常有帮助。

简易Web Server

你是否想过通过网络快速共享文件？好消息，Python为你提供了这样的功能。进入到你要共享文件的目录下并在命令行中运行下面的代码：

# Python 2

python -m SimpleHTTPServer

# Python 3

python -m http.server

漂亮的打印

你可以在Python REPL漂亮的打印出列表和字典。这里是相关的代码：

from pprint import pprint

my_dict = {'name': 'Yasoob', 'age': 'undefined', 'personality': 'awesome'}

pprint(my_dict)

这种方法在字典上更为有效。此外，如果你想快速漂亮的从文件打印出json数据，那么你可以这么做：

cat file.json | python -m json.tool

脚本性能分析 这可能在定位你的脚本中的性能瓶颈时，会非常奏效：

python -m cProfile my_script.py

备注：cProfile是一个比profile更快的实现，因为它是用c写的

CSV转换为json

在命令行执行这条指令

python -c "import csv,json;print json.dumps(list(csv.reader(open('csv_file.csv'))))"

确保更换csv_file.csv为你想要转换的csv文件

列表辗平

您可以通过使用itertools包中的itertools.chain.from_iterable轻松快速的辗平一个列表。下面是一个简单的例子：

a_list = [[1, 2], [3, 4], [5, 6]]

print(list(itertools.chain.from_iterable(a_list)))

# Output: [1, 2, 3, 4, 5, 6]

# or

print(list(itertools.chain(*a_list)))

# Output: [1, 2, 3, 4, 5, 6]

一行式的构造器

避免类初始化时大量重复的赋值语句

class A(object):

def __init__(self, a, b, c, d, e, f):

self.__dict__.update({k: v for k, v in locals().items() if k != 'self'})

14.0 For-Else

for循环还有一个else从句，我们大多数人并不熟悉。这个else从句会在循环正常结束时执行。这意味着，循环没有遇到任何break. 一旦你掌握了何时何地使用它，它真的会非常有用。我自己对它真是相见恨晚。

有个常见的构造是跑一个循环，并查找一个元素。如果这个元素被找到了，我们使用break来中断这个循环。有两个场景会让循环停下来。 - 第一个是当一个元素被找到，break被触发。 - 第二个场景是循环结束。

现在我们也许想知道其中哪一个，才是导致循环完成的原因。一个方法是先设置一个标记，然后在循环结束时打上标记。另一个是使用else从句。

这就是for/else循环的基本结构：

for item in container:

if search_something(item):

# Found it!

process(item)

break

else:

# Didn't find anything..

not_found_in_container()

14.0 使用C扩展

CPython还为开发者实现了一个有趣的特性，使用Python可以轻松调用C代码

开发者有三种方法可以在自己的Python代码中来调用C编写的函数-ctypes，SWIG，Python/C API。每种方式也都有各自的利弊。

首先，我们要明确为什么要在Python中调用C？

常见原因如下： - 你要提升代码的运行速度，而且你知道C要比Python快50倍以上 - C语言中有很多传统类库，而且有些正是你想要的，但你又不想用Python去重写它们 - 想对从内存到文件接口这样的底层资源进行访问 - 不需要理由，就是想这样做

14.1 CTypes

Python中的ctypes模块可能是Python调用C方法中最简单的一种。ctypes模块提供了和C语言兼容的数据类型和函数来加载dll文件，因此在调用时不需对源文件做任何的修改。也正是如此奠定了这种方法的简单性。

示例如下

实现两数求和的C代码，保存为add.c

//sample C file to add 2 numbers - int and floats

#include

int add_int(int, int);

float add_float(float, float);

int add_int(int num1, int num2){

return num1 + num2;

}

float add_float(float num1, float num2){

return num1 + num2;

}

接下来将C文件编译为.so文件(windows下为DLL)。下面操作会生成adder.so文件

#For Linux

$ gcc -shared -Wl,-soname,adder -o adder.so -fPIC add.c

#For Mac

$ gcc -shared -Wl,-install_name,adder.so -o adder.so -fPIC add.c

现在在你的Python代码中来调用它

from ctypes import *

#load the shared object file

adder = CDLL('./adder.so')

#Find sum of integers

res_int = adder.add_int(4,5)

print "Sum of 4 and 5 = " + str(res_int)

#Find sum of floats

a = c_float(5.5)

b = c_float(4.1)

add_float = adder.add_float

add_float.restype = c_float

print "Sum of 5.5 and 4.1 = ", str(add_float(a, b))

输出如下:

Sum of 4 and 5 = 9

Sum of 5.5 and 4.1 = 9.60000038147

在这个例子中，C文件是自解释的，它包含两个函数，分别实现了整形求和和浮点型求和。

在Python文件中，一开始先导入ctypes模块，然后使用CDLL函数来加载我们创建的库文件。这样我们就可以通过变量adder来使用C类库中的函数了。当adder.add_int()被调用时，内部将发起一个对C函数add_int的调用。ctypes接口允许我们在调用C函数时使用原生Python中默认的字符串型和整型。

而对于其他类似布尔型和浮点型这样的类型，必须要使用正确的ctype类型才可以。如向adder.add_float()函数传参时, 我们要先将Python中的十进制值转化为c_float类型，然后才能传送给C函数。这种方法虽然简单，清晰，但是却很受限。例如，并不能在C中对对象进行操作。

14.2 SWIG

SWIG是Simplified Wrapper and Interface Generator的缩写。是Python中调用C代码的另一种方法。在这个方法中，开发人员必须编写一个额外的接口文件来作为SWIG(终端工具)的入口。

Python开发者一般不会采用这种方法，因为大多数情况它会带来不必要的复杂。而当你有一个C/C++代码库需要被多种语言调用时，这将是个非常不错的选择。

示例如下(来自SWIG官网):

example.c文件中的C代码包含了不同的变量和函数:

#include

double My_variable = 3.0;

int fact(int n) {

if (n <= 1) return 1;

else return n*fact(n-1);

}

int my_mod(int x, int y) {

return (x%y);

}

char *get_time()

{

time_t ltime;

time(<ime);

return ctime(<ime);

}

编译它:

unix % swig -python example.i

unix % gcc -c example.c example_wrap.c \

-I/usr/local/include/python2.1

unix % ld -shared example.o example_wrap.o -o _example.so

最后，Python的输出:

>>> import example

>>> example.fact(5)

120

>>> example.my_mod(7,3)

1

>>> example.get_time()

'Sun Feb 11 23:01:07 1996'

>>>

我们可以看到，使用SWIG确实达到了同样的效果，虽然下了更多的工夫，但如果你的目标是多语言还是很值得的。

14.3 Python/C API

Python/C API可能是被最广泛使用的方法。它不仅简单，而且可以在C代码中操作你的Python对象。

这种方法需要以特定的方式来编写C代码以供Python去调用它。所有的Python对象都被表示为一种叫做PyObject的结构体，并且Python.h头文件中提供了各种操作它的函数。例如，如果PyObject表示为PyListType(列表类型)时，那么我们便可以使用PyList_Size()函数来获取该结构的长度，类似Python中的len(list)函数。大部分对Python原生对象的基础函数和操作在Python.h头文件中都能找到。

示例

编写一个C扩展，添加所有元素到一个Python列表(所有元素都是数字)

来看一下我们要实现的效果，这里演示了用Python调用C扩展的代码

#Though it looks like an ordinary python import, the addList module is implemented in C

import addList

l = [1,2,3,4,5]

print "Sum of List - " + str(l) + " = " + str(addList.add(l))

上面的代码和普通的Python文件并没有什么分别，导入并使用了另一个叫做addList的Python模块。唯一差别就是这个模块并不是用Python编写的，而是C。

接下来我们看看如何用C编写addList模块，这可能看起来有点让人难以接受，但是一旦你了解了这之中的各种组成，你就可以一往无前了。

//Python.h has all the required function definitions to manipulate the Python objects

#include

//This is the function that is called from your python code

static PyObject* addList_add(PyObject* self, PyObject* args){

PyObject * listObj;

//The input arguments come as a tuple, we parse the args to get the various variables

//In this case it's only one list variable, which will now be referenced by listObj

if (! PyArg_ParseTuple( args, "O", &listObj ))

return NULL;

//length of the list

long length = PyList_Size(listObj);

//iterate over all the elements

int i, sum =0;

for (i = 0; i < length; i++) {

//get an element out of the list - the element is also a python objects

PyObject* temp = PyList_GetItem(listObj, i);

//we know that object represents an integer - so convert it into C long

long elem = PyInt_AsLong(temp);

sum += elem;

}

//value returned back to python code - another python object

//build value here converts the C long to a python integer

return Py_BuildValue("i", sum);

}

//This is the docstring that corresponds to our 'add' function.

static char addList_docs[] =

"add( ): add all elements of the list\n";

/* This table contains the relavent info mapping -

, ,

,

*/

static PyMethodDef addList_funcs[] = {

{"add", (PyCFunction)addList_add, METH_VARARGS, addList_docs},

{NULL, NULL, 0, NULL}

};

/*

addList is the module name, and this is the initialization block of the module.

, ,

*/

PyMODINIT_FUNC initaddList(void){

Py_InitModule3("addList", addList_funcs,

"Add all ze lists");

}

逐步解释 - Python.h头文件中包含了所有需要的类型(Python对象类型的表示)和函数定义(对Python对象的操作) - 接下来我们编写将要在Python调用的函数, 函数传统的命名方式由{模块名}_{函数名}组成，所以我们将其命名为addList_add

然后填写想在模块内实现函数的相关信息表，每行一个函数，以空行作为结束 - 最后的模块初始化块签名为PyMODINIT_FUNC init{模块名}。

函数addList_add接受的参数类型为PyObject类型结构(同时也表示为元组类型，因为Python中万物皆为对象，所以我们先用PyObject来定义)。传入的参数则通过PyArg_ParseTuple()来解析。第一个参数是被解析的参数变量。第二个参数是一个字符串，告诉我们如何去解析元组中每一个元素。字符串的第n个字母正是代表着元组中第n个参数的类型。例如，"i"代表整形，"s"代表字符串类型, "O"则代表一个Python对象。接下来的参数都是你想要通过PyArg_ParseTuple()函数解析并保存的元素。这样参数的数量和模块中函数期待得到的参数数量就可以保持一致，并保证了位置的完整性。例如，我们想传入一个字符串，一个整数和一个Python列表，可以这样去写

int n;

char *s;

PyObject* list;

PyArg_ParseTuple(args, "siO", &n, &s, &list);

在这种情况下，我们只需要提取一个列表对象，并将它存储在listObj变量中。然后用列表对象中的PyList_Size()函数来获取它的长度。就像Python中调用len(list)。

现在我们通过循环列表，使用PyList_GetItem(list, index)函数来获取每个元素。这将返回一个PyObject*对象。既然Python对象也能表示PyIntType，我们只要使用PyInt_AsLong(PyObj *)函数便可获得我们所需要的值。我们对每个元素都这样处理，最后再得到它们的总和。

总和将被转化为一个Python对象并通过Py_BuildValue()返回给Python代码，这里的i表示我们要返回一个Python整形对象。

现在我们已经编写完C模块了。将下列代码保存为setup.py

#build the modules

from distutils.core import setup, Extension

setup(name='addList', version='1.0', \

ext_modules=[Extension('addList', ['adder.c'])])

并且运行

python setup.py install

现在应该已经将我们的C文件编译安装到我们的Python模块中了。

在一番辛苦后，让我们来验证下我们的模块是否有效

#module that talks to the C code

import addList

l = [1,2,3,4,5]

print "Sum of List - " + str(l) + " = " + str(addList.add(l))

输出结果如下

Sum of List - [1, 2, 3, 4, 5] = 15

如你所见，我们已经使用Python.h API成功开发出了我们第一个Python C扩展。这种方法看似复杂，但你一旦习惯，它将变的非常有效。

Python调用C代码的另一种方式便是使用Cython让Python编译的更快。但是Cython和传统的Python比起来可以将它理解为另一种语言，所以我们就不在这里过多描述了。

15 open函数

open 函数可以打开一个文件。超级简单吧？大多数时候，我们看到它这样被使用：

f = open('photo.jpg', 'r+')

jpgdata = f.read()

f.close()

有三个错误存在于上面的代码中。

open的返回值是一个文件句柄，从操作系统托付给你的Python程序。一旦你处理完文件，你会想要归还这个文件句柄，只有这样你的程序不会超出一次能打开的文件句柄的数量上限。

显式地调用close关闭了这个文件句柄，但前提是只有在read成功的情况下。如果有任意异常正好在f = open(...)之后产生，f.close()将不会被调用(取决于Python解释器的做法，文件句柄可能还是会被归还，但那是另外的话题了)。为了确保不管异常是否触发，文件都能关闭，我们将其包裹成一个with语句:

with open('photo.jpg', 'r+') as f:

jpgdata = f.read()

open的第一个参数是文件名。第二个(mode 打开模式)决定了这个文件如何被打开。

如果你想读取文件，传入r

如果你想读取并写入文件，传入r+

如果你想覆盖写入文件，传入w

如果你想在文件末尾附加内容，传入a

jpg图像文件一般不是人写的(而且其实不是人直接可读的)，因此你应该以二进制模式来打开它们，方法是在mode字符串后加一个b(你可以看看开头的例子里，正确的方式应该是rb)。

如果你以文本模式打开一些东西(比如，加一个t,或者就用r/r+/w/a)，你还必须知道要使用哪种编码。对于计算机来说，所有的文件都是字节，而不是字符。

那你怎么找出正在读的文件是用哪种编码写的呢？好吧，不幸的是，并没有一个十分简单的方式来检测编码。在不同的编码中，同样的字节可以表示不同，但同样有效的字符。因此，你必须依赖一个元数据(比如，在HTTP头信息里)来找出编码。越来越多的是，文件格式将编码定义成UTF-8。

有了这些基础知识，我们来写一个程序，读取一个文件，检测它是否是JPG(提示：这些文件头部以字节FF D8开始)，把对输入文件的描述写入一个文本文件。

import io

with open('photo.jpg', 'rb') as inf:

jpgdata = inf.read()

if jpgdata.startswith(b'\xff\xd8'):

text = u'This is a JPEG file (%d bytes long)\n'

else:

text = u'This is a random file (%d bytes long)\n'

with io.open('summary.txt', 'w', encoding='utf-8') as outf:

outf.write(text % len(jpgdata))

我敢肯定，现在你会正确地使用open啦！

16 协程

Python中的协程和生成器很相似但又稍有不同。主要区别在于： 生成器是数据的生产者 协程则是数据的消费者

首先我们先来回顾下生成器的创建过程。我们可以这样去创建一个生成器:

def fib():

a, b = 0, 1

while True:

yield a

a, b = b, a+b

然后我们经常在for循环中这样使用它:

for i in fib():

print i

这样做不仅快而且不会给内存带来压力，因为我们所需要的值都是动态生成的而不是将他们存储在一个列表中。更概括的说如果现在我们在上面的例子中使用yield便可获得了一个协程。协程会消费掉发送给它的值。Python实现的grep就是个很好的例子：

def grep(pattern):

print("Searching for", pattern)

while True:

line = (yield)

if pattern in line:

print(line)

等等！yield返回了什么？啊哈，我们已经把它变成了一个协程。它将不再包含任何初始值，相反要从外部传值给它。我们可以通过send()方法向它传值。这有个例子：

search = grep('coroutine')

next(search)

#output: Searching for coroutine

search.send("I love you")

search.send("Don't you love me?")

search.send("I love coroutine instead!")

#output: I love coroutine instead!

发送的值会被yield接收。我们为什么要运行next()方法呢？这样做正是为了启动一个协程。就像协程中包含的生成器并不是立刻执行，而是通过next()方法来响应send()方法。因此，你必须通过next()方法来执行yield表达式。

我们可以通过调用close()方法来关闭一个协程。像这样：

search = grep('coroutine')

search.close()

更多协程相关知识的学习大家可以参考David Beazley的这份精彩演讲。

17 函数缓存 (Function caching)

函数缓存允许我们将一个函数对于给定参数的返回值缓存起来。

当一个I/O密集的函数被频繁使用相同的参数调用的时候，函数缓存可以节约时间。

在Python 3.2版本以前我们只有写一个自定义的实现。在Python 3.2以后版本，有个lru_cache的装饰器，允许我们将一个函数的返回值快速地缓存或取消缓存。

我们来实现一个斐波那契计算器，并使用lru_cache。

from functools import lru_cache

@lru_cache(maxsize=32)

def fib(n):

if n < 2:

return n

return fib(n-1) + fib(n-2)

>>> print([fib(n) for n in range(10)])

# Output: [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

那个maxsize参数是告诉lru_cache，最多缓存最近多少个返回值。

我们也可以轻松地对返回值清空缓存，通过这样：

fib.cache_clear()

18 上下文管理器(Context managers)

上下文管理器允许你在有需要的时候，精确地分配和释放资源。

使用上下文管理器最广泛的案例就是with语句了。

想象下你有两个需要结对执行的相关操作，然后还要在它们中间放置一段代码。

上下文管理器就是专门让你做这种事情的。举个例子：

with open('some_file', 'w') as opened_file:

opened_file.write('Hola!')

上面这段代码打开了一个文件，往里面写入了一些数据，然后关闭该文件。如果在往文件写数据时发生异常，它也会尝试去关闭文件。上面那段代码与这一段是等价的：

file = open('some_file', 'w')

try:

file.write('Hola!')

finally:

file.close()

当与第一个例子对比时，我们可以看到，通过使用with，许多样板代码(boilerplate code)被消掉了。 这就是with语句的主要优势，它确保我们的文件会被关闭，而不用关注嵌套代码如何退出。

上下文管理器的一个常见用例，是资源的加锁和解锁，以及关闭已打开的文件(就像我已经展示给你看的)。

让我们看看如何来实现我们自己的上下文管理器。这会让我们更完全地理解在这些场景背后都发生着什么。

18.1 基于类的实现

一个上下文管理器的类，最起码要定义_enter_和_exit_方法。

让我们来构造我们自己的开启文件的上下文管理器，并学习下基础知识。

class File(object):

def __init__(self, file_name, method):

self.file_obj = open(file_name, method)

def __enter__(self):

return self.file_obj

def __exit__(self, type, value, traceback):

self.file_obj.close()

通过定义_enter_和_exit_方法，我们可以在with语句里使用它。我们来试试：

with File('demo.txt', 'w') as opened_file:

opened_file.write('Hola!')

我们的_exit_函数接受三个参数。这些参数对于每个上下文管理器类中的_exit_方法都是必须的。我们来谈谈在底层都发生了什么。

with语句先暂存了File类的_exit_方法

然后它调用File类的_enter_方法

_enter_方法打开文件并返回给with语句

打开的文件句柄被传递给opened_file参数

我们使用.write()来写文件

with语句调用之前暂存的_exit_方法

_exit_方法关闭了文件

18.2