Python刷题-5

1、当一个嵌套函数在其外部区域引用了一个值时，该嵌套函数就是一个闭包，以下代码输出值为：16
def adder(x):            
    def wrapper(y):           # 第二步
        return (x + y)        # 第五步
    return (wrapper)          # 第三步
# adder5是对wrapper的引用   此时x等于5
adder5 = adder(5)   #返回了 wrapper ，且x=5；  第一步 
print(adder5(adder5(6)))       # 第四步
闭包：如果一个函数内部又定义了一个函数，就把外部的函数称为外函数，内部的函数称为内函数。如果内函数引用了外函数的变量，而外函数返回内函数（引用），就把这种形式称之为 闭包。并且当外函数结束时会将变量绑定给内函数。
adder(5) = wrapper(x=5, y)
adder5 = wrapper(x=5, y)
adder5(6) = wrapper(x=5, 6) = 5 + 6 = 11
adder5(adder5(6)) = adder(11) = wrapper (x =5, 11) = 5 + 11 = 16
# 外部函数确定了x的值为5，内部函数的值为6，所以第一次计算结果为11，第二次计算，还是在x为5的前提下，需要在11的基础上再加5
那什么是闭包呢，一言以蔽之：一个持有外部环境变量的函数就是闭包。
因为wrapper是闭包 所以adder5返回的是wrapper函数 接下来adder5(6) 返回的是11=5+6 同理 再调用一次就是16 = 11+5

2、如下程序会打印多少个数:
# python2：9个
# python3:10个
k = 1000
sum = 0
while k > 1:
    sum += 1
    print(k)
    k = k/2
print(sum)
python2 整数除法/时，会取整的，所以应该是9个。
python3 除法/，结果是浮点的，所以是10个
# 1000
# 500.0
# 250.0
# 125.0
# 62.5
# 31.25
# 15.625
# 7.8125
# 3.90625
# 1.953125
# 10
# 代码运行应该是10个，python是不会自动取整的

3、What gets printed?   6  
kvps = { '1' : 1, '2' : 2 }
theCopy = kvps.copy()
kvps['1'] = 5
sum = kvps['1'] + theCopy['1']
print sum
# object.copy()和copy.copy(object)一样是浅拷贝，深拷贝只有copy.deepcopy(object)
# 在 Python2 和 Python3 中，copy() 方法的意义相同，均为返回一个浅复制的 dict 对象，而浅复制是指只拷贝父对象，不会拷贝对象的内部的子对象，即两个 dict 父对象 kvps 与 theCopy 相互独立，但对它们内部子对象的引用却是共享的，所以 kvps['1'] 的改变不影响 theCopy['1'] 的值（因为改变的是父对象的值）。
顺便一提，深复制是指完全拷贝父对象与子对象，即都相互独立。
注意，这里的子对象不是子类的对象，而是在父对象中的二级对象。

4、What gets printed?   4  
counter = 1
def doLotsOfStuff():
    global counter
    for i in (1, 2, 3):
        counter += 1
doLotsOfStuff()
print(counter)
# 当内部作用域想修改外部变量时，需要使用global声明。
# 考察 global 的意义，即在局部作用域 doLotsOfStuff() 函数中，声明对全局作用域中的 counter 变量的引用。
在变量前加global代表修改的是全局变量， 原counter=1,三次循环+1故＝4， 函数执行完，全局变量被修改＝4

5、有如下函数定义，执行结果正确的是？   foo(3)=18;foo(2)=12
def dec(f):
    n = 3
    def wrapper(*args,**kw):
        return f(*args,**kw) * n
    return wrapper
@dec                # 先执行dec，将 @dec 下面的 函数 作为dec()的参数
def foo(n):
    return n * 2
foo(2)
解析：
装饰器（Decorator）本身是一个函数，目的是在不改变待装饰函数代码的情况下，增加额外的功能，装饰器的返回值是已装饰的函数对象。
以foo(2)语句为例，上述代码等价于：
def dec(f):
    n = 3
    def wrapper(*args,**kw):
        return f(*args,**kw) * n
    return wrapper
def foo(n):
    return n * 2
foo=dec(foo)
foo(2)
由此可见，@dec的作用是把原foo函数（待装饰函数）赋值给dec函数（装饰器），然后将返回值wrapper函数（已装饰函数）重新赋值给foo函数。因此，foo（2）语句实际执行情况是：
def wrapper (2):
  return foo(2) * 3
注：以上代码是为了方便理解，直接将实参n=2代入函数定义中，语法上并无实际意义。
显然，用数学符号表示的话，函数执行结果为foo（2）= wrapper（2）= foo（2）*3= 2*2*3=12，其中前面的foo函数是已装饰函数，后面的foo函数是原来的待装饰函数。By the way，函数参数中的*args代表可变参数，**kw代表关键字参数。
@dec 装饰器，先执行dec(), 并将 @dec 下面的 函数 作为dec()的参数。 （装饰器的作用：为已经存在的对象添加额外的功能）
foo(n) = n * 2 * 3
foo(2) == (2*2)*3 == 12
foo(3) == (3*2)*3 == 18

1、object #公用方法
2、_object #半保护
                 #被看作是“protect”，意思是只有类对象和子类对象自己能访问到这些变量，
                  在模块或类外不可以使用，不能用’from module import *’导入。
                 #__object 是为了避免与子类的方法名称冲突， 对于该标识符描述的方法，父
                  类的方法不能轻易地被子类的方法覆盖，他们的名字实际上是
                  _classname__methodname。
3、_ _ object    #全私有，全保护
                       #私有成员“private”，意思是只有类对象自己能访问，连子类对象也不能访
                          问到这个数据，不能用’from module import *’导入。
4、_ _ object_ _     #内建方法，用户不要这样定义