python基础-面向对象（类）

类

1. 类的定义

>>> class P:

...     pass

...

>>> P

<class __main__.P at 0x0000000001F4B828>

类对象：只有具备自己的一些属性+操作这些属性的方法就可以成为对象，因为类也是对象

类是模板

 

类对象的使用：

#coding=utf-8

#类变量声明：变量名 =xxx    （全局变量）
#类变量调用：类名.变量名
#实例变量赋值：self.变量名 = xxx
#调用实例变量：self.变量名

#class TOY:          #经典类
class TOY(object):   #新式类
    TOY_NUMBER =0    #类变量
    def __init__(self,length,width,height,colour): #构造函数
        self.length = length  #实例变量
        self.width = width    #实例变量
        self.height = height  #实例变量
        self.colour =colour   #实例变量
        TOY.TOY_NUMBER +=1    #操作类变量

    def get_size(self):  #实例方法定义必须有self
                         #self表示未来调用此方法的具体实例
        return self.length,self.width,self.height

    def get_colour(self):#实例方法
        return self.colour

print TOY.TOY_NUMBER

duck = TOY(1,1,1,"yellow")  #实例化是生成实例的过程
duck.voice = "gaga"
print duck.voice
print duck
print duck.get_size()
print duck.get_colour()
print duck.height  #调用类的实例变量
print TOY.TOY_NUMBER

dog = TOY(10,10,10,"white")
print TOY.TOY_NUMBER

 

1. 类的实例化（从模板生成一个东西的过程就是实例化）

>>> x

<__main__.P instance at 0x0000000002795F08>

实例化对象：实例化后的结果就是实例化对象

实例是利用模板造出来的东西

实例是实例化之后的结果。实例化是一个过程。

 

练习：

 

 

 

1. 创建类

#coding=utf-8

 

class Employee(object):

  #所有员工基类

    empCount = 0

 

    def __init__(self, name, salary) :

    #类的构造函数

      self.name = name

      self.salary = salary

      Employee.empCount += 1

 

    def displayCount(self) :

     #类方法

      print "total employee ",Employee.empCount

 

    def displayEmployee(self) :

      print "name :",self.name , ", salary :", self.salary

 

    def f(self):

      self.displayEmployee()

 

e=Employee("wulaoshi","10k")

e.f()

 

 

 

类变量要用类名.变量名调用；实际变量要用实例变量名.变量名调用

实例变量也可以调用类变量，实例变量名.类变量名  此时会生成实例变量，不会影响类变量，只是两个变量重名。

实例：成员变量（我要操作的数据）+方法（我怎么操作这组数据）

实例：成员变量（类属性：类变量和实例变量）+方法（1 实例方法  2 静态方法 类方法）

 

4、类方法、实例方法、和静态方法

#encoding=utf-8
class Person:
    count=0
    def get_name(self):
        #实例方法
        self.f=1
        Person.count=10
        return "gloryroad!"

    @classmethod         #类方法
    def get_sex(cls,sex):
        #self.f=1     #  类方法和静态方法都不能使用实例化变量
        Person.count=20   #类方法、静态方法、实例方法都可以调用类变量
        return sex

    @staticmethod         #静态方法
    def get_height(height):
        #self.f=1
        Person.count=30
        return height

print Person.get_sex("male")  #类方法和静态方法不需要实例化就能直接调用；也可以实例化之后用实例化变量去调用
print Person.get_height(180)
p=Person()
print p.get_name()

 

 

小练习：

写一个类，有3种类方法

实例方法

类方法

静态方法

用类调用，一种是用实例调用，分别调用一下

 

#coding=utf-8


class BIRD:
    """gloryroad bird!"""
    REVOKE_COUNT =0
    sex = "male"
    def __init__(self,name):
        self.name 

 =name +" in the sanya"
        
 
    def get_name(self):
        BIRD.REVOKE_COUNT +=1
        print "REVOKE_COUNT:",BIRD.REVOKE_COUNT

        return self.name 

    @classmethod
    def set_sex(cls,sex):
        print cls.__module__
        BIRD.sex = sex
        return BIRD.sex

    @staticmethod
    def set_voice(voice):
        BIRD.voice =voice
        #print self.name 

        return  BIRD.voice

