Python的易混地带

710661809

　　每门编程语言都有易混淆的部分，下面列举出一些Python的易混淆知识点。

• 
  ＝＝ 和 is 的区别
  
  在Python中,”==” 操作符测试值的相等性； “is”表达式测试对象的一致性，即是否指向同一个对象。
  list1 = [1,('a',3)]
  list2 = [1,('a',3)]
  list1 == list2, list1 is list2 #(True,False)
  　　说明：list1和list2通过了”==”测试 (他们的值相等，因为它们的所有内容都是相等的)，但是is测试却失败了(它们是两个不同的对象，因此有不同的内存区域
  
  s1="spam"
  s2="spam"
  s1 == s2,s1 is s2 #(True,True)
  　　说明：或许你会惊讶，觉得这组得到的结果应该和上组得到的结果一致。事实上，内存中只有一个字符串’spam’供s1和s2共享。这个主要是因为在Python内部会暂时存储并重复使用短字符串。也就是说当创建短字符串的时候会首先到字符串的内存区域查找是否已经有该字符串相等的值存在，如果有则会指向该内存区域，否则重新开辟内存。
  
  s1='a b'
  s2='a b'
  s1 == s2,s1 is s2 #(True,False)
  　　说明：惊讶再次产生，你或许会质疑这不和上组的一样嘛，为啥结果不一样了？ 其实上组的说明部分已经说了，Python只是暂时存储短字符串，像这样中间有空格的字符串和较长的字符串，Python是不会存储的。也就是说，像这样的字符串创建时，Python会直接开辟内存
  
  
• 
  Python中的作用域
  
  Python 中，一个变量的作用域总是由在代码中被赋值的地方所决定的。
  
  
  
  • 函数定义了本地作用域，而模块定义的是全局作用域。
    
    如果想要在函数内定义全局作用域，需要加上global修饰符。
    
  • 变量名解析：LEGB原则
    
    当在函数中使用未认证的变量名时，Python搜索４个作用域[本地作用域(L)，之后是上一层结构中def或者lambda的本地作用域(E),
    
    之后是全局作用域(G)，最后是内置作用域(B)］并且在第一处能够找到这个变量名的地方停下来。如果变量名在整个的搜索过程中
    
    都没有找到，Python就会报错。
    补：上面的变量规则只适用于简单对象，当出现引用对象的属性时，则有另一套搜索规则:属性引用搜索一个或多个对象，而不是作用域，并且有可能涉及到所谓的"继承"
    
  • 访问全局变量演示
    # thismod.py
    var = 99
    def local():
    var = 0
    def glob1():
    global var
    var += 1
    def glob2():
    var = 0
    imp<wbr>ort thismod
    thismod.var += 1
    def glob3():
    var = 0
    imp<wbr>ort sys
    glob = sys.modules['thismod']
    glob.var += 1
    def test():
    print var
    local();glob1();glob2();glob3();
    print var</wbr></wbr>
    　　使用交互式测试该程序
    
    >>>imp<wbr>ort thismod
    &gt;&gt;&gt;thismod.test()
    99
    102</wbr>
    
  • 嵌套作用域演示
    def f1():
    x = 88
    def f2():
    print x
    f2()
    f1()    # 88
    
  • 作用域与带有循环变量的默认参数相比较
    
    不指定默认值的情况
    >>>def makeActions():
    ... acts = []
    ... for i in range(5):
    ... acts.append(lambda x: i ** x)
    ... return acts
    ...
    >>>acts = makeActions()
    >>>acts[0]
    <function <lambda> at 0x7f86aaf4c758>
    >>> acts[0](2)
    16
    >>> acts[2](2)
    16
    >>> acts[4](2)
    16
    　　指定默认值的情况：
    
    >>> def makeActions():
    ... acts = []
    ... for i in range(5):
    ... acts.append(lambda x, i=i: i ** x)
    ... return acts
    ...
    >>> acts = makeActions()
    >>> acts[0](2)
    0
    >>> acts[2](2)
    4
    >>> acts[4](2)
    16
    　　疑答：嵌套作用域中的变量在嵌套的函数被调用时才进行查找，所以它们实际上记住的是同样的值(在最后一次循环迭代中循环变量的值)。指定默认值可记住每一个循环变量的值。
    
    
  
  
  
• 
  imp<wbr>ort与reload的区别</wbr>
  
  
  
  • imp<wbr>ort 只导入一次，而reload可以在不中止Python程序的情况下，多次载入
    <pre>---- 编写一个模块文件changer.py ----
    message = "first version"def printer():
    print message
    ------- the end --------&gt;&gt;&gt; imp<wbr>ort changer
    &gt;&gt;&gt; changer.printer()
    first version不要关掉解释器，现在在另一个窗口编辑该模块文件
    message = "After version"def printer():
    print 'reloaded:',message然后回到交互模式
    &gt;&gt;&gt; imp<wbr>ort changer
    &gt;&gt;&gt; changer.printer()
    first version
    &gt;&gt;&gt; reload(changer)
    &lt;module 'changer' from 'changer.py'&gt;
    &gt;&gt;&gt; changer.printer()
    reloaded: After version</wbr></wbr></pre>
    </wbr>
    
  • reload没有传递性：reload加载模块时只重新加载该模块，而不会加载该模块imp<wbr>ort的其他模块</wbr>
    
  
  
  
• 
  经典类与新式类的区别
  
  在Python 2.2中，引入一种新的类，称为"新式"类，之前提到的类则称为"经典"类。新式类在语法和行为上，几乎完全和经典类兼容。他们主要的差异在于新式类从内置类型创建子类。如果没有恰当的内置类型可用，新的内置名称object就可以作为新式类的超类。因为基类A继承于object，而所有继承于object的类都将是新式类。这种继承方式的查找还是挺有意思的，我本人是比较喜欢新式类的继承方式，因为毕竟如果在继承类中有对于基类中对象的修改，那么这种修改应该是有意义的，而经典类的继承方式就有可能因为基类顺序的问题将这种有意义的修改屏蔽掉，所以还是新式类会比较好一些。而对于python语言的发展来说，python3.0以后所有的类继承方式都将是新式类的继承，也就说所有的类都将是新式类，所以这种继承方式也是我们有必要去掌握的。
  
  
  
  • 经典类继承搜索程序是绝对深度优先
    经典类: 搜索顺序是(D,B,A,C)
    >>> class A: attr = 1
    ...
    >>> class B(A): pass
    ...
    >>> class C(A): attr = 2
    ...
    >>> class D(B,C): pass
    ...
    >>> x = D()
    >>> x.attr
    1
    
  • 新式类继承搜索程序是宽度优先
    新式类：搜索顺序是(D,B,C,A)
    >>> class A(object): attr = 1
    ...
    >>> class B(A): pass
    ...
    >>> class C(A): attr = 2
    ...
    >>> class D(B,C): pass
    ...
    >>> x = D()
    >>> x.attr
    2
    
  
  
  
• 
  类变量与实例变量的区别
  当类为self属性赋值时，会填入实例对象。即，属性最后会位于实例的属性命名空间字典内，而不是类的。实例对象的命名空间保存了数据，会随实例的不同而不同，而self正是进入其命名空间的钩子。
  >>> class person:
  ... def name(self, name):
  ... self.name = name
  ...
  >>> person.__dict__
  {'__module__': '__main__', 'name': <function name at 0x7f28e96a1cf8>, '__doc__': None}
  >>> p1 = person()
  >>> p1.__dict__
  {}
  >>> p1.name('zhangsan')
  >>> p1.__dict__
  {'name': 'zhangsan'}
  >>> p2 = person()
  >>> p2.__dict__
  {}
  >>> p2.name('lisi')
  >>> p2.__dict__
  {'name': 'lisi'}
  >>> person.__dict__
  {'__module__': '__main__', 'name': <function name at 0x7f28e96a1cf8>, '__doc__': None}
  
• 
  静态方法、类方法以及实例方法的区别
  在Python2.2中，在类中定义方法是可能的，不需要实例就能够调用它：静态方法的运作差不多就像类中的简单无实例函数，而类方法传递的是类而不是实例。名为staticmethod和classmethod的特定的内置函数，必须在类中调用，才能使这些方法模式有效。虽然这个功能是伴随新式类增加的，但静态和类方法也能用于经典类。
  定义方式，传入的参数，调用方式都不相同。
  
  
  
  • staticmethod 不需要传入self和cls对象，只有一般的参数。可以通过实例或类对象进行调用。
    
  • classmethod需要传入cls对象，可以通过实例和类对象进行调用。
    
  • 实例method需要传入self实例对象，可以通过实例对象调用，用类调用时需要额外传入 实例对象。
    
  
  >>> class Multi:
  ... def imeth(self, x):
  ... print self, x
  ... def smeth(x):
  ... print x
  ... def cmeth(cls, x):
  ... print cls, x
  ... smeth = staticmethod(smeth) #make smeth a static method
  ... cmeth = classmethod(cmeth) #make cmeth a class method
  ...
  >>> obj = Multi()
  >>> obj.imeth(1) #Normal call, through instance
  <__main__.Multi instance at 0x7fc537cc6170> 1
  >>> Multi.imeth(obj,2) #Normal call, through class
  <__main__.Multi instance at 0x7fc537cc6170> 2
  >>> Multi.smeth(3) #Static call, through class
  3
  >>> obj.smeth(4) #Static call, through instance
  4
  >>> Multi.cmeth(5) #Class call, through class
  __main__.Multi 5
  >>> obj.cmeth(6) #Class call, through instance
  __main__.Multi 6
  　　注: Python自动把类（而不是实例）传入类方法第一个（最左侧）参数中。