1，包内部不要去尝试应用使用相对导入，一定不会成功的，他不支持这个机制，包内导入时一定要用绝对导入
2，复习接口类，抽象类，Python中没有接口类，有抽象类，抽象类是通过abc模块中的metaclass = ABCMeta 和@abstractmethod实现的
3，接口类和抽象类本质是做代码规范用的，我希望在子类中实现和父类方法名完全一样的方法
4，二者区别，在JAVA的角度看是有区别的，JAVA没有多继承，所以为了接口隔离原则，就设计了接口这个概念，支持多继承；JAVA本来就支持单继承，所以就有了抽象类。Python中既支持单继承，也支持多继承，所以对于接口类和抽象类的区别就不那么明显了。甚至在Python中根本没有接口类，但是Python的扩展模块中有一个模块确实实现了接口类的概念，所以不能说根本没有，只是内置模块中没有，没有内置接口类。
5，多态和鸭子类型，多态---Python天生支持多态，给子类找个爸爸，传爸爸的参数，Python里面崇尚鸭子类型，不依赖父类的情况下，实现两个类中的同名方法。
6，封装 ---私有的，在Python中只要__名字，就把这个名字私有化了，私有化之后，就不能从类的外部直接调用了，可以私有的有静态属性方法，对象的属性都可以私有化，这种私有化只是从代码级别做了变形，并没有真的约束，变形机制 _类名__方法。在类外用这个调用，在类的外部__名字调用。
7，私有属性
class Room:
def __init__(self,name,length,width):
self.name = name
self.__length =length
self.__width = width def area(self):
return self.__length * self.__width jin = Room('jin',3,5)
print(jin.area())
jin.name = 'lisa'
print(jin.name)
8，get set 方法保护属性不被修改,私有属性的查看方法
class Room:
def __init__(self,name,length,width):
self.__name = name
self.__length =length
self.__width = width def get_name(self):
return self.__name # 对私有对象的保护
def set_name(self,new_name):
if type(new_name) is str and new_name.isdigit() == False:
self.__name = new_name
else:
print('invalid name') def area(self):
return self.__length * self.__width jin = Room('jin',3,5)
jin.name = '' # 不是私有的话，可以随便改，要想办法约束一下
print(jin.name) jin.set_name('lisa')
print(jin.get_name())
# C++ 里面所有的属性都设置成私有的，
9，父类的私有属性可以被子类调用吗？否
class Foo:
__key = '' _Foo__key class Son(Foo):
print(Foo.__key) #_Son__key # 此句报错，由于不可以调用
# AttributeError: type object 'Foo' has no attribute '_Son__key
10，总结：会用到私有概念的场景，隐藏起一个属性，不想让类的外部调用；我想保护这个属性，不想让属性随意被改变；我想保护这个属性不被子类继承
11，之前老师欠着的三个内置函数：property,classmethod,staticmethod
12，property，内置装饰器函数，只在面向对象中使用，但是作为一个property属性，函数后面不能传递任何参数
from math import pi
class Circle:
def __init__(self,r):
self.r = r @property
def perimeter(self):
return 2 *pi *self.r @property
def area(self):
return self.r**2*pi c1 = Circle(5)
# print(c1.area()) # 面积不是动作，是一个属性才合理，如何伪装成一个属性呢？
print(c1.area)
print(c1.perimeter)
# c1.area = 70 # 不支持赋值
13，BMI指数，方法伪装的属性，不被允许修改，怎么办？
class Person:
def __init__(self,name,high,weight):
self.name = name
self.high = high
self.weigh = weight
# self.bmi = wight / (high **2) # 这样写虽然可以，但是不规范，操作属性的方法我们都是会在方法里面来写，各司其职，才更合理 @property
def bmi(self):
return self.weigh/self.high**2 jin = Person('jin',1.75,70)
# print(jin.bmi())
print(jin.bmi)
jin.name = 'tiger'
# jin.bmi = '23' # 不允许修改，怎么办？
14，方法一，name.setter 和 name.deleter
class Person:
def __init__(self,name):
self.__name = name @property
def name(self):
return self.__name + ' nb' @name.setter
def name(self,new_name): # 虽然是同名函数，但是不会覆盖
self.__name = new_name @name.deleter
def name(self):pass # 里面不实现的话，是没有办法删除的def self.name tiger = Person('tiger')
# print(tiger.name()) # tigernb,另外改成property之后就不可以这样覅用了
print(tiger.name) tiger.name = 'all students' # 无法修改怎么办？再定义一个函数
print(tiger.name) del tiger.name # 删除属性
print(tiger.name) # 注意三个函数的名字必须一样，并且一定要有一个@property方法，才可以有后面两个
15，和类属性的结合
class Goods:
discount = 0.8
def __init__(self,name,price):
self.name = name
self.__price = price # 私有价格，只有自己知道 @property
def price(self):
return self.__price * Goods.discount apple = Goods('apple',5)
print(apple.price)
16，staticmethod 静态的方法 三颗星，classmethod 类方法 四颗星，property 四星半，重要程度，私有属性，五颗星
17，classmethod ，把一个方法 变成一个类中的方法，这个方法就可以直接被类调用，不被需要依托于任何对象
class Goods:
__discount = 0.8
def __init__(self,name,price):
self.name = name
self.__price = price @property
def price(self):
return self.__price * Goods.__discount @classmethod
def change_discount(cls,new_discount): # 去掉self，我们不推荐这样写,标准写法，不要写成其他的
cls.__discount = new_discount # apple = Goods('apple',5)
# print(apple.price) # 这个折扣修改的动作，我们如何不自己来完成，而是用一个函数来完成？
# 如果我们定义成一个对象函数，那么我必须拿一个对象来进行折扣的修改，但是这个折扣是类属性，我希望所有的对象都自动修改
# 而不是通过某一个
# apple.change_discount(0.7)
Goods.change_discount(0.9)
# 当这个方法的操作只涉及静态属性的时候，就应该使用classmethod
18，staticmethod，如果一个函数本身和类和对象都没有什么关系，但是我就想把这个函数写入到类里面，想象春面向对象的语言，例如JAVA，C#
class Login:
def __init__(self,name,password):
self.name = name
self.pwd = password def login(self):pass @staticmethod # 不需要和类和对象产生任何关系，但是还可以放在类里面
def get_usr_pwd(): # 必须把它扔进类里面，才是面向对象
input('input usrname:')
input('input password:') l = Login('alex','')
l.get_usr_pwd() # 静态方法既可以被对象来访问，也可以用类来访问
Login.get_usr_pwd() # 何时使用静态方法
# 在完全面向对象的程序中，如果一个函数，既和对象没有关系，也和类没有关系，那么就用staticmethod将这个函数编程一个静态方法 # 类方法和静态方法都是类来调用的，那么对象可以调用吗？
# 可以的，想象对象可以调用静态属性吗？一样的道理，但是一般情况下，推荐用类名来调用
# 类方法，有一个默认参数 cls 代表这个类
# 静态方法，没有默认参数，就像函数一样
19，反射，非常重要，五颗星，把字符串当变量使用
# name = 'lisa'
# 'name' class Teacher:
dic = {'show stu info','show teacher info'} def show_student(self):
print('show student') def show_teacher(self):
print('show teacher') # menu = Teacher.dic
# for k in menu:
# print(k) 'dic' # 最后三个内置函数
# hasattr
# getattr
# defattr ret = getattr(Teacher,'dic') # 左右对应 Teacher.dic
print(ret) # {'show stu info', 'show teacher info'} # python中一切皆是对象，包括类和模块
20，反射类属性和类方法
class Teacher:
dic = {'show stu info','show teacher info'} def show_student(self):
print('show student') def show_teacher(self):
print('show teacher') @classmethod
def func(cls):
print('hahaha') ret = getattr(Teacher,'dic') # 左右对应 Teacher.dic，类.属性
print(ret) # {'show stu info', 'show teacher info'} ret2 = getattr(Teacher,'func')
ret2() # hahaha if hasattr(Teacher,'func2'):
ret = getattr(Teacher,'func')
ret() if hasattr(Teacher,'dic'):
ret = getattr(Teacher,'dic')
print(ret)
21，反射对象方法
# 反射对象函数
lisa = Teacher()
func = getattr(lisa,'show_student')
func()
22，使用实例，有了反射我就不用去一条条判断了，我只需要一条反射，去掉用相应的方法就行了，反射的妙用
for k in Teacher.dic:
print(k) key = input("输入需求：")
# print(Teacher.dic[key])
# 这个地方好在不需要去判断if key = 1 怎么样，key =2怎么样，用反射，程序自动就去调用了
if hasattr(lisa,Teacher.dic[key]):
func = getattr(lisa,Teacher.dic[key])
func()
23，反射非常的重要，也许现在只在面向对象这儿还体会不到他的好，但是到了以后网络编程，文件操作的时候，会用的非常多
24，通过反射可以对象名获取对象属性和普通方法，类名获取静态属性和类方法和静态方法
25，面向对象思维导图和计算器作业先欠着，后补