编程语言
首页 > 编程语言> > PYTHON1.面向对象_day02

PYTHON1.面向对象_day02

作者:互联网

课程:Python面向对象
进度:day2

上次内容回顾
1. 面向对象:以对象为中心
2. 三大特性:封装、继承、多态
3. 如何定义类、如何实现继承
     class 类名称(父类列表):
           # 构造函数
           # 其它成员函数

今天的内容
1. 多态:相同的方法,不同的表现(重点)
    1)事物除了共性外,还具有各自的特性(个性)
         多态就用来处理事物的个性
    2)多态能够在不影响父类行为(不修改父类代码)
         情况下,进行功能的扩展和变更
    3)使程序(软件设计)更具灵活性

2. 方法的重写:父类中定义过的方法子类中重新定义
    (重点)

3. 多态的实现:通过在子类中重写父类的方法实现多态(重点)
    (重点)
   
课堂练习:
编写一个手机类(Phone)
属性:名称(name), 价格(price),
           CPU, 屏幕尺寸( screen_size)
方法:开机(startup),关机(shutdown)
           打电话(call), 发短信(send_msg)
并编写测试代码
见 phone.py

  1 # phone.py
  2 # 手机类
  3 import time
  4 class Phone:
  5     def __init__(self, name, price,
  6                  CPU, screen_size):
  7         self.name = name
  8         self.price = price
  9         self.CPU = CPU
 10         self.screen_size = screen_size
 11 
 12     def startup(self):
 13         print("正在开机")
 14         time.sleep(2)
 15         print("开机成功")
 16 
 17     def shutdown(self):
 18         print("正在关机")
 19         time.sleep(2)
 20         print("关机成功")
 21 
 22     def call(self, phone_no):
 23         print("正在拨号")
 24         time.sleep(1)
 25         print("正在和%s通话" % phone_no)
 26 
 27     def send_msg(self, phone_no, msg):
 28         print("正在向%s发送信息..." % phone_no)
 29         time.sleep(2)
 30         print("【%s】发送成功" % msg)
 31 
 32     def __del__(self):  # 析构方法
 33         print("__del__方法被调用")
 34 
 35 def fun():
 36     phone = Phone("华为",1999.99,
 37                  "双核2G", 5.5)
 38     print("fun()函数退出")
 39 
 40 if __name__ == "__main__":
 41     myphone = Phone("华为",1999.99,
 42                     "双核2G", 5.5)
 43     fun()
 44     print("程序退出")
 45     # myphone程序退出时被销毁
 46 
 47 
 48 
 49     myphone.startup()  #启动
 50     myphone.call("13512345678") #打电话
 51     myphone.send_msg("13512345678","你好")
 52     myphone.shutdown()  #关机
phone.py

phone

4. 面向对象的技术特性
   1)构造和析构
      a)构造方法(重点)
        - 名称:在Python中,固定为__init__
        - 作用:是为对象创建属性,并且赋予初始值
        - 调用时机:对象被创建(实例化)自动调用
        - 如果在类中未定义,Python会给出默认的构造方法
        - 在继承关系中,如果父类定义了__init__方法
          在子类的构造方法中,必须要调用父类的构造方法

       b)析构方法
          - 名称:__del__
          - 调用时机: 对象被销毁时自动调用
                               del obj, 局部变量退出作用于,程序退出
          - 作用:对象销毁时,执行清理操作

   2)多重继承:一个类有多个父类
       - 如何实现多继承: 定义类的时候,继承自多个父类,
             父类之间用逗号隔开
       - 语法格式:
             class 类名称(父类1, 父类2, ......):
                     语句块

       - 通过多重继承,子类具有所有父类的特征和行为
       - 如果多个父类具有相同的方法(或属性名称),通过
         类的__mro__属性中记录的顺序进行方法查找

        MRO(Method Resolution Order)

        总的原则按照由下至上、从左至右(继承列表中前后)
         进行查找,直到object类,如果都没有找到就报错

  1 # mul_inh.py
  2 # 多重继承示例
  3 # 超人类继承自战士、飞行者、喷或者
  4 # 三个类
  5 class Fighter:  #战士类,默认继承自object
  6     def fight(self):
  7         print("我能战斗")
  8 
  9     def roar(self):  #吼叫
 10         print("战士吼叫:嗷嗷嗷")
 11 
 12 class Flyer:  #飞行者类
 13     def fly(self):
 14         print("我能飞行")
 15 
 16     def roar(self):  #吼叫
 17         print("飞行者吼叫:呜呜呜")
 18 
 19 class Firer: # 喷火者
 20     def fire(self):
 21         print("我能喷火")
 22 
 23 # 超人类,继承自Fighter,Flyer,Firer父类
 24 class SuperMan(Flyer,Fighter,Firer):
 25     pass
 26 
 27 if __name__ == "__main__":
 28     super_man = SuperMan() # 实例化超人对象
 29     super_man.fight()  # 超人战斗
 30     super_man.fly()    # 超人飞行
 31     super_man.fire()   # 超人喷火
 32     super_man.roar()   # 超人吼叫??
 33     # Mehtod Resolution Order
 34     # 决定调用哪一个类的方法
 35     # print(SuperMan.__mro__)
 36     print(SuperMan.__bases__) # __bases__绑定父类
 37     print(Fighter.__base__)
 38     print(Flyer.__base__)
 39 
