Python笔试题

题目全部来自于网络，答案为个人解答和收集，因此不保证其正确和完备性，写此文是为了整理下之前学过的知识点，作复习为之。

希望能够和大家一起讨论下有关Python的问题，但博主不承担任何人因采用本文内部分或完全内容而带来的任何损失。

1，是否知道动态语言(Python)中的鸭子类型？

1. #“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子。”  
2. #The idea is that you don't need a type in order to invoke an existing method on an object - if a method is defined on it, you can invoke it. The name comes from#the phrase "If it looks like a duck and quacks like a duck, it's a duck".  

鸭子类型（duck typing）是动态类型的一种风格。在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定。在鸭子类型中，关注的不是对象的类型本身，而是它是如何使用的。

鸭子类型在Python中被广泛使用。Python术语表这样定义鸭子类型：

'''Pythonic programming style that determines an object's type by inspection of its method or attribute signature rather than by explicit relationship to some type object ("If it looks like a duck and quacks like a duck, it must be a duck.") By emphasizing interfaces rather than specific types, well-designed code improves its flexibility by allowing polymorphic substitution. Duck-typing avoids tests using type() or isinstance(). Instead, it typically employs the EAFP (Easier to Ask Forgiveness than Permission) style of programming.'''

更多地解释...

2，是否知道可变参数与关键字参数？

可变参数也称可变长度的参数，因为我们在一些函数处理可变数量参数的情况。Python中使用*和**来指定元组和字典元素作为可变参数。

1. def foo(arg1,arg2,*nkw,**kw):  
2.     print 'arg1 is: ', arg1  
3.     print 'arg2 is: ', arg2  
4.     for eachNKW in nkw: print 'arg: ', eachNKW  
5.     for eachKW in kw.keys(): print "key arg '%s': '%s'" %(eachKW,kw[eachKW])  
6.   
7. #for example  
8. a_tuple=('x','y','z')  
9. a_dict={'A':10,'B':20}  
10. foo(1,2,3,4,5,lang='Python',ver=2.7,*a_tuple,**a_dict)  

关键字参数仅针对函数调用，可以让调用者以参数名来区分参数，这样解释器可以按给出的关键字达到匹配参数值的目的

1. def foo(x):  
2.     print x  
3. foo(23);foo('chain') #标准调用  
4. foo(x=23);foo(x='chain') #关键字调用  

3，对函数式编程是否有初步了解？

关于函数式编程，可以先参考这篇入门级文章。

不过Python不是也不大可能成为一门函数式编程语言。但是依然支持一些函数式语言的特性

比如匿名函数(利用关键字lambda创建)，并且有些常用的函数，如map(),filter(),reduce()


4，是否知道列表生成式？

列表表达式，是列表解析的一种扩展。

列表解析：[expr for iter_var in iterable if cond_expr]

列表表达式：(expr for iter_var in iterable if cond_expr)
使用列表表达式可以避免创建列表，它并不真正创建列表，而是返回一个生成器。这个生成器在每次计算出一个条目后，把这个条目yield出来。 生成器表达式使用了azy evaluation，只有在检索时才被赋值，所以在列表比较长的情况下使用内存上更有效。这样可以更节省内存，提高执行效率。

5，是否知道lambda/decorator/slots？

lambda，即关键字用来创建匿名函数。

1. def add(x,y): return x+y '''''等价于''' lambda x,y: x+y  

lambda函数可以接受任意个参数，包括可选参数，但是表达式只有一个。可以把lambda创建的一个函数（对象）赋值给一个变量（元组或列表）以后就可以随时调用了。如果不这样做，它则在运行的时候被创建出来，引用计数+1，然后没有地方被引用，计数归零后就会被自动回收掉了。

decorator，一般被称之为装饰模式，是用来扩展已有的功能。

在Python中即函数修饰符。可以把一个函数应用到另一个函数对象上，而且新函数对象依然绑定原来的变量。用法也很简单，只要将@函数名放在需要装饰的函数上面，就能够装饰了。

比较常见的就是把原来的函数装饰成类函数或静态函数

1. class C:  
2.   def foo(args): pass  
3.   f = staticmethod(f)  
4.   
5. class C:  
6.   @staticmethod  
7.   def foo(args):pass  

decorator并且可以带参数，比如：

