再次学习python面向对象。

class Employee:
    '所有员工得基类'
    empCount = 0 #empCount是一个类变量，它的值在类得所有实例之间共享。在内外部都可以用Employee.empCount访问
    
    def __init__(self,name,salary): #类得初始化方法或类得构造函数，当创建了这个类得实例时就会调用该方法
        self.name = name
        self.salary = salary
        Employee.empCount += 1 
        
    def displayCount(self):  #self代表类得实例，在定义类得方法时必须有，虽然在调用时不必传入相应得参数
        print("Total Employee %d" % Employee.empCount)
        
    def displayEmployee(self):
        print("Name:",self.name, ",salary:",self.salary)

#创建实例
emp1 = Employee("Zara",2000)
emp2 = Employee("Manni",5000) 

emp1.displayEmployee()

emp1.displayEmployee()

print("Total Employee %d" % Employee.empCount)

#添加或修改类的属性
emp1.age = 7

emp1.age

emp1.age = 8 #修改
del emp1.age #删除age属性

getattr(emp1, 'age') #访问对象的属性。

hasattr(emp1, 'age')    # 如果存在 'age' 属性返回 True。

setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8

delattr(emp1, 'age')    # 删除属性 'age'

python内置类属性
1.dict : 类的属性（包含一个字典，由类的数据属性组成）
2.doc :类的文档字符串
3.name: 类名
4.module: 类定义所在的模块（类的全名是'main.className'，如果类位于一个导入模块mymod中，那么 className.module 等于 mymod）
5.bases : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

class Employee:
   '所有员工的基类'
   empCount = 0
 
   def __init__(self, name, salary):
      self.name = name
      self.salary = salary
      Employee.empCount += 1
   
   def displayCount(self):
     print ("Total Employee %d" % Employee.empCount)
 
   def displayEmployee(self):
      print ("Name : ", self.name,  ", Salary: ", self.salary)
 
print ("Employee.__doc__:", Employee.__doc__)
print ("Employee.__name__:", Employee.__name__)
print ("Employee.__module__:", Employee.__module__)
print ("Employee.__bases__:", Employee.__bases__)
print ("Employee.__dict__:", Employee.__dict__)

#析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行：
class Point:
   def __init__( self, x=0, y=0):
      self.x = x
      self.y = y
   def __del__(self):
      class_name = self.__class__.__name__
      print (class_name, "销毁")
 
pt1 = Point()
pt2 = pt1
pt3 = pt1
print (id(pt1), id(pt2), id(pt3)) # 打印对象的id
del pt1
del pt2
del pt3

class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性，私有属性在类外部无法直接进行访问
    _weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n 
        self.age = a
        self._weight = w 
    def speak(self):
        print("%s 说：我 %d 岁。" %(self.name,self.age))

p = people("hh",10,30)
p.speak()

继承

#单继承
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构造函数
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法，方法重写，函数名不能变，函数体变化。
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))

s = student('ken', 10,60,3)
s.speak()

多继承和多重继承

多继承和多重继承
1.多继承是一个子类同时有两个父类或一个派生类同时有两个基类。
2.如果有这样三个类：人类、士兵类、步兵类，其中：士兵类继承了人类，步兵类继承了士兵类，这三个类之间的关系称之为 多重继承
继承概念
⁃ 在 Python 中允许一个类继承的父类继承自另外一个类，这种形式称为多重继承
⁃ 还允许一个类同时继承多个类，这种形式称为多继承
钻石继承
⁃ 一个类同时继承了两个或两个以上的类，继承的类又同时继承了另外一个类，这种关系称为钻石继承，也称菱形继承
⁃ 钻石继承要避免根类的多次初始化问题

#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
#多重继承和多继承（钻石继承）
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g) 
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

方法重写

class Parent:        # 定义父类
   def myMethod(self):
      print ('调用父类方法')
 
class Child(Parent): # 定义子类
   def myMethod(self):
      print ('调用子类方法')
 
c = Child()          # 子类实例
c.myMethod()         # 子类调用重写方法
super(Child,c).myMethod() #用子类对象调用父类已被覆盖的方法

class Child(Parent): # 定义子类,继承
    def hh(self):
        Parent.myMethod()

c = Child()          # 子类实例
c.myMethod()

子类继承父类构造函数说明

class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name) )
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def getName(self):
        return 'Son '+self.name
 
if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )
'''如果在子类中需要父类的构造方法就需要显式地调用父类的构造方法，或者不重写父类的构造方法。

子类不重写 __init__，实例化子类时，会自动调用父类定义的 __init__。'''

如果重写了init 时，实例化子类，就不会调用父类已经定义的 init

class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name) )
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def __init__(self, name): #重写构造函数，实例化时不再调用父类的构造函数
        print ( "hi" )
        self.name =  name
    def getName(self):
        return Father.getName(self) #继承父类的getName方法
class Son(Father):
    def __init__(self, name):
        print ( "hi" )
        self.name =  name
    def getName(self):  #重写方法
        return 'Son '+self.name
 
if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )

"""
1.如果重写了__init__ 时，要继承父类的构造方法，可以使用 super 关键字：  
2.super(子类，self).__init__(参数1，参数2，....)  
3.父类名称.__init__(self,参数1，参数2，...)
"""
class Father(object):
    def __init__(self, name):
        self.name=name
        print ( "name: %s" %( self.name))
    def getName(self):
        return 'Father ' + self.name
 
class Son(Father):
    def __init__(self, name):
        Father.__init__(self,name)
        #super(Son, self).__init__(name)
        print ("hi")
        self.name =  name
    def getName(self):
        return 'Son '+self.name
 
if __name__=='__main__':
    son=Son('runoob')
    print ( son.getName() )

"""

类的私有属性

__private_attrs：两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self，且为第一个参数，self 代表的是类的实例。

self 的名字并不是规定死的，也可以使用 this，但是最好还是按照约定是用 self。

类的私有方法

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。 self.__private_methods。 """

类的私有变量

class JustCounter:
    __secretCount = 0 #私有变量
    publicCount = 0 #公开变量
    
    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print(self.__secretCount)

counter = JustCounter()
counter.count()
counter.count()
print (counter.publicCount)
#print (counter.__secretCount)  # 报错，实例不能访问私有变量

类的私有方法

class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
#x.__foo()      # 报错

类的专有方法

"""
__init__ : 构造函数，在生成对象时调用
__del__ : 析构函数，释放对象时使用
__repr__ : 打印，转换
__setitem__ : 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__truediv__: 除运算
__mod__: 求余运算
__pow__: 乘方
运算符重载：
让自定义的类生成的对象（实例）能够使用运算符进行操作"""

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b
 
   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
      
   def __add__(self,other): #此方法用来制定self + other的规则
      return Vector(self.a + other.a, self.b + other.b)
   def __sub__(self,other): #此方法用来制定self + other的规则
      return Vector(self.a - other.a, self.b - other.b)  
   def addvector(self,other): #自定义方法来进行加法运算
      return Vector(self.a + other.a, self.b + other.b)
v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2)
print(v1.addvector(v2))#自定义方法进行加法运算
print(v1-v2) #如果没有加入__sub__运算，就会报错