python学习笔记之面向对象编程

面向对象的三大特征

封装，继承，多态

新式类和经典类

# 经典类
class ClassNameA:
   '''类的帮助信息'''   #类文档字符串
   pass


# 新式类,继承object类，推荐使用这种方式
class ClassNameC(object):
   '''类的帮助信息'''   #类文档字符串
   pass

getattr() setattr() hasattr()方法

class Hero(object):
    def __init__(self,name):
        self.name = name

    def info(self):
        print("英雄名称： %s " % (self.name))

A=Hero("张飞")

# getattr用法
t = getattr(A, "name")  # 获取A对象中的属性值
s = getattr(A,"abc","not find") # 获取A对象中的属性值，如果没有此属性，则返回not find默认值
f = getattr(A, "info") # 获取A对象的info函数引用

# hasattr用法
print(hasattr(A,"info"))    # True。因为存在info方法
print(hasattr(A,"name"))    # True。因为存在name变量
print(hasattr(A,"age"))     # False。因为不存在age方法或变量

# setattr用法
def test(self):
    """实例方法"""
    print("{}: 发出了一招强力的攻击...".format(self.name))

setattr(A, "attack",test)   # 将test函数添加到对象中A中，并命名为attack
A.attack(A)

setattr(A, "hp",2000)  # 对A对象添加hp属性
print(A.hp)

魔法方法

class Hero(object):
# __init__()方法是Python中一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法。如果没有定义__init__()方法，会有一个默认的，只是内容为空。
    def __init__(self,name,age):
        self.name = name # 姓名
        self.hp = 2600 # 生命值

# __str__方法需要返回一个字符串，当做这个对象的描述信息，当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法return的数据。
    def __str__(self):
        return '英雄名称: %s，生命值：%d'%(self.name,self.hp)

    # 当对象被删除时，会自动被调用，python会自动清除没有引用的对象，也可以使用del关键字手动清除，不过一般不需要这么做
    def __del__(self):
        print("__del__方法被调用")
        print("%s 被 GM 干掉了..." % self.name)	

A = A()  # 调用这一句则A对象的引用计数加1
print(sys.getrefcount(A)) # 获取A对象的引用计数，返回2，因为此次函数调用也会导致A对象的引用计数加1

内置类属性

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

print(Hero.__dict__)  # 输出包含了类的所有属性的字典
print(Hero.__doc__)   # 输出包含了类的文档字符串
print(Hero.__name__)  # 类的名称
print(Hero.__module__) # 类的模块
print(Hero.__bases__)   # 类的基类

继承

重写父类方法

class Parent(object):  # 定义父类
    parentAttr = 100

    def __init__(self):
        self.name=30
        print("调用父类构造函数")

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


class Child(Parent):  # 定义子类
    def __init__(self): # 子类重写构造函数，如果不重写则继承父类的构造函数
        Parent.__init__(self) # 子类执行父类的构造方法一
        super(Child,self).__init__() # 子类执行父类的构造方法一方法二
        print("调用子类构造方法")

    def getName(self):  # 子类重写父类的getName方法
        return 'Son ' + self.name

继承多个类

下面的例子中，A是顶层类，B和C都继承A，D继承B和C，演示D对象name属性的继承逻辑。如果D自己有name则使用自己的，否则使用C的，如果C也没有，则使用B的，如果B也没有则使用A的

class A(object):
    name = 'A'
    def __init__(self):
        print("Class A")

class B(A):
    # name = 'B'
    def __init__(self):
         print("Class B")

class C(A):
    # name = 'C'
    def __init__(self):
        print("Class C")

class D(C,B):
    # name = 'D'
    def __init__(self):
        # print("Class D")
        pass

test_object = D()
print(test_object.name)

私有属性和私有方法

私有属性和私有方法外部无法访问

class TestClass(object):
    __private_name = "狂师"   # 属性名以__开头的属性即为私有属性

    def display_var(self):
        print("打印私有变量: %s" % self.__private_name)
        print(self.__private_fun())

    def __private_fun(self):  # 方法名以__开头的方法为私有方法
        return ("执行私有方法: %s" % self.public_var)

object_var = TestClass()
print(object_var._TestClass__private_fun())  # 这种方式可以访问私有方法

类变量，成员变量，私有变量

class TestClass(object):
    num = 100  # 类变量,可以直接用类调用，或用实例对象调用

    def __init__(self, x, y):
        self.x = x  # 实例变量（成员变量）,需要它是在类的构造函数内以self.开头来定义的
        self.fuc(self.x, self.y) 

    def add(self):
        total = 2  # 局部变量
        self.vara = 3  # 局部变量，虽是以self.给出，但并没有在构造函数中进行初始化     

    def fuc(self, a, b):
        self.varc = 100  # 实例变量，他们在成员函数fuc()中定义，但是在构造函数中调用了fuc()函数，所以也是实例变量
        return a + b


object_a = TestClass(10, 20)
print(object_a.num) # 访问类变量
print(TestClass.num)

print(object_a.x)  # 访问实例变量
print(object_a.varc) # 访问实例变量

类的实例方法、静态方法、类方法

class TestClass(object):
    """类三种方法语法形式"""

	# 实例方法第一个参数以self命名，这是惯例，也可以以任何字符串命名
    def instance_method(self): 
        print("我是实例方法")

	# 静态方法不需要参数
    @staticmethod
    def static_method():
        print("我是静态方法")

	# 类方法第一个参数以cls命名，也是惯例
    @classmethod
    def class_method(cls):
        print("我是类方法")


test_object = TestClass()
test_object.instance_method()
test_object.static_method()
test_object.class_method()
print('----------------')
TestClass.static_method()  # 通过类直接调用静态方法
TestClass.class_method()   # 通过类直接调用类方法

@property装饰器示例

使用方法1

class TestClass(object):
    def __init__(self,name,age):
        # 设置成私有变量
        self.__name=name
        self.__age=age

    @property  # 此方法获取age的值，但是外部可以通过属性的方式调用此方法
    def age(self):
        return self.__age

    @age.setter # 此方法设置age的值，但是外部可以通过给属性赋值的方式调用此方法
    def age(self,value):
        if isinstance(value,int):
            self.__age=value
        else:
            raise ValueError('非整数类型')

    @age.deleter  
    def age(self):
        print("delete age")

test_object = TestClass('张三', 18)
# 使用装饰器，可以使用类与对象的方法直接调用
print(test_object.age)
# 这里直接使用setter进行赋值转换
test_object.age = 20
print(test_object.age)

# 删除age
del test_object.age

使用方法2

这种方式更加简便

class TestClass(object):
    def __init__(self,name,age):
        # 设置成私有变量
        self.__name=name
        self.__age=age

    def get_age(self):
        return self.__age

    def set_age(self,value):
        if isinstance(value,int):
            self.__age=value
        else:
            raise ValueError('非整数类型')

    def del_age(self):
        print("delet age")

    # 核心在这句
    age = property(get_age, set_age, del_age, "年龄")

test_object = TestClass('张三', 18)
# 使用装饰器，可以使用类与对象的方法直接调用
print(test_object.age)
# 这里直接使用setter进行赋值转换
test_object.age = 20
print(test_object.age)

自定义异常类

# 利用class, 自定义异常类
class MyError(Exception):
    def __init__(self, msg):
        self.msg = msg

    def __str__(self):
        return self.msg


try:
    raise MyError('类型错误')
except MyError as e:
    print('My exception occurred', e.msg)