标签：role   close   masm   foj   sel   blog   oat   tag   glin   

• os模板提供了一种方便的使用操作系统函数的方法
• sys模板可供访问由解释器使用或维护的变量和与解释器交互的函数

5 Python是如何进行内存管理的

• 一个对象分配一个新名称
  
  
• 将其放入一个容器中（如列表、元组或字典）
  
  

• 使用del语句对对象别名显示的销毁
  
  
• 引用超出作用域或被重新赋值
  
  

• 引用计数：Python在内存中存储每个对象的引用计数，如果计数变成0，该对象就会消失，分配给该对象的内存就会释放出来。
• 标记-清除：一些容器对象，比如list、dict、tuple，instance等可能会出现引用循环，对于这些循环，垃圾回收器会定时回收这些循环（对象之间通过引用（指针）连在一起，构成一个有向图，对象构成这个有向图的节点，而引用关系构成这个有向图的边）。
• 分代收集：Python把内存根据对象存活时间划分为三代，对象创建之后，垃圾回收器会分配它们所属的代。每个对象都会被分配一个代，而被分配更年轻的代是被优先处理的，因此越晚创建的对象越容易被回收。
  
  

• Pymalloc机制：为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
  
  
• 对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

6 写一个函数, 输入一个字符串, 返回倒序排列的结果

7 按升序合并如下两个list, 并去除重复的元素

Python pickle模块数据对象持久化操作

 

 1 Python 单例模式

 

 

使用模块

其实，Python 的模块就是天然的单例模式，因为模块在第一次导入时，会生成 .pyc 文件，当第二次导入时，就会直接加载 .pyc 文件，而不会再次执行模块代码。因此，我们只需把相关的函数和数据定义在一个模块中，就可以获得一个单例对象了。如果我们真的想要一个单例类，可以考虑这样做：

 

1 2 3 4 5 6

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

将上面的代码保存在文件 mysingleton.py 中，然后这样使用：

 

1 2 3

from mysingleton import my_singleton   my_singleton.foo()

 

使用 new

为了使类只能出现一个实例，我们可以使用 new 来控制实例的创建过程，代码如下：

 

class Singleton(object):

    def __new__(cls, *args, **kwargs):

        if not hasattr(cls, ‘_instance‘):

            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)

        return cls._instance

 

 

class Foo(Singleton):

    pass

 

foo1 = Foo()

foo2 = Foo()

 

print foo1 is foo2  # True

 

使用装饰器

我们知道，装饰器（decorator）可以动态地修改一个类或函数的功能。这里，我们也可以使用装饰器来装饰某个类，使其只能生成一个实例，代码如下：

from functools import wraps

def singleton(cls):

    instances = {}

    @wraps(cls)

    def wrapper(*args, **kwargs):

        if cls not in instances:

            instances[cls] = cls(*args, **kwargs)

        return instances[cls]

 

    return wrapper

 

 

@singleton

class Foo(object):

    pass

 

foo1 = Foo()

foo2 = Foo()

 

print foo1 is foo2   # True

 

在上面，我们定义了一个装饰器 singleton，它返回了一个内部函数 wrapper，该函数会判断某个类是否在字典 instances 中，如果不存在，则会将 cls 作为 key，cls(args, *kw) 作为 value 存到 instances 中，否则，直接返回 instances[cls]。

 

 

使用 metaclass

元类（metaclass）可以控制类的创建过程，它主要做三件事：

 

拦截类的创建

修改类的定义

返回修改后的类

使用元类实现单例模式的代码如下：

 

元类（参考： 深刻理解Python中的元类 ）是用于创建类对象的类，类对象创建实例对象时需要一定会调用 __call__ 方法，因此在调用 __call__ 时候保证始终只创建一个实例即可， type 是python中的一个元类。

 

class Singleton(type):

    def __call__(cls, *args, **kwargs):

        if not hasattr(cls, ‘_instance‘):

            cls._instance = super(Singleton, cls).__call__(*args, **kwargs)

        return cls._instance

 

 

class Foo(object):

    __metaclass__ = Singleton

 

 

foo1 = Foo()

foo2 = Foo()

 

print foo1 is foo2  # True

 

 

• Python 的模块是天然的单例模式，这在大部分情况下应该是够用的，当然，我们也可以使用装饰器、元类等方法

 

 

2 闭包

 

     闭包可以实现先将一个参数传递给一个函数，而并不立即执行，以达到延迟求值的目的。

满足以下三个条件：

• 必须有一个内嵌函数；
• 内嵌函数必须引用外部函数中变量；
• 外部函数返回值必须是内嵌函数。

 

def delay_fun(x, y):

    def caculator():

        return x+y

    return caculator

 

print(‘返回一个求和的函数，并不求和‘)

msum = delay_fun(3,4)

print(‘调用并求和:‘)

print(msum())

 

高阶函数可以接收函数做参数

什么是lambda表达式？它有什么好处？

在介绍高阶函数的用处之前，还需要了解另一个概念，没错，就是匿名函数。Python语言支持使用lambda 表达式作为匿名函数。

 

来看重点代码lambda x: x * x，这行代码就是一个完整的函数。使用lambda声明该行代码是一个lambda表达式，紧跟在后面的是函数的参数，多个参数用逗号,分割；然后使用冒号:分割开参数和函数体。

 

 

 

简单来说，lambda表达式通常是当你需要使用一个函数，但是又不想费脑袋去命名一个函数的时候使用，也就是通常所说的匿名函数。

 

lambda表达式一般的形式是：关键词lambda后面紧接一个或多个参数，紧接一个冒号“：”，紧接一个表达式。lambda表达式是一个表达式不是一个语句。

 

