Python自动化开发从浅入深-语言基础(类)

一、类对象和实例对象：

　　　　类对象提供默认行为，它是实例对象的工厂。实例对象是程序处理的实际对象，它们各自有独立的命名空间。类对象来自于语句，而实例来自于调用，每次调用一个类，就会得到这个类的新的实例。

　　执行class语句，就会得到类对象。

　　class <类名>:
 　　　<语句>

　　类实例化后，可以使用其属性，实际上，创建一个类之后，可以通过类名访问其属性。如果直接使用类名修改其属性，那么将直接影响到已经实例化的对象
　　例子：　　

#!/usr/bin/env python

class test(object):
    def a(self,b):
        print(b)
        return b


c = test().a('Hello World!')

运行结果

Hello World!

 test().a('Hello World')调用类test（注意：小括号）会产生实例对象，即可以读取所定义类属性的命名空间。

 

类的私有属性：
　　__private_attrs  两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs
类的方法：
　　在类地内部，使用def关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数self,且为第一个参数
私有的类方法：
　　__private_method 两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用slef.__private_methods

#!/usr/bin/env python

class test(object):
    __c = '私有变量'

    def __d(self):
        print('私有方法')

    def a(self,b):
        print('在类方法里调用私有变量==》',self.__c)
        print(b)
        self.__d()


        return b



#先打印"在类方法里调用私有变量==》 私有变量"
#再打印"Hello World!"
#最后打印“私有方法”
c = test().a('Hello World!')
#print('test().__c')  #在外部不能调用私有变量
#test().__d()         #在外部不能调用私有方法

 

类的专有方法：

在类的定义中，一般用__init__进行初始工作（构造），而在__del__中完成删除工作（析构） 。

__new__用于定制类的创建过程。 

• __init__        构造函数，在生成对象时调用 

#!/usr/bin/env python

class test(object):
    __c = '私有变量'

    def __init__(self):
        self.Init_a = 'Init_a'
        self.__private = 'private'

    def __d(self):
        print('私有方法')

    def a(self,b):
        print('在类方法里调用私有变量==》',self.__c)
        print(b)
        print(self.__private)
        self.__d()


        return b

#先打印"在类方法里调用私有变量==》 私有变量"
#再打印"Hello World!"
#最后打印“私有方法”
#加了一句，调用__init__中的私有变量，打印“”
c = test().a('Hello World!')
#print('test().__c')  #在外部不能调用私有变量
#test().__d()         #在外部不能调用私有方法
giveInit = test()
print(giveInit.Init_a)
#print(giveInit.__private) #在外部不能调用私有变量

运行结果

     在类方法里调用私有变量==》 私有变量
     Hello World!
     private
     私有方法
     Init_a

　　 

• __del__        析构函数，释放对象时使用 

class NewClass(object):
    num_count = 0 # 所有的实例都共享此变量，即不单独为每个实例分配
    def __init__(self,name):
        self.name = name
        NewClass.num_count += 1
        print (name,NewClass.num_count)
    def __del__(self):
        NewClass.num_count -= 1
        print ("Del",self.name,NewClass.num_count)
    def test():
        print ("aa")
aa = NewClass("Hello")
bb = NewClass("World")
cc = NewClass("I am come")

运行结果：

Hello 1
World 2
I am come 3
Del Hello 2
Del World 1
Del I am come 0

从上面例子中可以看出，连续建立了三个类的实例对象，先将构造函数执行完成，没有再执行构造时，开始逐步执行析构函数。

 

• 一些特殊的类属性。

class MyClass(object): 
　　"""This is MyClass's Docoment""" 
　　def __init__(self): 
　　self.i = 1234 

>>>>>> MyClass.__doc__ # 类型帮助信息 
"This is MyClass's Docoment""This is MyClass's Docoment" 

>>>>>> MyClass.__name__ # 类型名称 
'MyClass' 

>>>>>> MyClass.__module__ # 类型所在模块 
'__main__' 

>>>>>> MyClass.__bases__ # 类型所继承的基类(Python 支持多继承) 
(<type 'object'>,) 

>>>>>> MyClass.__dict__ # 类型字典，存储所有类型成员信息 
<dictproxy object at 0x00DC1AD0>
 
>>>>>> #以下是实例拥有的属性 
>>>>>> MyClass().__class__ # 实例的类型 
<class '__main__.MyClass'> 

>>>>>> MyClass().__module__ # 实例类型所在模块 
'__main__' 

>>>>>> MyClass().__dict__ # 对象字典，存储所有实例成员信息 
{'i': 1234} 

 

 

 

• __repr__      打印，转换

 

__setitem__ 按照索引赋值
__getitem__按照索引获取值
__len__       获得长度
__cmp__     比较运算
__call__      函数调用

__add__      加运算
__sub__      减运算
__mul__     乘运算
__div__      除运算
__mod__    求余运算
__pow__     乘方

#类定义  
    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 is speaking: I am %d years old" %(self.name,self.age))  

      
    p = people('tom',10,30)  
    p.speak()

二、继承类定义：

1.单继承

　　class <类名>(父类名)
   　　<语句>

　　class childbook(book)
   　　 age = 10

 

2.类的多重继承

　　class 类名(父类1,父类2,....,父类n)
     　　<语句1>

　　需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索，即方法在子类中未找到时，从左到右查找父类中是否包含方法

　　Python 支持多继承，但有几点需要注意：
　　-- 基类 __init__ / __del__ 需显示调用。
　　-- 继承方法的调用和基类声明顺序有关。

class Base1: 
　　def __init__(self): 
　　print "Base1" 

　　def test(self): 
　　print "Base1 test" 


class Base2: 
　　def __init__(self): 
　　　　print "Base2" 

　　def test(self): 
　　　　print "Base2 test" 

class MyClass(Base2,Base1): 
　　def __init__(self): 
　　　　Base1.__init__(self) 
　　　　Base2.__init__(self) 
　　　　print "MyClass" 

>>>>>> a = MyClass() 
Base1 
Base2 
MyClass 
>>>>>> a.test() 
Base2 test 

>>>>>> # 下面把 Base1 放在前面 
class MyClass(Base1,Base2): 
　　def __init__(self): 
　　Base1.__init__(self) 
　　Base2.__init__(self) 
　　print "MyClass" 

>>>>>> a = MyClass() 
Base1 
Base2 
MyClass 
>>>>>> a.test() 
Base1 test 
>>>>>>

 

 

（参照各类网站资料学习并整理）