Python编程：10个面试常问的问题

def class_test():
    class A(object):
        def show(self):
            print("class A")
        def hello(self):
            print("hello")
    class B(A):
        def show(self):
            print("class B")
    b =B()
    b.show()
    b.hello()
    # 调用类A的show方法
    b.__class__ = A
    b.show()  
    # __class__方法指向了类对象，只用给他赋值类型A，
    # 然后调用方法show，但是用完了记得修改回来。
    """OUT
    class B
    hello
    class A
    """

def call_test():
    class A(object):
        def __init__(self, a, b):
            self._a = a
            self._b = b
        def myprint(self):
            print("a =", self._a, "b =", self._b)
        # 为了能让对象实例能被直接调用，需要实现__call__方法
        def __call__(self, num):
            print("call:", num)
    a = A(1, 2)
    a.myprint()
    a(11)
    """OUT:
    a = 1 b = 2
    call: 11
    """

def new_test():
    class A(object):
        def __init__(self):
            print("A init")
        def foo(self):
            print("A foo")
    class B(object):
        def __init__(self, a):
            print("B init")
        # 使用__new__方法，可以决定返回那个对象，也就是创建对象之前，
        # 这个可以用于设计模式的单例、工厂模式。
        # __init__是创建对象是调用的。
        def __new__(cls, a):
            print("B new")
            if a>10:
                return super(B, cls).__new__(cls)
            return A()
        def foo(self):
            print("B foo")
    b1 = B(5)
    b1.foo()
    b2 = B(20)
    b2.foo()
    """OUT:
    B new
    A init
    A foo
    B new
    B init
    B foo
    """

def list_test():
    lst = [i for i in range(5)]
    print(lst)  # [0, 1, 2, 3, 4]
    list1 = [i for i in lst if i >2]
    print(list1)  # [3, 4]
    list1 = [i**2 for i in lst if i >2]
    print(list1)  # [9, 16]
    dict1 = {x: x**2 for x in (2, 4, 6)}
    print(dict1)  # {2: 4, 4: 16, 6: 36}
    dict2 = {x: "item" + str(x**2) for x in (2, 4, 6)}
    print(dict2)  # {2: 'item4', 4: 'item16', 6: 'item36'}
    set1 = {x for x in "hello world" if x not in "low level"}
    print(set1)  # {'r', 'h', 'd'}

def global_test():
    num = 10
    def f1():
        num = 20
        print("f1")
    def f2():
        print(num)
    f2()  # 10    
    f1()  # f1
    f2()  # 10
    # num不是个全局变量，所以每个函数都得到了自己的num拷贝，
    # 如果你想修改num，则必须用global关键字声明。
    global n
    n = 10
    def f3():
        global n  # 说明使用全局变量a，不说明则是局部变量
        n = 30
    def f4():
        print(n)
    f4()  # 10
    f3()
    f4()  # 30

def swap_test():
    a = 1 
    b= 2
    print("a =", a, "b =", b)
    a, b = b, a  # 一行代码交换两个变量值
    print("a =", a, "b =", b)

def default_test():
    class A(object):
        def __init__(self):
            print("init")
        # 当fn1方法传入参数时，我们可以给mydefault方法增加一个*args不定参数来兼容。
        def mydefault(self, *args):
            print("mydefault",args[0])
        # 方法__getattr__只有当没有定义的方法调用时，才调用他。
        def __getattr__(self, name):
            print("name:", name)
            return self.mydefault
    a = A()
    a.f1(0)
    a.f2(1, 2)
    a.f3(2, 3, 4)

# 一个包里有三个模块，mod1.py, mod2.py, mod3.py，
# 但使用from demopack import *导入模块时，只有mod1、mod3被导入了。
# 增加__init__.py文件，并在文件中增加：
# __all__ = ['mod1','mod3']
from demopack import *   # import * only allowed at module level
def packge_test():
    pass
"""OUT
mod1
mod3
"""

# 函数，接收整数参数n，返回一个函数，
# 函数的功能是把函数的参数和n相乘并把结果返回。
def closure_test():
    def add(num):
        def add_num(val):
            return num + val
        return add_num
    a = add(5)
    print(a(5))

def performance_test():
    import time
    def str_test(num):
        start = time.time()
        string = ""
        for i in range(num):
            string += str(i)
        end = time.time()
        print("str_time:", end - start)
        # print(string)
    def append_test(num):
        start = time.time()
        lst=[]
        for i in range(num):
            lst.append(str(i))
        end = time.time()
        print("append_time:", end - start)
        # print("".join(lst))
    num = 1000000
    str_test(num)  # str_time: 1.926110029220581
    append_test(num)  # append_time: 0.3060173988342285
    # str_time / append_time = 6.29411934275007
    # mygod!!! 时间相差6倍
    # python的str是个不可变对象，每次迭代，都会生成新的str对象来存储新的字符串
    # num越大，创建的str对象越多，内存消耗越大。
def main():
    performance_test()
if __name__ == '__main__':
    main()