Python面向对象

面向对象

1. 面向对象的三大特征: 封装、继承、多态。

1.1 封装

1. 在类中对数据的赋值、内部调用对外部用户是透明的
2. 这使类成了一个胶囊或者容器，里面包含着类的数据和方法
3. 作用
   1）防止数据被随意修改
   2） 使外部程序不需要关注对象内部的构造，只需要通过对外提供的接口进行直接访问。

1.2 Inheritance 继承（代码重用）

1.  一个类可以派生出子类，在这个父类里定义的属性、方法自动被子类继承
2. 比如CS中的警察和恐怖分子，可以将两个角色的相同点写到一个父类中，
然后同时去继承它
3. 使用经典类： Person.__init__(self,name,age) 并重写写父类Person的构造方法，
实现，先覆盖，再继承，再重构。

1.3 Polymorphism 多态（接口重用）

1．多态是面向对象的重要特性,简单点说:“一个接口，多种实现”
2. 指一个基类中派生出了不同的子类，且每个子类在继承同样的方法名的同时又对父类的方法做了不同的实现
3. 这就是同一种事物表现出的多种形态
4. 比如黄种人继承了人talk这个功能，但是他说的是中文，而美国人的talk是英文，但是他们是同样的talk
作用：简单的讲就是允许父类调用子类的方法

2.类方法、 静态方法、属性方法

2.1 类方法

1. 作用：无需实例化直接被类调用
2. 特性: 类方法只能访问类变量，不能访问实例变量
3. 类方法使用场景： 当我们还未创建实例，但是需要调用类中的方法
4. 调用方式: 既可以被类直接调用，也可以通过实例调用

class Dog:
	name = '类变量' #在这里如果不定义类变量仅定义实例变量依然报错
    def __init__(self,name):
        self.name = '实例变量'
        self.name = name
    @classmethod
    def eat(self,food):
        print("%s is eating %s"%(self.name,food))
Dog.eat('baozi')                   #方法1：使用类直接调用
d = Dog("ChenRonghua")          
d.eat("包子")                      #方法2：使用实例d调用

2.2 静态方式

1. 作用：静态方法可以更好的组织代码，防止代码变大后变得比较混乱。
2. 特性: 静态方法只是名义上归类管理，实际上在静态方法里访问不了类或则实例中的任何属性
3. 静态方法使用场景：
   　　1）我们要写一个只在类中运行而不在实例中运行的方法.
   　　2）经常有一些跟类有关系的功能但在运行时又不需要实例和类参与的情况下需要用到静态方法.
   　　3）比如更改环境变量或者修改其他类的属性等能用到静态方法.
   　　4）这种情况可以直接用函数解决, 但这样同样会扩散类内部的代码，造成维护困难.
4. 调用方式: 既可以被类直接调用，也可以通过实例调用

class Dog(object):
    def __init__(self,name):
        self.name = name
    @staticmethod
    def eat():
        print("I am a static method")
d = Dog("ChenRonghua")
d.eat()                     #方法1：使用实例调用
Dog.eat()                   #方法2：使用类直接调用

2.3.属性方法

作用：属性方法把一个方法变成一个属性，隐藏了实现细节,调用时不必加括号直接d.eat即可调用self.eat()方法

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

    @property
    def eat(self):
        print(" %s is eating" % self.name)
d = Dog("ChenRonghua")
d.eat()
# 调用会出以下错误， 说NoneType is not callable, 因为eat此时已经变成一个静态属性了， 
# 不是方法了， 想调用已经不需要加()号了，直接d.eat就可以了

2.4 魔法方法

1. type生成类调用顺序
__new__ :  先于__init__方法，每生成一个实例执行一次，__new__ 类方法创建实例对象
__init__ :  __init__方法每生成一个实例就会执行一次，初始化实例对象
__call__ :   后与__init__方法，C()() 使用类再加一个括号调用， C为类名称
__del__ :   析构方法，删除无用的内存对象（当程序结束会自动自行析构方法）

2.  类实例化时魔法方法调用顺序
class Student(object):
    def __new__(cls, *args, **kwargs):
        print('__new__')
        return object.__new__(cls)   # 必须返回父类的__new__方法，否则不不执行__init__方法，无法创建实例

    def __init__(self,name):
        print('__init__')
        self.name = name

    def __str__(self):                # 作用：打印实例时显示指定字符串，而不是内存地址
        print('__str__')
        return self.name

    def __call__(self, *args, **kwargs):        # 当执行C()(*args) 或者 s1(*args) 就会执行__call__
        print('__call__',*args)

    def __del__(self):                # 作用：清除无用的实例对内存的暂用
        print('__del__')

#1、实例化时机会执行__new__、__init__
s1 = Student('tom')

#2、执行 实例()  就会执行__call__ 方法，并将参数传递给__call__函数
s1('call01')

#3、当打印实例时就会执行 __str__ 方法下返回的字符串（默认返回的实例地址）
print(s1)

#4、析构方法：当删除实例时就会调用 __del__ 方法
del s1
# 析构方法作用：在程序结束后会自动执行析构方法删除所有实例
# 但是在程序运行时有很多实例是无用的，但是python内存回收机制却不会自动删除他们，这样就浪费内存
# 我们可以执行 del s1 ，那么在程序运行时，python内存回收机制会检测到这些实例时无用的，才会删除
# 其实我们执行del s1，并没有回收内存，只不过是摘除门牌号，python内存回收机制发现没有门牌号后会自动回收内存

2.5 反射 hasattr 、getattr、 setattr、delattr

1. hasattr(ogj,name_str) 判断一个对象里是否有对应的字符串方法

class Dog(object):
    def eat(self,food):
        print("eat method!!!")
d = Dog()

#hasattr判断对象d是否有eat方法，有返回True，没有返回False
print(hasattr(d,'eat'))     #True
print(hasattr(d,'cat'))     #False

2. getattr(obj,name_str) 根据字符串去获取obj对象里的对应的方法的内存地址

class Dog(object):
    def eat(self):
        print("eat method!!!")
d = Dog()

if hasattr(d,'eat'):          # hasattr判断实例是否有eat方法
    func = getattr(d, 'eat')  # getattr获取实例d的eat方法内存地址
    func()                    # 执行实例d的eat方法
#运行结果：  eat method!!!

3. 使用setattr给类实例对象动态添加一个新的方法
4. delattr删除实例属性