多应用+插件架构,代码干净,二开方便,首家独创一键云编译技术,文档视频完善,免费商用码云13.8K 广告
# 对象 [TOC] ## 访问控制(私有属性和私有方法) ```python # 私有属性(变量) class Student(object): def __init__(self, name, score): self.__name = name # 属性的名称前加上两个下划线__,外部就不能访问 self.__score = score def _show_info(self): print(self.__name) print(self.__score) def print_score(self): print('%s: %s' % (self.__name, self.__score)) bart = Student('Bart Simpson', 59) bart.__name # AttributeError: 'Student' object has no attribute '__name' bart.print_score() # Bart Simpson: 59 bart.__name = 'New Name' # 设置__name变量! bart.__name # 'New Name' # 注意: 看上去好像设置私有变量成功,但实际上这个__name变量和class内部的__name变量不是一个变量!内部的__name变量已经被Python解释器自动改成了_Student__name,而外部代码给bart新增了一个__name变量 bart.__show_info() # 私有方法不能访问:AttributeError: 'Student' object has no attribute '__show_info' ``` 1. 变量名类似__xxx__的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变量,特殊变量是可以直接访问的,不是private变量 2. 只以一个下划线开头的实例变量名,比如_name,这样的实例变量外部是可以访问的,但是,按照约定俗成的规定,当你看到这样的变量时,意思就是,“虽然我可以被访问,但是,请把我视为私有变量,不要随意访问”。 ## 类的方法 ```python class Foo: name = 'who' count = 0 # __init__也属于实例方法,实例方法必须依托于实例 def __init__(self, name): self.name = name # 每实例一次,调用一次, 这里可以统计该类调用的次数 self.__class__.count += 1 print(self.__class__.count) # 类实例方法:第一个参数强制为类实例对象,一般用self代替 # 类实力为对象后可以直接访问的方法 # 可以通过这个类实例对象(self)访问对象属性 # 可以通过类实例对象(self)的__class__属性访问类属性 def hi(self , str): print(self.__class__.name) # who print(str , self.name) # hello zxg # 类方法:cls即为类自身 @classmethod def class_method(cls): print(cls.count) # 静态方法 # 不能传递和类或实例相关的参数,如cls或self,但可以传递其他参数 @staticmethod def static_method(nickname): print(nickname) if __name__ == '__main__': foo01 = Foo('zxg') # foo01.hi('hello') # Foo.hi('hello') # 报错:实例方法不能通过类直接用,必须依托于实例,当然可以把foo01的对象作为第一参数传进去 foo01.class_method() # 可以通过实例调用 Foo.class_method() # 也可以直接通过类来调用 # foo01.static_method('zxg') # Foo.static_method('zxg') # print(foo01) # print(Foo) ``` 1. 逻辑上,类方法应当只被类调用,实例方法实例调用,静态方法两者都能调用 2. 主要区别在于参数传递上的区别,实例方法悄悄传递的是self引用作为参数,而类方法悄悄传递的是cls引用作为参数。而静态方法不会任何隐式传递 ## 使用__slots__限制实例的属性 ```python class Student(object): __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称 # 使用__slots__要注意,__slots__定义的属性仅对当前类实例起作用,对继承的子类是不起作用的: class GraduateStudent(Student): pass bart = Student() # 对象实例不需要用new ``` ## 类和类方法的装饰器 ### 类方法中的装饰器 ```python # 原来的class class Student(object): def get_score(self): return self._score def set_score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value class Student(object): @property def score(self): return self._score @score.setter def score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value s = Student() s.score = 'haha' # OK,实际转化为s.set_score(60) s.score # OK,实际转化为s.get_score() # 只定义getter方法,不定义setter方法就是一个只读属性 class Student(object): @property def birth(self): return self._birth @birth.setter def birth(self, value): self._birth = value @property def age(self): return 2018 - self._birth zxg = Student() zxg.birth = 1988 zxg.age # 30 Student.sex = 1 zxg.sex = 1 # python一切皆对象,类也属于对象,可以动态为类添加属性,该属性会体现在实例后的对象里面 ``` ### 类装饰器 #### 函数装饰类 ##### 装饰器无参数 ```python #给每个类打印一句话 def Decorator(obj): print("定义了一个装饰器函数") return obj # 相当于执行 Decorator(School) @Decorator class School(): pass def godme(fun): def __godme(self,message): print('before') fun(self,message) print('after') return __godme class Person: def show(self,message): print(message) @godme def say(self,message): print(message) person = Person() # 相当于 godme(person.say('happy')) # 调用顺序 godme() -> __godme()-> person.say() # 输出顺序 before -> happy -> after person.say('happy') ``` ##### 装饰器有参数 ```python #给每个类添加一个可变的数据属性 def Decorator(**kwargs): def add(obj): # <class '__main__.School'> print(obj) "添加数据属性" print('调用外部函数的**kwargs',kwargs) for key,val in kwargs.items(): # 添加数据属性 setattr(obj,key,val) return obj print("外部传入的参数为:",kwargs) return add # 执行顺序: # 1.运行Decorator函数,先打印外部的传入的参数,返回add函数名; # 2.再执行School = add(School) # Decorator(addr = "浙江省杭州市",name ="浙江大学")(School) @Decorator(addr = "浙江省杭州市",name ="浙江大学") class School(): def __init__(self,price): self.price =price ``` #### 类装饰函数或方法 ##### 无参数 ```python class tracer: def __init__(self,func): print('__init__ is called' ) self.calls = 0 self.func = func def __call__(self,*args): self.calls += 1 print(args) print('call %s to %s' %(self.calls, self.func.__name__)) self.func(*args) @tracer def spam(a, b, c): print(a + b + c) ''' 1. 相当于 tracer(spam(1,2,3)) 2. 调用顺序:__init__(spam) -> __call__() -> spam(a, b, c) ''' spam(1,2,3) ``` ##### 有参数 ```python class tracer: def __init__(self, *args): self.calls = 0 self.args = args print(args) def __call__(self, func): self.func = func def realfunc(*args): self.calls += 1 print('call %s to %s' %(self.calls, self.func.__name__)) self.func(*args) return realfunc # 相当于tracer("xxxx")(spam) # 调用顺序 __init__("xxxx") -> __call__(spam) -> realfunc(a, b, c) -> spam(a, b, c) @tracer("xxxx") def spam(a, b, c): print(a + b + c) spam(1,2,3) ``` ## 继承 ```python class Parent: def myMethod(self): print ('调用父类方法') class Child(Parent): def myMethod(self): # super().myMethod(); # Python3,如果super在类里面的话,可以省略里面的参数 print ('调用子类方法') c = Child() # 子类实例 c.myMethod() # 子类调用重写方法 super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法 ``` ## 多重继承 在设计类的继承关系时,通常,主线都是单一继承下来的,如果需要“混入”额外的功能,通过多重继承就可以实现。 ```python class Dog(Mammal, RunnableMixIn, CarnivorousMixIn): pass ``` ## 定制类(魔术方法) 类似PHP中的魔术方法 ```python # __str__ # 打印实例时调用 # __repr__ # console直接敲命令时调用 # object python的顶级父类 class Student(object): def __init__(self, name): self.name = name # print打印时触发 def __str__(self): return 'Student object (name: %s)' % self.name # 控制台输出时触发 __repr__ = __str__ # 在Python console直接敲命令时调用__repr__方法,又因为__repr__方法跟__str__的内容一样 zxg = Student('zxg') print(zxg) # Student object (name: zxg) # __iter__ 实现迭代 # __getitem__ list化之后取第几个元素及切片 class Fib(object): def __init__(self): self.a, self.b = 0, 1 # 初始化两个计数器a,b def __iter__(self): return self # 实例本身就是迭代对象,故返回自己 # 循环时触发 def __next__(self): self.a, self.b = self.b, self.a + self.b # 计算下一个值 if self.a > 100: # 退出循环的条件 raise StopIteration() return self.a # 返回下一个值 # list化之后切片触发 def __getitem__(self, n): print(n) if isinstance(n, int): # n是索引 a, b = 1, 1 for x in range(n): a, b = b, a + b return a if isinstance(n, slice): # n是切片 start = n.start stop = n.stop if start is None: start = 0 a, b = 1, 1 L = [] for x in range(stop): if x >= start: L.append(a) a, b = b, a + b return L f = Fib() f[5] # 5 f[:5] # slice(1, 5, None) for n in f: print(n) # __setitem__() # 设置元素时触发 # __delitem__() # 删除元素时触发 # 通过以上的几个魔术方法,可以把自己定义的类表现出list,dict,tuple的特性 # __getattr__ 获取不存在的元素时调用 class Chain(object): def __init__(self, path=''): self._path = path def __getattr__(self, path): return Chain('%s/%s' % (self._path, path)) def __str__(self): return self._path __repr__ = __str__ Chain().status.user.list # /status/user/list 实现链式操作 # __call__ # 对实例直接调用 class Student(object): def __init__(self, name): self.name = name # 对实例直接调用的时候,调用的就是这个方法 def __call__(self): print('My name is %s.' % self.name) s = Student('Michael') s() # 直接可以调用 # __new__ 当你继承一些不可变的class时(比如int, str, tuple), 提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass。 ``` ## 待处理 __del__ __enter__ __exit__ ## 使用枚举类 ```python from enum import Enum Month = Enum('Month', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec')) print(Month) # <enum 'Month'> for name, member in Month.__members__.items(): # Sep => Month.Sep , 9 print(name, '=>', member, ',', member.value) ``` ## __new__ 和 __init__ > **实际上在我们实例化对象时,python默认执行了__new__操作,先创建类实例,然后返回给__init__初始化实例** ```python # python新类允许用户重载__new__和__init__方法。__new__创建类实例,__init__初始化一个已被创建的实例; class newStyleClass(object): # __new__在顶级父类object是一个静态方法 # cls代表当前类 def __new__(cls): print("__new__ is called") return super(newStyleClass, cls).__new__(cls) # self def __init__(self): print("__init__ is called") print("self is: ", self) newStyleClass() # 我们发现__new__函数先被调用,接着__init__函数在__new__函数返回一个实例的时候被调用,并且这个实例作为self参数被传入了__init__函数 # 若__new__()没有正确返回当前类cls的实例,那__init__()将不会被调用,即使是父类的实例也不行。 obj = 12 # obj can be an object from any class, even object.__new__(object) class returnExistedObj(object): def __new__(cls): print("__new__ is called") return obj # __init__不被调用 # return super(returnExistedObj,cls).__new__(cls) def __init__(self): print("__init__ is called") print("self is: ", self) returnExistedObj() ``` ## 使用元类 ### 通过type函数临时创建类 Python函数和类的定义,不是编译时定义的,而是运行时动态创建的;所以可以在运行时临时动态的创建类 `type`传入三个参数: 1. class的名称; 1. 继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法; 1. class的方法名称与函数绑定,这里我们把函数fn绑定到方法名hello上。这里的dict的参数是**kws; ```python def fn(self, name='world'): # 先定义函数 print('Hello, %s.' % name) Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class o = Hello() o.hello() ``` ### metaclass 除了使用type()动态创建类以外,要控制类的创建行为,还可以使用metaclass。先定义metaclass,就可以创建类,最后创建实例。 metaclass是Python面向对象里最难理解,也是最难使用的魔术代码。正常情况下,你不会碰到需要使用metaclass的情况 ```python # metaclass是类的模板(类的类),所以必须从`type`类型派生: # metaclass的类名总是以Metaclass结尾 class ListMetaclass(type): def __new__(cls, name, bases, attrs): attrs['add'] = lambda self, value: self.append(value) return type.__new__(cls, name, bases, attrs) # 有了ListMetaclass,我们在定义类的时候还要指示使用ListMetaclass来定制类,传入关键字参数metaclass # 当我们传入关键字参数metaclass时,魔术就生效了,它指示Python解释器在创建MyList时,要通过ListMetaclass.__new__()来创建,在此,我们可以修改类的定义,比如,加上新的方法,然后,返回修改后的定义。 class MyList(list, metaclass=ListMetaclass): pass L = MyList() L.add(1) print(L) ``` **元类的作用** 1. 拦截类的创建; 2. 修改类; 3. 返回修改之后的类; ```python # 看下面这个例子 # type其实也是个元类 class UpperAttrMetaclass(type): def __new__(cls, clsname, bases, dct): uppercase_attr = {} for name, val in dct.items(): if not name.startswith('__'): uppercase_attr[name.upper()] = val else: uppercase_attr[name] = val return super(UpperAttrMetaclass, cls).__new__(cls, clsname, bases, uppercase_attr) # 我们知道在python中一切皆对象 # 那么下面我们的s其实就是一个类对象,它的__name__其实和Foo的__name__是一样的 # 看下面的方法是不是和type创建类有点像? s = UpperAttrMetaclass('Foo',(object,),{'bar':'bip'}) print(hasattr(s,'bar')) # False print(hasattr(s,'BAR')) # True print(s.BAR) # bip class Foo(object,metaclass=UpperAttrMetaclass): bar='bip' print(hasattr(Foo,'bar')) print(hasattr(Foo,'BAR')) print(Foo.BAR) # 最后它们输出的结果其实是一模一样的,这就说明了类其实和我们普通的实例对象差不多,只不过普通实例是通过类创建,而类是通过元类创建 # 而__new__就是用来创建实例的,不论是普通的实例,还是类实例,总之就是个实例 ``` **意义** 实现面向对象高级编程,体现其“开闭原则”:把扩展打开,把修改关闭。 比如: 编写一个ORM框架,所有的类都只能动态定义,因为只有使用者才能根据表的结构定义出对应的类来。 ```python class Field(object): def __init__(self, name, column_type): self.name = name # 字段名 self.column_type = column_type # 字段类型 def __str__(self): return '<%s: %s>' % (self.__class__.__name__, self.name) class StringField(Field): def __init__(self, name): # super().__init__(name, 'varchar(100)') # Python3里面的super可以省略StringField, self super(StringField, self).__init__(name, 'varchar(100)') # 字段名和字段类型 class IntegerField(Field): def __init__(self, name): super(IntegerField, self).__init__(name, 'bigint') # 字段名和字段类型 class ModelMetaclass(type): def __new__(cls, name, bases, attrs): # cls: 正在被生成的对象, name: 生成该对象的类名, bases: 父类集合, attrs: 属性方法集合 if name == 'Model': # 若类名为Model, 则是对Model的修改,这里是原样返回 return type.__new__(cls, name, bases, attrs) print('Found model: %s' % name) # 输出类的名字 mappings = dict() # 初始化user类的属性方法字典 for key, value in attrs.items(): if isinstance(value, Field): print('Found mappings: %s ==> %s' % (key, value)) # 输出属性类型和属性名 mappings[key] = value # 将属性类型(key)和属性名(value)加入到字典 for key in mappings.keys(): attrs.pop(key) # 类属性中删除该Field属性, 否则容易造成运行时错误(实例的属性会遮盖类的同名属性) attrs['__mappings__'] = mappings # 将属性方法字典加入到属性方法集合中 attrs['__table__'] = name # 表名(此处假设类名即为表名) return type.__new__(cls, name, bases, attrs) class Model(dict, metaclass=ModelMetaclass): # 使用ModelMetaclass来创建类 def __init__(self, **kw): # **kw命名关键词参数 print(kw) super(Model, self).__init__(**kw) def __getattr__(self, key): # 获得values try: return self[key] except KeyError: raise AttributeError(r"'Model' object has no attribute '%s'" % key) def __setattr__(self, key, value): # 设置属性/方法名 self[key] = value def save(self): # 将属性保存到数据库(此处仅为生成相应的SQL语句) fields = [] params = [] args = [] for k, v in self.__mappings__.items(): fields.append(v.name) # 将字段名加入到fields中 params.append('?') # 向params中添加xxx个问号 args.append(getattr(self, k, None)) # 将values加入args中 sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params)) # 生成SQL语句, join方法是将list中的内容以前面的符号作为分隔连在一起 print('SQL: %s' % sql) print('ARGS: %s' % args) class User(Model): # 定义类的属性到列的映射: id = IntegerField('id') name = StringField('username') email = StringField('email') password = StringField('password') # 创建一个实例: u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到数据库: u.save() # 过程是 ''' 从上到下执行: Model => ModelMetaclass => User(以及里面的属性IntegerField,StringField等) => ModelMetaclass => Model.save ''' ``` ### `__metaclass__` python2继承元类的语法 ```python # python3 class Model(dict, metaclass=ModelMetaclass): pass # python2 class Model(dict): __metaclass__ = ModelMetaclass pass ```