mul_inh.py

mul  

3)object类:所有类的总父类,如果定义类时候,没有
       指定父类,则默认从object类继承

                         
       类的父类可以通过__base__属性查看

   4)super()和issubclass()
      - super()函数
        作用:返回绑定的父类
              有时候需要显式调用父类方法
              就使用super()函数
        格式:super(type, ojb) 返回obj对象父类
              super() 返回当前对象父类

                      只能在类的方法中调用

     - issubclass: 判断一个类是否是另一个
                    类的子类,如果是返回True
                    如果不是返回False
        格式:issubclass(cls, class_or_tuple)
        
5. 函数重写(重点,理解原理)
   1)对象转字符函数的重写
     - str:将对象转换成人阅读的字符串
            重写__str__()

     - repr: 返回字符串,给Python解释器阅读
             通过eval(repr(obj))能够还原obj
             对象,重写__repr__()

     - 当调用str(obj)将对象转换成字符串
       时,其搜索顺序为:
       + 优先查找obj.__str__()方法(包括父类)
       + 如果上一步不存在,则调用obj.__repr__()
       + 如果上一步不存在,则调用object.__repr__()

  1 
  2 class A:
  3     def __init__(self, name):
  4         self.name = name
  5 
  6     def __str__(self):  # 重写__str__函数
  7         return "name = %s" % self.name
  8 
  9 class B(A):
 10     def __init__(self, name, id):
 11         super().__init__(name) # 调用父类构造方法
 12         self.id = id  # id属性被创建
 13 
 14     def __repr__(self):  # 重写__repr__方法
 15         # 返回例如"B('Jerry','0001')"
 16         return "B('%s','%s')" % (self.name, self.id)
 17 
 18     def __str__(self):  # 重写__str__函数
 19         return "name=%s,id=%s"%(self.name,self.id)
 20 
 21 b = B("Jerry", "0001")  # ==》
 22 print(b)
 23 
 24 # str_obj = repr(b)
 25 # print(str_obj)
 26 # new_obj = eval(str_obj)  # 通过调用eval函数还原对象
 27 # print(new_obj)
 28 
 29 # print(b)  # B类中重写__str__方法,所以可以直接打印
 30 # str_obj = str(b)  # 将b对象转换成字符串
 31 # print(str_obj)
 32 
 33 #super(B, b).print() # 根据对象b找到父类,并调用父类的print
 34 # print(issubclass(B, (A,object)))    # True
 35 # print(issubclass(B,object)) # True
 36 # print(issubclass(A, B))  # False
