参考https://github.com/taizilongxu/interview_python#27-readreadline%E5%92%8Creadlines

1 Python的函数参数传递

看两个例子

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

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

所有的变量都可以理解是内存中一个对象的“引用”

通过id来看引用a的内存地址可以比较理解：

a = 1
def fun(a):
    print "func_in",id(a)   # func_in 41322472
    a = 2
    print "re-point",id(a), id(2)   # re-point 41322448 41322448
print "func_out",id(a), id(1)  # func_out 41322472 41322472
fun(a)
print a  # 1

可以看到，在执行完a = 2之后，a引用中保存的值，即内存地址发生变化，由原来1对象的所在的地址变成了2这个实体对象的内存地址。

而第2个例子a引用保存的内存值就不会发生变化：

a = []
def fun(a):
    print "func_in",id(a)  # func_in 53629256
    a.append(1)
print "func_out",id(a)     # func_out 53629256
fun(a)
print a  # [1]

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

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

【注】第二个函数内部调用的是可变对象的方法，如果改为赋值语句的话，就会等同于第一个函数效果，具体如下：

a = []
def fun(a):
    print("func_in",id(a))  # func_in 53629256
    a = [1, 2, 3]
    print("func_in", id(a)) # func_in 53629300
print("func_out",id(a))     # func_out 53629256
fun(a)
print(a)  # []

当然，很容易想到如果传入不可变类型的字符串形参，然后在函数值调用字符串方法修改字符串呢？放心，Python已经帮你想好了阻止这种现象的出现而违反这种约定的方法，因为字符串的方法必须重新赋值才对原有串起到修改的作用，如下，重新赋值就等同于上述函数一了，所以Python函数参数传递严格遵循引用规则。

a = "abc"
def fun(a):
    print("func_in",id(a))  # func_in 53629256
    a.replace("b", "d")     # a = a.replace("b", "d")
    print("func_in", id(a)) # func_in 53629256
print("func_out",id(a))     # func_out 53629256
fun(a)
print(a)  # abc

2 @staticmethod和@classmethod

Python其实有3个方法,即静态方法(staticmethod),类方法(classmethod)和实例方法,如下:

def foo(x):
    print "executing foo(%s)"%(x)

class A(object):
    def foo(self,x):
        print "executing foo(%s,%s)"%(self,x)

    @classmethod
    def class_foo(cls,x):
        print "executing class_foo(%s,%s)"%(cls,x)

    @staticmethod
    def static_foo(x):
        print "executing static_foo(%s)"%x

a=A()

这里先理解下函数参数里面的self和cls.这个self和cls是对类或者实例的绑定,对于一般的函数来说我们可以这么调用foo(x),这个函数就是最常用的,它的工作跟任何东西(类,实例)无关.
对于实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例,就是foo(self, x),为什么要这么做呢?因为实例方法的调用离不开实例,我们需要把实例自己传给函数,调用的时候是这样的a.foo(x)(其实是foo(a, x)).类方法一样,只不过它传递的是类而不是实例,A.class_foo(x)(其实是foo(A, x)).注意这里的self和cls可以替换别的参数,但是python的约定是这俩,还是不要改的好.
对于静态方法其实和普通的方法一样,不需要对谁进行绑定,唯一的区别是调用的时候需要使用a.static_foo(x)或者A.static_foo(x)来调用.

\	实例方法	类方法	静态方法
a = A()	a.foo(x)	a.class_foo(x)	a.static_foo(x)
A	不可用	A.class_foo(x)	A.static_foo(x)

3 类变量和实例变量

类变量

是可在类的所有实例之间共享的值（也就是说，它们不是单独分配给每个实例的）。例如下例中，num_of_instance 就是类变量，用于跟踪存在着多少个Test 的实例。

实例变量

实例化之后，每个实例单独拥有的变量。

class Test(object):  
    num_of_instance = 0  
    def __init__(self, name):  
        self.name = name  
        Test.num_of_instance += 1  
  
if __name__ == '__main__':  
    print Test.num_of_instance   # 0
    t1 = Test('jack')  
    print Test.num_of_instance   # 1
    t2 = Test('lucy')  
    print t1.name , t1.num_of_instance  # jack 2
    print t2.name , t2.num_of_instance  # lucy 2

