#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__
