Python interview_python

https://github.com/taizilongxu/interview_python

1 Python的函数参数传递

　　strings, tuples, 和numbers是不可更改的对象，而list,dict等则是可以修改的对象

2 Python中的元类(metaclass)

3 @staticmethod和@classmethod

python 三个方法，静态方法（staticmethod），类方法（classmethod），实例方法

4 类变量和实例变量

类变量就是供类使用的变量,实例变量就是供实例使用的.

若是list,dict修改实例变量，类变量也改变。strings, tuples, 和numbers是不可更改的对象，故实例变量和类变量不同。

5 Python自省

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

6 字典推导式

列表推导式（list comprehension）

In [39]: [x*x for x in range(10)]
Out[39]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2.7加入字典推导式

>>> strings = ['import','is','with','if','file','exception']  
  
>>> D = {key: val for val,key in enumerate(strings)}  
  
>>> D  
{'exception': 5, 'is': 1, 'file': 4, 'import': 0, 'with': 2, 'if': 3}  

7 单下划线、双下划线

http://stackoverflow.com/questions/1301346/what-is-the-meaning-of-a-single-and-a-double-underscore-before-an-object-name

single underscore : private

>>> class MyClass():
...     def __init__(self):
...             self.__superprivate = "Hello"
...             self._semiprivate = ", world!"
...
>>> mc = MyClass()
>>> print mc.__superprivate
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: myClass instance has no attribute '__superprivate'
>>> print mc._semiprivate
, world!
>>> print mc.__dict__
{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

8 字符串格式化:%和.format

sub1 = "python string!"
sub2 = "an arg"

a = "i am a %s" % sub1
b = "i am a {0}".format(sub1)

c = "with %(kwarg)s!" % {'kwarg':sub2}
d = "with {kwarg}!".format(kwarg=sub2)

print a    # "i am a python string!"
print b    # "i am a python string!"
print c    # "with an arg!"
print d    # "with an arg!"

"hi there %s" % (name,)   # supply the single argument as a single-item tuple

9 迭代器和生成器

10 *args and **kwargs

*args,例如,它可以传递任意数量的参数.  You would use *args when you're not sure how many arguments might be passed to your function

**kwargs,允许你使用没有事先定义的参数名.

*args表示任何多个无名参数，它是一个tuple；**kwargs表示关键字参数，它是一个dict。

https://stackoverflow.com/questions/3394835/args-and-kwargs/3394898#3394898

def foo(*args, **kwargs):
    print 'args = ', args
    print 'kwargs = ', kwargs
    print '---------------------------------------'

if __name__ == '__main__':
    foo(1,2,3,4)
    foo(a=1,b=2,c=3)
    foo(1,2,3,4, a=1,b=2,c=3)
    foo('a', 1, None, a=1, b='2', c=3)

输出结果如下：

args =  (1, 2, 3, 4) 
kwargs =  {} 
--------------------------------------- 
args =  () 
kwargs =  {'a': 1, 'c': 3, 'b': 2} 
--------------------------------------- 
args =  (1, 2, 3, 4) 
kwargs =  {'a': 1, 'c': 3, 'b': 2} 
--------------------------------------- 
args =  ('a', 1, None) 
kwargs =  {'a': 1, 'c': 3, 'b': '2'} 
---------------------------------------

# 当调用函数时你也可以用 * 和 ** 语法
def star_operation(name, value, count):
    print("Name: {}, Value: {}, Count: {}".format(name, value, count))

if __name__ == "__main__":

    # 它可以传递列表(或者元组)的每一项并把它们解包. 注意必须与它们在函数里的参数相吻合
    a_list = ["名字", "值", "计数器"]
    a_dict = {'a':1, 'b':2, 'b':3}
    star_operation(*a_list)
    star_operation(**a_dict.items())

输出：

Name: 名字, Value: 值, Count: 计数器

 

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-33-d38ee010e1b9> in <module>()
     10     a_dict = {'a':1, 'b':2, 'b':3}
     11     star_operation(*a_list)
---> 12     star_operation(**a_dict.items())

TypeError: star_operation() argument after ** must be a mapping, not list

**后面必须是 mapping，映射

11 面向切面编程AOP和装饰器

装饰器的作用就是为已经存在的对象添加额外的功能

# how decorators work

def makebold(fn):
    def wrapped():
        return "<b>" + fn() + "</b>"
    return wrapped
def makeitalic(fn):
    def wrapped():
        return "<i>" + fn() + "</i>"
    return wrapped

@makebold
@makeitalic
def hello():
    return "hello world"

print hello() ## returns  "<b><i>hello world</i></b>"

函数即是对象

def shout(word="yes")
    return word.capitalize()+"!"

print (shout())  # Yes!

# As an object, you can assign the function to a variable like any other object
scream = shout

# Notice we don't use parenthese: we are not calling the fuction,
# we are putting the function "shout" into the variable "scream".
# It means you can then call "shout" from "scream":
print (scream()) #  Yes!

# More than that, it means you can remove the old name 'shout',
# and the function will still be accessible from 'scream'

del shout
try:
    print(shout())
except NameError, e:
    print(e) #  "name 'shout' is not defined"

print(scream()) # Yes!

python: function can be defined inside another function / 函数能够定义在其他函数内。

Functions references:

　　1.can be assigned to a varible

　　2.can be defined in another function

def getTalk(kind="shout"):

    # We define functions on the fly
    def shout(word="yes"):
        return word.capitalize()+"!"

    def whisper(word="yes") :
        return word.lower()+"...";

    # Then we return one of them
    if kind == "shout":
        # We don't use "()", we are not calling the function, we are returning the function object
        return shout
    else:
        return whisper

# How do you use this strange beast?

# Get the function and assign it to a variable
talk = getTalk()      

# You can see that "talk" is here a function object:
print(talk)
#outputs : <function shout at 0xb7ea817c>

# The object is the one returned by the function:
print(talk())
#outputs : Yes!

# And you can even use it directly if you feel wild:
print(getTalk("whisper")())
#outputs : yes...

Decorator :

'wrappers', let you execute code before and after the function they decorate without modifying the function itself.

methods and functions are really the same. The only difference is that methods expect that their first argument is a reference to the current object (self).

方法和函数的唯一区别是，方法的第一个参数是对当前对象的引用，self. 　

Python自带的几个装饰器：property，staticmethod。。

Django 使用装饰器来管理缓存和权限控制。

Twisted 用来实现异步调用。

12 鸭子类型

鸭子类型是动态类型的一种风格，在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前 方法和属性的集合所决定。

例如，在不使用鸭子类型的语言中，我们可以编写一个函数，它接受一个类型为鸭的对象，并调用它的走和叫方法。在使用鸭子类型的语言中，这样的一个函数可以接受一个任意类型的对象，并调用它的走和叫方法。如果这些需要被调用的方法不存在，那么将引发一个运行时错误。任何拥有这样的正确的走和叫方法的对象都可被函数接受的这种行为引出了以上表述，这种决定类型的方式因此得名。

网络

5 Post和Get

区别：

一个用于获取数据，一个用于修改数据。