import json
import re
def interactive(): #与用户交互
    name=input('>>: ').strip()
    pwd=input('>>: ').strip()
    email=input('>> ').strip()
    return {   #把结果返回
        'name':name,
        'pwd':pwd,
        'email':email
    }

def check(user_info): #检测 user_info 接收上一步返回的结果
    is_valid=True  #默认是有效 True的

    if len(user_info['name']) == 0:
        print('用户名不能为空')
        is_valid=False  #现在这个数据是无效的

    if len(user_info['pwd']) < 6:
        print('密码不能少于6位')
        is_valid=False

    if not re.search(r'@.*?.com$',user_info['email']):
        print('邮箱格式不合法')
        is_valid=False

    return {    #返回结果
        'is_valid':is_valid,  
        'user_info':user_info
    }

def register(check_info): #注册
    if check_info['is_valid']:
        with open('db.json','w',encoding='utf-8') as f:
            json.dump(check_info['user_info'],f)


def main():
    user_info=interactive()

    check_info=check(user_info)

    register(check_info)

if __name__ == '__main__':
    main()

#先定义类
class LuffyStudent:
    school='luffycity'

    def learn(self):
        print('is learning')

    def eat(self):
        print('is sleeping')


#后产生对象
stu1=LuffyStudent()
stu2=LuffyStudent()
stu3=LuffyStudent()

print(stu1)
print(stu2)
print(stu3)

#先定义类
class LuffyStudent:
    school='luffycity' #数据属性


    def learn(self): #函数属性
        print('is learning')

    def eat(self): #函数属性
        print('is sleeping')


#查看类的名称空间
#print(LuffyStudent.__dict__) #{'__module__': '__main__', 'school': 'luffycity', 'learn': <function LuffyStudent.learn at 0x000000000226CAE8>, '__dict__': <attribute '__dict__' of 'LuffyStudent' objects>, '__weakref__': <attribute '__weakref__' of 'LuffyStudent' objects>, '__doc__': None}
#print(LuffyStudent.__dict__['school'])  #luffycity
#print(LuffyStudent.__dict__['learn'])   #<function LuffyStudent.learn at 0x000000000294CAE8>


#查
#print(LuffyStudent.school) #就相当于这样查找 ：LuffyStudent.__dict__['school']  #luffycity
#print(LuffyStudent.learn) #LuffyStudent.__dict__['learn'] 与上边输出结果一样的

#增
LuffyStudent.county='China'
# print(LuffyStudent.__dict__)
print(LuffyStudent.county)  #China

#删
del LuffyStudent.county

#改
LuffyStudent.school='Luffycity'

#__init__方法用来为对象定制对象自己独有的特征

#该方法是在对象产生之后才会执行，只用来为对象进行初始化操作，可以有任意代码，但一定不能有返回值

class LuffyStudent:
    school='luffycity'

                 #stu1, '王二丫', '女', 18 传给self，name,sex,age
    def __init__(self,name,sex,age):
        self.Name=name
        self.Sex=sex
        self.Age=age

        #stu1.Name='王二丫'
        #stu1.Sex='女'
        #stu1.Age=18

    def learn(self):
        print('is learning')

    def eat(self):
        print('is sleeping')


#后产生对象
stu1=LuffyStudent('王二丫','女',18) ##LuffyStudent.__init__(stu1,'王二丫','女',18)

#加上__init__方法后，实例化的步骤:
# 1、先产生一个空对象stu1
# 2、然后调用LuffyStudent.__init__(stu1,'王二丫','女',18)


#查
print(stu1.__dict__)   #{'Name': '王二丫', 'Sex': '女', 'Age': 18}
#print(stu1.Name)
#print(stu1.Sex)
#print(stu1.Age) #18

#改
# stu1.Name='李二丫'
# print(stu1.__dict__)
# print(stu1.Name)
#删除
# del stu1.Name
# print(stu1.__dict__)
#增
# stu1.class_name='python开发'
# print(stu1.__dict__)  #{'Name': '王二丫', 'Sex': '女', 'Age': 18, 'class_name': 'python开发'}

