一、面向对象的三大特征
1、封装：提高程序的安全性
（1）将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。
（2）在python中没有专门的修饰符用于属性的私有，如果该属性不希望在类对象外部被访问，前边使用两个"_"。但是可以通过_类名__变量名 来访问，dir(类名)查看所有属性（靠程序员的自觉性）
2、继承：提高代码的复用性
（1）如果一个类没有继承任何类，则默认继承object
- object类是所有类的父类，因此所有类都有object类的属性和方法。
- 内置函数dir()可以查看指定对象所有属性
- object有一个__str__()方法，用于返回一个对于“对象的描述”，对应于内置函数str()经常用于print()方法，帮我们查看对象的信息，所以我们经常会对__str__()进行重写
class Human(object): def __init__(self,name,age): self.name=name self.age=age def __str__(self): return '我的名字是{0},我的年龄是{1}'.format(self.name,self.age) human=Human("王大锤",20) print(dir(human)) print(human) #我的名字是王大锤,我的年龄是20 默认会调用__str__()这样的方法 print(type(human)) #<class '__main__.Human'>
（2）python支持多继承 比如：class C(A,B)
（3）定义子类时，必须在其构造函数中
（4）方法重写
- 如果子类对继承自父类的某个属性或者方法不满意，可以在子类中对其（方法体）进行重新编写
- 子类重写后的方法中可以通过super().xxx()调用父类中被重写的方法
class Person(object): #person继承object类 def __init__(self,name,age): self.name=name self.age=age def info(self): print(self.name,self.age) class Student(Person): def __init__(self,name,age,stu_num): super().__init__(name,age) self.stu_num=stu_num def info(self): super().info() print(self.stu_num) class Teacher(Person): def __init__(self,name,age,teachofyear): super().__init__(name,age) self.techofyear=teachofyear stu=Student('张三',20,10001) teacher=Teacher('里斯',38,10) stu.info() #张三 20 10001 teacher.info() #里斯 38
3、多态：提高程序的可扩展性和可维护性
（1）简单的说，多态就是“具有多种形态”，它指的是：即便不知道一个变量所引用的对象到底是什么类型，仍然可以通过这个变量调用方法，在运行过程中根据变量所引用对象的类型，动态决定调用哪个对象中的方法。
（2）python是动态语言，只要存在这个行为即可。Java是静态语言，必须存在限制条件。
二、特殊方法和特殊属性
1、特殊属性
class A(): pass class B(): pass class C(A,B): def __init__(self,name,age): self.name=name self.age=age #创建C类的对象 x=C('张三',30) #x是C类的一个实例对象 print(x.__dict__) #{'name': '张三', 'age': 30} 实例对象的属性字典 print(C.__dict__) #{'__module__': '__main__', '__init__': <function C.__init__ at 0x000001FEDF8B0C10>, '__doc__': None} print(x.__class__) #<class '__main__.C'> 输出了对象所属的类 print(C.__bases__) #C类的父类类型的元组 (<class '__main__.A'>, <class '__main__.B'>) print(C.__base__) #类的基类（离得最近的）<class '__main__.A'> print(C.__mro__) #类的层次结构 (<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>) print(A.__subclasses__()) #子类的列表 [<class '__main__.C'>]
2、特殊方法
- add方法
a=10 b=100 c=a+b d=a.__add__(b) print(c) #110 print(d) #110 class Hebing(): def __init__(self,name): self.name=name def __add__(self, other): return self.name+other.name one=Hebing('张三') two=Hebing('里斯') s=one+two #实现了两个对象的加法运算（因为在Hebing类中，编写__add__()特殊的方法） print(s) #张三里斯
- new和init方法
三、类的浅拷贝和深拷贝
1、变量的赋值操作
只是形成两个变量，实际上还是指向同一个对象
2、浅拷贝
python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象
3、深拷贝
使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同
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(id(cpu1)) #1964961551936 print(id(cpu2)) #1964961551936 #(2)类的浅拷贝 disk=Disk() #创建了一个硬盘类的对象 computer=Computer(cpu1,disk) #创建了一个计算机类的对象 #浅拷贝 import copy print(id(disk)) #1741100798784 computer2=copy.copy(computer) print(id(computer),id(computer.cpu),id(computer.disk)) #1741106057424 1741100799552 1741100798784 print(id(computer2),id(computer2.cpu),id(computer2.disk)) #1741106057712 1741100799552 1741100798784 #深拷贝 computer3=copy.deepcopy(computer) print(id(computer),id(computer.cpu),id(computer.disk)) #2142420472016 2142419473984 2142419473216 print(id(computer3),id(computer3.cpu),id(computer3.disk)) #2142420472736 2142420473648 2142420633008
