一、封装之property
@property把一个函数伪装成一个数据类型
@伪装成数据的函数名.setter 控制该数据的修改,修改该数据时触发
@伪装成数据的函数名.delect 控制该数据的删除,删除该数据时触发
class People: def __init__(self,name): self.__name=name @property #将name()函数伪装成一个数据属性name def name(self): #obj.name print('您现在访问的是用户名。。。') return self.__name @name.setter #obj.name='EGON' 执行 name=x 修改 name 值时触发该方法 def name(self,x): # print('=================',x) if type(x) is not str: raise TypeError('名字必须是str类型,傻叉') self.__name=x @name.deleter # 执行 del 对象.name 时触发该方法 def name(self): # print('就不让你删') del self.__name obj=People('egon') # print(obj.name) # print(obj.name()) # print(obj.name) # obj.name='EGON' # print(obj.name) # obj.name=123 del obj.name obj.name
二、多态
1、 什么是多态
多态指的是同一种事物多种形态
2、为什要用多态
用基类创建一套统一的规则,强制子类去遵循(使用抽象类实现),这样便可以
在不用考虑对象具体类型的前提下而直接使用对象下的方法
3、多态性:一种调用方式,不同的执行效果(多态性)
注意:多态与多态性是两种概念
4、多态的使用
-
- 继承
class Animal: def eat(self): pass def bark(self): print('叫') class Cat(Animal): def jiao(self): print('喵喵喵') class Dog(Animal): def speak(self): print('汪汪汪') class Pig(Animal): def han(self): print('哼哼哼') c=Cat() d=Dog() p=Pig() # 多态性:可以在不用考虑对象具体类型的前提下而直接使用对象下的方法 # c.eat() # d.eat() # p.eat() # d.bark() # p.bark() # c.bark() d.speak() c.jiao() p.han()
- 抽象类
import abc #abstract class class Animal(metaclass=abc.ABCMeta): @abc.abstractmethod def eat(self): pass @abc.abstractmethod def bark(self): pass # obj=Animal() # 抽象基类本身不能被实例化 class Cat(Animal): def eat(self): print('cat eat') def bark(self): print('喵喵喵') class Dog(Animal): def eat(self): print('dog eat') def bark(self): print('汪汪汪') class Pig(Animal): def eat(self): print('pig eat') def bark(self): print('哼哼哼') c=Cat() d=Dog() p=Pig() # c.bark() # d.bark() # p.bark() # def BARK(Animal): 向上转型 # Animal.bark() # # # BARK(c) # BARK(d) # BARK(p)
- 鸭子类型(长得像鸭子就被当作是鸭子)
class Foo: def f1(self): print('from foo.f1') def f2(self): print('from foo.f2') class Bar: def f1(self): print('from bar.f1') def f2(self): print('from bar.f2') obj1=Foo() obj2=Bar() obj1.f1() obj1.f2() obj2.f1() obj2.f2() class Disk: def read(self): print('disk read') def write(self): print('disk write') class Txt: def read(self): print('txt read') def write(self): print('txt write') class Process: def read(self): print('process read') def write(self): print('process write') obj1=Disk() obj2=Txt() obj3=Process() obj1.read() obj2.read() obj3.read()
- 继承
三、classmethod和staticmethod
classmethod
绑定方法:
在类内部定义的函数,默认就是给对象来用,而且是绑定给对象用的,称为对象的绑定方法
1. 绑定对象的方法特殊之处:
应该由对象来调用,对象来调用,会自动将对象当作第一个参数传入
2. 绑定到类的方法特殊之处:
应该由类来调用,类来调用,会自动将类当作第一个参数传入
import settings class People: def __init__(self,name,age): self.name=name self.age=age def tell(self): print('%s:%s' %(self.name,self.age)) @classmethod def from_conf(cls): return cls(settings.NAME,settings.AGE) # p=People('egon',19) # p.tell() # p1=People(settings.NAME,settings.AGE) # p1.tell() # p2=People(settings.Name,settings.AGE) # p3=People('alex',74) # p3.tell() # print(People.from_conf) # p4=People.from_conf(People) # print(People.from_conf) # p4=People.from_conf() # p4.tell()
2、staticmethod:
非绑定方法,就是一个普通函数
特性: 既不跟类绑定,也不跟对象绑定,这意味着谁都能用
谁来用都是一个普通函数,也就是说没有自动传值的特性了
import settings import hashlib import time class People: def __init__(self,name,age): self.uid=self.create_id() self.name=name self.age=age def tell(self): print('%s: %s:%s' %(self.uid,self.name,self.age)) @classmethod def from_conf(cls): return cls(settings.NAME,settings.AGE) @staticmethod def create_id(): m=hashlib.md5() m.update(str(time.clock()).encode('utf-8')) return m.hexdigest() obj=People('egon',18) # print(obj.uid,obj.name,obj.age) # obj.tell() # print(obj.create_id) # print(People.create_id) print(obj.create_id()) print(People.create_id())