#实例化
# stu2=LuffyStudent('李三炮','男',38) #Luffycity.__init__(stu2,'李三炮','男',38)
# print(stu2.__dict__)
# print(stu2.Name)
# print(stu2.Age)
# print(stu2.Sex)

class LuffyStudent:
    school='luffycity'

    def __init__(self,name,sex,age):
        self.Name=name
        self.Sex=sex
        self.Age=age

    def learn(self):
        print('%s is learning %s' %(self.Name))

    def eat(self):
        print('%s is sleeping' %self.Name)

#后产生对象
stu1=LuffyStudent('王二丫','女',18)
stu2=LuffyStudent('李三炮','男',38)
stu3=LuffyStudent('张铁蛋','男',48)
# print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)


#对象：特征与技能的结合体
#类：类是一系列对象相似的特征与相似的技能的结合体

#类中的数据属性：是所以对象共有的,id都一样
# print(LuffyStudent.school,id(LuffyStudent.school))  #luffycity 43599280
#
# print(stu1.school,id(stu1.school))  #luffycity 43599280
# print(stu2.school,id(stu2.school))  #luffycity 43599280
# print(stu3.school,id(stu3.school))

#类中的函数属性:是绑定给对象使用的，绑定到不同的对象是不同的绑定方法，对象调用绑定方式时，会把对象本身当作第一个传入，传给self

##obj.method称为绑定方法,内存地址都不一样

# print(LuffyStudent.learn)   #<function LuffyStudent.learn at 0x000000000225CB70>

# print(stu1.learn)           ##绑定方法 bond  
# LuffyStudent.learn(stu1)   #is learning
# LuffyStudent.learn(stu2)   #is learning
# LuffyStudent.learn(stu3)

#Author:Kris

x='global' ##函数中的参数
class LuffyStudent:
    school='luffycity'
    def __init__(self,name,sex,age):
        self.Name=name
        self.Sex=sex
        self.Age=age
    def learn(self,x):
        print('%s is learning %s' %(self.Name,x))
    def eat(self):
        print('%s is sleeping' %self.Name)

#后产生对象
stu1=LuffyStudent('王二丫','女',18)
stu2=LuffyStudent('李三炮','男',38)
stu3=LuffyStudent('张铁蛋','男',48)
print(stu1.__dict__)
# print(stu2.__dict__)
# print(stu3.__dict__)

##加参数x后
print(stu1.learn)  #加不加参数它都是绑定方法<bound method LuffyStudent.learn of <__main__.LuffyStudent object at 0x0000000001EF1EF0>>
stu1.learn(1)      #learn（stu1,1）#把stu1传给self，1传给x  # is learning
print(stu2.learn)  #<bound method LuffyStudent.learn of <__main__.LuffyStudent object at 0x0000000001EF1F28>>
print(stu3.learn)

stu2.learn(2)
stu3.learn(3)

##代码同上
# stu1.x='from stu1'  #没有之后再去类里边找
# LuffyStudent.x='from Luffycity class'
#print(stu1.x) ##打印出 from stu1


print(stu1.__dict__)  # {'Name': '王二丫', 'Sex': '女', 'Age': 18, 'x': 'from stu1'}
print(stu1.x)         ##只在类里边找，类里边没有，不去全局里找，所以不会打印 x='global'这个一开始定义的全局 from 

print(type[1,2]) # 打印<class  'list'>
print(list) 

print(Luffycity) #打印类,代码见上 输出 <class '__main__.Luffystudent'>


l1 = [1,2,3] ##就等于l = list([1,2,3])

l1.append(4) ##等同于list.append(l1,4) 
print(l1)

class student():
    school = 'luffycity'
    count = 0
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
        ##self.count += 1  ##这样写不行
        student.count += 1
    def learn():
        print('%s is learnning'%self.name)

stu1 = student('alex', 22,'male')
stu2 = student('sindy', 24,'female')

print(student.count)
print(stu1.count)
print(stu2.count)

print(stu1.__dict__)
print(stu2.__dict__)

class Garen():
    camp = 'Demacia'
    def __init__(self,nickname,life_value,aggresivity):
        self.nicakname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
        
     def attack(self,enemy):
        enemy.life_value -= self.aggresivity

class Raren():
    camp = 'Noxus'
    def __init__(self,nickname,life_value,aggresivity):
        self.nicakname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
        
     def attack(self,enemy):
        enemy.life_value -= self.aggresivity

