day 23 对象的名称空间 类，对象属性和方法 封装 接口提供

一、对象的特有名称空间

# 对象独有的名称空间：在产生对象时就赋初值

'''
class ted:
    def func():       当func里不存在参数时，调用时不需要给值
        print('hah')
ted.func()
'''
'''
class ted:
    def func(self):
        print('hah')
ted.func('useless')
'''
#类里面的方法属于谁的名称空间，就被谁调用
#类里面的方法的名称空间不属于对象，怎么实现调用这些方法
#方法如下：
#1
class student:
    def set_stu(stu,name,sex):
        stu.name=name
        stu.sex=sex
stu1=student()
#将对象stu1作为参数传递到方法里去 此时将对象的名称空间里放入我们想要的值，也就是赋值
student.set_stu(stu1,'bob','male')
print(stu1.__dict__)   #{'name': 'bob', 'sex': 'male'}
print(stu1.name)       #bob
print(stu1.sex)        #bob

#2
#将产生的对象的空的名称空间与名称空间赋值操作整合
class students:

    #__init__会在实例化对象时被调用
    #1.会为实例化的对象形成空的名称空间
    #2.就是一个方法，可以被传参，在类名（实参）这种方式下调用并传参  __init__(self,形参）
    #第一个self就是要产生的当前对象
    #在方法内部，形参拿到了实参值，使用self.属性名=形参 本质上=实参，为对象的名称空间添加属性！
    def __init__(self,name,sex):
        print('1<<<',self)
        self.name=name  
        self.sex=sex   #建议新增的参数与属性名（变量名）命名保持一致
        return None   #默认值返回为None
stu2=students('tom','female')
print(stu2.name,stu2.sex)   #tom female

二、类中方法的第一个默认参数：对象方法

class student:
    pass
text=student()

def func():
    print('我又来了！')
student.func=func   #在类的字典中添加func这个key,value为对应的函数func的地址,即为类添加东西
# print(student.__dict__)

class student1:
    pass
text1=student1()
def func1(a):  #此处需要一个参数a，用来接受text1自身
    print('你咋又来了？')
student1.func1=func1
text1.func1()   #==student1.__dict__['func1](text1)
# 给类添加一个函数，通过对象去调用这个函数，本质上等价于在这个函数中传入一个参数text1
#对象使用类的函数，本质上还是通过类去获取对应的关系，将对象传进去

#总结：所有的函数的第一个参数都是通过类调用函数传进去来调用对象
text1.func1()==student1.__dict__['func1'](text1)==student1.func1(text1)

# 对象调用方法的第一个参数一定是调用该方法的参数！

三、类方法

#类方法
#下面所有为自己推导的，先自己了解一下相关流程，系统有更好的方法，在后面介绍
class tool:
    #类自己的方法
    def add(n1,n2):
        return n1+n2
res=tool.add(10,20)   #类使用自己的方法时，存在几个参数就传入几个
print(res) #30
text=tool()
#print(text.add(10,20))    这样输出，会出错，原因是加上自身，我们给了3个实参，而方法只接受了2个参数
                           #接受的第一个参数是其本身（text),第二个是给的参数10，第三个未被接收
#小点：类的名字，对象都可以使用，但是出现了类与对象使用方法时，传入的参数有差异！
#解决的方案   语法糖
class took:
    def acd(cls,n1,n2):
        cls.fn()
        return n1+n2

    def fn():   #里面不给参数时，类调用时不需要给实参，对象调用时需要给定一个实参，可以为self,也可以为其它
        print('小样，咋又来了？')

    #如果方法a被对象took调用，那么也会在内部调用b, b间接被外界对象took调用
    def a(self):
        self.b()
    def b(self):
        pass

text1=took()
res=took.acd(took,10,20)
# print(text1.acd(10,20))   #此时会出错，在调用方法fn时，缺少自身的一个参数

#系统的方法 @classmethod 装饰器
class Tool:
    #类方法：可以被类与对象调用的方法，第一个参数一定是类
    #类方法不建议拿对象来调用
    @classmethod
    def add(cls,n1,n2):
        print(id(cls))     #两个地址是一样的，还是证明了对象是通过类去调用方法的！因此不建议用对象此时来调用方法
        return n1+n2
print(Tool.add(12000,18000))  #此时传入的第一个参数是类本身
tool=Tool()
print(tool.add(13,15)) #对象调用类方法，此时传入方法的第一个参数不是对象，而是 tool.__class__

·

四、属性与方法的总结

#属性与方法的总结（类最好使用类方法，对象最好使用对象方法）

