其中有可能是自己想到的一些知识点,也有一些是网上收集的.

看两个例子:

如果还不明白的话,这里有更好的解释:http://stackoverflow.com/questions/986006/how-do-i-pass-a-variable-by-reference

这个非常的不常用,但是像ORM这种复杂的结构还是会需要的,详情请看:http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python

Python其实有3个方法,即静态方法(staticmethod),类方法(classmethod)和实例方法,如下:

更多关于这个问题:http://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod-in-python

classPerson:

参考:http://stackoverflow.com/questions/6470428/catch-multiple-exceptions-in-one-line-except-block

这个也是python彪悍的特性.

自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.比如type(),dir(),getattr(),hasattr(),isinstance().

可能你见过列表推导时,却没有见过字典推导式,在2.7中才加入的:

d= {key: valuefor (key, value)in iterable}

>>>classMyClass():

或者:http://www.zhihu.com/question/19754941

.format在许多方面看起来更便利.你可以重用参数,但是你用%就不行.最烦人的是%它无法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题:

这个是stackoverflow里python排名第一的问题,值得一看:http://stackoverflow.com/questions/231767/what-does-the-yield-keyword-do-in-python

这是中文版:http://taizilongxu.gitbooks.io/stackoverflow-about-python/content/1/README.html

用`*args`和`**kwargs`只是为了方便并没有强制使用它们.

当你不确定你的函数里将要传递多少参数时你可以用`*args`.例如,它可以传递任意数量的参数:

>>>defprint_everything(*args):

for count, thinginenumerate(args):

...print'{0}.{1}'.format(count, thing)

>>> print_everything('apple','banana','cabbage')

0. apple

1. banana

2. cabbage

相似的,`**kwargs`允许你使用没有事先定义的参数名:

>>>deftable_things(**kwargs):

...for name, valuein kwargs.items():

...print'{0} ={1}'.format(name, value)

>>> table_things(apple='fruit',cabbage='vegetable')

cabbage= vegetable

apple= fruit

你也可以混着用.命名参数首先获得参数值然后所有的其他参数都传递给`*args`和`**kwargs`.命名参数在列表的最前端.例如:

`*args`和`**kwargs`可以同时在函数的定义中,但是`*args`必须在`**kwargs`前面.

当调用函数时你也可以用`*`和`**`语法.例如:

>>>defprint_three_things(a,b,c):

...print'a ={0}, b ={1}, c ={2}'.format(a,b,c)

>>> mylist= ['aardvark','baboon','cat']

>>> print_three_things(*mylist)

a= aardvark, b= baboon, c= cat

就像你看到的一样,它可以传递列表(或者元组)的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.当然,你也可以在函数定义或者函数调用时用*.

这个AOP一听起来有点懵,同学面阿里的时候就被问懵了...

装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，**装饰器的作用就是为已经存在的对象添加额外的功能。**

这个问题比较大,推荐:http://stackoverflow.com/questions/739654/how-can-i-make-a-chain-of-function-decorators-in-python

中文:http://taizilongxu.gitbooks.io/stackoverflow-about-python/content/3/README.html

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”

我们并不关心对象是什么类型，到底是不是鸭子，只关心行为。

比如在python中，有很多file-like的东西，比如StringIO,GzipFile,socket。它们有很多相同的方法，我们把它们当作文件使用。

又比如list.extend()方法中,我们并不关心它的参数是不是list,只要它是可迭代的,所以它的参数可以是list/tuple/dict/字符串/生成器等.

鸭子类型在动态语言中经常使用，非常灵活，使得python不想java那样专门去弄一大堆的设计模式。

引自知乎:http://www.zhihu.com/question/20053359

函数重载主要是为了解决两个问题。

1. 可变参数类型。

2. 可变参数个数。

另外，一个基本的设计原则是，仅仅当两个函数除了参数类型和参数个数不同以外，其功能是完全相同的，此时才使用函数重载，如果两个函数的功能其实不同，那么不应当使用重载，而应当使用一个名字不同的函数。

好吧，那么对于情况 1 ，函数功能相同，但是参数类型不同，python 如何处理？答案是根本不需要处理，因为 python 可以接受任何类型的参数，如果函数的功能相同，那么不同的参数类型在 python 中很可能是相同的代码，没有必要做成两个不同函数。

那么对于情况 2 ，函数功能相同，但参数个数不同，python 如何处理？大家知道，答案就是缺省参数。对那些缺少的参数设定为缺省参数即可解决问题。因为你假设函数功能相同，那么那些缺少的参数终归是需要用的。

好了，鉴于情况 1 跟 情况 2 都有了解决方案，python 自然就不需要函数重载了。

