python语法31[类]

一 最简单的类

>>>   class  c(object):  pass

>>>  x  =  c()
>>>  issubclass(c,object)
True
>>>  type( 10 )
< class   ' int ' >
>>>  issubclass(int,object)
True
>>>  type( ' aaa ' )
< class   ' str ' >
>>>  issubclass(str,object)
True
>>>

注意：
python与C#一样，为纯面向对象语言，所有的类都有共同的基类object。
python的内置类型都有对应的class对应，例如整形对应的类为int，字符串对应的类为str等。
类的定义使用关键字class，类名后面（）为基类的名字。

二 简单类

>>>class MyClass:
      """ This is the simple class for testing """
    i = 100
     def  PrintI():
         print (i)
     def   __init__ (self):
        self.x = 10
        self.y = 20
        self. __total = self.x + self.y
         print ( " constructor! " )
     def   __del__ (self):
         print ( " deconstructor! " )
     def   __PrintTotal (self):
         print (self. __total )
     def  PrintSelf(self):
         print ( " print x ,y and total " )
         print (self.x)
         print (self.y)
        self. __PrintTotal ()

        
>>>   print (MyClass. __name__ )
MyClass
>>>   print (MyClass. __doc__ )
This  is  the simple  class   for  testing
>>>  myC = MyClass()
constructor!
>>>  myC.i
100
>>>  MyClass.i
100
>>>  myC.x
10
>>>  myC.y
20
>>>  myC.PrintSelf()
print  x ,y  and  total
10
20
30
>>>  myC._MyClass__total
30
>>>  myC._MyClass__PrintTotal()
30
>>>  myC.z = 30
>>>  myC.z
30
>>>   del  myC.z
>>>   del  myC
deconstructor!
>>>

 注意：
一些默认的属性__name__表示类的名字，__doc__表示类的说明字符串，__dict__类的整个dictionary。
__init__(self)和__del__为类的默认的构造和析构函数。
myC=MyClass()用来定义实例。
i为MyClass的静态变量，可以使用MyClass.i 或myC.i来访问。
x,y为类MyClass的成员变量。
PrintSelf（）为类MyClass的成员方法。
__total和__PrintTotal()为类MyClass的私有成员和方法，但是这个只是一个约定，可以使用myC._MyClass__total和myC._MyClass__PrintTotal()来访问。
z为myC的实例的成员，不属于类MyClass。
使用del来删除类对象或实例的成员变量。

三 类和对象的属性的判定和函数的修改

class  Class:
    answer  =   42
     def   __init__ (self):
        self.x  =   10
     def  method(self):
         print (  ' Hey a method ' )
    
print (hasattr(Class,  ' answer ' ))
# True
print (hasattr(Class,  ' question ' ))
# False
print (hasattr(Class(),  ' x ' ))
# True
print (hasattr(Class,  ' method ' ))
# True

print (getattr(Class,  ' answer ' ))
# 42
print (getattr(Class,  ' question ' ,  ' What is six times nine? ' ))
# 'What is six times nine?'
print (getattr(Class(),  ' x ' ))
# 10
getattr(Class(), ' method ' )()
# 'Hey a method'

class  MyClass:
    def  method(self):
         print (  ' Hey a method ' )

instance  =  MyClass()
instance.method()
# 'Hey a method'

def  new_method(self):
     print (  ' New method wins! ' )


MyClass.method  =  new_method
instance.method()
# 'New method wins!'

del  MyClass.method
print (hasattr(MyClass,  ' method ' ))
# False
# instance.method()

instance.y  =   20
print (instance.y)
del  instance.y

可以使用hasattr来判断类和实例的属性是否存在，如果存在可以使用getattr来获得值，此时的属性包含变量和方法。

类和实例的属性可以在使用的过程中进行增删改，此时的属性包含变量和方法。

 

四 类的静态和类方法

class  MyClass2:
    @classmethod
     def  a_class_method(cls):
         print  ( ' I was called from class %s '   %  cls)

    @staticmethod
     def  a_static_method():
         print  ( ' I have no idea where I was called from ' )
        
     def  a_static_method2():
         print ( ' i am just called by the class ' )


instance2  =  MyClass2()

MyClass2.a_class_method()
instance2.a_class_method()
#  both print 'I was called from class __main__.MyClass2'

MyClass2.a_static_method()
instance2.a_static_method()
#  both print 'I have no idea where I was called from'

MyClass2.a_static_method2()
# 'i am just called by the class'
# instance2.a_static_method2() # throw exception

类方法和使用staticmethod修饰的静态方法，调用方法相同，均可以使用类或对象调用。

对于没有staticmethod修饰的静态方法，只能使用类来调用。

 

五 类的继承

>>>   class  Employee:
    companyname = " microsoft "
     def  printCompany():
         print (companyname)
     def   __init__ (self,name,salary):
        self.name = name
        self.salary = salary
         print ( " Constructor Employee " )
     def   __del__ (self):
         print ( " DeConstructor Employee " )
     def  PrintSelf(self):
         print (self.name)
         print (self.salary)

>>>   class  Developer(Employee):
     def   __init__ (self,name,salary,area):
        Employee. __init__ (self,name,salary)
        self.area = area
         print ( " Constructor Developer " )
     def   __del__ (self):
        Employee. __del__ (self)
         print ( " DeConstructor Developer  " )
     def  PrintSelf(self):
        Employee.PrintSelf(self)
         print (self.area)

>>>  d = Developer( " bill " , 10000 , " c " )
Constructor Employee
Constructor Developer
>>>  d.PrintSelf()
bill
10000
c
>>>   del  d
DeConstructor Employee
DeConstructor Developer 
>>>

注意：继承还有多继承和C++，C#的相似。