Python学习笔记_类与对象Ⅱ

面向对象的三大特征
封装：
提高程序的安全性。将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。在Python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个“_”。

class Student:
    def __init__(self, name, age):
        self.name = name
        self.__age = age  # age年龄不希望在类的外部使用，所以加了两个_

    def show(self):
        print(self.name, self.__age)  # age不希望在类的外部使用，但可以在内部使用


stu = Student('张三', 20)
stu.show()  # 张三 20
# 在类的外部使用name与age
print(stu.name)  # 张三
# print(stu.__age)  # 'Student' object has no attribute '__age'   说明__age不希望在类的外部使用

# 尽管加两个”_“的属性不希望在外部使用，但还是可以使用的
# 使用下面语句观察实例stu中有哪些属性和方法
print(dir(stu))
"""
['_Student__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', 
'__eq__', '__format__', '__ge__', '__getattribute__', '__gt__',
'__hash__', '__init__', '__init_subclass__', '__le__', '__lt__',
'__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'show']
"""
# 可以发现一个  _Student__age
print(stu._Student__age)  # 20   即 在类的外部可以通过  _Student__age 对__age进行访问

继承：
提高代码的复用性。

# 语法格式：
class 子类类名(父类1, 父类2...):
      pass

如果一个类没有继承任何类，则默认继承object。
Python支持多继承（即语法格式中子类类名后的括号中可以写多个父类），定义子类时，必须在其构造函数中调用父类的构造函数。

# 定义一个Person类
class Person(object):  # person继承object类
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def info(self):
        print(self.name, self.age)


# 定义一个Person的子类Student，让Student继承Person
class Student(Person):
    def __init__(self, name, age, stu_num):
        super().__init__(name, age)
        self.stu_num = stu_num


# 定义一个Person的子类Teacher
class Teacher(Person):
    def __init__(self, name, age, teach_year):
        super().__init__(name, age)
        self.teach_year = teach_year


stu = Student('张三', 20, '1702004')
teacher = Teacher('李四', 34, 10)
stu.info()  # 张三 20
teacher.info()  # 李四 34

方法重写
如果子类对继承自父类的某个属性或方法不满意，可以在子类中对其（方法体）进行重新编写。
子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法。

object类
object类是所有类的父类，因此所有类都有object类的属性和方法。
内置函数dir()可以查看指定对象所有属性。
object有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮助我们查看对象的信息，所以我们经常会对__str()__进行重写。

class Student:  # 默认继承object类
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):  # 重写__str__()
        return '我的名字是{0}，今年{1}岁'.format(self.name, self.age)


stu = Student('张三', 20)
print(dir(stu))   # 查看stu中所有的属性和方法  输出的类和属性是Student从object中继承的
print(stu)  # 我的名字是张三，今年20岁  如果没有在Student中重写__str__()，此处输出为  <__main__.Student object at 0x00000260EF5756F0>
# 上面语句默认调用__str__()方法
print(type(stu))  # <class '__main__.Student'>

多态
提高程序的可拓展性和可维护性。
简单的说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，任然可以通过这个变量的调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法

class Animal(object):
    def eat(self):
        print('动物会吃')


class Dog(Animal):
    def eat(self):
        print('狗吃骨头...')


class Cat(Animal):
    def eat(self):
        print('猫吃鱼...')


class Person:  # 不继承任何类，即默认继承object
    def eat(self):
        print('人吃五谷杂粮')


# 定义一个函数，函数中传入eat方法
def fun(obj):
    obj.eat()


# 开始调用函数
fun(Cat())  # 猫吃鱼...
fun(Dog())  # 狗吃骨头...
fun(Animal())  # 动物会吃
fun(Person())  # 人吃五谷杂粮  Person与Animal不存在继承关系，但Person中有eat方法，所以也会调用Person中的eat方法

静态语言和动态语言关于多态的区别：
Python是动态语言
静态语言实现多态的三个必要条件：继承、方法重写、父类引用指向子类对象
动态语言的多态崇尚“鸭子类型”，当看到一只鸟走起来像鸭子、游起泳来像鸭子、走起来也像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为。

特殊属性和特殊方法
特殊属性：dict__获得类对象或实例对象所绑定的所有属性和方法的字典
特殊方法：
①__len()，通过重写__len__()方法，让内置函数len()的参数可以是自定义类型
②__add__()，通过重写__add__()方法，可使用自定义对象具有“+”功能
③__new__()，用于创建对象
④__init__()，对创建的对象进行初始化

类的浅拷贝与深拷贝
变量的赋值操作：只是形成两个变量，实际上还是指向同一个对象

class CPU:
    pass


class Disk:
    pass


class Computer:
    def __init__(self, cpu, disk):
        self.cpu = cpu
        self.disk = disk


# (1)变量的赋值
cpu1 = CPU()
cpu2 = cpu1
print(cpu1)  # <__main__.CPU object at 0x00000197B1D5FEE0>
print(cpu2)  # <__main__.CPU object at 0x00000197B1D5FEE0>
# cpu1与cpu2的内存地址是相同的，实际上是一个对象放在两个变量中

浅拷贝：Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象。

深拷贝：使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。

浅拷贝深拷贝需要用的时候再去仔细看看，第一遍学没学懂