python琐碎的知识积累,闭包

1. 以下的代码的输出将是什么? 说出你的答案并解释。

     

class Parent(object):
    x = 1

class Child1(Parent):
    pass

class Child2(Parent):
    pass

print Parent.x, Child1.x, Child2.x
Child1.x = 2
print Parent.x, Child1.x, Child2.x
Parent.x = 3
print Parent.x, Child1.x, Child2.x

输出结果

1 1 1
1 2 1
3 2 3

这个原因很简单，如果子类么有的话，你就用父类的，如果子类重写的话，那么父类在怎么改变都都对我子类么有影响啊

2 ：以下的代码的输出将是什么? 说出你的答案并解释？

   

def div1(x,y):
    print("%s/%s = %s" % (x, y, x/y))

def div2(x,y):
    print("%s//%s = %s" % (x, y, x//y))

div1(5,2)
div1(5.,2)
div2(5,2)
div2(5.,2.)

 

答案输出：

5/2 = 2
5.0/2 = 2.5
5//2 = 2
5.0//2.0 = 2.0

python没有明确的类型说明，如果你输入的是两个整数，默认按整数处理

3：以下的代码的输出将是什么? 说出你的答案并解释？

def extendList(val, list=[]):
    list.append(val)
    return list

list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList("a")

print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3

输出结果

list1 = [10, "a"]
list2 = [123]
list3 = [10, "a"]

新的默认列表仅仅只在函数被定义时创建一次。随后当 extendList 没有被指定的列表参数调用的时候，其使用的是同一个列表。这就是为什么当函数被定义的时候，表达式是用默认参数被计算，而不是它被调用的时候。

4  刚刚理解了下Python的闭包，感觉还是很难理解的

闭包（Closure）是词法闭包（Lexical Closure）的简称，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，即使已经离开了创造它的环境也不例外。所以，有另一种说法认为闭包是由函数和与其相关的引用环境组合而成的实体。其实给个函数更容易理解

def make_adder(addend):
    def adder(augend):
        return augend + addend
    return adder

p = make_adder(23)
q = make_adder(44)

print p(100)
print q(100)

输出 123  144 

我们发现,make_adder是一个函数,包括一个参数addend,比较特殊的地方是这个函数里面又定义了一个新函数,这个新函数里面的一个变量正好是外部make_adder的参数.也就是说,外部传递过来的addend参数已经和adder函数绑定到一起了,形成了一个新函数,我们可以把addend看做新函数的一个配置信息,配置信息不同,函数的功能就不一样了,也就是能得到定制之后的函数.
再看看运行结果,我们发现,虽然p和q都是make_adder生成的,但是因为配置参数不同,后面再执行相同参数的函数后得到了不同的结果.这就是闭包.

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

f1()，f2()和f3()结果实际上都是9，在闭包中，我认为就是在函数的嵌套中，for循环先执行完，然后在执行def f（）因此得到的结果都是9，原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。

返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。算法

5 函数作为返回值

>>> def calc_sum(*args):
...    ax = 0
...    for n in args:
...       print type(args) 
...       ax = ax + n
...    return ax
... 

>>> print calc_sum(1,2,3,4)
<type 'tuple'>
<type 'tuple'>
<type 'tuple'>
<type 'tuple'>
10

可变参也就是放在一个元组里面，对于这个函数你就是传数进去立马出结果，实际上这个可以让结果延迟，只需要返回值放在函数中，当你调用函数的时候才有结果

>>> def lazy_sum(*args):
...    def sum():
...       ax = 0
...       for n in args:
...          ax = ax + n
...       return ax
...    return sum
... 
>>> f = lazy_sum(1,3,4,5,6)
 <function sum at 0x7f396b7aa8c0>
>>> f()
19