b=BIRD("seagull2")
print b.get_name()
print BIRD.set_sex("f")
print b.set_sex("m")
print BIRD.set_voice("a.......")
print b.set_voice("a.......")

#函数里面的传入参数：局部变量

#带有类名调用的变量：类变量

#带有self的变量：实例变量

#方法里面的局部变量：既没有类名，也没有self,在方法里声明和使用

#方法执行完毕，则局部变量被释放掉，且无法使用。

#类方法：可以被实例和类分别调用，可以使用类变量，不可以使用实例变量

#         类方法可以仅使用类名做调用，即不需要生成实例，所以不能使用

#         实例变量

#实例方法：可以使用实例变量，可以使用类变量。

#静态方法：不支持实例变量，理由同类方法，不使用附加的self，cls参数

#可以支持类和实例分别调用

 

 

1. 调用

调用被封装的内容时，有两种情况：
➢通过对象直接调用
➢通过 self 间接调用

实例化变量 增、删、改

#coding=utf-8
class BIRD:
    def __init__(self,name):
        print "name1"
b=BIRD("seagull")
b.age =1 
print b.age
del b.age
print b.age

 

类变量增、删、改
#coding=utf-8
class BIRD:
    def __init__(self,name):
        print "name1"
b=BIRD("seagull")
BIRD.age = 11
print BIRD.age
BIRD.age = 12
print BIRD.age
del BIRD.age
print BIRD.age

 

 

 

实例是可以调用类变量的，因此当类变量名和实例变量名同名时，删除了实例变量，再去调用时会自动去找到类变量，因此下面的例子没有报错

#enconding = utf-8

class BIRD:

    def __init__(self,name):

        print "name1"

 

b=BIRD("s1")

b.age = 111

print b.age

BIRD.age = 11

print BIRD.age

 

del b.age

print b.age

 

 

#enconding = utf-8

class BIRD:

    def __init__(self,name):

        print "name1"

 

b=BIRD("s1")

b.age = 111

print b.age

BIRD.age = 11

print BIRD.age

 

del b.age

print b.age

 

del b.age

print b.age

但是二次删除就找不到类变量了，就会报错了

 

 

1. 经典类的属性

#encoding=utf-8

class Foo:

 

    def func(self):

        print "func!"

 

    # 定义属性

    @property

    def prop(self):

       # log.info (“gloryroad”)

        return "gloryroad"

# ############### 调用 ###############

foo_obj = Foo()

 

foo_obj.func()

print foo_obj.prop   #调用属性

 

 

方法：foo_obj.func()
属性：foo_obj.prop

@property装饰器就是负责把一个方法变成属性调用的

 

1. 新式类的属性

#encoding=utf-8

class Goods(object):

 

    @property

    def price(self):

        print '@property'

 

    @price.setter

    def price(self, value):

        print '@price.setter'

 

    @price.deleter

    def price(self):

        print '@price.deleter'

 

# ############### 调用

obj = Goods()

 

obj.price          # 自动执行 @property 修饰的 price 方法，并获取方法的返回值

 

obj.price = 123   # 自动执行 @price.setter修饰的 price 方法，并将 123 赋值给方法的参数

del obj.price      # # 自动执行 @price.deleter修饰的 price 方法

 

 

小练习：自行修改setter，控制值在100到1000直接才能修改，否则不能修改

#encoding=utf-8

class Goods(object):

 

    @property

    def price(self):

        print '@property'

 

    @price.setter

    def price(self, value):

        if not isinstance(value,int):

            raise ValueError('price must be an integer!')

        if value<100 or value>1000:

            raise ValueError('price must between 100~1000!')

        self._price = value

    

    @price.deleter

    def price(self):

        print '@price.deleter'

 

