面向对象的成员及调用方法

'''一，面向对象的进阶
    成员
        （字段  静态字段（每个对象都有一份用 （区别：没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