其它

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

#使用__new__方法，可以决定返回哪个对象，也就是在创建对象之前。__init__是创建对象之后调用的。

 

5.全局和局部变量

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

f2()
f1()
f2()

#结果：
9
9

 

使用global关键字声明：

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

def f2():
    print(num)

f2()
f1()
f2()

#结果：
9
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))


#结果
6

 

9. 性能

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

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

print(strtest(3))  #firstXXX

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