其它

1.  补充：__iter__

class Foo(object):

    def __iter__(self):
        # return iter([11,22,33,44,55])   # 迭代器 __next__

        yield 1  # 生成器，也有__next__
        yield 2
        yield 3


obj = Foo()

for item in obj:
    print(item)

 

from types import FunctionType


class RowItems(object):
    def __init__(self, option, x1, x2, x3):
        self.option = option
        self.x1 = x1
        self.x2 = x2
        self.x3 = x3

    def __iter__(self):
        yield 1
        yield 11
        yield 111
        yield 1111
        yield 11111
        yield 111111
        yield 1111111


class Option(object):
    def __init__(self, name_or_func, status):
        self.name_or_func = name_or_func
        self.status = status

    def is_func(self):
        if isinstance(self.name_or_func, FunctionType):
            return True


def func(configs):
    for option in configs:
        if option.is_func():
            data_list = None
        else:
            data_list = RowItems(option, 11, 22, 33)

        yield data_list


list_filter_config = [
    Option('name', True),
    Option('email', True),
]

"""
如何打印？
    yield 1  
    yield 11
    yield 111
"""

result = func(list_filter_config)
for v in result:

    for j in v:  # 循环 v，即可
        print(j)

 

2. 对象是否可以可以通过索引取值

class Foo(object):
    def __getitem__(self, item):
        return 123

obj = Foo()
print(obj[1])   #123

 

3. 类继承

如何调用类A的show方法？

class A(object):
    def show(self):
        print 'base show'

class B(A):
    def show(self):
        print 'derived show'
 
obj = B()
obj.show()

 

方法：

obj = B()
obj.__class__=A
obj.show()
 
#__class__方法指向了类对象，将给它赋值类型A，然后调用A的show方法

 

4. new和int

下面代码输出了什么？

class B(object):
    def fn(self):
        print('B fn')

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


class A(object):
    def fn(self):
        print('A fn')

    def __new__(cls, a):
        print('NEW:', a)
        if a > 10:
            return super(A, cls).__new__(cls)
        return B()

    def __init__(self, a):
        print('INIT:', a)


a1 = A(5)
a1.fn()
a2 = A(20)
a2.fn()


#结果
'''

NEW: 5
B INIT
B fn
NEW: 20
INIT: 20
A fn

'''

 

5. 全局和局部变量

num = 9
def f1():
    num=20
    
def f2():
    print(num)

f2()
f1()
f2()

#结果：
9

 

使用global关键字声明：

num = 9
def f1():
    global num
    num=20

def f2():
    print(num)

f2()
f1()
f2()

#结果：
20

 

6. 默认方法

class A(object):
    def __init__(self, a, b):
        self.a1 = a
        self.b1 = b

    def mydefault(self):
        print('default')


a1 = A(10, 20)
a1.fn1()
a1.fn2()
a1.fn3()

方法 fn1/fn2/fn3,都未定义，添加代码。让没有定义的方法都调用mydefault函数，上面代码应该输出：

default
default
default

 

具体操作：

class A(object):
    def __init__(self, a, b):
        self.a1 = a
        self.b1 = b

    def mydefault(self):
        print('default')

    def __getattr__(self, item):
        return self.mydefault


a1 = A(10, 20)
a1.fn1()
a1.fn2()
a1.fn3()

 

补充：__getattr__只有当没有定义的方法调用时，才是调用它。当fn1方法传入参数时，可以给mydefault方法增加一个 *args不定参数来兼容。

class A(object):
    def __init__(self, a, b):
        self.a1 = a
        self.b1 = b

    def mydefault(self,*args):
        print('default:' + str(args[0]))

    def __getattr__(self, item):
        return self.mydefault


a1 = A(10, 20)
a1.fn1(33)
a1.fn2('hello')
a1.fn3(999)

# #结果：
default:33
default:hello
default:999

 

7. 包管理

一个包里有三个模考，mod1.py,mod2.py,mod3.py,但使用from demopack import * 导入模块时，如何保证只有mod1,mod3被导入。

具体操作：

#增加__init__.py文件，并在文件中增加：
   __all___ = ['mod1','mod3']

 

8. 闭包

写一个函数，接收整数参数n,返回一个函数，函数的功能是把 函数的参数和n 相乘并把结果放回

def func(f):
    def inner_func(n):
        return f * n
    return inner_func

num = func(3)
print(num(2))

 

9. 性能

解析下面的代码慢在那里：

def strtest(num):
    str = 'first'
    for i in range(num):
        str+='X'
    return str

print(strtest(3))  #firstXXX


#j解析： Python的str是个不可变对象，每次迭代，都会生成新的str对象来存储新的字符串，num越大，创建的str对象越多
，内存消耗越大。