【补充】

class Person:
    name="aaa"

p1=Person()
p2=Person()
p1.name="bbb"
print p1.name  # bbb
print p2.name  # aaa
print Person.name  # aaa

这里p1.name="bbb"实际是p1对象为自己创建了一个实例变量，之后p1.name中的name变量便不再是类属性，而是p1对象自己的实例属性，这种不通过init函数初始化实例属性的方法是不好的，一般慎用！
再看下面的例子:

class Person:
    name=[]

p1=Person()
p2=Person()
p1.name.append(1)
print p1.name  # [1]
print p2.name  # [1]
print Person.name  # [1]

类属性为可变变量，对象.类属性.方法()可以直接修改类属性(慎用)，这就回归了我们问题一的函数参数传递，一般修改类属性还是类名.类属性修改比较好。

4 Python自省

这个也是python彪悍的特性.

自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.比如：
type()---变量类型
dir()---返回对象的属性列表
getattr()---返回一个对象属性值（getattr(对象, 属性)）
hasattr()---判断对象是否包含某种方法（hasattr(list, 'append')）
isinstance()---判断一个对象是否是一个已知的类型（isinstance (a,int)）

a = [1,2,3]
b = {'a':1,'b':2,'c':3}
c = True
print type(a),type(b),type(c) # <type 'list'> <type 'dict'> <type 'bool'>
print isinstance(a,list)  # True

5 列表推导式和字典推导式

# 列表推导式
l= [squared(i) for i in range(30) if i % 3 is 0]
# 字典推导式
d = {key: value for (key, value) in iterable}

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

>>> 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内部的名字,用来区别其他用户自定义的命名,以防冲突，就是例如__init__(),__del__(),__call__()这些特殊方法
_foo:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式.不能用from module import * 导入，其他方面和公有一样访问；
__foo:这个有真正的意义:解析器用_classname__foo来代替这个名字,以区别和其他类相同的命名,它无法直接像公有成员一样随便访问,通过对象名._类名__xxx这样的方式可以访问.

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

.format在许多方面看起来更便利，对于%最烦人的是它无法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题:

"hi there %s" % name

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

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

但是有点丑。.format就没有这些问题。

"hi there {}".format(name)

8 迭代器和生成器

这里有个关于生成器的创建问题面试官有考： 问： 将列表生成式中[]改成() 之后数据结构是否改变？ 答案：是，从列表变为生成器

>>> L = [x*x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x*x for x in range(10))
>>> g
<generator object <genexpr> at 0x0000028F8B774200>

通过列表生成式，可以直接创建一个列表，将所有的值一次性加载到内存中。但如果创建一个包含百万元素的列表，会占用很大的内存空间，如：我们只需要访问前面的几个元素，后面大部分元素所占的空间都是浪费的。因此，没有必要创建完整的列表（节省大量内存空间）。
在Python中，我们可以采用生成器：边循环，边计算的机制—>generator，生成器是将列表生成式的[]改成(),不会将所有的值一次性加载到内存中,延迟计算,一次返回一个结果,它不会一次生成所有的结果,这对大数据量处理,非常有用。如：

sum(x for x in range(10000000000))
sum([x for x in range(10000000000)])

第一个几乎没什么内存占用,第二个内存占有很多。

yield实现简单的生成器

一般函数生成斐波那契数列

def create_num(n):
    a, b = 0, 1
    current_num = 0
    while current_num < n:
        print(a)
        a, b = b, a + b
        current_num += 1

create_num(5)
# 0
# 1
# 1
# 2
# 3

上述函数将数列直接打印，但是我们需要将这个数列变为一个可迭代对象，能够用for循环去遍历（当然我们可以将上述函数进行改造，使其生成一个列表，但如果是生成斐波那契数列前一百万项，那么这个列表将占用很大内存），可以使用yield将函数改为生成器，这样需要的时候再计算，不会占用很大空间，实现很简单，只需将create_num函数中的print语句改为yield语句即可使create_num函数变为一个生成器，代码如下：

