一、封装
封装是一种将对象的属性和方法绑定在一起的机制，使得他们在类的外部不可被访问。这种机制在Python中很容易实现，通过在方法和属性名前面加上双下划线 "__"，可以将它们变为私有的。
通过封装，我们可以将类的实现细节隐藏起来，只暴露出一些必要的接口，使得外部的代码不易受到内部实现的变化产生的影响。
class Student:
def __init__(self, name, age):
self.__name = name
self.__age = age
def show(self):
print("Name: {}, Age: {}".format(self.__name, self.__age))
s = Student("Alice", 18)
s.show()
#输出：Name: Alice, Age: 18
s.__name = "Bob"
#此处是错误的，因为__name是私有属性
s.show()
#输出：Name: Alice, Age: 18
二、抽象
抽象是面向对象编程中一个非常重要的概念。它可以将某个类抽象成一个抽象类，简单的说就是只定义接口，不实现具体的功能。这样，子类可以继承这个抽象类，并且必须实现它定义的接口。
抽象的好处是提高了代码的可维护性，使得程序的代码结构更加清晰，更加易于扩展。
from abc import ABCMeta, abstractmethod
class Shape:
__metaclass__ = ABCMeta
@abstractmethod
def area(self):
pass
@abstractmethod
def perimeter(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height
def area(self):
return self.width * self.height
def perimeter(self):
return 2 * (self.width + self.height)
r = Rectangle(3, 4)
print(r.area())
#输出：12
print(r.perimeter())
#输出：14
三、属性和方法的访问控制
Python提供给了我们一些机制，用于控制属性和方法的访问。在类中，我们通常分为三个级别：公共、保护和私有。
- 公共：任何地方都可以访问
- 保护：只有子类和当前类可以访问
- 私有：只有当前类可以访问
class Person:
def __init__(self, name, age):
self.name = name
self._age = age #保护属性
self.__weight = 50 #私有属性
def say(self):
print("{} says: I'm {} years old.".format(self.name, self._age))
def __myself(self):
print("{} is {} kg.".format(self.name, self.__weight))
p = Person("Tom", 25)
print(p.name)
#输出：Tom
print(p._age)
#输出：25
print(p.__weight)
#此处是错误的，因为__weight是私有属性
p.say()
#输出：Tom says: I'm 25 years old.
p.__myself()
#此处是错误的，因为__myself是私有方法
四、多重继承
Python允许多重继承，即一个类可以继承多个类。这种继承方式可以使代码的复用性更高，但同时带来了更加复杂的代码逻辑。
多重继承的好处是可以在不同的类中实现不同的功能，并且可以从多个类中继承属性和方法。但是它也加剧了代码的不可控性和不确定性。
class A:
def functionA(self):
print("Function A")
class B:
def functionB(self):
print("Function B")
class C(A, B):
def functionC(self):
print("Function C")
c = C()
c.functionA()
#输出：Function A
c.functionB()
#输出：Function B
c.functionC()
#输出：Function C
五、类的属性和方法
在Python中，除了实例属性和方法之外，还有类属性和方法。类属性和方法与类相关联，而不是与实例相关联。类属性和方法可以通过类本身来调用。
class MyClass:
name = "MyClass"
@classmethod
def method(cls):
print("Calling Class Method...")
@staticmethod
def stMethod():
print("Calling Static Method...")
m = MyClass()
print(m.name)
#输出：MyClass
m.method()
#输出：Calling Class Method...
m.stMethod()
#输出：Calling Static Method...
MyClass.method()
#输出：Calling Class Method...
MyClass.stMethod()
#输出：Calling Static Method...
