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"方法,在代码末尾不同的对象调用相同的方法名，但结果却显示不同，这就是多态。