def create_num(n):
    a, b = 0, 1
    current_num = 0
    while current_num < n:
        # print(a)
        yield a  # 如果一个函数中有yield，那么这个函数就不再是函数，而是一个生成器模板
        a, b = b, a + b
        current_num += 1

# 创建一个生成器对象
obj = create_num(5)
for num in obj:
    print(num)
# 0
# 1
# 1
# 2
# 3

9 *args 和 **kwargs

用args和kwargs只是为了方便并没有强制使用它们.
当你不确定你的函数里将要传递多少参数时你可以用args.例如,它可以传递任意数量的参数:

>>> def print_everything(*args):
        for count, thing in enumerate(args):
...         print '{0}. {1}'.format(count, thing)
...
>>> print_everything('apple', 'banana', 'cabbage')
0. apple
1. banana
2. cabbage

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

>>> def table_things(**kwargs):
...     for name, value in kwargs.items():
...         print '{0} = {1}'.format(name, value)
...
>>> table_things(apple = 'fruit', cabbage = 'vegetable')
cabbage = vegetable
apple = fruit

你也可以混着用.命名参数首先获得参数值然后所有的其他参数都传递给args和*kwargs.命名参数在列表的最前端.例如:

def table_things(titlestring, **kwargs)

args和kwargs可以同时在函数的定义中,但是args必须在kwargs前面.
当调用函数时你也可以用和*语法.例如:

>>> def print_three_things(a, b, c):
...     print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)
...
>>> mylist = ['aardvark', 'baboon', 'cat']
>>> print_three_things(*mylist)

a = aardvark, b = baboon, c = cat

就像你看到的一样,它可以传递列表(或者元组)的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.当然,你也可以在函数定义或者函数调用时用*.
当理解了这些，试试下面：

def print_three_things(name, *args, **kwargs):
    print(name)
    for elem in args:
        print(elem, end=" ")
    print()
    for k, v in kwargs.items():
        print('{0} = {1}'.format(k, v), end=",")
    print()

name = "xiaoming"
l = ['1', '2', '3']
d = {"age": 18, "height": "183cm"}
print_three_things(name, *l, **d)

# xiaoming
# 1 2 3 
# age = 18,height = 183cm,

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

AOP

简言之、这种在运行时，编译时，类和方法加载时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

我们管切入到指定类指定方法的代码片段称为切面，而切入到哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时再切入对象中去，从而改变其原有的行为。

优点是：这样的做法，对原有代码毫无入侵性

装饰器

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

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

函数就是对象.因此,对象:

• 可以赋值给一个变量
• 可以在其他函数里定义
• 函数可以返回另一个函数
• 函数作为参数传递

简单装饰器

def decorator(fun):
    def wrapper():
        print("方法执行前")
        fun()
        print("方法执行后")
    return wrapper

@decorator  
# 相当于my_fun = decorator(my_fun)
def my_fun():
    print("需要装饰的函数")

# 执行
my_fun()
# 输出:
# 方法执行前
# 需要装饰的函数
# 方法执行后

在装饰器函数里传入参数

def decorator(fun):
    print("装饰器内的语句")  # 此处会在装饰的时候执行
    def wrapper(arg1, arg2):
        print("接收到两个参数", arg1, arg2)
        fun(arg1, arg2)
    return wrapper

@decorator
def my_fun(first_name, last_name):
    print("我的名字是", first_name, last_name)
# 输出:
# 装饰器内的语句

my_fun("Peter", "Venkman")
# 输出:
# 接收到两个参数 Peter Venkman
# 我的名字是 Peter Venkman

把参数传给装饰器

def decorator_out(decorator_arg1, decorator_arg2):
    print("我是外层装饰器，接收参数", decorator_arg1, decorator_arg2)
    def decorator_in(fun):
        print("我是内层装饰器，接收到外层装饰器参数", decorator_arg1, decorator_arg2)
        def wrapper(function_arg1, function_arg2) :
            print("我是wrapper，可以接收所有参数，装饰器参数有{0} {1}，被装饰函数参数有{2} {3}" .format(decorator_arg1, decorator_arg2, function_arg1, function_arg2))
            return fun(function_arg1, function_arg2)
        return wrapper
    return decorator_in