# ############### 调用

obj = Goods()

obj.price    

obj.price = 120

print obj._price

 

del obj.price

 

 

 

 

老师的方法：

#encoding=utf-8

class Goods(object):
    def __init__(self,value):
        self.value = value

    @property
    def price(self):
        print '@property'
        return self.value

    @price.setter
    def price(self, value):
        print '@price.setter'
        if value >=100 and value <=1000:
            self.value = value

    @price.deleter
    def price(self):
        print '@price.deleter'
        del self.value

# ############### 调用
obj = Goods(100)
print obj.price
obj.price = 123    # 自动执行 @price.setter 修饰的 price 方法，并
print obj.price
del obj.price      # 自动执行 @price.deleter 修饰的 price 方法
#print obj.price

 

 

注意：只适用于新式类

新式类中的属性有三种访问方式，并分别对应了三个被@property、 @方法名.setter、 @方法名.deleter修饰的方法

 

1. 使用函数添加、删除、修改、访问类属性

getattr(obj, name[, default]) : 访问对象的属性，如果存在返回对象属性的值，
否则抛出AttributeError异常

（1）访问的属性不存在，且无默认返回值

#encoding=utf-8

 

class Goods(object):

 

    def __init__(self,value):

        self.value = value

 

obj = Goods(100)

print getattr(obj,"value1")

 

（2）访问的属性不存在，默认返回值为“000000”

#encoding=utf-8

 

class Goods(object):

 

    def __init__(self,value):

        self.value = value

 

obj = Goods(100)

print getattr(obj,"value1","000000")

 

 

 

（3）访问的属性存在

#encoding=utf-8

 

class Goods(object):

 

    def __init__(self,value):

        self.value = value

 

obj = Goods(100)

print getattr(obj,"value")

 

 

 

hasattr(obj,name) : 检查是否存在某个属性，存在返回True，否则返回False

#encoding=utf-8

 

class Goods(object):

 

    def __init__(self,value):

        self.value = value

 

obj = Goods(100)

print hasattr(obj,"value")

print hasattr(obj,"value1")

 

 

 

setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性，该函数无返回值。若存在则更新这个值

#encoding=utf-8

 

class Goods(object):

 

    def __init__(self,value):

        self.value = value

 

obj = Goods(100)

setattr(obj,"value",1111)

print obj.value

 

setattr(obj,"value1",2222)

print obj.value1

 

 

delattr(obj, name) : 删除属性，如果属性不存在则抛出AttributeError异常，该函数也无返回值。

#encoding=utf-8

 

class Goods(object):

 

    def __init__(self,value):

        self.value = value

 

obj = Goods(100)

setattr(obj,"value",1111)

print obj.value

 

setattr(obj,"value1",2222)

print obj.value1

 

delattr(obj,"value1")

delattr(obj,"value2")

 

 

 

小练习：判断是否存在，如果存在就删除并提示删除成功

#encoding=utf-8

 

class Goods(object):

 

    def __init__(self,value):

        self.value = value

 

obj = Goods(100)

setattr(obj,"value",1111)

print obj.value

 

setattr(obj,"value1",2222)

print obj.value1

 

 

if hasattr(obj,"value1"):

    delattr(obj,"value1")

print "del success"

 

 

1. Python内置类属性

Python有如下内置的类属性：
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
__doc__ :类的文档字符串，也就是类的帮助信息。
__name__: 类名
__module__: 类定义所在的模块（类的全名是’ __main__.className’ ，如果类位于一个导入模块mymod中，那么className.__module__ 等于mymod）
__bases__ : 类的所有父类（包含了所有父类组成的元组）

#encoding=utf-8

 

class Goods(object):

 

    def __init__(self,value):

        self.value = value

 

obj = Goods(100)

print Goods.__dict__

 

print"--"*50

print Goods.__doc__

 

print"--"*50

print Goods.__name__

 

