Python学习-面向对象编程（九）

ゝ一纸荒年。 2021-09-25 08:44 443阅读 0赞

> 学习笔记-python
> 
> 学习地址：[https://www.liaoxuefeng.com/wiki/1016959663602400][https_www.liaoxuefeng.com_wiki_1016959663602400]
> 
> 健忘选手，做好笔记，温故而知新

*  面向对象编程
 *  类和实例
 *  访问限制
 *  继承和多态
 *  获取对象信息
 *  实例属性和类属性

**一：面向对象编程**

面向对象编程——Object Oriented Programming，简称OOP。OOP把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。

类（Class）和实例（Instance），和java一样。

**二：类和实例**

类的定义：

# object表示该类是从哪个类继承下来的
    class Dog(object):
        pass

创建实例：

blackDog = Dog()

# 变量blackDog是指向Dog的实例
    # <__main__.Dog object at 0x0000000002529518>
    print(blackDog)
    # <class '__main__.Dog'>
    print(Dog)

绑定实例：

# 给实例变量绑定属性
    blackDog.name = "黑狗"
    print(blackDog.name)

**三：访问限制**

`__name`，私有变量（private），只能内部访问

# object表示该类是从哪个类继承下来的
    class Dog(object):
        # 可以定义方法，在创建实例的时候，把属性绑上去：
        # （类似java中创建构造方法，然后在创建实例同时赋值）
        # self表示创建的实例本身，在__init__方法内部，可以把属性绑定到self
        def __init__(self, name):
            self.__name = name
    
        # __name：私有变量
        def get_name(self):
            return self.__name
    
        def set_name(self, name):
            self.__name = name
    
        # 其实就是在类中封装了数据，在类中的方法使用
        # 好处是实例调用方法，不需要知道内部实现细节
        def dog_name(self):
            print("狗叫%s" % self.__name)
    
    
    # 创建实例
    whiteDog = Dog("小白")
    whiteDog.dog_name()

\_a是可以访问的，但约定为“别随意访问我”

\_\_a不能直接访问的原因是因为Python解释器对外把`__name`变量改成了`_Dog__name`，所以，仍然可以通过`_Dog__name`来访问`__name`变量（不建议这样访问）

from pytest.a import Dog
    
    blackDog = Dog("小黑")
    # 结果是小黑
    print(blackDog._Dog__name)

**四：继承和多态**

子类（Subclass），被继承的class称为基类、父类或超类（Base class、Super class）

# 父类
    class Animal(object):
    # 子类
    class Dog(Animal):

子类拥有父类的全部功能，子类也可以增加一些方法，如果子类存在父类一样的方法，即子类的方法覆盖了父类的方法，运行时使用的是子类的方法，即多态。

参考以前学习java来理解：

**（1）对象的上转型对象：[https://blog.csdn.net/weixin\_42717928/article/details/96380070][https_blog.csdn.net_weixin_42717928_article_details_96380070]**

子类的引用可以赋值给父类，反过来不行

b = Animal() # b是Animal类型
    c = Dog() # c是Dog类型
    
    # 结果是True,说明了c是Dog类型，也是Animal类型
    isinstance(c, Animal)

**（2）继承与多态：[https://blog.csdn.net/weixin\_42717928/article/details/96380532][https_blog.csdn.net_weixin_42717928_article_details_96380532]**

多态性是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为

子类重写了父类的方法，上转型对象调用这个方法一定是调用了子类重写的方法

**（3）abstract类与多态：[https://blog.csdn.net/weixin\_42717928/article/details/96381299][https_blog.csdn.net_weixin_42717928_article_details_96381299]**

利用多态进行程序设计可以体现程序设计的“开闭”原则

区别：静态语言java和动态语言python

Java要传入`Animal`类型，则传入的对象必须是`Animal`类型或者它的子类，否则，将无法调用`run()`方法

python不一定需要传入`Animal`类型。我们只需要保证传入的对象有一个`run()`方法就可以了（所谓的鸭子类型？应该是这样理解）

class Animal(object):
        def run(self):
            print('动物在跑')
    
    class Dog(Animal):
        # 重写run方法
        def run(self):
            print('狗在跑')
    
    class Fish(Animal):
        # 这里不重写，直接继承父类的run方法
        pass
    
    # 这里的animal是变量
    def run_times(animal):
        # 因为执行了run方法，所以要求传入的参数可以调用run方法
        animal.run()
    
    # Dog重写了run方法，执行的是Dog类的run
    run_times(Dog())
    run_times(Fish())
    # 结果：
    # 狗在跑
    # 动物在跑
    
    
    备注：如果我们要实现猫在跑，只需要写一个猫类，执行run_times传入猫的实例即可

**五：获取对象信息**

（1）判断类型

# 判断基本类型
    # <class 'int'>
    print(type(123))
    
    # 判断指向函数的变量
    # <class 'builtin_function_or_method'>
    a = abs
    print(type(a))
    
    # 判断指向类的变量
    # <class '__main__.Animal'>
    a = Animal()
    print(type(a))

（2）比较类型

# 比较2个变量类型是否相同。结果True
    type(123) == type(456)
    
    # 判断对象是否是函数
    import types
    def fn():
        pass
    # True
    type(fn)==types.FunctionType
    type(abs) == types.BuiltinFunctionType
    type(lambda x: x) == types.LambdaType
    type((x for x in range(5))) == types.GeneratorType

（3）isinstance

# 对于class继承关系，使用type不好，可以使用isinstance()函数
    # 优先使用该类型，可以将指定类型及其子类"一网打尽"
    isinstance(a, Dog)
    
    # 判断变量是否是某些类型中的一种
    # 判断是否是list或者tuple
    isinstance([1, 2, 3], (list, tuple))

（4）dir

# 获取对象的所有属性和方法
    # ['__add__', '__class__']
    dir('123')
    
    # 类似__xxx__的属性和方法是有特殊作用的，如对象调用len()，实际上该对象会调用__len__()方法
    # len('123')等价于'123'.__len__()
    # 我们想使用自定义的len，可以重写__len__方法

class a(object):
        def __init__(self):
            self.x = 9
    
    
    a = a()
    # 是否有属性x，结果True
    hasattr(a, 'x')
    
    # 如果没设置值之前使用getattr，会报错AttributeError: 'a' object has no attribute 'y'，可以返回一个默认值
    print(getattr(a, 'y', 404))
    
    # 设置属性y
    setattr(a, 'y', 10)
    
    # 获取属性y的值
    print(getattr(a, 'y'))
    
    # 方法同理，放入方法名即可

**六：实例属性和类属性**

# 给实例绑定属性的方法是通过实例变量，或者通过self变量
    def __init__(self, name):
        self.name = name
    
    
    # a是实例
    a.name = 'xx'

class B(object):
        # 该属性归类所有，该类的梳理均可访问
        name = "小黑"
    
    
    a = B()
    # 结果是小黑（对象调用属性）
    a.name
    # 结果是小黑（类名调用属性）
    B.name
    # 给实例绑定name属性,再次访问结果是小白
    a.name = '小白'
    # 备注：原因是实例属性比类属性优先级高，所有两者不要使用相同名字

[https_www.liaoxuefeng.com_wiki_1016959663602400]: https://www.liaoxuefeng.com/wiki/1016959663602400
[https_blog.csdn.net_weixin_42717928_article_details_96380070]: https://blog.csdn.net/weixin_42717928/article/details/96380070
[https_blog.csdn.net_weixin_42717928_article_details_96380532]: https://blog.csdn.net/weixin_42717928/article/details/96380532
[https_blog.csdn.net_weixin_42717928_article_details_96381299]: https://blog.csdn.net/weixin_42717928/article/details/96381299