g1 = Garen('草丛伦',100,30)

r1 = Riven('瑞雯雯',80,50)
print(r1.life_value)
g1.attack(r1)
print(r1.life_value)

class ParentClass1: #定义父类
    pass

class ParentClass2: #定义父类
    pass

class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
    pass

class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
    pass

>>> SubClass1.__bases__ #__base__只查看从左到右继 承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

class Hero:
    camp = 'Demacia'
    def __init__(self,nickname,life_value,aggresivity):
        self.nicakname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
class Garen(Hero):
    pass
# class Raren(Hero):
#     pass
g1 = Garen('kris',100,30) #Garen类里边没有__init__方法，回去父类里边找__init__
print(g1.nicakname,g1.life_value,g1.aggresivity)

class Hero:
    camp = 'Demacia'
    #x = 3
    def __init__(self,nickname,life_value,aggresivity):
        self.nicakname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
class Garen(Hero):
    x = 2
    pass
# class Raren(Hero):
#     pass
g1 = Garen('kris',100,30) #Garen类里边没有__init__方法，回去父类里边找__init__
print(g1.nicakname,g1.life_value,g1.aggresivity)
g1.x = 1
print(g1.x)  # 1

#属性查找练习
class Foo:
    def f1(self):
        print('from Foo.f1')
    def f2(self):
        print('from Foo.f2')
        self.f1() ##相当于b.f1()  b对象本身里边找不到f1，然后去b的类Bar里边找
class Bar(Foo):
    def f1(self):
        print('from Bar.f2')
b = Bar()
b.f2() #对象没有定义__init__方法，自己的找不到f2，就去自己的类里边找，没有再去父类里边  #打印 from Foo.f2    from Bar.f2

class Hero:
    def __init__(self,nickname,life_value,aggresivity):
        self.nicakname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
class Garen(Hero):
    camp = 'Demacia'
    def attack(self,enemy):
        print('from Garen class')  #当子类中派生出新的属性，就以派生的新的属性为准，如果没有就遗传父类的
　　　　 enemy.life_value -= self.aggresivity

class Raren(Hero):
    camp = 'Noxus'
g1 = Garen('kris',100,20)
r1 = Raren('瑞雯雯',80,50)

# print(g1.camp)        #Demacia
# g1.attack(r1)         #from Garen class
# print(r1.life_value)  #60

g1.attack(r1)

class A(object):
    def test(self):
        print('from A')
class B(A):
    def test(self):
        print('from B')
class C(A):
    def test(self):
        print('from C')
class D(B):
    # def test(self):
    #     print('from D')
    pass
class E(C):
    def test(self):
        print('from E')
class F(D,E):
    # def test(self):
    #     print('from F')
    pass
#查找顺序 F--D--B--E--C--A
f1=F()
f1.test() #先找到test这个属性，找到发现是一个方法才可以加括号 #from B
print(F.mro())


