Python常见语言特性

本文借鉴了http://python.jobbole.com/85231/，然后总结了自己的见解

Python语言特性

1 Python的函数参数传递

看两个例子:

Python

1 2 3 4 5

a = 1 def fun ( a ) :      a = 2 fun ( a ) print a    # 1

Python

1 2 3 4 5

a = [ ] def fun ( a ) :      a . append ( 1 ) fun ( a ) print a    # [1]

所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。

这里记住的是类型是属于对象的，而不是变量。而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples, 和numbers是不可更改的对象，而list,dict等则是可以修改的对象。(这就是这个问题的重点)

当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有半毛关系了.所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉.而第二个例子就不一样了,函数内的引用指向的是可变对象,对它的操作就和定位了指针地址一样,在内存里进行修改.

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

2 Python中的元类(metaclass)

3 实例、静态、类方法

4 类属性和实例属性

5 Python自省

这个也是python彪悍的特性.

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

6 推导式

7 Python中单下划线和双下划线

Python

1 2 3 4 5 6 7 8 9 10 11 12 13 14

>>> 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!' }

__foo__

:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突.

_foo

:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.

__foo

:这个有真正的意义:解析器用

_classname__foo

来代替这个名字,以区别和其他类相同的命名.

详情见 http://www.zhihu.com/question/19754941

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

.format在许多方面看起来更便利.对于

%

它无法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题:

Python

1	"hi there %s" % name

但是,如果name恰好是(1,2,3),它将会抛出一个TypeError异常.为了保证它总是正确的,你必须这样做:

Python

1	"hi there %s" % ( name , )    # 提供一个单元素的数组而不是一个参数

你为什么不用它?

