四

列表表达式

[expression for item1 in iterable1 if condition1
            for item2 in iterable2 if condition2
            for item3 in iterable3 if condition3
            ....
            for itemN in iterableN if conditionN
 ]

等价于:
s = []
for item1 in iteration1:
    if condition1:
        for item2 in iteration2:
            if condition2:
                ...
                for itemN in iterableN:
                    if conditionN:
                        s.append(expression)

生成器表达式

(expression for item1 in iterable1 if condition1
            for item2 in iterable2 if condition2
            for item3 in iterable3 if condition3
            ....
            for itemN in iterableN if conditionN
 )
#生成一个生成器对象

eval和exec类似 执行一个字符串表达式，并返回结果
他们会在调用者的命名空间执行。他们接受1到2个参数分别用作函数执行的全局和局部命名空间
如果省略一个或两个命名空间，那么函数就会使用全局或局部空间的当前值。
（如下代码是同时存在的）
x = 7
y = 10
a = exec('print(x,y)')  #7 10

globals={ 'x':1,'y':2}
a = exec('print(x,y)',globals)   #1 2

globals={ 'x':1,'y':2}
locals = {'x':4,'y':5}
a = eval('print(x,y)',globals,locals)  #4 5

在给exec()或者是eval()函数传递字符串时，解析器首先会将这个字符串编译为字节码，这个过程非常消耗资源，所以如果代码要反复执行，最好先编译，再执行。

compile(str,filename,kind)

str 需要编译的字符串，或者说：需要执行的字符串。

filename 定义该字符串的文件

kind 编译代码的类型 single 代表一条语句。exec 代表一组语句。 eval 代表一个表达式

可以将compile函数返回的代码传递给eval()或者是exec()

s = 'print("hello")'
c = compile(s,'','single')
exec(c)  #hello
eval(c)   #hello

s = '3*5+4*7'
c = compile(s,'','eval')
a = eval(c)
print(a)  #43


s = "for i in range(3):print(i)"
c = compile(s,'','exec')
eval(c)  #0 1 2

抽象基类

定义抽象基类需要使用abc模块该模块定义了一个元类（ABCMeta）和一组装饰器（

abstractmethod,abstractproperty,abstractstaticmethod,abstractclassmethod

）

要定义抽象类，需要将元类设置为ABCMeta，因为抽象类的实现离不开元类。四个装饰器的作用是指定抽象类的子类必须要实现的方法、属性、静态方法、类方法。

抽象类不可以实例化，否则会引发 TypeError错误

from abc import ABCMeta,abstractmethod,abstractproperty,abstractstaticmethod,abstractclassmethod
class Foo(metaclass = ABCMeta):
    @abstractmethod
    def name(self,x):  #子类必须实现该方法，但是子类参数可以不是 x，
        pass

    @abstractproperty 
    def age(self):    #子类必须实现该属性
        pass

    
    def sex(self):  #子类不强制实现
        pass
 


foo = Foo() #TypeError: Can't instantiate abstract class Foo with abstract methods age, name #实例化抽象类报错


class Stup(Foo):
    def cla(self):
        print('cla')

    @property
    def age(self):
        print('hello')

    def name(self,name1):  # 抽象类不会对参数进行一致性检查，抽象类用的是x，子类用的是 name1
        print('bye',name1)

子类如果没有实现 age 和name ，那么报错和上面那个错误一样。但是如果
没有实现sex 则没问题


fool = Stup()

fool.cla() #'cla'
fool.age    #'hello'
fool.name('liming') #'bye liming'


已有类注册，   已有类注册抽象类不会对已有类进行方法属性等之类的限定。用处只是在进行类型检查（isinstance和issubclass）
class Bea:
    def beat(self):
        print('bea')

Foo.register(Bea)
b = Bea()
b.beat()  #'bea'

print(isinstance(b,Foo)) #True
print(issubclass(Bea,Foo)) #True
    

python 中的and从左到右计算表达式，若所有值均为真，则返回最后一个值，若存在假，返回第一个假值。

or也是从左到有计算表达式，返回第一个为真的值。

IDLE 1.2.4
>>>'a'and'b'
'b'
>>>''and'b'
''
>>>'a'or'b'
'a'
>>>''or'b'
'b'

类似三目表达式的用法：bool? a : b
>>> a ='first'
>>> b ='second'
>>>1and a or b   # 等价于 bool = true时的情况
'first'
>>>0and a or b   # 等价于 bool = false时的情况
'second'
>>> a =''
>>>1and a or b   # a为假时，则出现问题
'second'
>>>(1and[a]or[b])[0]# 安全用法，因为[a]不可能为假，至少有一个元素
''
>>>