print"--"*50

print Goods.__module__

 

print"--"*50

print Goods.__bases__

 

 

常量举例：

#coding=utf-8

class _const:

    class ConstError(TypeError):pass

    def __setattr__(self, name, value):

        if self.__dict__.has_key(name):

            raise self.ConstError, "Can't rebind const (%s)" %name

        self.__dict__[name]=value

 

import sys

print __name__

sys.modules[__name__] = _const()

 

 

小练习：导入了其他的木块，想确定使用的某个类在哪个包里面，可以用__module__获取

a.py:

#encoding=utf-8
class Goods(object):
    """good class """
    def __init__(self,value):
        self.value = value
        self.name 

 = "name"

    def get_name(self):
        return "goods name"
# ############### 调用
obj = Goods(100)
#print Goods.__module__

 

b.py

#coding=utf-8
import b
print b.Goods.__module__

 

 

1. 类变量

修改类变量：

#encoding=utf-8

class Goods(object):
    """good class """
    num = 100
    def __init__(self,value):
        self.value = value
        self.name  = "name"
    @staticmethod
    def set_num():
        Goods.num =1

# ############### 调用
obj = Goods(100)
obj.set_num()
print obj.num

 

1. 小结几种方法的区别

类方法可以被类对象或实例调用，实例方法只能被实例调用，它只属于类的单个实例拥有，静态方法两者都能调用，它在类和实例间共享。 Python实现了一定的灵活性使得类方法和静态方法，都能够被实例和类二者调用。

所以三者主要区别在于参数传递上的区别，实例方法隐含传的参数是类实例self，而类方法隐含传递的参数是类本身cls，而静态方法无隐含参数，主要为了类实例也可以直接调用静态方法。

1. Python类中隐藏数据

__init   两个__ 下划线的是私有方法

私有方法在类的内部可以随意调用，外部不能随便调用

#encoding=utf-8

class Goods(object):
    """good class """
    num = 100
    def __init__(self,value):
        self.value = value
        self.name= "name"

    def __func(self):   #私有方法
        print "private method"
    
    def get_name(self):
        self.__func()

# ############### 调用
obj = Goods(100)
obj.get_name()    #通过get_name间接调用私有方法self.__func()

 

练习：自己写一个私有方法并调用

#encoding=utf-8

 

class Goods(object):

    """good class """

    num = 100

    def __init__(self,value):

        self.value = value

        self.name= "name"

 

    def __test(self):

        print "private method"

    

    def get_name(self):

        self.__test()

 

# ############### 调用

obj = Goods(100)

#obj.test()   #在类外部直接调用私有方法是不可以的

obj.get_name()

 

 

 

 

 

1. 类的私有属性

#encoding=utf-8

class Goods(object):
    """good class """
    __num = 100
    def __init__(self,value):
        self.value = value
        self.__name = "name"
    
    def get_name(self):
        print Goods.__num
        print self.__name

# ############### 调用
obj = Goods(100)
print obj.get_name()

 

  练习：自己定义类的私有属性，并在类外部调用

#encoding=utf-8

 

class Goods(object):

    """good class """

    __num = 100

    def __init__(self,value):

        self.value = value

        self.__name= "name"   #这里得用self调用，直接用Goods不行

 

    def test(self):

        print Goods.__num

        print self.__name

# ############### 调用

obj = Goods(100)

#print Goods.__num

#print Goods.__name

print obj.test()

 

 

1. 但是私有也可以通过特殊方法进行修改

#encoding=utf-8

 

class Goods(object):

    """good class """

    __num = 100

    def __init__(self,value):

        self.value = value

        self.__name = "name"

    

    def get_name(self):

        print Goods.__num

        print self.__name

 

# ############### 调用

obj = Goods(100)

obj._Goods__name = "gloryroad!"

print obj._Goods__name

 

 

 

1. 单继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。即一个派生类（derived class）继承基类（bass class）字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。

