Python基础知识

 with语句：如果with语句或语句块中发生异常，会调用默认的异常处理器处理，但文件还是会正常关闭

　　这看起来充满魔法，但不仅仅是魔法，Python对with的处理还很聪明。基本思想是with所求值的对象必须有一个 __enter__() 方法，一个 __exit__() 方法。紧跟with后面的语句被求值后，返回对象的 __enter__() 方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后，将调用前面返回对象的 __exit__() 方法。下面有例子介绍with具体运行过程：

# 这是with的具体运行过程
class Sample:
    def __enter__(self):
        print "In __enter__()"
        return "Foo"

    def __exit__(self, type, value, trace):
        print "In __exit__()"
def get_sample():
    return Sample()
with get_sample() as sample:
    print "sample:", sample

输出结果：
In __enter__()
sample: Foo
In __exit__()

 python assert（断言）：

　　assert断言是声明其布尔值必须为真的判定，如果发生异常就说明表达示为假。可以理解assert断言语句为 raise-if-not ，用来测试表示式，其返回值为假，就会触发异常

assert  表达式
assert  表达式，表达式     （多个表达式）
assert  表达式，‘错误信息’   （添加错误信息参数）
# 下面有一个求质数的例子返回True或False：
def isPrime(n):
    assert n >= 2, 'n必须大于等于2'
    from math import sqrt
    for i in range(2, int(sqrt(n))+1):
        if n % i == 0:
            return False
    return True

print(isPrime(5))   #  传值5>2为质数
print(isPrime(4))   #  传值4>2不为质数
print(isPrime(1))   #  传值1<2

运行结果：
True   
False
Traceback (most recent call last):
  File "E:/My_yanjiu/凤凰财经.py", line 13, in <module>
    print(isPrime(1))
  File "E:/My_yanjiu/凤凰财经.py", line 3, in isPrime
    assert n >= 2, 'n必须大于等于2'
AssertionError: n必须大于等于2    # assert 断言错误信息

 try...except...finally语句:

　　当 try 语句执行时发生异常，回到try语句层，寻找后面是否有 except 语句。找到except语句后，会调用这个自定义的异常处理器。except将异常处理完毕后，程序继续往下执行。 finally 语句表示，无论异常发生与否，finally中的语句都要执行。

try：
    pass
except：
    pass
finally:
    pass

 copy()与deepcopy()的区别:

　　 copy 拷贝一个对象，但是对象的属性还是引用原来的， deepcopy 拷贝一个对象，把对象里面的属性也做了拷贝，deepcopy之后完全是另一个对象了。下面有代码解释：

import copy

a = ['a', 'b', 'c', [1, 2]]
b = copy.copy(a)
c = copy.deepcopy(a)
a[3].append('d')

print(a)
print(b)
print(c)
b[3].append('f')
print(a)
print(b)
print(c)

运行结果：
['a', 'b', 'c', [1, 2, 'd']]
['a', 'b', 'c', [1, 2, 'd']]
['a', 'b', 'c', [1, 2]]
['a', 'b', 'c', [1, 2, 'd', 'f']]
['a', 'b', 'c', [1, 2, 'd', 'f']]
['a', 'b', 'c', [1, 2]]

 　　这里再给做点小补充：对于简单的 object，用 shallow copy 和 deep copy 没区别。复杂的 object， 如 list 中套着 list 的情况，shallow copy 中的 子list，并未从原 object 真的「独立」出来。

Python装饰器：http://www.cnblogs.com/Egbertbaron/p/7242445.html

　　装饰器本质上是一个Python函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象。它经常用于有切面需求的场景，比如：插入日志、性能测试、事务处理、缓存、权限校验等场景。有了装饰器，就可以抽离出大量与函数功能本身无关的雷同代码并继续重用。

简述__new__和__init__的区别

　　__new__:创建对象是调用，会返回当前对象的一个实例。通常用于控制生成一个新实例的过程。它是类级别的方法。

　　__init__:创建完对象后调用，对当前对象的一些实例初始化，无返回值。通常用于初始化一个新实例，控制这个初始化的过程，比如添加一些属性， 做一些额外的操作，发生在类实例被创建完以后。它是实例级别的方法。

光看概念不好理解，下面我们写代码帮助大家理解下：

class A():
    def __new__(cls):
        print('__new__')

    def __init__(self):
        print('__init__')

A()

运行结果：
__new__

　　上面的代码可以简单的看出来如果 __new__() 和 __init__() 同时存在优先调用__new__。并且__init__没有返回值。

　　下面我们说说__new__()和__init__()之间有什么关系：如果__new__返回一个对象的实例，会隐式调用__init__。如果__new__()不返回一个对象的实例，__init__()不会被调用。

class A(object):
    def __new__(cls):
        object = super(A, cls).__new__(cls)
        print('__new__')
        return object

    def __init__(self):
        print('__init__')

A()
   
运行结果：
__new__
__init__

垃圾回收

　　1、引用计数

　　　　python里每一个东西都是对象，他们的核心就是一个结构体：PyObject，PyObject是每个对象必有的内容，其中ob_refcnt就是作为引用计数，他的的ob_refcnt就会增加，当引用他的对象被删除，它的ob_refcnt就会减少。

　　　　优点：

　　　　　　简单

　　　　　　实时性：一旦没有引用，内存就直接释放了。不用像其他机制等到特定时机。实时性还带来一个好处：处理回收内存的时间分摊到 平时。

　　　　缺点：

　　　　　　维护引用计数消耗资源

　　　　　　循环引用

　　2、标记-清楚机制

　　3、分带回收技术

函数是编程

　　匿名函数

Python的作用域以及Python搜索变量的顺序