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

PYTHON1.面向对象_day03

作者:互联网

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

上次内容回顾
1. 多态
   1)什么是多态:同一个方法,在不同
      子类中有不同的表现
   2)方法的重写来实现
   3)保持程序的扩展性、灵活性
  
2. 面向对象的技术特性
   1)构造方法与析构方法
     a)构造:__init__()
        调用时机:对象被创建时自动调用
        作用:创建对象属性,并赋值
        注意:子类构造方法显示调用父类构造
              方法
     b)析构方法:__del__()
        调用时机:对象被销毁时调用
        作用:对象销毁时执行清理操作
       
   2)object类:所有类最终的父类
                如果类定义时没有指定父类
                默认从object中继承
                __base__查看父类
  3)super()和issubclass()函数
      super(): 获得父类的绑定
      两种格式:super()  只能在类方法中使用
                super(type, obj) obj必须是type示例化的对象
     
      issubclass():判断某个是不是另一个类的子类
      格式:issubclass(cls, cls_or_tuple)

  4)多重继承:一个类有多个父类
      MRO: 方法解析顺序,__mro__
           从下至上,从左至右
          
3. 函数重写:让对象操作更方便
   1)对象转字符串函数
     str(): __str__(),返回字符串给人阅读
     repr():__repr__(),返回字符串给解释器阅读
 
   2)内建函数
     abs(): __abs__()
     len(): __len__()
     reversed(): __reversed()__
     round():__round()__
    
   3)数值转换函数
     int(): __int__()
     float(): __float__()
     complex(): __complex__()
     bool(): __bool__()
    
4. 属性操作函数
   getattr(obj, name):获取对象属性
   setattr(obj, name, value):设置某个属性值
   hasattr(obj, name):判断对象有没有某个属性
   delattr(obj, name):删除某个属性值
  
作业:见account.py


今天内容
1. 可迭代对象
   1)什么是迭代器
   2)代码特征:重写__iter__()方法返回可迭代对象
                重写__next__()方法获取下一个元素
   3)__next__()方法,实现迭代器协议
      如果有下一个元素,则返回
      如果没有下一个元素,抛出StopIteration异常
   4)示例:见myiter.py

  1 # myiter.py
  2 # 通过函数重写,实现自定义迭代器
  3 class MyIter:
  4     #用列表初始化对象
  5     def __init__(self, lst):
  6         self.data = lst #lst是列表
  7         self.cur_index = 0 #计数器
  8 
  9     def __iter__(self):# 返回可迭代对象
 10         return MyIter(self.data)
 11 
 12     def __next__(self):# 获取下一个元素
 13         if self.cur_index >= len(self.data):
 14             raise StopIteration #抛出异常
 15         else:
 16             i = self.cur_index #记录计数器
 17             self.cur_index += 1 #计数器加1
 18             return self.data[i] #返回元素
 19 
 20 if __name__ == "__main__":
 21     myiter = MyIter(range(1,10))
 22     for x in myiter:
 23         print(x, end=" ")
 24 
myiter.py

myiter

2. 运算符重载
   1)什么是运算重载:自定义类中,重写
     某些方法,重写后就可以对对象进行
     某些运算符操作
   2)目的
      a)简化对象操作。例如:
        c = "abc" + "123"
        d = "123" > "456"
      b)代码清晰、直观
      c)可以在类中自定义运算规则    
      注意:运算重载不要改变原有意义
 
   3)算术运算符重载
     - 重写方法后,支持+,-,*,//,/,%,**
     - 重载方法和运算符的对应关系
       __add__(self,rhs)   self + rhs
       __sub__(self,rhs)   self - rhs
       __mul__(self,rhs)   self * rhs
       __truediv__(self,rhs)   self / rhs
       __floordiv__(self,rhs)  self // rhs
       __mod__(self,rhs)       self % rhs
       __pow__(self,rhs)       self ** rhs

  
   课堂练习:在MyList类中,重载+,*运算符
           L1 = MyList([1,2,3])
           L2 = MyList([4,5,6])
           L1 + L2==>MyList([1,2,3,4,5,6])
           L1*2 ==> MyList([1,2,3,1,2,3])
           见mylist.py
          
     4)反向算术运算符重载
        在正向运算符重载的函数前面加r
        例如:__radd__(), __rsub__()...
        支持:2 + obj (对象在操作符右边)

    5)复合运算操作符
        在正向运算符重载的方法前加i前缀
        例如:__iadd__(), __isub__()...
        重载运算符后,执行复合表达式
        ojb += 2,首先查找__iadd__(),
        如果没有找到,则再查找__add__(),
        如果再没有找到,报TypeError异常
       
     6)比较运算符:>,<,>=,<=,==,!=
       - 重写方法和运算符的对照关系
         __lt__(self, rhs)   self < rhs
         __gt__(self, rhs)   self > rhs
         __eq__(self, rhs)   self == rhs
         __ne__(self, rhs)   self != rhs
         __ge__(self, rhs)   self >= rhs
         __le__(self, rhs)   self <= rhs

       - 示例:见truck.py

  1 # truck.py
  2 # 卡车类,演示运算符重载
  3 class Truck:
  4     def __init__(self, load):
  5         self.load = load #载重
  6 
  7     def __add__(self, value):#重载+运算符
  8         print("__add__()被调用")
  9         return Truck(self.load + value)
 10 
 11     def __mul__(self, value): #重载*运算符
 12         return Truck(self.load * value)
 13 
 14     #反向+运算符重载,支持 3 + truck操作
 15     def __radd__(self, value):
 16         print("__radd__()被调用")
 17         return Truck(self.load + value)
 18 
 19     # 符合运算符重载,支持obj += 2表达式
 20     # def __iadd__(self, value):
 21     #     print("__iadd__()被调用")
 22     #     return Truck(self.load + value)
 23 
 24     def __str__(self):
 25         return "load: %d" % self.load
 26 
 27     def __gt__(self, other): # 重载>运算符
 28         print("__gt__()方法被调用")
 29         if self.load > other.load:
 30             return True
 31         else:
 32             return False
 33 
 34     # def __lt__(self, other): # 重载<运算符
 35     #     if self.load < other.load:
 36     #         return True
 37     #     else:
 38     #         return False
 39 
 40 if __name__ == "__main__":
 41     t1 = Truck(20)
 42     t2 = Truck(25)
 43     print(t1 > t2)  # 调用__gt__()
 44     print(t1 < t2)  # 调用__lt__()
 45     #t = Truck(20)
 46     #t2 = t + 1 # t2接受返回的对象
 47     #t2 = 1 + t  # 调用__radd__()方法
 48     # t += 1 # 调用__iadd__()方法,如果没有该方法,调用__add__
 49     # print(t)
 50     # t3 = t * 4
 51     # print(t3)