#encoding=utf-8
class BIRD(object):
    def __init__(self,category):
        self.category = category
    def get_name(self):
        return "BIRD"
    @classmethod
    def get_age(cls):
        return 20

    @staticmethod
    def get_sex():
        return "Male"

class CHINA_BIRD(BIRD):
    def get_voice(self):
        return "jiujiu!"

class US_BIRD(BIRD):
    def get_voice(self):
        return "gaga!"

cb = CHINA_BIRD("Fly")
ub = US_BIRD("Fly")
print cb.category
print CHINA_BIRD.get_age()
print cb.get_age()
print CHINA_BIRD.get_sex()
print cb.get_sex()
print cb.get_voice()
print ub.get_voice()

 

练习：写一个人的类，实现继承，并通过子类实例化后调用父类方法

#encoding=utf-8

 

class Person(object):

    def __init__(self,name):

        self.name = name

    def get_sex(self):

        return "male"

    @classmethod

    def get_age(cls):

        return 25

    @staticmethod

    def get_height():

        return 175

 

class China_person(Person):

    def get_haircolour(self):

        return "black"

 

class English_person(Person):

    def get_haircolour(self):

        return "yellow"

 

person1 = China_person("qwq")

print person1.get_sex()

print person1.get_age()

print person1.get_haircolour()

 

person2 = English_person("Amilly")

print person2.get_age()

print person2.get_height()

print person2.get_haircolour()

 

 

 

继承举例：

#encoding=utf-8

class Animal:

 

    def eat(self):

        print u"%s 吃 " %self.name 

 

    def drink(self):

        print u"%s 喝 " %self.name 

 

    def shit(self):

        print u"%s 拉 " %self.name 

 

    def pee(self):

        print u"%s 撒 " %self.name 

 

class Cat(Animal):

 

    def __init__(self, name):

        self.name = name

        self.breed = u'猫'

 

    def cry(self):

        print u'喵喵叫'

 

class Dog(Animal):

    

    def __init__(self, name):

        self.name = name

        self.breed = u'狗'

        

    def cry(self):

        print u'汪汪叫'

        

 

# ######### 执行 #########

 

c1 = Cat(u'小白家的小黑猫')

c1.eat()

 

c2 = Cat(u'小黑的小白猫')

c2.drink()

 

d1 = Dog(u'胖子家的小瘦狗')

d1.eat()

 

 

 

1. 子类调用积累方法

#coding=utf-8

class Parent(object): # define parent class 

  parentAttr = 100 

  def __init__(self): 

    "父类构造方法，用于初始化工作"

    print "Calling parent constructor" 

 

  def parentMethod(self): 

    print 'Calling parent method' 

 

  def setAttr(self, attr): 

    Parent.parentAttr = attr 

 

  def getAttr(self): 

    print "Parent attribute :", Parent.parentAttr

 

class Child1(Parent): # define child1 class 

  def __init__(self): 

    "子类构造方法，用于初始化子类本身数据的工作"

    print "Calling child1 constructor" 

 

  def childMethod(self): 

    print 'Calling child1 method' 

    Parent.parentMethod(self) #调用基类的方法，所以要加上参数self

 

class Child2(Parent): # define child2 class 

  #没有实现__init__方法，则会调用基类的__init__方法

  def childMethod(self): 

    print 'Calling child2 method' 

    self.parentMethod()  #子类调用自己从父类那继承过来的父类的方法

 

c1 = Child1() # 实例化子类 1

c2 = Child2() # 实例化子类 2

c1.childMethod() # 调用子类1的方法

c2.childMethod() # 调用子类2的方法

c1.parentMethod() # 子类实例对象调用父类方法

c1.setAttr(200) # 再次调用父类的方法

c1.getAttr() # 再次调用父类的方法

 

1. 方法重写

#coding=utf-8

class P:
    def __init__(self,name):
        print u"父类被初始化"
        print name
    def get_name(self):
        print "P"

