再谈抽象

时间 2019-11-11

标签再谈抽象繁體版

原文原文链接

多态

1 from random import choice
2 x = choice(['hello, world!',[1,2,'e','e',4]])
3 print(x.count('e'))
 执行结果

经过打印一条消息来指出对象的长度
1 def length_message(x):
2     print("the length of", repr(x), "is", len(x))
3 length_message('xiaoming')
执行结果

建立自定义类

 对foo调用set_name和greet是，foo都会做为第一个参数自动传递给它们
 1 class person:
 2 
 3     def set_name(self, name):
 4         self.name = name
 5 
 6     def get_name(self):
 7         return self.name
 8 
 9     def greet(self):
10         print("hello, world! I'm {}.".format(self.name))
11 foo = person()
12 bar = person()
13 foo.set_name('haha xiaoming')
14 bar.set_name('hehe xiaogang')
15 foo.greet()
16 bar.greet()
执行结果

属性、函数和方法express

指定超类dom

 Filter是一个过滤序列的通用类。实际上，它不会过滤掉任何东西
 1 class Filter:
 2     def init(self):
 3         self.blocked = []
 4     def filter(self, sequence):
 5         return [x for x in sequence if x not in self.blocked]
 6  7 f = Filter()
 8 f.init()
 9 a=f.filter([1,2,3])
10 print(a)
 执行结果

 Filter类的用途在于可用做其余类（如将'SPAM'从序列中过滤掉的SPAMFilter类）的基类（超类）.
 1 class Filter:
 2     def init(self):
 3         self.blocked = []
 4     def filter(self, sequence):
 5         return [x for x in sequence if x not in self.blocked]
 6 
 7 class SPAMFilter(Filter):
 8     def init(self):
 9         self.blocked = ['SPAM']
10 s = SPAMFilter()
11 s.init()
12 a = s.filter(['SPAM','SPAM','SPAM','SPAM','eggs','bacon','SPAM'])
13 print(a)
   执行结果

深刻探讨继承函数

 1 class Filter:
 2     def init(self):
 3         self.blocked = []
 4     def filter(self, sequence):
 5         return [x for x in sequence if x not in self.blocked]
 6 
 7 class SPAMFilter(Filter):
 8     def init(self):
 9         self.blocked = ['SPAM']
10 s = SPAMFilter()
11 s.init()
12 s.filter(['SPAM','SPAM','SPAM','SPAM','eggs','bacon','SPAM'])
13 a=issubclass(SPAMFilter, Filter)       （要肯定一个类是不是另外一个类的子类issubclass，可以使用内置方法issubclass）
14 print(a)
   执行结果

a=issubclass(Filter, SPAMFilter)
print(a)

若是你有一个类，并想知道它的基类，可访问其特殊属性__bases__
a=SPAMFilter.__bases__
print(a)
b=Filter.__bases__
print(b)

s = SPAMFilter()
a=isinstance(s, SPAMFilter)
b=isinstance(s, str)
print(a)
print(b)

多个超类spa

   子类TalkingCalculator自己无所做为，其全部的行为都是从超类哪里继承的.关键是经过从Calculator那里继承calculate，并从Talker那里
 继承talker,这被称为多重继承
 1 class Calculator:
 2     def calculate(self, expression):
 3         self.value = eval(expression)
 4 
 5 class Talker:
 6     def talk(self):
 7         print('Hi, my value is', self.value)
 8 
 9 class TalkingCalculator(Calculator, Talker):
10     pass
11 tc = TalkingCalculator()
12 tc.calculate('1 + 2 * 3')
13 tc.talk()
   执行结果

接口和内省 3d

   一般，你要求对象遵循特定的接口（即实现特定的方法），但若是须要，也可很是灵活的踢出要求：不是直接调用方法的并期待一切顺利，而是检查所需的
 方法是否存在；若是不存在，就改弦易辙
 1 class Calculator:
 2     def calculate(self, expression):
 3         self.value = eval(expression)
 4 
 5 class Talker:
 6     def talk(self):
 7         print('Hi, my value is', self.value)
 8 
 9 class TalkingCalculator(Talker, Calculator):
10     pass
11 tc = TalkingCalculator()
12 a=hasattr(tc,'talk')
13 b=hasattr(tc, 'fnord')
14 print(a)
15 print(b)
   执行结果

抽象基类 code

抽象类（即包含抽象方法的类）最重要的特征是不能实例化
1 from abc import ABC, abstractmethod
2 
3 class Talker(ABC):
4     @abstractmethod
5     def talk(self):
6         pass
7 Talker()
执行结果

   如今实例化没有任何问题，这是抽象基类的主要用途，并且只有在这种情形下使用isinstance才是稳当的：若是先检查给定的实例确实是Talker对象，就能
 相信这个实例在须要的状况下有方法tale
 1 from abc import ABC, abstractmethod
 2 
 3 class Talker(ABC):
 4     @abstractmethod
 5     def talk(self):
 6         pass
 7 class knigget(Talker):
 8     def talk(self):
 9         print("Ni!")
10 k = knigget()
11 a=isinstance(k, Talker)
12 print(a)
13 k.talk()
   执行结果

函数描述orm

callable(object) 判断对象是否可调用的（如是不是函数或方法）对象

getattr(object,name[,default]) 获取属性的值，还可提供默认值blog

hasattr(object, name) 肯定对象是否有指定的属性继承

isinstance(object, class) 肯定对象是不是指定类的实例

issubclass(A, B) 肯定A是不是B的子类

random.choice(sequence) 从一个非空序列中随机的选择一个元素

setattr(object, name, value) 将对象的指定属性设置为指定的值

type(object) 返回对象的类型