a.py

  2)内建函数重写
     - abs()函数:重写__abs__()
     - len()函数: 重写__len__()
     - reversed()函数: 重写__reversed__()
     - round()函数:重写__round__()
    
     课堂练习:重写__len__()和__round__()
               重写__reversed__()
     示例见my_list.py

  1 # mylist.py
  2 # 自定义列表
  3 class MyList:
  4     def __init__(self, iterable=[]):
  5         self.data = [x for x in iterable]
  6 
  7     # 重写__abs__()函数
  8     def __abs__(self):
  9         #对每个元素求绝对值,用产生的结果实例化一个MyList对象
 10         return MyList(abs(x) for x in self.data)
 11 
 12     def __str__(self):  # 重写__str__()函数
 13         ret = ""
 14         for x in self.data:
 15             ret += str(x)  # 将元素由数字转换成字符串
 16             ret += " "
 17         return ret   # 返回结果串
 18 
 19     def __len__(self):  # 重写__len__函数,返回元素个数
 20         return len(self.data)
 21 
 22     # 对每个元素求近似值,并实例化对象返回
 23     def __round__(self):
 24         return MyList(round(x,2) for x in self.data)
 25 
 26     # 重写__reversed__,倒序
 27     def __reversed__(self):
 28         tmp = []
 29         x = len(self.data) - 1  # 最后元素下标
 30         while x >= 0:
 31             tmp.append(self.data[x])
 32             x -= 1   # 计数器减1
 33         return MyList(tmp)  # tmp是经过倒序的可迭代对象
 34 
 35     def __add__(self, other): # L1 + L2
 36         return MyList(self.data + other.data)
 37 
 38     def __mul__(self, value): # L1 * 2
 39         return MyList(self.data * value)
 40 
 41     def __eq__(self, other): # 重载==运算符
 42         len1 = len(self.data)  # 取data属性长度
 43         len2 = len(other.data) # 取另一个对象data的长度
 44         if len1 != len2: # 长度不相等,无需比较
 45             return False
 46 
 47         for i in range(0, len1):
 48             if self.data[i] != other.data[i]:
 49                 return False #只要出现元素不相等,返回False
 50         return True
 51 
 52     def __ne__(self, other): # 重载!=运算符
 53         return not (self == other)
 54 
 55     def __gt__(self, other):
 56         len1 = len(self.data)  # 取data属性长度
 57         len2 = len(other.data) # 取另一个对象data的长度
 58         min_len = min(len1, len2) # 获得循环上限
 59 
 60         for i in range(min_len): # 以长度短的作为循环上限
 61             if self.data[i] == other.data[i]:
 62                 continue
 63             elif self.data[i] > other.data[i]:
 64                 return True
 65             elif self.data[i] < other.data[i]:
 66                 return False
 67         if len1 == len2:  #相等
 68             return False
 69         elif len1 > len2: #前面的元素相等,长度比对方大
 70             return True
 71         else:
 72             return False
 73 
 74     def __neg__(self): #重载符号运算符
 75         return MyList(-x for x in self.data)
 76 
 77     def __contains__(self, e): # in/not in运算符重载
 78         print("__contains__()被调用")
 79         return e in self.data
 80 
 81     def __getitem__(self, i): # 重载[]取值操作
 82         return self.data[i]
 83 
 84     def __setitem__(self, i, value):#重载[]赋值操作
 85         self.data[i] = value
 86 
 87     def __delitem__(self, i): #重载[]删除操作
 88         del self.data[i]
 89 
 90 if __name__ == "__main__":
 91     L = MyList([-1, 2, -3, 4, -5])
 92     print(L[0])  # 索引取值
 93     L[2] = 333   # 通过索引设置值
 94     print(L)
 95     del L[3]     # 删除
 96     print(L)
 97 
 98     # print(2 in L)   # True
 99     # print(4 not in L) # False
100 
101     #print(-L)  # 对对象执行负号运算
102 
103     # L1 = MyList([1,3,5])
104     # L2 = MyList([1,3,5,7])
105     # print(L1 > L2)
106     # L = MyList([-1, 2, -3, 5.6789])
107     # L3 = MyList([3,4,5])
108     # print(L + L3)
109     # print(L * 2)
110     # print(2 * L)
111 
112     # print(reversed(L))  # 对象元素逆序并打印
113     # print(len(L))   # 打印返回的长度
114     # print(round(L)) # 打印新产生的对象
115     #                 # 每个元素都是原对象元素的近似值
116     # L2 = abs(L)  # 重写了__abs__()函数,支持abs表达式
117     # print(L2)  # 重写了__str__()函数,所以支持print()
my_list.py
   3)数值转换函数重写
     - int(): 重写__int__()
     - float(): 重写__float__()
     - complex(): 重写__complex__()
     - bool: 重写__bool__()
     示例见my_number.py

  1 # my_number.py
  2 # 自定义数字类型
  3 # 数值转换函数重写示例
  4 class MyNumber:
  5     def __init__(self, value):
  6         self.data = value #值,字符串
  7 
  8     def __int__(self):
  9         return int(float(self.data))
 10 
 11     def __float__(self):
 12         return float(self.data)
 13 
 14     def __complex__(self):
 15         return complex(self.data)
 16 
 17 if __name__ == "__main__":
 18     num = MyNumber("123.45")
 19     print(getattr(num, "data")) # "123.45"
 20     print(num.data)  # "123.45"
 21 
 22     setattr(num, "data", "456.78")
 23     print(getattr(num, "data")) #456.78
 24 
 25     print(hasattr(num, "data")) #True
 26     print(hasattr(num, "aaaa")) #False
 27 
 28     delattr(num, "data") #删除data属性
 29     print(hasattr(num, "data")) #False
 30 
 31     # print(int(num))  #将num对象转换成int
 32     # print(float(num))
 33     # print(complex(num))
