python面向对象

python面向对象

目录:

1.类的定义和使用

2.类的封装

3.类的继承

4.多态

1.类的定义和使用

查、增加、修改、删除、初始化方法、实例化

__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

#python 类的定义和使用     
class Ticket():
     #__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
     #self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。
     #self 代表的是类的实例，代表当前对象的地址
    def __init__(self,checi,fstation,tstation,fdate,ftime,ttime):
        self.checi=checi
        self.fstation=fstation
        self.tstation=tstation
        self.fdate=fdate
        self.ftime=ftime
        self.ttime=ttime
    def printinf(self):
        print("车次",self.checi)
        print("出发站",self.fstation)
        print("到达站",self.tstation)
        print("出发时期",self.fdate)
        print("出发时间",self.ftime)
        print("到达时间",self.ttime)
#实例化类其他编程语言中一般用关键字 new，但是在 Python 中并没有这个关键字，类的实例化类似函数调用方式。
#以下使用类的名称 Ticket 来实例化，并通过 __init__ 方法接收参数。
a1=Ticket("K111","北京","西安","2019-01-18","12:00","16:00")    #创建 Ticket 类的第一个对象(也即实例化类)
a2=Ticket("K112","北京","西安","2019-01-20","12:00","16:00")    #创建 Ticket 类的第二个对象
print(type(a1),a1)  #
print(a1.fdate)     ##使用点号 . 来访问对象的属性
a1.printinf()
a2.printinf()
#可以添加，删除，修改类的属性
# 添加一个 'train' 属性
a1.code = "train"  
print(a1.code)     #train
# 修改 'a1.ftime' 属性
a1.ftime = "10:00"  
print(a1.ftime)     #10:00
# 删除 'a1.ttime' 属性
del a1.ttime  
print(a1.ttime)   #报错：AttributeError: 'Ticket' object has no attribute 'ttime'

2.类的封装

类中把某些属性和方法隐藏起来(或者说定义成私有的)，只在类的内部使用、外部无法访问

在python中用双下划线的方式实现隐藏属性（设置成私有的）

#python 类的封装
import  requests
import shelve
import pickle
class Station():
    def __init__(self,code,cn,qp,jp):
        self.__code=code
        self.__cn=cn
        self.__qp=qp    #私有属性，仅类的内部使用，外部无法调用
        self.__jp=jp
    def getcode(self,s1):
        if s1 in [self.__code,self.__cn,self.__jp]:
            return self.__code
    def getCn(self):
        return self.__cn
    def printinfo(self):
        print("code:{:<10}cn:{:<10}gp:{:<25}jp:{:<20}".format(self.__code,self.__cn,self.__gp,self.__jp))
try:
    with open("stations.txt","rb") as f:
        txt=pickle.load(f)
except Exception as e:
    url="https://kyfw.12306.cn/otn/resources/js/framework/station_name.js?station_version=1.9090"
    txt=requests.get(url).text
    with open("stations.txt","wb") as f:
        pickle.dump(txt,f)
inf=txt[:-2].split("@")[1:]
stations=[]
for record in inf:
    rlist=record.split("|")
    stations.append(Station(rlist[2],rlist[1],rlist[3],rlist[4]))    #直接将类的对象添加到列表中
def getstation(str):
    while True:
            fs=input("%s站:"%str)
            fstations=list(filter(lambda i:i.getcode(fs),stations))
            if len(fstations)==0:
                print("错误的输入!")
                continue
            elif len(fstations)==1:
                print("您输入的%s是%s:"%(str,fstations[0].getCn()))
            elif len(fstations)>1:
                print("检测到比较多的车站信息，提供下列多种选择!")
                for i in range(len(fstations)):
                    print((i+1),"、",fstations[i].getCn(),sep="")
                sel=int(input("请选择:")) - 1
                print("您输入的{}是{}".format(str,fstations[sel].getCn()))
            break    

cfz=getstation("出发")
ddz=getstation("到达")

3.类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

父类的属性和方法子类可以使用