@decorator_out("Leonard", "Sheldon")
# 相当于两步
# temp = decorator_out("Leonard", "Sheldon")
# my_fun = temp(my_fun)
def my_fun(function_arg1, function_arg2):
    print("我是被装饰的函数，只知道自己的参数: {0} {1}".format(function_arg1, function_arg2))
# 输出:
# 我是外层装饰器，接收参数 Leonard Sheldon
# 我是内层装饰器，接收到外层装饰器参数 Leonard Sheldon

my_fun("Rajesh", "Howard")
#输出:
#我是wrapper，可以接收所有参数，装饰器参数有Leonard Sheldon，被装饰函数参数有Rajesh Howard
# 我是被装饰的函数，只知道自己的参数: Rajesh Howard

装饰器的知识点

• 装饰器使函数调用变慢了.一定要记住.
• 装饰器不能被取消(有些人把装饰器做成可以移除的但是没有人会用)所以一旦一个函数被装饰了.所有的代码都会被装饰.
• Python自身提供了几个装饰器,像property, staticmethod.
• Django用装饰器管理缓存和视图的权限.

11 Python中重载

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

• 可变参数类型。
• 可变参数个数。

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

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

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

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

12 新式类和旧式类

新式类很早在2.2就出现了,所以旧式类完全是兼容的问题,Python3里的类全部都是新式类.这里有一个MRO(Method Resolution Order， 方法解析顺序)问题可以了解下(新式类继承是根据C3算法,旧式类是深度优先),<Python核心编程>里讲的也很多.

• 一个旧式类的深度优先的例子

class A():
    def foo1(self):
        print "A"
class B(A):
    def foo2(self):
        pass
class C(A):
    def foo1(self):
        print "C"
class D(B, C):
    pass

d = D()
d.foo1()

# A

按照经典类的查找顺序从左到右深度优先的规则，在访问d.foo1()的时候,D这个类是没有的..那么往上查找,先找到B,里面没有,深度优先,访问A,找到了foo1(),所以这时候调用的是A的foo1()，从而导致C重写的foo1()被绕过.
而这个问题在新式类中得到修复，新的对象模型采用的是从左到右，广度优先的方式进行查找，在访问d.foo1()的时候,D这个类是没有的..那么往上查找,先找到B,里面没有,广度优先,访问C,找到了foo1(),所以这时候调用的是C的foo1()，解决了C重写的foo1()被绕过的问题.

13 __new__和__init__的区别

这个new确实很少见到,先做了解吧.

• __new__是一个静态方法,而__init__是一个实例方法.
• __new__方法会返回一个创建的实例,而__init__什么都不返回.
• 只有在__new__返回一个cls的实例时后面的__init__才能被调用.
• 当创建一个新实例时调用__new__,初始化一个实例时用__init__.

【注】__metaclass__是创建类时起作用.所以我们可以分别使用__metaclass__,__new__和__init__来分别在类创建,实例创建和实例初始化的时候做一些小手脚.

14 单例模式

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例类的特殊类。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问，从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个，单例模式是最好的解决方案。
new()在init()之前被调用，用于生成实例对象。利用这个方法和类的属性的特点可以实现设计模式的单例模式。单例模式是指创建唯一对象，单例模式设计的类只能实例一个对象 这个绝对常考啊.绝对要记住1~2个方法,当时面试官是让手写的.

使用__new__方法

class Singleton(object):
    _instance = None
    def __new__(cls, *args, **kw):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

singleton = Singleton()

共享属性

创建实例时把所有实例的__dict__指向同一个字典,这样它们具有相同的属性和方法.

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

borg = Borg()

装饰器版本

def singleton(cls):
    instance = None
    def getinstance(*args, **kw):
        nonlocal instance  # 修改外部装饰器函数中变量instance，注意不能使用global
        if instance is None:
            instance = cls(*args, **kw)
        return instance
    return getinstance

@singleton
class MyClass:
  ...

import方法

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

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

my_singleton = My_Singleton()

# to use
from mysingleton import my_singleton

my_singleton.foo()

15 Python中的作用域

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

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

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

16 GIL(Global Interpreter Lock)全局解释器锁

