1，
# 面向对象的三大特性：继承，多态和封装
# 继承：
# 单继承： ****
# 父类（超类，基类）
# 子类（派生类） 派生方法和派生属性
# 子类的对象在调用方法和属性：先用自己的，自己没有，采用父类的
# 多继承：（面试）
# 不会超过三个父类，不要超过三层 ***
# 如果子类自己有用自己的，如果没有就用离子类最近的那个父类的
# 抽象类和接口类 **
# 经典类和新式类 继承规则不同，深度优先和广度优先 ***** （面试）
# super 只有在python3中使用 mro ****
# super 是根据mro 广度优先顺序找上一个类
# 多态：（面试）
# 多态和鸭子类型 # 封装：***（面试）
# 私有的
#__名字
# 只能在类的内部调用，子类都无法继承 # 三个装饰器
# @property **** 规范 面试 # @name.setter
# @staticmethod ***
# @classmethod ***** 当一个方法使用了类的静态变量时，就给这个方法加上@classmethod装饰器，默认传cls参数
2，
class Goods():
__discount = 0.8
@classmethod
def change_discount(cls):
cls.__discount = 0.5 Goods.change_discount()
3，组合：表达的是什么有什么的关系 五颗星，一个类的属性是另外一个类的对象
4，面向对象的进阶
# isinstance() 和 issubclass() ***
# 反射 ****** 非常非常的重要，高级的设置，JAVA里面也有反射，会让程序变得很简洁，任何地方都可以用，模块函数都可以
# setattr()
# delattr()
# getattr()
# hasattr()
# __str__ 和__repr__ ** 所有双下方法，知道有这么个方法就行，主要是很多人用不太好这些双下方法
# __del__
# item系列
# __getitem__
# __setitem__
# __delitem__
5,isinstance 检查一个obj是否是一个类的对象
class Foo():pass
class Foo1():pass
obj = Foo()
print(isinstance(obj,Foo))
print(isinstance(obj,Foo1))
6，issubclass(sub,super) 检查sub类是否是super类的派生类
class A():pass
class B(A):pass
print(issubclass(B,A))
7，反射，非常非常重要的知识点，反射是用字符串类型的名字去操作变量，和eval有点类似
8，反射对象的属性
name = 1
eval('print(name)')
# eval会有很大的安全隐患，因为你不知道你执行的代码是什么来自哪里，除非写死了，不然有很大的安全隐患
# 但是反射就不会有安全问题，他不是真的拿到了一段python代码，他是操作内存中已经存在的变量 # 第一种：反射对象中的属性和方法
class A:
def func(self):
print('in func') a = A()
a.name = 'Alex' # 反射对象的属性
ret = getattr(a,'name') # 通过变量名的字符串形式取到值
print(ret)
print(a.__dict__) 变量名 = input(">>>")
print(getattr(a,变量名))
print(a.__dict__[变量名]) # 相当于这样，但是我们一般不这么用
9，反射对象的方法
class A:
def func(self):
print('in func') ret = getattr(a,'func')
ret()
10，反射类的属性,方法和静态方法
class A:
price = 20
def __init__(self,name):
self.name = name
def func(self):
print('in func') @classmethod
def func2(cls):
print('classmethod') @staticmethod
def func3():
print('staticmethod') a = A('lisa')
# 反射对象的属性
if hasattr(a,'name'):
ret = getattr(a,'name')
print(ret)
# 反射对象的方法
if hasattr(a,'func'):
ret = getattr(a,'func')
ret() # 反射类的属性
if hasattr(A,'price'):
ret = getattr(A,'price')
print(ret) # 反射类的方法
if hasattr(A,'func2'):
ret = getattr(A,'func2')
ret() # 反射静态的方法
if hasattr(A,'func3'):
ret = getattr(A,'func3')
ret()
11，反射模块的属性和方法
# 模块my的代码
day = "monday"
def func():print('func in module my.py')
import my
# 反射模块的属性和方法 print(getattr(my,'day'))
print(getattr(my,'func'))
12，反射自己模块中的变量，另外自己模块的函数也是可以的
import sys
year = 2019
print(sys.modules['__main__'].year)
print(sys.modules['my']) def qqxing():print('qqxing') # 反射自己模块中的变量
ret = getattr(sys.modules['__main__'],'qqxing') # 这样写其实是有坑的，因为如果我不是在这个模块开始运行的，他就不叫__main__了
ret()
print(getattr(sys.modules[__name__],变量名)) # 这样就可以了
13，应用time模块的一个小实例，要反射的函数有参数如何处理？下面的例子给出了解答
import time
print(time.strftime('%Y-%m-%d %H:%M:%S'))
print(getattr(time,'strftime')('%Y-%m-%d %H:%M:%S'))
14，一个模块中的类能不能反射得到
import my
print(getattr(my,"C")) # 拿到类
print(getattr(my,"C")()) # 实例化
15，总结：什么.什么的形式都可以用反射来得到，目前我们没有用到太多应用他的场景，但是后面用到他的地方非常多
16，getattr和hasattr 是一对儿，夫妻档要一起用
17，setattr，delattr几乎不会用到的，不占用星，用的非常少
class A:
pass a = A()
setattr(A,'name','nezha')
setattr(a,'name','alex') print(A.name)
print(a.name) delattr(a,'name') # 删掉对象的会用类的name print(A.name)
print(a.name)
18，类里面内置的双下方法，__str__ 和__repr__ 以前有讲过str()和repr()
class A(object):pass
# def __str__(self): # 只要是str方法，一定要返回一个字符串
# return 'str方法' a = A()
print(str(a))
如果类里面的str方法没有实现，那么会去调用object类里面的str方法，返回类的字符串
object里面有一个__str__,一旦被调用，就返回调用这个方法的对象的内存地址
运行结果：
<__main__.A object at 0x1072d6320>
class A(object):
def __str__(self): # 只要是str方法，一定要返回一个字符串
return 'str方法'
# 自己实现了str方法会用自己的
a = A()
print(str(a)) # 会自动调用类里面的双下str方法
运行结果：
str方法
19，str print str %s
class A(object):
def __str__(self): # 自己写会定义一个比较人性化的结果
return "A's object" a = A()
print(str(a))
print(a) # 默认打印一个对象，就是打印出这个对象的地址，调用a.__str__
# 这个不涉及原理或者什么，只是python的一种规定
l = [1,2,3,4,5] # 实例化了一个列表类的对象
print(l) # 为何打印l就会显示出里面的每一个元素，这就是他做了处理
# [1, 2, 3, 4, 5]
class A(object):
def __str__(self): # 自己写会定义一个比较人性化的结果
return "A's object" a = A()
print('%s:%s'%(A,a)) %s实际上走的也是双下str方法
运行结果：
<class '__main__.A'>:A's object
20，__repr__，调用repr和%r方法会自动调用类里面的双下repr方法
class Teacher(object):
def __init__(self,name,salary):
self.name = name
self.salary = salary def __str__(self): # 自己写会定义一个比较人性化的结果, 如果不返回str会报错的
return "A's object" def __repr__(self):
return str(self.__dict__) lisa = Teacher('lisa',100)
print(lisa)
print(repr(lisa)) 运行结果：
A's object
{'name': 'lisa', 'salary': 100}
21，总结一下
# 自己没有定制双下repr方法，那么会调用父类的repr方法，输出对象的内存地址，
# repr方法是str方法的备胎，自己没有定制str方法，那么会找repr方法，如果也没有repr方法，那么会调用父类的str方法。
22，repr是 str的备胎，str不能做repr的备胎
23，双下len方法，这些双下方法又称为魔法方法，是调用其他的自动来触发的
class A:
def __len__(self):
return 100 # 返回值必须是整数,小数也不行 a = A()
print(len(a))
23，__len__,这个方法必须实现了，才可以在下面调用，object类并没有定义所有的双下__len__方法，不一定所有的内置方法都被object收录了，比方说数字。有一些模块，比如说时间，不具备len,也没有意义，所以只能是所有的类都有的，会被object收录。定制对象的长度
class Classes:
def __init__(self,name):
self.name = name
self.student = [] def __len__(self):
return len(self.student) s9 = Classes('python')
s9.student.append('lisa')
s9.student.append('lucy')
print(len(s9)) #
24，__del__双下del方法，析构方法，del 既执行了方法，又删除了变量，析构函数，在删除一个对象之前，在做一些收尾工作
class A:pass
# def __del__(self):
# print('执行我啦！') a = A()
del a # 会自动调用双下del方法
print(a) # 提示出错，NameError: name 'a' is not defined
# 需要注意的是a 双下del 即使我们不定制，那么调用的时候也会自动去调用父类的双下del删除
25，del 被删除的情况，引用计数，达到零了会被删除，这是第一种情况，第二种情况，
26，双下__call__方法
class A:
def __init__(self,name,age):
self.name = name
self.age = age
# def __call__(self):
# print('执行我啦lala') def __call__(self, *args, **kwargs):
for k in self.__dict__:
print(k,end=' ') a = A('lisa',22)
a() # TypeError: 'A' object is not callable ,不实现call方法会报出这个错误
A('lisa',22)() # 见到这样的不要不认识，实际上就是调用双下call方法