python核心编程 第十三章 类

#encoding=utf-8
class baseclass(object):
    pass
class classname(baseclass):#baseclass父类
    pass
    #class_suite#类体
#如果没有父类，用object“所有类之母”，python特性
myclassObject = classname() #实例化，保存到变量myclassObject中，否则会自动回收

class MyData(object):
    pass #类作为名称空间，没有任何实现，只是为了给实例提供相同的关系空间

myObj = MyData()
myObj.x = 4
myObj.y = 5
#MyData类没有任何方法或属性，x，y是实例的独特属性，不是类的属性
#实例使用类作为名称空间容器

'''-------------类的功能 方法--------------------'''
'''--调用方法1）定义类（方法）2）创建实例3）用实例调用方法--------'''
class MyClass(object):
    def foo(self):
        print 'class method'
#self在所有类的方法声明中都存在？。self代表实例对象本身
#假设有一个带两参数的方法，所有调用只需要传递第二个参数
myobj = MyClass()
myobj.foo()

'''----------------理解self-------------------'''
#self只有在类的方法中才会有，独立的函数或方法是不必带有self的。
#self在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

#self指的是类实例对象本身(注意：不是类本身)。
#为什么self不指向类本身，若是，有多个实例对象时，self指向哪个呢？

#self不必非写成self，但是约定俗成，统一标准便于理解

#假如你有一个带两参数的方法，所有你的调用只需要传递第二个参数
#比如def foo(self,name)   foo('bill')

'''----__init__()方法-----'''
#实例化过程中。调用__init__(),相当于构造函数，可以设定一些初始值，或运行一些初步诊断代码
#在实例被创建后，实例化调用返回这个实例之前，去执行一些特定的任务

class myclass(object):
    def __init__(self,nm,ph):#定义构造器
        self.name = nm     #设置name
        self.phone = ph          #设置phone
        print 'create instance for :',self.name
    def updataPhone(self,newph): #定义方法
        self.phone = newph
        print 'updata phone for :',self.name
#实例化myclass时候会隐式调用__init__()

'''--------创建实例------------'''
john = myclass('John Doe','4085551212')
jane = myclass('Jane Doe','6505551212')
'''--------访问实例属性-----------'''
print john  #<__main__.mayclasss object at 实例对象的地址>
print john.name,john.phone,jane.name,jane.phone
'''-----方法调用（通过实例）---------'''
jane.updataPhone('4155551212')
print jane.phone

'''---------创建子类-----------'''
#子类保持父类所有特性，定制属于它的特色功能
#子类继承了基类的属性，继承了updatePhone方法
class EmployeeClass(myclass):
    def __init__(self,nm,ph,id,em):
        #子类定义自己的__init__，否则基类的__init__会被调用
        #子类重写自己的构造器，则需要显示调用基类的构造器才会被执行
        myclass.__init__(self,nm,ph)
        #显示调用基类的__init__需要，显示传递self实例，
        #因为我们是在子类实例中调用这个方法？
        self.empid = id
        self.email = em
    def updateemali(self,newem):
        self.email = newem
        print 'updata email address for:',self.name
john = EmployeeClass('John Doe','4085551212',42,'john@spam.doe')
print john
print john.name,john.phone,john.email
john.updataPhone('4155551212')
print john.phone
john.updateemali('john@doe.spam')
print john.email

#类对比现实世界，像汽车修理店，实例就像一个类的参与者
#抽象，类的属性，数据的接口的实现。就是创建类的属性和方法
#封装，通过接口访问。但是python类的属性是完全公开的。
#派生，子类
#多态，对于c++：virtue，覆盖重载，接口重用，python不支持纯虚函数，
class C(object):
    foo = 100
print C.foo
#方法绑定，没有实例，方法是不能被调用的

#查看类的属性，dir(),__dict__
class Myclass(object):
    myVersion = '1.2'
    def showMyVersion(self):
        print Myclass.myVersion
print dir(Myclass) #返回列表，对象的属性的一个名字列表
print Myclass.__dict__    #返回字典，keys=属性名，values=属性对象的数据值

#特殊的类属性
print C.__name__,C.__doc__,C.__bases__,C.__dict__,C.__module__,C.__class__
    #类C的名字,文档说明，  所有父类    属性  定义所在模块__main__ 实例C对应的类

#__new__()更像一个构造器，__del__()解构器，但是python有垃圾对象回收机制
#解构器只被调用一次，引用计数为0，隐式调用解构器
c1 = C()    #实例初始化
c2 = c1        #创建一个别名
c3 = c1        #创建另一个别名
print id(c1),id(c2),id(c3)     #返回同一引用
del c1 #清除一个引用
del c2
del c3 #引用全部清除，调用解构器


#计算在美国一些大都市中的旅馆中寄宿时，租房总费用。
class HotelRoomCalc(object):
    'hotel room rate calculator'
    def  __init__(self,rt,sales=0.085,rm=0.1):
        self.salesTax = sales
        self.roomTax = rm
        self.roomRate = rt
    def calcTotal(self,days=1):
        daily = round((self.roomRate *14 *(1 + self.roomTax + self.salesTax)), 2)
        #daily = round((self.roomRate * 14 (1+self,roomTax+self.salesTax)),2)
        return float(days) * daily

sfo = HotelRoomCalc(299)
print sfo.calcTotal()    #一天租金
print sfo.calcTotal(2)    #2天租金

sea = HotelRoomCalc(189,0.086,0.068)#新实例
print sea.calcTotal()

#查看实例属性，dir(),__dict__
print dir(sea)
print sea.__dict__