'''一，面向对象的进阶
成员
（字段 静态字段（每个对象都有一份用 （区别：没self）），普通字段（每个对象都不同的数据用（区别：有self））
方法 静态方法（无需使用对象封装的内用用 （区别：没self）），类方法，普通方法（使用对象中的数据用（区别：有self）），
特性 普通特性（将方法伪造成字段的方法去执行，前提是要创建一个值去接收它。）
）
通过类访问：静态字段，静态方法(staticmethod),类方法(classmethod)
通过对象访问：普通字段，类的方法。
————快速判断，类执行，对象执行 调用（有self用对象调用。无self用类调用）
成员修饰符
面向对象中一些常用特殊方法 __init__ __call__ __delitem__
二，异常处理
三，单列模式'''
'''
导入模块
m = __import__('python',fromlist = True)
去模块中寻找类
class_name = getattr(m,'Foo')
根据类创建对象
obj = class_name('Alex')
去对象中寻找name对应的值
val = getattr(obj,'name')
'''
class Foo:
#静态字段
country = 'china'
def __init__(self,name):
#普通字段
self.name = name
#普通方法
def show(self):
print('111')
@classmethod
def xxoo(cls):
print('class')
#静态方法
@staticmethod
def xx():
print('22')
#特性，将方法伪造成一种字段的形式
@property
def end(self):
temp = '%s pp'%self.name
return temp
@end.setter
def end(self,velue):
print(velue)
#类访问静态字段
print(Foo.country)
#类访问静态方法
Foo.xx()
#类访问类方法
Foo.xxoo()
#特性伪造成字段的形式去访问，不用加括号。
obj = Foo('奥巴马')
print(obj.end)
#字段可以重新复制
Foo.country = '中国'
print(Foo.country)
'''字段既然可以重新赋值，那么伪造静态的形式，是否也可以进行重新赋值呢。当然OK了。前提是要创建一个值去接收它。 '''
Foo.end = '123'
print(Foo.end)
'''
成员修饰符
（在python 里面只有两种，公有 私有，）
私有的 只有在自己类中能调用，其它任何地方都不能访问， 包括子类。
如果想要调用私有的，必须借助内部方法来执行。
普通字段，静态字段，普通方法 ，静态方法，类方法，普通特性
__call__ 执行方法 Foo()(), 或者把类赋给一个对象，然后对象 加括号执行 r = Foo(), r()。
__getitem__执行方法，对象[]中括号去执行 t['adfa']
——setitem__执行方法，t['yy'] = 'uu' 就相当于給字典的一个添加 键 值
——delitem__执行方法, del t['adfa'] 就相当于字典中删除某个 值
__dict__ 执行方法，查看对象和类里面的方法， print(对象.__dict__) print(类.__dict__)
'''
class Foo:
"""
我是类的注释
"""
oo = 'xx' #(属于公共的，内部外部都可以调用)
__xx = 'oo'#(成员修饰符，只有内部可以调用，)
def __init__(self):
self.name = '牛'
def __call__(self):
print('call')
def __getitem__(self,item):
print(item)
def __setitem__(self,keys,value):
print(keys,value)
def __delitem__(self,keys):
print(keys)
def fetch(self):
print(Foo.__xx)
print(Foo.__add())
@staticmethod
def __add():
print('class')
'''
print(Foo.oo)
print(Foo.__xx)
'''
t = Foo()
t.fetch()
t()
t['adfa']
t['yy'] = 'uu'
del t['adfa']
print(t.__dict__)
print(Foo.__dict__)
'''异常处理'''
inp = input('输入数字')
try:
mun = int(inp)
print(mun)
#'''Exception 是一个 错误库，判断此代码出现的错误类型，然后赋值一个 对象名 接收'''
except Exception as w:
print(w)
''' 主动触发错误 '''
try:
print('123')
raise Exception('出错了...')
except Exception as e:
print(e)
class Foo:
def __init__(self,arg):
self.ox = arg
def __str__(self):
return self.ox
obj = Foo('出错了')
print(obj)
'''assert断言， 判断是否为异常，如果是异常就会报错。'''
assert 1==1
assert 1==2