1. def deco(args):  
2.     return len  
3.  
4. @deco  
5. def foo(x):  
6.     return list(x)  
7.   
8. print foo('chain')  

slots ，

__slots__是一个类变量，由一序列型对象组成，由所有合法标识构成的实例属性的集合来表示。任何试图创建一个不在__slots__中的名字的实例属性都会导致AttributeError异常。这样就很好地控制了用户随意地动态增加实例属性。可以想象成C++的private成员变量。

6，py文件在运行时会产生pyc文件，用于缓存编译后代码？[a.正确 b.错误 c.不完全正确]
Python在执行时，首先会将.py文件中的源代码编译成Python的byte code，然后再由Python Virtual Machine来执行这些编译好的byte code。Python在执行完这些byte code后，会销毁PyCodeObject，所以下次再次执行.py文件时，Python需要重新编译源代码，创建PyCodeObject，然后执行byte code。Python提供一种机制，保存编译的中间结果，即byte code，或者更准确地说，保存PyCodeObject。事实上，Python确实提供了这样一种机制——Pyc文件。当Python运行结束后，这些信息甚至还会被存储在Pyc文件中。pyc文件中的PyCodeObject对象也是以一种嵌套的关系联系在一起的。(C)


7，python支持多线程，能够单进程无缝发挥多路CPU的优势[a.支持，能够 b.支持，不能够 c.不支持，能够 d.不支持，不能够]
（B）


8，在python中，使用for从列表中删除元素是错误的做法，会导致___________。正确的做法是使用python内置的____________函数。
有可能导致IndexError，但也有可能完成删除的操作。正确做法是用filter(IsOdd,a_list)


9，改正以下程序中的错误，并写出结果（禁止使用python运行）

1. a=10  
2. def test (*b):  
3.     print (a,type(b));  
4.     a = 20;  
5.     print a;  
6.     print b[0](b[0])  
7.   
8.   
9. if __name__ == "__main__":  
10.    print test (*[test]);  

(1，语句后的;可以删除，
 2，第一次使用a应该加上关键字global，
 3，函数最后一句会造成递归的栈溢出


10，题目要求同上题

1. def wrap_info (f):  
2.     b = {"b":10};  
3.     def inner_func (*p, **k):  
4.         print b['b'], p, k;  
5.         b['b'] += 1;  
6.         f(*p, **k);  
7.     return inner_func;  
8.   
9.   
10. def info (s):  
11.     print "func info: %s" % s;  
12.   
13.   
14. if __name__ == "__main__":  
15.     f1 = wrap_info (info);  
16.     f1 ("a");  
17.     f2 = wrap_info (info);  
18.     f1 ("b");  
19.     f2 ("c");  

(语句后的;可删除。其他无错


11，补完以下函数，使得继承此类的对象具有单例特性
class singleton (object):
    """ 单例模式的实现 """
    def __new__ (cls, **kargs):
        """ """
(

1. class singleton (object):  
2.     __instance = None  
3.    def __new__ (cls, **kargs):  
4.        if not cls.__instance: #if '_instance' not in cls.__dict__:  
5.         cls.__instance=super(singleton(cls, **kargs))  
6.     return cls.__instance  

)


12，yield通常在python中被用做生成器，但实际上，这一实现是一种被称为协程的多线程交互模式。请补全下面的代码，使得两个虚拟的线程能够互相交互运行(允许python上机)

1. def thread_1 ():  
2.     for i in range (0, 10):  
3.         print i;  
4.         yield i;  
5.   
6.   
7. def thread_2 ():  
8.     for i in range (20, 30):  
9.         print i;  
10.         yield i;  
11.   
12.   
13. def run (thread_pool):  
14.   
15.   
16. if __name__ == "__main__":  
17.     thread_pool = [];  
18.     thread_pool.append (thread_1 ());  
19.     thread_pool.append (thread_2 ());  
20.     run (thread_pool);  

（结果为0-9和20-29交替出现，不用考虑多函数的生成器停止不同步问题。
该题也为多种答案，运行通过即可。
def run (thread_pool):
    try:
        while True:
            for i in thread_pool:
                i.next ();
    except StopIteration:
        pass

其他答案亦可，但结果不能交替出现不算分。未能捕获StopIteration扣分

转自：http://blog.csdn.net/chain2012/article/details/7481295