[stackoverflow](http://stackoverflow.com/questions/54867/what-is-the-difference-between-old-style-and-new-style-classes-in-python)

这篇文章很好的介绍了新式类的特性:http://www.cnblogs.com/btchenguang/archive/2012/09/17/2689146.html

新式类很早在2.2就出现了,所以旧式类完全是兼容的问题,Python3里的类全部都是新式类.这里有一个MRO问题可以了解下(新式类是广度优先,旧式类是深度优先),<Python核心编程>里讲的也很多.

这个`__new__`确实很少见到,先做了解吧.

1.`__new__`是一个静态方法,而`__init__`是一个实例方法.

2.`__new__`方法会返回一个创建的实例,而`__init__`什么都不返回.

3. 只有在`__new__`返回一个cls的实例时后面的`__init__`才能被调用.

3. 当创建一个新实例时调用`__new__`,初始化一个实例时用`__init__`.

[stackoverflow](http://stackoverflow.com/questions/674304/pythons-use-of-new-and-init)

ps:`__metaclass__`是创建类时起作用.所以我们可以分别使用`__metaclass__`,`__new__`和`__init__`来分别在类创建,实例创建和实例初始化的时候做一些小手脚.

defsingleton(cls):

instances= {}

defgetinstance():

ifclsnotin instances:

instances[cls]=cls()

return instances[cls]

return getinstance

classMyClass:

Python 中，一个变量的作用域总是由在代码中被赋值的地方所决定的。

函数定义了本地作用域，而模块定义的是全局作用域。 如果想要在函数内定义全局作用域，需要加上global修饰符。

变量名解析：LEGB原则 当在函数中使用未认证的变量名时，Python搜索４个作用域[本地作用域(L)，之后是上一层结构中def或者lambda的本地作用域(E), 之后是全局作用域(G)，最后是内置作用域(B)］并且在第一处能够找到这个变量名的地方停下来。如果变量名在整个的搜索过程中 都没有找到，Python就会报错。 补：上面的变量规则只适用于简单对象，当出现引用对象的属性时，则有另一套搜索规则:属性引用搜索一个或多个对象，而不是作用域，并且有可能涉及到所谓的"继承"

线程全局锁(Global Interpreter Lock),即Python为了保证线程安全而采取的独立线程运行的限制,说白了就是一个核只能在同一时间运行一个线程.

见[Python 最难的问题](http://www.oschina.net/translate/pythons-hardest-problem)

解决办法就是多进程和下面的协程(协程也只是单CPU,但是能减小切换代价提升性能).

知乎被问到了,呵呵哒,跪了

简单点说协程是进程和线程的升级版,进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间,而协程就是用户自己控制切换的时机,不再需要陷入系统的内核态.

Python里最常见的yield就是协程的思想!可以查看第九个问题.

闭包(closure)是函数式编程的重要的语法结构。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。

当一个内嵌函数引用其外部作作用域的变量,我们就会得到一个闭包. 总结一下,创建一个闭包必须满足以下几点:

1. 必须有一个内嵌函数

2. 内嵌函数必须引用外部函数中的变量

3. 外部函数的返回值必须是内嵌函数

感觉闭包还是有难度的,几句话是说不明白的,还是查查相关资料.

重点是函数运行后并不会被撤销,就像16题的instance字典一样,当函数运行完后,instance并不被销毁,而是继续留在内存空间里.这个功能类似类里的类变量,只不过迁移到了函数上.

闭包就像个空心球一样,你知道外面和里面,但你不知道中间是什么样.

其实就是一个匿名函数,为什么叫lambda?因为和后面的函数式编程有关.

推荐:[知乎](http://www.zhihu.com/question/20125256)

这个需要适当的了解一下吧,毕竟函数式编程在Python中也做了引用.

推荐:[酷壳](http://coolshell.cn/articles/10822.html)

python中函数式编程支持:

filter 函数的功能相当于过滤器。调用一个布尔函数`bool_func`来迭代遍历每个seq中的元素；返回一个使`bool_seq`返回值为true的元素的序列。

>>>a= [1,2,3,4,5,6,7]

>>>b=filter(lambdax: x>5, a)

>>>print b

>>>[6,7]

map函数是对一个序列的每个项依次执行函数，下面是对一个序列每个项都乘以2：

>>> a=map(lambdax:x*2,[1,2,3])

>>>list(a)

[2,4,6]

reduce函数是对一个序列的每个项迭代调用函数，下面是求3的阶乘：

>>> functools.reduce(lambdax,y:x*y,range(1,4))

其实所有的I/O都是轮询的方法,只不过实现的层面不同罢了.

这个问题可能有点深入了,但相信能回答出这个问题是对I/O多路复用有很好的了解了.其中tornado使用的就是epoll的.

[selec,poll和epoll区别总结](http://www.cnblogs.com/Anker/p/3265058.html)

基本上select有3个缺点:

1. 连接数受限

2. 查找配对速度慢

3. 数据由内核拷贝到用户态

poll改善了第一个缺点

epoll改了三个缺点.

数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。

fib=lambdan:1if n<=2else fib(n-1)+ fib(n-2)

在一个m行n列二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。