truck.pytruck
       - 比较规则:
         >: 首先找__gt__(), 没有找__lt__()
            并将执行__lt__()结果取反
            如果__lt__()不存在则报错
         <: 规则和大于相反
         >=:首先找__ge__(), 没有找__le__()
            并将执行__le__()结果取反
            __le__()不存在则报错
         <=:规则和大于等于相反
         ==:首先找__eq__(), 如果不能存在则
            判断两个对象ID值,相同返回True
            不同返回False
         !=:首先找__ne__(),不存在则找
            __eq__()并执行取反
            如果__eq__()不存在则比较ID
            ID相同返回False,否则返回True
     
     课堂练习:在MyList类中,重载>,<,==,!=
       操作符,比较规则如下:
       等于:data属性元素个数相等
             并且相同位置上的值相等
       大小比较:[1,2,4] > [1,2,3]
                 [1,2,3,4] > [1,2,3]
                 [1,2,4] > [1,2,3,4]
       代码见:mylist.py   
      
     7)一元运算符:带一个操作数的操作符
       __neg__(self)   -self  负号运算
       __pos__(self)   +self  正号运算
       __invert__(self) ~self 取反运算

      
       作用:重写上述方法,支持对象如下操作:
             -obj, +obj, ~obj
            
     8)in/not in运算符重载
        只需要重载__contains__(self,e)
        in运算,则直接调用__contains__()
        not in运算,调用__contains__()取反

    
     9)索引运算符重载:支持[]操作
        __getitem__(self,i)       self[i]
        __setitem__(self,i,value) self[i]=value
        __delitem__(self,i)       del self[i]

3. 实例的内置属性
   1)__dict__属性:绑定实例自身的变量字典
      包括父类创建的属性和私有属性

      示例:
      am = AutoMobile("卡车","blue",4.0)
      print(am.__dict__)

     
  2)__class__属性:绑定创建该对象的类
     
作业:   
1)编写一个汽车租赁程序,包含汽车类(Car),
客户类(Customer), 租车店类(CarStore),各个
类包含的属性和方法有:
     Car类:
         属性
         car_id    车辆id号
         name    车辆名称
         is_lend    是否出租
         price    每天单价
         start_date    起租日期
         end_date    租赁终止日期
         方法
         __str__()
        
     Customer类:
         属性
         cust_id        客户编号
         cust_name    客户姓名
         tel_no        客户电话
         方法
         __str__()
     CarStore类:
         属性
         cars        所有车辆列表
         customers    所有客户列表
         方法
         __load_cars()    加载所有车辆信息
         __load_customers()    加载所有客户信息
         print_cars_info()    打印所有车辆信息
         find_car()            查找车辆
         add_car()            添加车辆
         del_car()            删除汽车
         lend()                租车
         back()                还车
