面向对象编程
类和实例
类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都互相独立，互不影响；
方法就是与实例绑定的函数，和普通函数不同，方法可以直接访问实例的数据；
通过在实例上调用方法，我们就直接操作了对象内部的数据，但无需知道方法内部的实现细节。
和静态语言不同，Python允许对实例变量绑定任何数据，也就是说，对于两个实例变量，虽然它们都是同一个类的不同实例，但拥有的变量名称都可能不同
访问权限
如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线__，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问
以之前的Student类，name score 属性为例：
如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：
class Student(object):
...
def get_name(self):
return self.__name
def get_score(self):
return self.__score
如果又要允许外部代码修改score怎么办？可以再给Student类增加set_score方法：
class Student(object):
...
def set_score(self, score):
self.__score = score
在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的
__xxx 是私有变量，_xxx 是公有变量，但约定俗成，最好当成私有变量，不要随意访问
获取对象信息
type()
isinstance()
用在class判断继承关系上方便
dir()
获得一个对象的所有属性和方法，可以使用dir()函数，它返回一个包含字符串的list
getattr()
>>> getattr(obj, 'y') # 获取属性'y'
19
setattr()
>>> setattr(obj, 'y', 19) # 设置一个属性'y'
>>> hasattr(obj, 'y') # 有属性'y'吗？
True
hasattr()
>>> hasattr(obj, 'x') # 有属性'x'吗？
True
通过内置的一系列函数，我们可以对任意一个Python对象进行剖析，拿到其内部的数据。要注意的是，只有在不知道对象信息的时候，我们才会去获取对象信息。
实例属性和类属性
由于Python是动态语言，根据类创建的实例可以任意绑定属性。
给实例绑定属性的方法是通过实例变量，或者通过self变量：
class Student(object): # 给实例绑定属性的方法是通过实例变量，或者通过self变量
def __init__(self, name,score):
self.name = name
self.score = score
s = Student('Bob', 90) # 这里init定义2个参数，所以这里必须输入2个参数，否则报错
s.name
# 输出结果： 'Bob'
s.score
# 输出结果：90
In [204]: class Student(object):
...: sex = 'girl' # 类属性
...: def __init__(self, name, score): # 实例属性
...: self.name = name
...: self.score = score
...:
In [205]: s = Student('lily',99)
In [206]: s.name
Out[206]: 'lily'
In [207]: s.score
Out[207]: 99
In [208]: instance = Student() # 必须传入2参数
TypeError: __init__() missing 2 required positional arguments: 'name' and 'score'
In [209]: instance = Student('lily',99)
In [210]: instance.sex # sex是类属性，但该类的实例同样可以访问它
Out[210]: 'girl'
但是，如果Student类本身需要绑定一个属性呢？可以直接在class中定义属性，这种属性是类属性，归Student类所有：
class Student(object): # 类属性
name = 'Student'
类属性虽然归类所有，但类的所有实例都可以访问到
>>> class Student(object):
... name = 'Student'
...
>>> s = Student() # 创建实例s
>>> print(s.name) # 打印name属性，因为实例并没有name属性，所以会继续查找class的name属性
Student
>>> print(Student.name) # 打印类的name属性
Student
>>> s.name = 'Michael' # 给实例绑定name属性
>>> print(s.name) # 由于实例属性优先级比类属性高，因此，它会屏蔽掉类的name属性
Michael
>>> print(Student.name) # 但是类属性并未消失，用Student.name仍然可以访问
Student
>>> del s.name # 如果删除实例的name属性
>>> print(s.name) # 再次调用s.name，由于实例的name属性没有找到，类的name属性就显示出来了
Student
⚠️注意：从上面的例子可以看出，在编写程序的时候，千万不要把实例属性和类属性使用相同的名字，因为相同名称的实例属性将屏蔽掉类属性，但是当你删除实例属性后，再使用相同的名称，访问到的将是类属性
对类 子类 继承 类属性 类方法 的实验
class Model(object):
def __init__(self, high, sex):
self.high = high
self.sex = sex
weight = 100 # 类属性
def love(self,x): # 实例属性
print(x, ': i love you~')
class Man(Model):
def __init__(self, age):
self.age = age
state = 'china' # 类属性
def miss(self,y): # 实例属性
print(y, ': i miss you much~')
def what_the_fuck(z):
print(z.love('kobe'), ':tell me duck type, what the fuck~')
# 测试 Model
test = Model(180, 'male') # test 为Model类的实例
test1 = Model(high = 180, sex = 'male') # 在ORM章节，定义有这样的参数输入，本质等价
print( test,test1 ) # 结果一样: <__main__.Model object at 0x1070609b0> #
print( test.high, test.sex ) # 结果: 180 male #
print( Model.weight, test.weight ) # 结果: 100 100 # weight是类属性，所以类与实例均可调用
print( test.love('lily') ) # 结果: lily : i love you~ # 其他方式均报错
# 测试 Man，继承自 Model
jack = Man(18) # 只能输入一个age参数，父类的 high sex 不影响它
# 除非用 super()方法去继承，这样父类里的__init__(self, *args,**kwargs)才能被继承作为子类生成实例时必须输入的参数
print( jack, jack.age, jack.miss('lily'), jack.love('lily') ) # 运行正常，第一个提示为对象；可识别父类的 love 方法
print( jack.high ) # 报错，不识别父类的 high
print( jack.state, Man.state, jack.weight, Man.weight ) # 结果 china china 100 100 # 也是就是说子类的类和实例 都 可以继承父类的类属性
# 测试鸭子类型
z = Man(18)
print( what_the_fuck(z) ) # 结果: kobe : i love you~ kobe : i love you~ # 这就是鸭子类型，把类实例作为函数的参数，函数中正好有该类实例的自身的函数，可自动识别