打印出：
from B
[<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

class Hero:
    def __init__(self,nickname,life_value,aggresivity):
        self.nicakname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
class Garen(Hero):
    camp = 'Demacia'
    def attack(self,enemy):
        Hero.attack(self,enemy)  #类中使用函数要把它的参数都传进去；指名道姓的使用
        print('from Garen class')  #当子类中派生出新的属性，就以派生的新的属性为准，如果没有就遗传父类的
class Raren(Hero):
    camp = 'Noxus'
g1 = Garen('kris',100,30)
r1 = Raren('瑞雯雯',80,50)

print(r1.life_value) #80
g1.attack(r1)        #from Garen class
print(r1.life_value) #50

class Hero:
    def __init__(self,nickname,life_value,aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
class Garen(Hero):
    camp = 'Demacia'
    def __init__(self,nickname,life_value,aggresivity,weapon):
        Hero.__init__(self,nickname,life_value,aggresivity) #相当于 self.nickname = nickname ...
        self.weapon = weapon
    def attack(self,enemy):
        Hero.attack(self,enemy)  #类中使用函数要把它的参数都传进去；###第一种方式:指名道姓的使用
        print('from Garen class')  #当子类中派生出新的属性，就以派生的新的属性为准，如果没有就遗传父类的
class Raren(Hero):
    camp = 'Noxus'
g = Garen('kris',100,40,'屠龙刀')
print(g.__dict__)   #{'nickname': 'kris', 'life_value': 100, 'aggresivity': 40, 'weapon': '屠龙刀'}

class Hero:
    def __init__(self,nickname,life_value,aggresivity):
        self.nicakname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
class Garen(Hero):
    camp = 'Demacia'
    def attack(self,enemy):
        super(Garen,self).attack(enemy) #对象来调用  ##依赖继承  #重用父类方法  #可以理解为得到了父类的对象
        print('from Garen class') #super（Garen,self）得到的是一个特殊对象，对象得到的就是它的绑定方法而不是函数了，第一个参数self就不用传了 ，只需传enemy即可
class Raren(Hero):
    camp = 'Noxus'
g1 = Garen('kris',100,30)
r1 = Raren('瑞雯雯',80,50)

g1.attack(r1)         #from Garen class
print(r1.life_value)  #50  #80-30

class Hero:
    def __init__(self,nickname,life_value,aggresivity):
        self.nickname = nickname
        self.life_value = life_value
        self.aggresivity = aggresivity
    def attack(self,enemy):
        enemy.life_value -= self.aggresivity
class Garen(Hero):
    camp = 'Demacia'
    def __init__(self,nickname,life_value,aggresivity,weapon):
        #Hero.__init__(self,nickname,life_value,aggresivity) #相当于 self.nickname = nickname ...
        #super(Garen,self).__init__(nickname,life_value,aggresivity) #在py2中
        super().__init__(nickname,life_value,aggresivity) #在py3中简写
        self.weapon = weapon
    def attack(self,enemy):
        Hero.attack(self,enemy)  #指名道姓的使用
        print('from Garen class')
g = Garen('kris',100,40,'屠龙刀')
print(g.__dict__)  #{'nickname': 'kris', 'life_value': 100, 'aggresivity': 40, 'weapon': '屠龙刀'}

class A:
    def f1(self):
        print('from A')
        super().f1()  #它是基于C类往下找的，走到这的时候接着往下找，所以去找了B类
class B:
    def f1(self):
        print('from B')
class C(A,B):
    pass
print(C.mro())
#[<class '__main__.C'>,
# <class '__main__.A'>,
# <class '__main__.B'>,
# <class 'object'>]
c=C()
c.f1() 

 打印：  

  [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
  from A
  from B

class People:
    school = 'luffycity'
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
class Teacher(People):
    def __init__(self,name,age,sex,level,salary):
        super().__init__(name,age,sex)
        self.level = level
        self.salary = salary
    def teach(self):
        print('%s is teaching'%self.name)
class Student(People):
    school = 'luffycity'
    def __init__(self,name,age,sex,class_time):
        super().__init__(name,age,sex)
        self.class_time = class_time
    def learn(self):
        print('%s is learning'%self.name)
class Course:
    def __init__(self,course_name,course_price,course_period):
        self.course_name = course_name
        self.course_price = course_price
        self.course_period = course_period
    def tell_info(self):
        print('课程名<%s> 课程价钱<%s> 课程周期<%s>' %(self.course_name,self.course_price,self.course_period))
teacher1 = Teacher('alex',22,'male',10,3000)
teacher2 = Teacher('egon',24,'female',30,4000)
python = Course('python',3000,'3months')
linux=Course('linux',2000,'4mons')

print(python.course_name)  #python
teacher1.course = python  ###把两个类组合到一起  Course类以Teacher类的对象作为数据属性 ;course作为数据属性使用。
teacher2.course = python 
print(python)             #<__main__.Course object at 0x000000000298E208>
print(teacher1.course)    #<__main__.Course object at 0x000000000229F240>
print(teacher2.course)    #<__main__.Course object at 0x000000000229F240>
print(teacher1.course.course_name) #python
print(teacher2.course.course_name) #python
teacher1.course.tell_info()        #课程名<python> 课程价钱<3000> 课程周期<3months>

student1=Student('张三',28,'female','08:30:00')
student1.course1=python    #组合  course1
student1.course2=linux

student1.course1.tell_info()  ##可以得到学生1学的课程的信息 #课程名<python> 课程价钱<3000> 课程周期<3months>
student1.course2.tell_info()                             #课程名<linux> 课程价钱<2000> 课程周期<4mons>
student1.courses=[]         #可扩展性比较强，定义个列表，所有学生学的课程都放这里边了；     #把两个类或者多个类组合到一起就是组合
student1.courses.append(python)
student1.courses.append(linux)
print(student1.courses)    #[<__main__.Course object at 0x00000000029772E8>, <__main__.Course object at 0x0000000002977320>]

class People:
    school='luffycity'
    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

class Teacher(People):
    def __init__(self,name,age,sex,level,salary,):
        super().__init__(name,age,sex)
        self.level=level
        self.salary=salary
    def teach(self):
        print('%s is teaching' %self.name)

class Student(People):
    def __init__(self, name, age, sex, class_time,):
        super().__init__(name,age,sex)
        self.class_time=class_time
    def learn(self):
        print('%s is learning' % self.name)

class Course:
    def __init__(self,course_name,course_price,course_period):
        self.course_name = course_name
        self.course_price = course_price
        self.course_period = course_period
    def tell_info(self):
        print('课程名<%s> 课程价钱<%s> 课程周期<%s>' %(self.course_name,self.course_price,self.course_period))

class Date:
    def __init__(self,year,mon,day):
        self.year=year
        self.mon=mon
        self.day=day
    def tell_info(self):
        print('%s-%s-%s' %(self.year,self.mon,self.day))

student1=Student('张三',28,'female','08:30:00')
d=Date(1988,4,20)
python=Course('python',3000,'3mons')

student1.birh=d   
student1.birh.tell_info()   #1988-4-20

student1.course=python
student1.course.tell_info() #课程名<python> 课程价钱<3000> 课程周期<3mons>

import abc   #第三方模块---抽象类把子类给规范化
class Animal(metaclass=abc.ABCMeta): #只能被继承，不能被实例化   #把它做成一个抽象类
    all_type='animal'   #数据属性
    @abc.abstractmethod   ##保证子类必须有这个方法，必须叫这个名字，给它规范化加个装饰器
    def run(self):
        pass
    @abc.abstractmethod
    def eat(self):
        pass
#animal=Animal()  #不能实例化抽象类，会报错

class People(Animal):  #继承抽象类
    def run(self):
        print('people is running')
    def eat(self):
        print('people is eating')

class Pig(Animal):
    def run(self):
        print('people is walking')
    def eat(self):
        print('people is eating')

class Dog(Animal):
    def run(self):
        print('people is walking')
    def eat(self):
        print('people is eating')
#peo1=People()
#pig1=Pig()
#dog1=Dog()

#peo1.eat()
#pig1.eat()
#dog1.eat()
#
# print(peo1.all_type)  #进行查找，找到抽象类里边，抽象类本质还是个类

#多态：同一类事物的多种形态
##下面的多态性是动态多态性；
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

class Cat(Animal):  #新扩展的
    def talk(self):
        print('say miamiao')

#多态性：指的是可以在不考虑对象的类型的情况下而直接使用对象
peo1=People()  #对象
dog1=Dog()
pig1=Pig()
cat1=Cat()

# peo1.talk()  #它们的类型就是这些类，不考虑它们的类型，它们三个都是动物，我照着动物的标准直接用就行了，这就是多态性
# dog1.talk()
# pig1.talk()


def func(animal):  #用户直接使用   ##定义一个统一的接口，同一个接口直接调用就可以了，这就是多态性的好处。
    animal.talk()
func(peo1) #say hello
func(pig1) #say aoao
func(dog1) #say wangwang
func(cat1) #say miamiao

#class File:   ##这个父类没有意义
#　　def read(self):
#　　　　pass
#　　def write(self):
#　　　　pass

class Disk:   #磁盘不是文件，直接继承就给人误解了
    def read(self):
        print('disk read')
    def write(self):
        print('disk write')
class Text:
    def read(self):
        print('text read')
    def write(self):
        print('text write')
# f = open()
# f.read()
# f.write()

disk=Disk()  #得到磁盘的对象
text=Text()  #得到Text的对象

disk.read()  #大家用的都是同一套接口，不用管你是不是文件，我直接使用就可以了，降低了使用者的复杂度，这就叫鸭子类型
disk.write()
text.read()
text.write()
#类与类之间不用继承父类，只要把它们做的像就可以了
#序列类型：列表list，元祖tuple，字符串str，  同一种类型的三种形态
l=list([1,2,3])
t=tuple(('a','b'))
s=str('hello')

# print(l.__len__()) #3  打印统计长度  ，只要它是序列类型我就可以用len
# print(t.__len__()) #2
# print(s.__len__()) #5

# def len(obj):  #本来就是内置函数，不用写了     统一的接口
#     return obj.__len__()
print(len(l)) #3
print(len(t)) #2
print(len(s)) #5

class A:
    __x=1 ##实际上是这种形式 _A__x=1  #只是一种变形操作，在类定义阶段就发生了，执行之前
    def __init__(self,name):
        self.__name=name    #self._A__name=name
    def __foo(self): # _A__foo
        print('run foo')
    def bar(self):
        self.__foo() #self._A__foo()
        print('from bar')
print(A.__dict__) #查看类的名称空间 #{'__module__': '__main__', '_A__x': 1, '__init__': <function A.__init__ at 0x000000000298CB70>, '_A__foo': <function A.__foo at 0x000000000298CBF8>, 'bar': <function A.bar at 0x000000000298CC80>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
# print(A.__x)  #会报错
# print(A.__foo) #报错
a = A('egon')
#a._A__foo()#只要就可以调用到了，变行之后的  #打印run foo
#a._A__x 
#print(a.__name)   #会报错，访问不到了，它原本是a.__dict__['__name']
#print(a.__dict__)  #查看对象a的名称空间  #打印：{'_A__name': 'egon'}
a.bar() ###在类内部可以之间使用 打印：run foo   from bar

class Foo:
    def __func(self): #_Foo__func
        print('from foo')
class Bar(Foo):
    def __func(self): #_Bar__func
        print('from bar')
# b=Bar()
# b.func() #会报错的

#特点3
class Foo:
    def __func(self): #_Foo__func
        print('from foo')
class Bar(Foo):
    def __func(self): #_Bar__func
        print('from bar')
# b=Bar()
# b.func()

# class B:
#     __x=1
#     def __init__(self,name):
#         self.__name=name #self._B__name=name

#验证问题一：
# print(B._B__x)  #1  python这个语法就是要隐藏，你就别这样做了，直接不隐藏就可以了

#验证问题二：
# B.__y=2    #类定义之后，没有变形
# print(B.__dict__)
#打印：{'__module__': '__main__', '_B__x': 1, '__init__': <function B.__init__ at 0x000000000297CB70>, '__dict__': <attribute '__dict__' of 'B' objects>, '__weakref__': <attribute '__weakref__' of 'B' objects>, '__doc__': None, '__y': 2}

# b=B('egon')
# print(b.__dict__) #{'_B__name': 'egon'}  查看变形了，在类定义阶段已经变形了

# b.__age=18   ##在定义之后再变形，不会变了
# print(b.__dict__)  #{'_B__name': 'egon', '__age': 18}
# print(b.__age)     ##输出打印出 18

#验证问题三：
# class A:
#     def foo(self):
#         print('A.foo')
#
#     def bar(self):
#         print('A.bar')
#         self.foo() #实际上就是b.foo()了
#
# class B(A):
#     def foo(self):
#         print('B.foo')
#
# b=B()
# b.bar()  打印出 A.bar  B.foo

#对比
# class A:
#     def __foo(self):  #_A__foo
#         print('A.foo')
#
#     def bar(self):
#         print('A.bar')
#         self.__foo() #实际上就是b._A__foo()了 我只调用自己类里边的，不到其他类里边找
#
# class B(A):
#     def __foo(self): #_B__foo
#         print('B.foo')
#
# b=B()
# b.bar()   打印：A.bar  A.foo

#一：封装数据属性：明确的区分内外，控制外部对隐藏的属性的操作行为
class People:
    def __init__(self,name,age):
        self.__name=name
        self.__age=age
    def tell_info(self):
        print('Name:<%s> Age:<%s>' %(self.__name,self.__age))
    def set_info(self,name,age):  #一个接口
        if not isinstance(name,str):   #附加一些操作逻辑，  “谁是谁的实例，谁是谁的对象的意思”，name是不是str的实例
            print('名字必须是字符串类型')
            return
        if not isinstance(age,int):
            print('年龄必须是数字类型')
            return
        self.__name=name   ##修改名字和年龄
        self.__age=age

p=People('egon',18)
# p.tell_info() # Name:<egon> Age:<18>

# p.set_info('EGON',38)  #用的别人给你开的接口给修改的名字和年龄
# p.tell_info() # Name:<EGON> Age:<38>  来查看的   ##对属性、年龄的修改不是直接修改，已经隐藏起来了不让你修改；
                                                  # 通过一个接口间接修改，接口上又附加了一些操作逻辑来控制你对属性的操作

# p.set_info(123,38)    #名字必须是字符串类型
p.set_info('egon','38') #年龄必须是数字类型
p.tell_info()           #Name:<egon> Age:<18>

#二、 封装方法：隔离复杂度
class ATM:
    def __card(self):
        print('插卡')
    def __auth(self):
        print('用户认证')
    def __input(self):
        print('输入取款金额')
    def __print_bill(self):
        print('打印账单')
    def __take_money(self):
        print('取款')
    def withdraw(self):  #用户调一个取款的功能就可以了
        self.__card()
        self.__auth()
        self.__input()
        self.__print_bill()
        self.__take_money()
a=ATM()
a.withdraw() #直接调用取款功能，类外部的使用者不用关心其他的
#插卡 用户认证 输入存款金额 打印账单 取款

class Room:
    def __init__(self,name,owner,weight,length,height):
        self.name=name
        self.owner=owner
        self.__weight=weight
        self.__length=length
        self.__height=height  #高度

    def tell_area(self):   #开一个接口，只访问面积或者体积就可以了；可扩展性体现在接口上，用户记住接口名就可以了
        return self.__weight * self.__length * self.__height

r=Room('卫生间','alex',10,10,10)
# print(r.tell_area())
print(r.tell_area())#1000

class People:
    def __init__(self,name,weight,height):
        self.name=name
        self.weight=weight
        self.height=height
    @property  
    def bmi(self):  
        return self.weight / (self.height ** 2)  #返回值作为它的结果

p=People('egon',75,1.81)
# p.bmi=p.weight / (p.height ** 2)  ##会报错，不能设置属性； 它原来就是这样算的
# print(p.bmi) #22.89307408198773   加上装饰器调用的时候就不用加bmi（）了
                                    #本质是触发了bmi这个方法的执行，拿到它的返回值打印就可以了  使用者感受不到
# print(p.bmi()) #会报错；           加括号，代表你要去调用这个函数，这个功能，去做什么、去干什么，一个动词，bmi应该是一个名词，一个属性。
# print(p.bmi)   #22.89307408198773；这样子调用是最好的，要加一个装饰器

# p.height=1.82
# print(p.bmi)  #22.6421929718633  会跟着传入参数而变

p.bmi=3333 #报错AttributeError: can't set attribute  #bmi背后是一个方法，不能赋值

class People:
    def __init__(self,name):
        self.__name=name
    @property
    def name(self):  #接口  ###查看
        # print('getter')
        return self.__name
    @name.setter  #这个name是经过上边的装饰器装饰过后的，再去调用setter  ###修改
    def name(self,val):
        # print('setter',val)
        if not isinstance(val,str):
            print('名字必须是字符串类型')
            return
        self.__name=val
    @name.deleter   ###删除
    def name(self):
        print('deleter')
        print('不允许删除')
p=People('egon')

# print(p.get_name()) #AttributeError: 'People' object has no attribute 'get_name'  #可以拿到结果，最好是数据属性
# print(p.name)      #egon  这样是最好的，需要加装饰器伪装下。
# p.name #对应的是一个方法，访问行为，触发的是查看； 不能赋值，要想赋值需要再定义一个name

#修改
# p.name='EGON' #触发修改
# p.name=123   ##名字必须是字符串类型
# print(p.name) #看看有没有改成功 EGON

del p.name  #deleter  不能删除