2)实现上述类,并编写测试代码
    

  1 # car_store.py
  2 # 汽车租赁模拟程序
  3 class Car: # 车辆类
  4     def __init__(self, car_id, name,
  5                  price, is_lend):
  6         self.car_id = car_id #车辆编号
  7         self.name = name #名称
  8         self.price = price #价格
  9         self.is_lend = is_lend #是否出租
 10         self.start_date = "" #起租日期
 11         self.end_date = "" #预计归还日期
 12         self.cust_id = "" #租车客户编号
 13 
 14     def __str__(self):
 15         ret = "车辆编号:%s,名称:%s,单价:%.2f," \
 16             "是否出租:%s" %(self.car_id,
 17             self.name, self.price,self.is_lend)
 18         return ret
 19 
 20 class Customer: #客户类
 21     def __init__(self,cust_id,cust_name,tel_no):
 22         self.cust_id = cust_id
 23         self.cust_name = cust_name
 24         self.tel_no = tel_no
 25 
 26     def __str__(self):
 27         ret = "客户编号:%s,客户名称:%s,电话:%s" \
 28           %(self.cust_id, self.cust_name, self.tel_no)
 29 
 30 class CarStore: #租车店类
 31     def __init__(self):
 32         self.cars = [] #车辆列表
 33         self.customers = [] #客户列表
 34         self.__load_cars() #加载车辆列表
 35         self.__load_customers()#加载客户列表
 36 
 37     def __load_cars(self): #加载车辆列表
 38         self.cars.append(Car("1","GOLF",400,"否"))
 39         self.cars.append(Car("2","凯越",350,"否"))
 40         self.cars.append(Car("3","奥迪",1200,"否"))
 41         self.cars.append(Car("4","凯美瑞",800,"否"))
 42         self.cars.append(Car("5","宝来",450,"否"))
 43 
 44     def __load_cars(self): #加载车辆列表,从文件中读取
 45         with open("/home/tarena/aid1805/lx/面向对象/day03/cars_list.txt") as f:
 46             line = f.readline(256).replace("\n","")
 47             custinfo = line.split(",")
 48             car_id = custinfo[0]
 49             car_name = custinfo[1]
 50             price = float(custinfo[2])
 51             is_len = custinfo[3]
 52             car = Car(car_id,car_name,price,is_len)
 53             self.cars.append(car) #对象添加到列表
 54 
 55     def __load_customers(self):#加载客户列表
 56         cust1 = Customer("C0001","张大大","15811223344")
 57         cust2 = Customer("C0002","李小小","13233333444")
 58         cust3 = Customer("C0003","赵四","18044445555")
 59         self.customers.append(cust1)
 60         self.customers.append(cust2)
 61         self.customers.append(cust3)
 62 
 63     def print_cars_info(self): #打印车辆信息
 64         for car in self.cars: #遍历车辆列表并打印
 65             print(car)
 66 
 67     def find_car(self, car_id): #根据车辆编号查询
 68         for car in self.cars: #遍历车辆列表
 69             if car.car_id == car_id: #编号相等
 70                 print(car)
 71                 return
 72         print("未找到车辆信息")
 73         return
 74 
 75     def add_car(self, car): #添加车辆,car为Car的对象
 76         if isinstance(car, Car): #car是Car类的实例
 77             self.cars.append(car)
 78         else:
 79             print("对象类型有误")
 80         #可以增加id号是否存在的逻辑判断
 81         return
 82 
 83     def del_car(self, car_id): #根据车辆编号删除
 84         for car in self.cars:
 85             if car.car_id == car_id:
 86                 self.cars.remove(car) #删除对象
 87         return
 88 
 89     def lend(self, car_id, cust_id,
 90             start_date, end_date): #租车
 91         for car in self.cars:
 92             if car.car_id == car_id:
 93                 if car.is_lend == "是":#已出租
 94                     print("该车辆已经出租")
 95                     return
 96                 else: #未出租
 97                     setattr(car, "is_lend", "是")#改状态
 98                     setattr(car, "cust_id", cust_id)
 99                     setattr(car, "start_date", start_date)
100                     setattr(car, "end_date", end_date)
101                     print("车辆出租登记完成")
102                     return
103         print("未找到车辆信息")
104         return
105 
106     def back(self, car_id): #还车
107         for car in self.cars:
108             if car.car_id == car_id:
109                 setattr(car, "is_lend", "否")#改状态
110                 setattr(car, "cust_id", "")
111                 setattr(car, "start_date", "")
112                 setattr(car, "end_date", "")
113                 print("还车登记完成")
114                 return
115         print("未找到该车辆信息")
116         return
117 
118 if __name__ == "__main__":
119     car_store = CarStore()  #实例化租车店对象
120     car_store.print_cars_info() #打印车辆信息
121     print("")
122     #租车方法测试
123     car_store.lend("3","C0001","2018-01-01","2018-01-03")
124     car_store.print_cars_info()
125 
126     #还车方法测试
127     car_store.back("3")
128     car_store.print_cars_info()
129 
130      #添加车辆方法测试
131     car_store.find_car("3") #查找编号为3的车辆
132 
133     car = Car("6","捷达",300,"否")
134     car_store.add_car(car)  #将car对象添加到cars列表
135     car_store.print_cars_info()
car_store.pycar_store

标签:__,day03,car,self,面向对象,cars,PYTHON1,id,def
来源: https://www.cnblogs.com/shengjia/p/10387147.html