• Python语言和GIL没有半毛钱关系，仅仅是因为历史原因在Cpython解释器(C语言编写的Python解释器)中，难以移除GIL
• 每个线程在执行过程中都需要先获取GIL，保证同一时刻只有一个线程可以执行代码
• 对于io密集型任务，python的多线程起到作用，因为遇到IO阻塞会自动释放GIL锁，但对于cpu(计算)密集型任务，python的多线程几乎占不到任何优势，还有可能因为争夺资源而变慢
• Python使用多进程可以利用多核CPU资源
• 多线程爬取比单线程性能有所提升，因为遇到IO阻塞会自动释放GIL锁
• 解决办法（多线程利用多核CPU资源）：
  (1)更换解释器，如Jpython(JAVA语言编写的Python解释器)
  (2)在使用多线程的地方使用其他语言编写程序

【注】Python中，对于io密集型任务，使用线程或协程解决，但对于cpu(计算)密集型任务，使用进程解决

17 进程、线程、协程

• 进程是资源分配的单位
• 线程是操作系统调度的单位
• 进程切换需要的资源很大，效率很低
• 线程切换需要的资源一般，效率一般（不考虑GIL）
• 协程切换任务资源很小，效率高
• 多进程，多线程根据CPU核数不一样可能是并行的，但协程是在一个线程中，所以一定是并发的

简单来说协程是进程和线程的升级版，进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间，而协程就是用户自己控制切换的时机，通过在线程中实现调度，避免了陷入内核级别的上下文切换造成的性能损失，进而突破了线程在IO上的性能瓶颈。

Python里最常见的yield就是协程的思想!

18 lambda匿名函数

lambda函数不需要专门的名字来说明，通常来完成简单的功能。

lambda x, y: x*y  # 函数输入是x和y，返回它们的积x*y

19 闭包

匿名函数、函数、闭包、对象当做实参时，有什么区别？

• 匿名函数能够完成基本的简单功能，传递的是这个函数的引用（只有功能）
• 函数能够完成较为复杂的功能，传递的是这个函数的引用（只有功能）
• 闭包能够完成较为复杂的功能，传递的是这个闭包中的函数以及数据（功能+数据），相比对象占用极少空间
• 对象封装较为复杂的数据和功能，传递很多数据和很多功能（功能+数据）

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

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

def line(k, b):
    def create_y(x):
        print(k * x + b)
    return create_y

# 第一条线 y = x + 2
line1 = line(1, 2)  # k = 1, b = 2会被保存在line1这个函数引用中，只需要赋值一次
line1(0)
line1(1)
line1(2)

# 第二条线 y = 2x + 3
line2 = line(2, 3) 
line2(0)
line2(1)
line2(2)

【注】如果闭包外层函数定义了临时变量，要在内层函数中进行修改，需用nonlocal关键字，如下：

def test1():
    a = 1
    def test2():
        nonlocal a
        print(a)
        a = 2
        print(a)
    return test2

test1()()
# 1
# 2

如果去掉上述代码中nonlocal a语句，那么程序在print(a)处就会报错，因为解释器会把内层test2函数中a = 2看成是定义的一个局部变量，而在定义局部变量a前打印其值会报变量未定义的错误，此处需留意，如问题14中使用装饰器实现单例模式就用到此技巧。

20 Python函数式编程

filter 函数

filter 函数的功能相当于过滤器。调用一个布尔函数bool_func来迭代遍历每个seq中的元素；返回一个使bool_seq返回值为true的元素的序列。

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

map函数

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

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

reduce函数

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

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

21 Python里的拷贝

引用、copy()、deepcopy()的区别

import copy
a = [1, 2, 3, 4, ['a', 'b']]  #原始对象

b = a  #赋值，传对象的引用
c = copy.copy(a)  #对象拷贝，浅拷贝
d = copy.deepcopy(a)  #对象拷贝，深拷贝

a.append(5)  #修改对象a
a[4].append('c')  #修改对象a中的['a', 'b']数组对象

结果：
a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
c =  [1, 2, 3, 4, ['a', 'b', 'c']]
d =  [1, 2, 3, 4, ['a', 'b']]

上述语句可理解为下图：