• 为了和Python2.5兼容(譬如logging库建议使用

  %

  (issue #4))

https://blog.csdn.net/wo_renfanzi/article/details/51477796

9 迭代器和生成器

10 函数参数

        pass

用

*args

和

**kwargs

只是为了方便并没有强制使用它们.

当你不确定你的函数里将要传递多少参数时你可以用

*args

.例如,它可以传递任意数量的参数:

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

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

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

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

12 面向对象三大特性

多态 通俗的就是鸭子模型：

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

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

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

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

13 Python中重载

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

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

1. 可变参数类型。
2. 可变参数个数。

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

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

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

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

14 新式类和旧式类

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

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

15 

__new__

和

__init__

的区别

1. __new__

   是一个静态方法,而

   __init__

   是一个实例方法.

2. __new__

   方法会返回一个创建的实例,而

   __init__

   什么都不返回.
3. 只有在

   __new__

   返回一个cls的实例时后面的

   __init__

   才能被调用.
4. 当创建一个新实例时调用

   __new__

   ,初始化一个实例时用

   __init__

   .

16 单例模式

这个绝对常考啊.绝对要记住1~2个方法,当时面试官是让手写的.

1 使用

__new__

方法

Python

1 2 3 4 5 6 7 8 9

class Singleton ( object ) :      def __new__ ( cls , * args , * * kw ) :          if not hasattr ( cls , '_instance' ) :              cls . _instance = super ( Singleton , cls ). __new__ ( cls , * args , * * kw )          return cls . _instance   class MyClass ( Singleton ) :      a = 1

2 共享属性

创建实例时把所有实例的

__dict__

指向同一个字典,这样它们具有相同的属性和方法.

Python

1 2 3 4 5 6 7 8 9

class Borg ( object ) :      _state = { }      def __new__ ( cls , * args , * * kw ) :          ob = super ( Borg , cls ) . __new__ ( cls , * args , * * kw )          ob . __dict__ = cls . _state          return ob   class MyClass2 ( Borg ) :      a = 1

3 装饰器版本

Python

1 2 3 4 5 6 7 8 9 10 11

def singleton ( cls , * args , * * kw ) :      instances = { }      def getinstance ( ) :          if cls not in instances :              instances [ cls ] = cls ( * args , * * kw )          return instances [ cls ]      return getinstance   @ singleton class MyClass :    . . .

4 import方法

作为python的模块是天然的单例模式

Python

1 2 3 4 5 6 7 8 9 10 11

# mysingleton.py class My_Singleton ( object ) :      def foo ( self ) :          pass   my_singleton = My_Singleton ( )   # to use from mysingleton import my_singleton   my_singleton . foo ( )

17 Python中的作用域

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

当 Python 遇到一个变量的话他会按照这样的顺序进行搜索：

本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）

18 GIL线程全局锁

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

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

详情见我之前的博文

20 闭包

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

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

1. 必须有一个内嵌函数
2. 内嵌函数必须引用外部函数中的变量
3. 外部函数的返回值必须是内嵌函数

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

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

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

21 lambda函数

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

22 Python函数式编程

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

python中函数式编程支持:

filter 函数的功能相当于过滤器。调用一个布尔函数

bool_func

来迭代遍历每个seq中的元素；返回一个使

bool_seq

返回值为true的元素的序列。

Python

1 2 3 4

>>> a = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ] >>> b = filter ( lambda x : x > 5 , a ) >>> print b >>> [ 6 , 7 ]

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

Python

1 2 3

>>> a = map ( lambda x : x * 2 , [ 1 , 2 , 3 ] ) >>> list ( a ) [ 2 , 4 , 6 ]

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

Python

1 2	>>> reduce ( lambda x , y : x * y , range ( 1 , 4 ) ) 6

23 Python里的拷贝

赋值：给对象创建一个新的引用，修改其中任意一个变量都会影响到另一个。

单层非嵌套

的可变类型的数据类型来说，深浅拷贝都是一样的拷贝了其内容。

多层嵌套     

浅拷贝：多层的嵌套可变类型的数据，它只是拷贝了一层的引用，没有拷贝其深层内容。

深拷贝：它拷贝是递归式的拷贝，拷贝的是目的对象的所有内容。

24 Python垃圾回收机制

Python GC主要使用引用计数（reference counting）来跟踪和回收垃圾。在引用计数的基础上，通过“标记-清除”（mark and sweep）解决容器对象可能产生的循环引用问题，通过“分代回收”（generation collection）以空间换时间的方法提高垃圾回收效率。

1 引用计数

PyObject是每个对象必有的内容，其中

ob_refcnt

就是做为引用计数。当一个对象有新的引用时，它的

ob_refcnt

就会增加，当引用它的对象被删除，它的

ob_refcnt

就会减少.引用计数为0时，该对象生命就结束了。

优点:    1.简单   2.实时性

缺点:     1.维护引用计数消耗资源   2.循环引用

2 标记-清除机制

基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记，然后清扫一遍内存空间，把所有没标记的对象释放。

3 分代技术

分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量。

Python默认定义了三代对象集合，索引数越大，对象存活时间越长。

举例：

当某些内存块M经过了3次垃圾收集的清洗之后还存活时，我们就将内存块M划到一个集合A中去，而新分配的内存都划分到集合B中去。当垃圾收集开始工作时，大多数情况都只对集合B进行垃圾回收，而对集合A进行垃圾回收要隔相当长一段时间后才进行，这就使得垃圾收集机制需要处理的内存少了，效率自然就提高了。在这个过程中，集合B中的某些内存块由于存活时间长而会被转移到集合A中，当然，集合A中实际上也存在一些垃圾，这些垃圾的回收会因为这种分代的机制而被延迟。

25 Python的is

is是对比地址,==是对比值

26 read,readline和readlines

• read 读取整个文件
• readline 读取下一行,使用生成器方法
• readlines 读取整个文件到一个迭代器以供我们遍历

27 Python2和3的区别

推荐：《Python 2.7.x 和 3.x 版本的重要区别》

联系方式

QQ：1217675462

欢迎交流