class china:
    #属于类的属性
    name='wuchanghu'

    #属于对象的属性
    def __init__(self,name):
        self.name=name
    #属于类的方法,获取名字
    @classmethod
    def get_name(cls):
        return cls.name

    #属于对象的方法,获取名字
    def get_names(self):
        return self.name

city=china('anqing')
country=china('wangjiang') #产生两个对象

#类方法的使用
print(china.get_name())  #类调用自己的方法

print(city.get_name())   #对象来调用
print(country.get_name())
#总结：类方法拿对象调用并没有多少意义，不建议拿对象来调用

#对象方法的使用
print(china.get_names(city))
print(china.get_names(country))  #类来调用对象的方法

print(city.get_names())
print(country.get_names())#对象来调用对象方法，本质上还是通过类去调用

五、封装

class func:

    def get_box(self):
        print('找到保险箱')

    def get_money(self):
        print('取出12000')
fn=func()
fn.get_box()
fn.get_money()   #在类外面可以取到里面的值

#需求：将类中的一些功能与属性进行隐藏，不让外界总结访问（可以间接访问）
#措施： 在属性前面加上__,此时在外界不能通过__属性取出
#下面是类的封装
class func:
    __name='jun'   #也可对类的属性进行隐藏
    @classmethod
    def __get_box(cls):
        print('输入密码，找到保险箱')
        cls.__get_money() #在内部可以通过__get_box()来访问另外的属性
    @classmethod
    def __get_money(cls):
        #可以在此添加具体数据与功能来做安全操作
        print('取出12000')
fn=func()
fn._func__get_box()    #输入密码，找到保险箱   \n   取出12000
print(fn._func__name)
#虽然说此时进行了封装，然而对熟知python规则的人来说，真的是一个鸡肋

#下面是类的属性的封装
class f1:
    def __init__(self,money):
        self.__money=money
    def __text(self):
        print('run away')
a=f1(8888)   #值可以正常传入
a._f1__text()
print(a._f1__money)  #取出需要通过_f1__money来做到

#下面是对象的属性的获取
class dx:
    def __init__(self):
        print('hah')
        self.money=200
        # return self.money   return 的返回值应该为None
    def fun1(self,money):
        self.money=money
        return self.money

d=dx()
print(d.money)   #200
print(d.fun1(100))  #100
print(d.money)      #100   self.money对于对象自己来说就是一个变量而已，只是在用他的变量名，值可以改变

#对象的封装
#对象方法的封装
class dx:
    def __init__(self):
        print('hah')
        self.__money=200

    def __fun1(self,money):
        self.money=money
        return self.money
x=dx()
print(x._dx__money)    #200
print(x._dx__fun1(333))  #300
print(x._dx__money)    #200    因为fun1里面的money与__money不是同一个变量

#对象属性的封装
class dx:
    def __init__(self):
        print('hah')
        self.__money=200
    def __fun1(self,money):
        self.__money=money
        return self.__money
x=dx()
# print(x.money)    #此时通过这种途径找不到
print(x._dx__money)       #200
print(x._dx__fun1(333))   #333
print(x._dx__money)       #333   同一个变量名，值一改变，就都变了

封装的另外一种取值方法：

对象的属性：封装的目的
1.对象的属性值一般来源于外界，外界是有权利再次访问的
2.封装的目的不是让外界无法访问，而是不让其直接访问，可以在完成安全处理后再访问

class dx:
    def __init__(self):
        print('haha')
        self.__money=200
    @property  #取值     #加上@property a.money代表使用该方法，而不再是找这个money函数的函数名
    def money(self):
        print('走方法拿到的money')  #走方法拿到的money  \n  200
        return self.__money

    # #赋值
    @money.setter             #加上了@money.setter,实际上是调用了该方法，并给其传值    a.money=1111  ==  a.money(1111）
    def money(self,money):
        self.__money=money
        print('我有没有走')
        return self.__money
    #删除
    @money.deleter             #加上这个装饰器，外界的删除，会调用该方法，在其内部在做相应处理
    def money(self):
        print('逗你玩')
        # del self.__money     #在类内部可以访问到其他方法,注释该功能后，系统并没有删除掉该属性
a=dx()
print(a.money)    #走方法拿到的money  返回self.__money=200
a.money=111       #我有没有走    返回赋值后的money=111
print(a.money)    #走方法拿到的money  返回已经赋值后的self.__money=111

del a.money       #在类外面，此时的del a.money 并不是直接删除，而是通过调用 删除方法 完成相对应的功能
print(a.money)    #走方法拿到的money    属性money并没有删除

#总结：约定俗成，对一种属性提高对外的接口时，也就是加上了这几个装饰器，那这些属性对应的方法名必须是一样的！
#  同时，@property必须在上面，其他随意，因此存在一定的顺序