class S1(P):
    def __init__(self,x):
        print u"子类被初始化"
        P.__init__(self,x)
    def get_name(self):
        print "S1"

s = S1("gloryroad") 
#子类会自动调用基类的构造函数，参数会自动传到基类

s.get_name()

 

1. 子类调用父类的方法

调用父类的方法1：

#coding=utf-8

class P:

    def __init__(self,name):

        print u"父类被初始化"

        print name

 

    def get_name(self):

        print "P"

 

class S1(P):

    def __init__(self,x):

        print u"子类被初始化"

        P.__init__(self,x)

 

    def get_name(self):

        P.get_name(self)

s = S1("gloryroad") 

s.get_name()

 

调用父类的方法2：
#coding=utf-8
class P:
    def __init__(self,name):
        print u"父类被初始化"
        print name
    def get_name(self):
        print "P"
class S1(P):
    def __init__(self,x):
        print u"子类被初始化"
        P.__init__(self,x)
s = S1("gloryroad") 
s.get_name()

 

调用父类的方法3：
#coding=utf-8

class P:
    def __init__(self,name):
        print u"父类被初始化"
        print name
    def get_name(self):
        print "P"
class S1(P):
    def __init__(self,x):
        print u"子类被初始化"
        P.__init__(self,x)
    def func(self):
        self.get_name()
s = S1("gloryroad") 
s.func() 

 

 

1. 调用父类的__init__方法

子类调用基类的构造函数有两种方法，基本语法如下：
1、 super(subclassName, self).__init__( [parameter1[,parameter2....]])
2、 superclassName.__init__(self, [parameter1[,parameter2....]])
注意：
两次参数列表中的self参数都是必不可少的，如果基类的构造方法中有除了self参数外别的参数，调用时，也必须传入同等数量、同等类型的参数。
当子类不定义自己的构造方法时，默认会自动调用父类的构造方法。Python中super函数只能在构造方法中使用。

 

 

 

方法一：

#encoding=utf-8

class A(object):
  name=''
  def __init__(self,x):
    self.name 

='fosterwu'

  def getName(self):
    return 'A ' + self.name 


class C(A):
  def __init__(self,x):
    super(C, self).__init__(x) #调用基类构造方法

if __name__=='__main__':  

  c = C("g")
  print c.getName()

 

方法二：

#coding=utf-8

 

class P(object):

    def __init__(self,name):

        print u"父类被初始化"

        print name

 

    def get_name(self):

        print "P"

 

class S1(P):

    def __init__(self,x):

        print u"子类被初始化"

        super(S1,self).__init__(x) 

 

    def func(self):

        self.get_name()

 

s = S1("gloryroad") 

#子类会自动调用基类的构造函数，参数会自动传到基类

 

s.func()

 

 

1. 类间的关系判断

#coding=utf-8

class P(object):
    def __init__(self,name):
        print u"父类被初始化"
        print name

    def get_name(self):
        print "P"

class S1(P):
    def __init__(self,x):
        print u"子类被初始化"
        super(S1,self).__init__(x) 

    def func(self):
        self.get_name()

s = S1("gloryroad") 

print issubclass(S1,P)
print isinstance(s,P)
print isinstance(s,S1)

 

 

 

1. 多重继承

多重继承中，子类在没有定义自己的构造方法时，以第一个父类为中心。

如果子类重新定义了自己的构造方法，就不会调用父类的构造方法。但如果仍想调用父类的构造方法，这个时候调用哪个父类的构造方法，由你自己确定，并且多重继承时，调用具体哪个父类的构造方法时只能使用如下方法：
superclassName.__init__(self, [parameter1[,parameter2....]] )

如果父类中有同名的方法时，通过子类的实例对象去调用的该方法也是第一个父类中的方法。同样你可以用我们上边说的“子类调用基类方法”中的的方法去调用具体哪个父类中的方法。 Parent.parentMethod(self)

 

代码示例：没有自己的构造函数时默认调用第一个继承类

#coding=utf-8

