类与对象的属性与方法以及封装

class Student:
    identify = '学生'
stu = Student()
print(stu.identify)
Student.identify = '新学生'
print(stu.identify)
stu1 = Student()
stu1.identify='学生1'
stu1.name = 'bob'
stu1.age = 19
stu1.sex = 'male'
print(stu1.__dict__)
stu2 = Student()
stu2.identify = '学生2'
stu2.name = 'tom'
stu2.age =28
stu2.sex = 'female'
print(stu2.__dict__)

class  Student:
    # __init__方法会在实例化对象时 被调用
    #1 会为实例化对象的形成空的名称空间
    #2 就是一个方法，可以被传参，在类名（实参）这种方式下调用并传参__init__(slef,形参)
    #3 第一个的self 就是要产生的当前对象，
    #重点：在方法的内部，形参拿到了实参值， 利用self。属性名 = 形参= 实参值，对对象的名称空间添加属性
    def __init__(self,name,age):
        print('2...',self)
        self.name = name
        self.age = age
    def fn():
        print('fn run ')
    def set_stu(stu,name,age):
        stu.name = name
        stu.age = age

print(Student.__dict__)
Student.fn()
stu1=Student('bob',18)
print(stu1.__dict__)
Student.set_stu(stu1,'bob',18)
print(stu1.__dict__)
print(stu1.name)
print(stu1.age)
print(stu1.__dict__['name'])
print(stu1.__dict__['age'])
stu2 = Student('tom','female')
print(stu2.name,stu2.age,stu2.__dict__)
#如果产生空名称空间与对名称空间赋值操作的整合

class Student:
    def __init__(self,name):
        self.name = name
    def study(self):
        print(self.name +'bob')
stu1 = Student('kankan')
stu1.study()
stu1=Student('tom')
stu1.study()
class Student():
    pass
stu = Student()
def func(args):
    print('func run ')
Student.func = func
stu.func()
# stu.func ==  Student.__dict__['func'](stu) ==Student().func(stu)

#对象调用类方法
class A:
    def test(self):
        print(self)
        pass
a = A()
a.test()
A.test(a)
A.__dict__['test'](a)


class Tool:
    def add(cls,n1,n2):
        cls.fn()
        return n1+n2
    def fn(self):
        pass
    def a(self):
        self.b()
    def b(self):
        pass
# res = Tool.add(Tool,10,12)
# print(res)

tool= Tool()
print(tool.add(10,20))


class Tool:
    def add(cls,n1,n2):
        return n1+n2
print(Tool.add(Tool,10,20))
tool = Tool()
print(tool.add(10,20))

class Tool:
    @classmethod
    def add(cls,n1,n2):
        print(id(cls))
        cls.test()
        return n1+n2
    @classmethod
    def test(cls):
        pass
print(Tool.add(10,20))
tool = Tool()
print(tool.add(100,200))
print(id(Tool),id(tool))

class OldBoy:
    #属于类的属性
    name = '老男孩'
    #属于对象的属性
    def __init__(self,name):
        self.name = name
    #属于类的方法
    @classmethod
    def get_class_name(cls):
        return cls.name
    #属于对象的方法
    def get_school_name(self):
        return self.name
shanghai = OldBoy('上海校区')
shenzhen = OldBoy('深圳校区')

#类方法的使用
#建议使用类调用
print(OldBoy.get_class_name())
print(shanghai.get_class_name())
print(shenzhen.get_class_name())
#对象方法的使用
#类调用对象方法，必须把要操作的对象手动传入
print(OldBoy.get_school_name(shanghai))
print(OldBoy.get_school_name(shenzhen))
#对象调用方法
print(shanghai.get_school_name())
print(shenzhen.get_school_name())

#封装
class A:
    x= 10
    y=20
    def f1(self):
        print('f1 run ')
    def f2(self):
        print('f2 run')
    def get_box(self):
        print('找到保险箱')
        self.get_money()
    def get_money(self):
        print('输入密码，取出零花钱')

a = A()
print(a.x)
print(a.y)
a.f1()
a.f2()
a.get_box()
# 将类中的一些功能与属性，进行隐藏，不让外界直接访问 间接访问
# 封装 对外隐藏类中一些属性与方法的实现细节
# 优点：外界不能直接访问，让内部的属性与方法具有安全保障

class A:
    __cord = '0020876'
    @classmethod
    def __get_money(cls):
        print('输入密码，取出100零花钱')
    @classmethod
    def test(cls,flag):
        print('test方法被外界调用')
        if flag == '自家人':
            print(cls.__cord)
            cls.__get_money()
#A.test('自家人')


#  封装的原理：把用__开头的名字更名为_类名__变量名，所以直接通过
#变量名|__变量名就访问不到
print(A._A__cord)
(A._A__get_money)()

#对象的属性与方法封装集中与类的属性与方法封装原理一样
class AAA:
    def __init__(self,money):
        self.__money = money
        self.__id = 1000
    @property
    def  id(self):
        return self.__id
    @id.setter
    def id(self,id):
        self.__id = id
    #对象的属性封装
    #1对象的属性值一般都来源于外界，外界是有去权利再次访问的
    #2封装的目的不是外为无法访问，而是不让其直接访问，可以在完成安全处理后在访问
    #3如何做到外界还是通过变量名来对属性进行取值赋值，但是走得还是方法直接拿到的值
    # --__money被封装，外界还是可以通过对象。money取值赋值
    #取值
    @property
    def money(self):
        return self.__money
    @money.setter
    def money(self,money):
        self.__money = money

    @money.deleter
    def money(self):
        del self.__money
    def get_money(self,flag):
        if flag == '自家人':
            return self.__money
        return 0

    def set_money(self,money):
        self.__money += money
    def __test(self):
        print('test run ')

a = AAA(8888)
#print(a.__money)
print(a._AAA__money)
a._AAA__test()
print(a.get_money('自家人'))
a.set_money(100000)
print(a.get_money('自家人'))
print(a.money)
a.money = 9999999
print(a.money)
del a.money# 不能删除 删了就再找不到了