• b = a，赋值，将b直接指向a指向的地址
• c = copy.copy(a)，浅拷贝，重新指向一块地址，只拷贝a顶层对象，对子对象不拷贝，继续指向原来的引用
• d = copy.deepcopy(a)，深拷贝，重新指向一块地址，将a无论是顶层对象还是子对象都复制一份

【注】对于不可变类型，如：

import copy
a = (1, 2, (3, 4)) 

b = a
c = copy.copy(a) 
d = copy.deepcopy(a) 

id(a), id(b), id(c), id(d)相同，都是直接传递引用，因为a为不可变类型，并且子对象都是不可变类型
而对于：

import copy
a = (1, 2, [3, 4]) 

b = a
c = copy.copy(a) 
d = copy.deepcopy(a) 

id(a), id(b), id(c)相同，都是直接传递引用，id(d)不同，因为虽然a为不可变类型，但子对象中有可变类型，深拷贝会自动检查子对象中是否有可变类型，若有，则重新指向一块地址，将所有对象复制一份

22 Python内存管理机制

(1)Python的存储问题

• 由于python中万物皆对象，所以python的存储问题是对象的存储问题，并且对于每个对象，python会分配一块内存空间去存储它。在定义一个变量时，变量指向这一对象，其实该变量只是该对象的一个引用，保存该对象地址
• 对于整数和短小的字符等，python会执行缓存机制，即将这些对象进行缓存，不会为相同的对象分配多个内存空间
• 容器对象，如列表、元组、字典等，存储的其他对象，仅仅是其他对象的引用，即地址，并不是这些对象本身

(2)引用计数

当一个对象有新的引用时，它的引用计数就会增加，当引用它的对象被删除，它的引用计数就会减少，引用计数为0时，该对象生命就结束了。

(3)垃圾回收

• 当内存中有不再使用的部分时，垃圾收集器就会把他们清理掉。它会去检查那些引用计数为0的对象，然后清除其在内存的空间。
• 垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0)。

(4)分代技术

• Python同时采用了分代(generation)回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。
• Python将所有的对象分为0，1，2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0，1，2，即对所有对象进行扫描。

23 read,readline和readlines

• read()：一次性读取整个文件内容。推荐使用read(size)方法，size越大运行时间越长
• readline()：每次读取一行内容。内存不够时使用，一般不太用
• readlines()：一次性读取整个文件内容，并按行返回到list，方便我们遍历

24 Python2和3的区别

(1)Unicode编码

• Python2默认ASCII编码方式，但是ASCII编码无法对中文等字符进行有效编码
• Python3默认的编码方式是UTF-8

(2)print

print语句没有了，取而代之的是print()函数

(3)xrange

• 在 Python2中有xrange()和range()，前者是创建一个生成器，后者则是直接生成一个列表
• 在 Python3中，只有range()，功能就是Python2中xrange() 那样创建一个生成器，不再存在xrange()函数

(4)数据类型

Python3去除了long类型，现在只有一种整型——int，但它的行为就像Python2中的long

25 常用正则表达式（匹配邮箱）

举例：zhang_san-001@gmail.com

(1)分析邮件名称部分

• 26个大小写英文字母表示为a-zA-Z
• 数字表示为0-9
• 下划线表示为_
• 中划线表示为-
• 由于名称是由若干个字母、数字、下划线和中划线组成，所以需要用到+表示多次出现

根据以上条件得出邮件名称表达式：[a-zA-Z0-9_-]+

(2)分析域名部分

一般域名的规律为“N级域名.三级域名.二级域名.顶级域名”，比如qq.com、www.qq.com、mp.weixin.qq.com、12-34.com.cn，分析可得域名类似** .** .** .**组成。

• **部分可以表示为[a-zA-Z0-9_-]+
• .**部分可以表示为\.[a-zA-Z0-9_-]+
• 多个.**可以表示为(\.[a-zA-Z0-9_-]+)+

综上所述，域名部分可以表示为[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

(3)最终表达式：

由于邮箱的基本格式为“名称@域名”，需要使用^匹配邮箱的开始部分，用$匹配邮箱结束部分以保证邮箱前后不能有其他字符，所以最终邮箱的正则表达式为：^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$