#python 类的继承
#面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。
#通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。
from prettytable import PrettyTable
class Ticket():
    def __init__(self,from_station,to_station,from_time,to_time,id,wu):
        self.from_station=from_station
        self.to_station=to_station
        self.from_time=from_time
        self.to_time=to_time
        self.id=id
        self.wu=wu
    def display(self):
        print(self.id,self.from_station,self.to_station,self.from_time,self.to_time)
#继承Ticket类，继承有什么好处？最大的好处是子类获得了父类的全部属性及功能
class Gd(Ticket):
    def __init__(self,from_station,to_station,from_time,to_time,id,yideng,erdeng,wu):
        Ticket.__init__(self,from_station,to_station,from_time,to_time,id,wu)
        self.yideng=yideng
        self.erdeng=erdeng
    def insert(self):
        ptable=PrettyTable("车次 出发站 到达站 出发时间 到达时间 一等座 二等座 无座".split())
        ptable.add_row([self.id,self.from_station,self.to_station,self.from_time,self.to_time,self.yideng,self.erdeng,self.wu])
        print(ptable)
class Tkz(Ticket):
    def __init__(self,from_station,to_station,from_time,to_time,id,ruanw,yingw,yingzuo,wu):
        Ticket.__init__(self,from_station,to_station,from_time,to_time,id,wu)
        self.ruanw=ruanw
        self.yingw=yingw
        self.yingzuo=yingzuo
            
    def insert(self):
        ptable=PrettyTable("车次 出发站 到达站 出发时间 到达时间 软卧 硬卧 硬座 无座".split())
        ptable.add_row([self.id,self.from_station,self.to_station,self.from_time,self.to_time,self.ruanw,self.yingw,self.yingzuo,self.wu])
        print(ptable)
g1=Gd("北京","上海","10:00","18:00","G11",2,3,4)
g2=Gd("北京","西安","10:00","18:00","G22",2,3,4)
t1=Tkz("北京","西安","12:00","18:00","K112",4,3,4,6)
t2=Tkz("北京","郑州","11:00","18:00","K111",4,3,5,6)
g1.insert()
g2.insert()

4.多态

多态:同一父类的不同子类可以为同名方法执行不同的操作

#python 类的多态 

from prettytable import PrettyTable
class Ticket():
    def __init__(self,from_station,to_station,from_time,to_time,id,wu):
        self.from_station=from_station
        self.to_station=to_station
        self.from_time=from_time
        self.to_time=to_time
        self.id=id
        self.wu=wu
    def display(self):
        print(self.id,self.from_station,self.to_station,self.from_time,self.to_time)
class Gd(Ticket):
    def __init__(self,from_station,to_station,from_time,to_time,id,yideng,erdeng,wu):
        Ticket.__init__(self,from_station,to_station,from_time,to_time,id,wu)
        self.yideng=yideng
        self.erdeng=erdeng
    def display(self):
        ptable=PrettyTable("车次 出发站 到达站 出发时间 到达时间 一等座 二等座 无座".split())
        ptable.add_row([self.id,self.from_station,self.to_station,self.from_time,self.to_time,self.yideng,self.erdeng,self.wu])
        print(ptable)
class Tkz(Ticket):
    def __init__(self,from_station,to_station,from_time,to_time,id,ruanw,yingw,yingzuo,wu):
        Ticket.__init__(self,from_station,to_station,from_time,to_time,id,wu)
        self.ruanw=ruanw
        self.yingw=yingw
        self.yingzuo=yingzuo
            
    def display(self):
        ptable=PrettyTable("车次 出发站 到达站 出发时间 到达时间 软卧 硬卧 硬座 无座".split())
        ptable.add_row([self.id,self.from_station,self.to_station,self.from_time,self.to_time,self.ruanw,self.yingw,self.yingzuo,self.wu])
        print(ptable)
g1=Gd("北京","上海","10:00","18:00","G11",2,3,4)
g2=Gd("北京","西安","10:00","18:00","G22",2,3,4)
t1=Tkz("北京","西安","12:00","18:00","K112",4,3,4,6)
t2=Tkz("北京","郑州","11:00","18:00","K111",4,3,5,6)
for i in [g1,g2,t1,t2]:
    i.display()

通过上面的代码可以看到，不同的子类子类以及父类都有"display"方法,在代码末尾不同的对象调用相同的方法名，但结果却显示不同，这就是多态。