python学习记录 — (10)面向对象-类

ObjectOriented.py

#coding=utf-8
#################################### Python面向对象 ####################################

#################### 封装 ####################
class People:               # 定义类（使用ClassName.__name__查看类名）
    '人类'                  # 类文档字符串 （使用ClassName.__doc__查看）

    counter = 0             # 静态变量 公有
    _tag = "人类"           # 静态变量 保护
    __type = "base"         # 静态变量 私有

    # 构造器
    def __init__(self,name,age,id = 0):
        "参数：name(string),age(numbers),id(numbers)"
        People.counter += 1
        self.name = name                    # 公有成员
        self.age = age
        self.__id = id or People.counter    # 私有成员

    # 析构器
    def __del__(self):
        print "del a %s object"%(self.__class__.__name__)

    # 私有方法
    def __getId(self):
        return self.__id

    # 公有方法
    def introduce(self):
        print("我叫%s，今年%d岁!"%(self.name,self.age))

    def showId(self):
        print("Id = %d"%(self.__getId()))

    def ShowType(self):
        print("My type is %s"%(self.__type))

    # 运算符重载
    def __add__(self, other):
        return self.age+other.age


"""测试"""
boy = People("boy",20)
boy.introduce()             ## 我叫boy，今年20岁!
boy.showId()                ## Id = 1
boy.ShowType()              ## My type is base
print People.counter        ## 1
print boy.name,boy.age      ## boy 20

girl = People('girl',19)
girl.introduce()            ## 我叫girl，今年19岁!
girl.showId()               ## Id = 2
girl.ShowType()             ## My type is base
print People.counter        ## 2
print girl.name,girl.age    ## girl 19

print("boy'age + girl'age = %d"%(boy+girl)) ## boy'age + girl'age = 39


""" 访问属性

getattr(obj, name[, default]) : 访问对象的属性。
hasattr(obj,name) : 检查是否存在一个属性。
setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。
delattr(obj, name) : 删除属性。

"""
print getattr(boy,"name")   ## beijiaan
print hasattr(boy,'age')    ## True
setattr(boy,'age',25)
delattr(boy,'name')
#print getattr(boy,"name")   ## 报错：AttributeError: People instance has no attribute 'name'

""" Python内置类属性

__doc__ : 类的文档字符串 
__name__ : 类名 
__module__ : 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod） 
__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
__dict__ : 类的属性（包含一个字典，由类的数据属性组成）

"""
print People.__doc__        ## 人类
print People.__name__       ## People
print People.__module__     ## __main__
print People.__bases__      ## ()
print People.__dict__       ##

""" 对象销毁（垃圾回收）
垃圾回收/跟踪技术：
    1. 引用计数（内部跟踪变量），Python内部记录了所有使用中的对象的引用数量；
    当1个对象被创建时，就创建了1个引用计数，当引用计数变为0，它就被垃圾回收；（不是立即回收）
    2. 循环垃圾收集器（作为引用计数的补充）；
"""
a = 123  # 创建1个对象 <123>，创建1个引用a，<123>counter创建，且<123>counter = 1
b = a    # 创建1个引用b，<123>counter = 2
c = [b]  # 创建1个对象 <[b]>，创建1个引用c[0]，<123>counter = 3

del a    # 删除1个引用，<123>counter = 2
b = 1    # 创建1个对象 <1>，删除1个引用b，<123>counter = 1
c[0] = 2 # 创建1个对象 <2>，删除1个引用c[0]，<123>counter = 0（然后等待python垃圾回收）

boyTemp = boy
del boy # 只是删除了引用，并不删除对象（因为还有1个引用）
print("wait")
del girl    ## del a People object
del boyTemp ## del a People object


#################### 继承 ####################
"""继承方法：
Class DerivedClass(BaseClass1,BaseClass2):
    ...
"""
class Programmer(People):
    '程序员'

    # 重写变量
    counter = 100
    __type = 'programmer'

    # 重写方法
    def introduce(self):
        print("我叫%s，今年%d岁，我是一名程序员!" % (self.name, self.age))

"""测试"""
boy = Programmer("beijiaan",25)
boy.introduce()             ## 我叫beijiaan，今年25岁，我是一名程序员!
boy.showId()                ## Id = 3（注意！）
boy.ShowType()              ## My type is base（注意！）
print Programmer.counter    ## 100
print boy.name,boy.age      ## beijiaan 25

girl = Programmer('Simin',22)
girl.introduce()            ## 我叫girl，今年19岁，我是一名程序员!
girl.showId()               ## Id = 4（注意！）
girl.ShowType()             ## ## My type is base（注意！）
print Programmer.counter    ## 100
print girl.name,girl.age    ## Simin 22

""" 继承需要注意的：
1. 保护类型的变量（_name），只能允许类本身与子类访问；（不能用于from import*）
2. 私有类型的变量（__name），只能允许类本身访问；
3. 私有成员，不能显式继承，只能允许类本身访问；
"""
class base:
    number = 0
    public_variable = "base 公有静态"
    _protect_variable = "base 保护静态"
    __private_variable = "base 私有静态"
    def showpublic(self):
        print(self.public_variable)
        print(self.public)
    def showprotect(self):
        print self._protect_variable
    def showprivate(self):
        print(self.__private_variable)
        print(self.__private)
    def getId(self):
        return self.__id
    def __privateFunc(self):
        print("base 私有函数")

    def __init__(self):
        self.number += 1
        self.__id = self.number
        self.public = "base 公有成员"
        self.__private = "base 私有成员"

'''私有成员，不能显式继承，只能允许类本身访问'''
class derived1(base):
    def showpublic2(self):
        print(self.public_variable)
        print(self.public)
    def showprotect2(self):
        print self._protect_variable
    def showprivate2(self):
        print self.__private_variable # !!AttributeError: derived1 instance has no attribute '_derived1__private_variable'
        print self.__private   # !!AttributeError: derived1 instance has no attribute '_derived1__private'

print "===="
obj1 = derived1()
obj1.showpublic()   ## base 公有静态 / base 公有成员
obj1.showpublic2()  ## base 公有静态 / base 公有成员
obj1.showprotect()  ## base 保护静态
obj1.showprotect2() ## base 保护静态
obj1.showprivate()  ## base 私有静态  / base 私有成员
#obj1.showprivate2() ## 报错！
del obj1

'''有新的构造器，是不会调用旧的构造器'''
'''要注意基类中调用了私有成员的方法，即使新构造器重写了与基类一样的私有成员，调用该基类方法也会报错（公有的成员则可以）'''
'''对于私有静态变量，在哪个类访问，则是哪个类的私有静态变量（注意，公有与保护的静态则不然，它被子类继承了）'''
class derived2(base):
    public_variable = "derived2 公有静态"
    _protect_variable = "derived2 保护静态"
    __private_variable = "derived2 私有静态"
    def showprivate2(self):
        print self.__private_variable
        print self.__private
    def __init__(self):
        self.public = "derived2 公有成员"
        self.__private = "derived2 私有成员"

print "===="
obj1 = derived2()
obj1.showpublic()   ## derived2 公有静态 / derived2 公有成员
obj1.showprotect()  ## derived2 保护静态
#obj1.showprivate()  ## base 私有静态  / 报错！derived2 instance has no attribute '_base__private'
obj1.showprivate2() ## derived2 私有静态 / derived2 私有成员

''' 检测继承
issubclass(sub,sup) : 布尔函数判断一个类是另一个类的子类或者子孙类；
isinstance(obj, Class) : 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。
'''
print issubclass(derived2,base) # True
print isinstance(obj1,derived2) # True
print isinstance(obj1,base)     # True