class P(object):
    def __init__(self,name):
        print "P constructor"
        self.name =name
        self.age =100
    def fuc(self):
        print "P:func"

    def p_fuc(self):
        print "P_func"

class S(object):
    def __init__(self,x):
        print "S constructor"
        self.name  =x
        self.sex = "male"

    def fuc(self):
        print "s:func"

    def s_fuc(self):
        print "s_func"

class A(P,S):
    pass
    
a =A("gloryroad")

 

示例二：子类有自己的构造函数会调用自己的

#coding=utf-8

 

class P(object):

    def __init__(self,name):

        print "P constructor"

        self.name =name

        self.age =100

    def fuc(self):

        print "P:func"

 

    def p_fuc(self):

        print "P_func"

 

class S(object):

    def __init__(self,x):

        print "S constructor"

        self.name =x

        self.sex = "male"

 

    def fuc(self):

        print "s:func"

 

    def s_fuc(self):

        print "s_func"

 

class A(P,S):

    def __init__(self):

        print "A constructor"

    

a =A()

 

 

示例三：集成的多个类中有重名的方法，调用时会默认用第一个

#coding=utf-8

 

class P(object):

    def __init__(self,name):

        print "P constructor"

        self.name  =name

        self.age =100

    def func(self):

        print "P:func"

 

    def p_func(self):

        print "P_func"

 

class S(object):

    def __init__(self,x):

        print "S constructor"

        self.name =x

        self.sex = "male"

 

    def func(self):

        print "s:func"

 

    def s_func(self):

        print "s_func"

 

class A(P,S):

    pass

    

a =A("gloryroad")

a.func()

a.p_func()

a.s_func()

 

 

示例四：在子类中把继承的父类都做初始化，这样都可以进行调用且不会出错。

#coding=utf-8

class P(object):

    def __init__(self,name):

        print "P constructor"

        self.name =name

        self.age =100

    def func(self):

        print "P:func"

 

    def p_func(self):

        print "P_func"

 

class S(object):

    def __init__(self,x):

        print "S constructor"

        self.name =x

        self.sex = "male"

 

    def func(self):

        print "s:func"

 

    def s_func(self):

        print "s_func"

 

class A(P,S):

    def __init__(self,name):

        P.__init__(self,"gloryroad")    #把继承的父类都做初始化，后面想调用哪个都可以，而且不会出错

        S.__init__(self,"gr")

    def func(self):

        S.func(self)

a =A("gloryroad")

a.func()

 

 

总结：

#coding=utf-8

经典类、新式类（object）
类变量、实例变量、局部变量、属性@property ：增删改查
实例方法、类方法、静态方法
私有变量、私有方法分别前面加“__“,只能在类内部可以调用

构造函数：实例化对象的时候，自动调用，可以有参数也可以没有
如果一个类没有构造函数，系统自动给你加一个。

继承：
单继承：一个基类
没有构造函数，自动调用基类的构造函数
有构造函数，则不会自动调用基类的构造函数
建议：子类定义构造函数，且显示调用基类的构造函数
显示调用基类的构造函数的2个方法：
推荐使用的（多重继承可以使用）：superclassname.__init__(self,param1,param2....)
不推荐使用：super(subclassname,self).__init__(param1,param2....)

子类可以获取所有父类的全部方法、类变量和实例变量
如果子类中有同名的变量和方法，则会覆盖（隐藏）父类的内容

多继承：多个基类
如果没有实现子类的构造函数，会以第一个基类为中心，进行初始化
如果子类调用基类的方法，且多个基类有同名方法，则会以第一个基类为中心
如果不想调用第一个，superclassname.methodname(self)

建议：所有的子类都有构造函数，且同时初始化所有父类的构造函数

 

类的用途：

1 抽象共性，做继承

2 仅用于数据和方法的封装，方便调用

例如：excel类：

      数据：某excel文件、sheet

      操作的方法：

      excel文件、sheet数据的增删改查