Python面向对象

  1 # （1）定义类：在PPython中可以使用class来创建一个专门类
  2 class Acount:
  3     pass
  4 def account(name,number,balance):
  5     aact=Acount()
  6     aact.name=name
  7     aact.number=number
  8     acct.balance=balance
  9     return aact
 10 def deposit(acct,amount):
 11     if amount <= 0:
 12         print("存款金额不得为负")
 13     else:
 14         acct.balance +=amount
 15 def withdrow(acct,amount):
 16     if amount <= 0:
 17         print("余额不足")
 18     else:
 19         acct.balance -= amount
 20 def desc(acct):
 21     return "Account('{name}','{number}',{balance})".format(name=acct.name,number=acct.number,balance=acct.balance)
 22     
 23 # (2-1) 定义__init__方法:在Python中，对象方法的第一个参数一定是对象本身
 24 class Amount:
 25     def __int__(self,name,number,balance):
 26         self.name=name
 27         self.number=number
 28         self.balance=balance
 29 # （2-2）定义__str__()方法
 30 class Account:
 31     def __str__(self):
 32         return "Account('{name}','{number}',{balance})".format(name=self.name,number=self.number,balance=self.balance)
 33         
 34 # （3）定义内部属性：如果想要避免用户字节的误用，那么可以使用self.__XXX的方法定义内部值域
 35 class Account:
 36     def __int__(self,name,number,balance):
 37         self.__name=name
 38         self.__numner=number
 39         self.__balance=balance
 40 # (4)定义外部属性：可以考虑在这类方法上加注@property
 41 class Account:
 42     def __int__(self,name,number,balance):
 43         self.__name=name
 44         self.__numner=number
 45         self.__balance=balance
 46     @property
 47     def name(self):
 48         return self.__name
 49 # (5)静态方法与类方法
 50 # 标注 @staticmethod:虽然可以通过实例来调用@staticmethod标注，但是建议通过类名来调用，明确让类名称作为静态方法的命名空间
 51 class Accoutn:
 52     @staticmethod
 53     def default(name,number):
 54         return Acount(name,number,100)
 55 # 标注@classmethod：类中的方法如果标注了@classmethod，那么第一个参数一定是接受所在类的type实例
 56 class Account:
 57     @classmethod
 58     def default(clz,name,number):
 59         return clz(name,numberm,100)
 60         
 61 # (6)定义运算符
 62 class Rational:
 63     def __init__(self,numer,denom):
 64         self.numer=numer
 65         self.denom=denom
 66     def __add__(self, other):
 67         return Rational(self.numer*other.denom+other.numer*self.denom,self.denom*other.denom)
 68     def __sub__(self, other):
 69         return Rational(self.numer*other.denom-other.numer*self.denom,self.denom*other.denom)
 70     def __mul__(self, other):
 71         return Rational(self.numer*other.numer,self.denom*other.denom)
 72     def __truediv__(self, other):
 73         return Rational(self.numer * other.denom, self.denom * other.denom)
 74     def __str__(self):
 75         return '{numer}/{denom}'.format(numer=self.numer,denom=self.denom)
 76     def __repr__(self):
 77         return 'Rational({numer},{denom})'.format(numer=self.numer,denom=self.denom)
 78 r1=Rational(1,2)
 79 r2=Rational(2,3)
 80 print(r1+r2)
 81 print(r1-r2)
 82 print(r1*r2)
 83 print(r1/r2)
 84 
 85 # (7)__new__(), __init__(),__del__()
 86 # __init__()是在类的实例构建之后进行初始化的方法，类的实例如何构建实际上是由__new__()来定义。
 87 # __new__()方法的第一个参数是类本身，之后可定义任何参数作为构建对象之用。
 88 # __new__()方法可以返回对象，如果返回的对象是第一个参数的类实例，接下来就会执行__init__()方法，__init__()方法的第一个参数就是__new__()返回的对象。
 89 # __new__()如果没有返回第一个参数的类实例(返回别的实数或None),就不会执行__init__()方法.
 90 class Some:
 91     def __new__(cls, isClsInstance):
 92         print("__new__")
 93         if isClsInstance:
 94             return object.__new__(cls)
 95     def __init__(self,isClsInstance):
 96         print('__init__')
 97         print(isClsInstance)
 98 Some(True)
 99 Some(False)
100 # __new__()如果返回第一个参数的类实例，就会执行__init__()方法，借助定义__new__()方法就可以决定如何构建对象与初始化对象，一个应用例子如下：
101 class Logger:
102     __loggers={}    #保存已创建的Logger实例
103     def __new__(cls, name):
104         if name not in cls.__loggers:   #如果字典中不存在对应的Logger就创建
105             logger=object.__new__(cls)
106             cls.__loggers[name]=logger
107             return logger
108         return cls.__loggers[name] #否则返回字典中对应的Logger实例
109     def __init__(self,name):
110         #为了不重复设置Logger实例属性，使用vars(self)获取Logger实例上的属性列表
111         if name not in vars(self):
112             self.name=name #设置Logger的名称
113     def log(self,message):  #简单模拟日志的行为
114         print('{name}:{message}'.format(name=self.name,message=message))
115 logger1=Logger('xlogging')
116 logger1.log('一些日志信息')
117 logger2=Logger('xlogging')
118 logger2.log('另外一些日志信息')
119 logger3=Logger('xlog')
120 logger3.log('再来一些日志信息')
121 print(logger1==logger2)
122 print(logger2==logger3)
123 # 如果想在对象被删除时自行定义一些清楚相关资源的操作，可以做执行__del__()方法
124 class Some:
125     def __del__(self):
126         print('__del__')
127 s=Some()
128 s=None
129 
130 # (8)类的继承：类名称旁边多了个括号，并指定了类，这在Python中代表这继承该类
131 class Role:
132     def __init__(self,name,level,blood):
133         self.name=name
134         self.level=level
135         self.blood=blood
136     def __str__(self):
137         return "('{name}',{level},{blood})".format(**vars(self))
138     def __repr__(self):
139         return self.__str__()
140 class SwordMan(Role):
141     def fight(self):
142         print('挥剑攻击')
143 class Magician(Role):
144     def fight(self):
145         print('魔法攻击')
146     def cure(self):
147         print('魔法治疗')
148 # 鸭子类型：思考对象的行为，而不是对象的种类。按此苏伟设计的程序，会有比较高的通用性。
149 def draw_fight(role):
150     print(role,end='')
151     role.fight()
152 swordsman=SwordMan('Justin',1,200)
153 draw_fight(swordsman)
154 magician=Magician('Monica',1,100)
155 draw_fight(magician)

# (9)创建ABC(抽象基类)
from abc import ABCMeta,abstractmethod
class Ordering(metaclass=ABCMeta):
    # 在这里使用@abstractmethod标注不是必要的，使用@abstractmethod标注具有提醒的作用
    @abstractmethod
    def __eq__(self, other):
        pass
    @abstractmethod
    def __gt__(self, other):
        pass
    def __ge__(self, other):
        return self > other or self == other
    def __lt__(self, other):
        return not(self > other and self == other)
    def __le__(self, other):
        return (not self >= other) or self ==other
    def __ne__(self, other):
        return not self ==other
class Ball(Ordering):   #继承Ordering
    def __init__(self,radius):
        self.radius=radius
    def __eq__(self, other):  # 实现__eq__()与__gt__()
        return hasattr(other,'radius') and self.radius == other.radius
    def __gt__(self, other):
        return hasattr(other,'radius') and self.radius > other.radius
b1=Ball(10)
b2=Ball(20)
print(b1 > b2)
print(b1 <= b2)
print(b1 == b2)