一、对象的特有名称空间
# 对象独有的名称空间：在产生对象时就赋初值
'''
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 同一个变量名，值一改变，就都变了
待续