想更加详细的了解Python中的Lamdba表达式可以点击这里：Lambda 表达式有何用处？如何使用？ - Python

 

 

3 装饰器

 

装饰器是一个工厂函数，接受一个函数作为参数，然后返回一个新函数，其闭包中包含被装饰的函数。有了装饰器，可以提取大量函数中与本身功能无关的类似代码 ( 这块在Flask中用于定义路由的@app.route，就是一个很好的例子)，达到代码重用的目的。

 

装饰器本质上是一个Python函数，它可以让其它函数在不作任何变动的情况下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景。比如：插入日志、性能测试、事务处理、缓存、权限校验等。

有了装饰器我们就可以抽离出大量的与函数功能无关的雷同代码进行重用。

有关于具体的装饰器的用法看这里：装饰器 - 廖雪峰的官方网站

 

from functools  import wraps

def deco(func):

    @wraps(func)

    def warpper(*args, **kwargs):

        print(‘start‘)

        func(*args, **kwargs)

        print(‘end‘)

    return warpper

 

@deco

def myfunc(parameter):

    print("run with %s" % parameter)

 

myfunc("something")

 

 

4 迭代器和生成器

 

迭代器：是访问集合元素的一种方式，从集合的第一个元素开始访问，直到所有元素被访问结束。其优点是不需要事先准备好整个迭代过程中的所有元素，仅在迭代到某个元素时才开始计算该元素。适合遍历比较巨大的集合。__iter__()：方法返回迭代器本身， __next__()：方法用于返回容器中下一个元素或数据。

 

生成器：

生成器其实是一种特殊的迭代器，不过这种迭代器更加优雅。它不需要再像上面的类一样写__iter__()和__next__()方法了，只需要一个yiled关键字。

带有yield的函数不再是一个普通函数，而是一个生成器。当函数被调用时，返回一个生成器对象。不像一般函数在生成值后退出，生成器函数在生成值后会自动挂起并暂停他们的执行状态。

 

• 容器是一系列元素的集合，str、list、set、dict、file、sockets对象都可以看作是容器，容器都可以被迭代（用在for，while等语句中），因此他们被称为可迭代对象。
  
  
• 可迭代对象实现了__iter__方法，该方法返回一个迭代器对象。
  
  
• 迭代器持有一个内部状态的字段，用于记录下次迭代返回值，它实现了__next__和__iter__方法，迭代器不会一次性把所有元素加载到内存，而是需要的时候才生成返回结果。
  
  
• 生成器是一种特殊的迭代器，它的返回值不是通过return而是用yield。
  
  

‘‘‘迭代器‘‘‘

print(‘for x in iter([1, 2, 3, 4, 5]):‘)

for x in iter([1, 2, 3, 4, 5]):

    print(x)

 

‘‘‘生成器‘‘‘

def myyield(n):

    while n>0:

        print("开始生成...:")

        yield n

        print("完成一次...:")

        n -= 1

for i in myyield(4):

    print("遍历得到的值:",i)

 

 

生成器表达式

 

(i for i in range(5))

// 返回迭代器

<generator object <genexpr> at 0x7ff3e8f0d960>

列表解析，返回list

 

[i for i in range(5)]//

返回list

[0,

1, 2, 3, 4]

 

 

4 生成器

 

生成器不会把结果保存在一个系列中，而是保存生成器的状态，在每次进行迭代时返回一个值，直到遇到StopIteration异常结束。

 

生成器语法

 

首先，用[]推导出来的是迭代器（Iterables）。用()推导出来的是生成器（Generators）。

 

生成器表达式： 通列表解析语法，只不过把列表解析的[]换成()

生成器表达式能做的事情列表解析基本都能处理，只不过在需要处理的序列比较大时，列表解析比较费内存。

 

 

>>> gen = (x**2 for x in range(5))

>>> gen

<generator object <genexpr> at 0x0000000002FB7B40>

>>> for g in gen:

...   print(g, end=‘-‘)

...

0-1-4-9-16-

>>> for x in [0,1,2,3,4,5]:

...   print(x, end=‘-‘)

...

0-1-2-3-4-5-

 

生成器函数： 在函数中如果出现了yield关键字，那么该函数就不再是普通函数，而是生成器函数。

 

但是生成器函数可以生产一个无线的序列，这样列表根本没有办法进行处理。

 

yield 的作用就是把一个函数变成一个 generator，带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator。

 

 

题外话： 生成器是包含有__iter()和next__()方法的，所以可以直接使用for来迭代，而没有包含StopIteration的自编Iter来只能通过手动循环来迭代。

 

 

看到上面的结果，现在你可以很有信心的按照Iterator的方式进行循环了吧！

 

在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。

 

 

1. 按照鸭子模型理论，生成器就是一种迭代器，可以使用for进行迭代。
2. 第一次执行next(generator)时，会执行完yield语句后程序进行挂起，所有的参数和状态会进行保存。再一次执行next(generator)时，会从挂起的状态开始往后执行。在遇到程序的结尾或者遇到StopIteration时，循环结束。

 

 

def fib(max):

    n, a, b = 0, 0, 1

    while n < max:

        print(b)   # yield b

        a, b = b, a + b

        n = n + 1

    return ‘done’

 

 

例如对于大文件内搜索关键词，generator 和 yield 的组合更灵活：

def search(keyword, filename):

    # Temporarily read the file

    f = open(filename, ‘r‘)

    # Loop through the file by line

    for line in f:

        # Return the line with keyword

        if keyword in line:

            yield line

    f.close()

Python面试知识点汇总

标签：role   close   masm   foj   sel   blog   oat   tag   glin   

原文地址：http://www.cnblogs.com/Bob-FD/p/7133660.html