my_number.py

my_number

6. 属性管理函数:操作对象属性
   1)getattr: 获取对象属性值
     - 格式: getattr(obj, name[,default])
     - 作用: getattr(x, "y") 等同于
              x.y表达式
             
   2)setattr: 设置对象属性值
     - 格式:setattr(obj, name, value)
     - 作用:setattr(x, "y", "zzz")等同于
             x.y = "zzz"表达式   
    
   3)hasattr: 判断有没有某个属性值
     - 格式:hasattr(obj, name)
     - 返回:布尔类型,有-True 没有-False
  
   4)delattr: 删除对象某个属性值
     - 格式:delattr(obj, name)
     - 作用:delattr(x, "y")等同于
             del x.y 表达式

作业:
1)编写一个账户类(Account)
    属性:账号(acct_no), 户名(acct_name),
          开户日期(reg_date),
          账户类型(acct_type)(借记卡/贷记卡),
          状态(acct_status)(正常,挂失,冻结,注销)
          余额(balance)
    方法:存款(diposite)
          取款(draw)
          冻结(freeze), 解冻(unfreeze)
          挂失(report_loss),解挂失(relieve_loss)
          修改账户信息(modify_acct_info)
2)编写测试代码

  1 # account.py
  2 # 账户类
  3 dict_status = {  #状态字典
  4   0:"正常",1:"冻结",2:"挂失",3:"销户"
  5 }
  6 dict_type = {0:"借记账户", 1:"贷记账户"}
  7 
  8 class Account:
  9     def __init__(self, acct_no, acct_name,
 10                  reg_date, acct_type,
 11                  acct_status, balance):
 12         self.acct_no = acct_no #账号
 13         self.acct_name = acct_name #户名
 14         self.reg_date = reg_date #开户日期
 15         self.acct_type = acct_type #类型
 16         self.acct_status = acct_status #状态
 17         self.balance = balance #余额
 18 
 19     def diposite(self, amt): #存款
 20         print("存款前余额:%.2f"%self.balance)
 21         self.balance += amt #修改余额
 22         print("存款后余额:%.2f"%self.balance)
 23 
 24     def draw(self, amt): #取款
 25         if self.acct_status == 0: #正常
 26             if self.balance < amt: #余额不足
 27                 print("余额不足")
 28                 return
 29             else:  #余额充足
 30                 print("取款前余额:%.2f" % self.balance)
 31                 self.balance -= amt #修改余额
 32                 print("取款后余额:%.2f" % self.balance)
 33         else:  #非正常状态
 34             print("状态不允许取款")
 35 
 36     def freeze(self): # 冻结
 37         if self.acct_status != 0:
 38             print("状态不允许冻结")
 39             return
 40         self.acct_status = 1 #状态置为冻结
 41         print("账户已冻结")
 42 
 43     def unfreeze(self): #解冻
 44         if self.acct_status != 1: #判断已冻结
 45             print("状态不允许解冻")
 46             return
 47         self.acct_status = 0 #状态置为正常
 48         print("账户已解冻")
 49 
 50     def __str__(self): #重写__str__()
 51         # 将状态转换为对应的字符串
 52         status = dict_status[self.acct_status]
 53         # 将类型转换为对应的字符串
 54         type = dict_type[self.acct_type]
 55         ret="账号:%s,户名:%s,开户日期:%s,类型:%s,状态:%s,余额:%.2f"\
 56             %(self.acct_no, self.acct_name, \
 57              self.reg_date, type, \
 58              status, self.balance)
 59         return ret
 60 
 61 if __name__ == "__main__":
 62     acct = Account("6223450001", "张大大",
 63                    "2018-01-01", 0, 0, 2000.00)
 64     acct.diposite(1000.00)  #存款
 65     acct.draw(500)  #取款
 66     print(acct)  #打印账户信息
 67     acct.freeze() #冻结
 68     print(acct)  #打印账户信息
 69     acct.unfreeze() #解冻
 70     print(acct)  #打印账户信息
 71 
 72 
 73 
 74 
account.py

acct

标签:__,day02,self,data,面向对象,print,acct,PYTHON1,def
来源: https://www.cnblogs.com/shengjia/p/10386957.html