Python成员修饰符，metaclass，异常，反射，单例

一、成员修饰符
公有成员
私有成员, __字段名
- 无法直接访问，只能间接访问
class Foo:
def __init__(self,name,age):
self.name = name
#self.age = age
self.__age = age

obj = Foo()
obj.name
#obj.age
obj.__age

二、特殊成员
__init__ 类()自动执行
__del__
__call__ 对象() 类()() 自动执行
__int__ int(对象)
__str__ str()

__add__
__dict__ # 将对象中封装的所有内容通过字典的形式返回
__getitem__ # 切片（slice类型）或者索引
__setitem__
__delitem__

__iter__
# 如果类中有 __iter__ 方法，对象=》可迭代对象
# 对象.__iter__() 的返回值： 迭代器
# for 循环，迭代器，next
# for 循环，可迭代对象，对象.__iter__()，迭代器，next
# 1、执行li对象的类F类中的 __iter__方法，并获取其返回值
# 2、循环上一步中返回的对象
三、metaclass,类的祖宗
a. Python中一切事物都是对象
b.
class Foo:
pass
obj = Foo()
# obj是对象，Foo类
# Foo类也是一个对象，type的对象

c.
类都是type类的对象 type(..)
“对象”都是以类的对象 类()
四、异常处理
raise Exception('数据库处理错误')

五、反射

六、单例模式

成员修饰符：

#Python中类的成员有字段、方法、属性
#一、成员修饰符，二、特殊成员，三、metaclass,类的祖宗，四、异常处理，五、反射，六、单例模式
class Foo:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.__age = age  #私有，外部无法直接访问
    def show(self):
        return self.__age
obj = Foo('alex',12)
print(obj.name)
print(obj.age)
# print(obj.__age)  #Foo' object has no attribute '__age'
ret=obj.show()
print(ret)
#静态字段也可以私有化
class foo:
    __v='1233'

    def __init__(self):
        pass
    def show(self):
        return foo.__v
    @staticmethod
    def stat():
        return foo.__v
# print(foo.__v)  #此时静态方法私有化，无法直接访问
ret=foo().show()
print(ret)
ret=foo.stat()
print(ret)

#方法也有公有私有化
class foo:
    def __f1(self):
        return 'abc'
    def f2(self):
        r=self.__f1()
        return r
obj=foo()
# ret=obj.__f1
# print(ret)  #'foo' object has no attribute '__f1'
ret=obj.f2()
print(ret)

#子类不能访问父类中的私有字段，私有字段只是本类中能访问
class F:
    def __init__(self):
        self.ge=123
        self.__gene=123
class S(F):
    def __init__(self,name):
        self.name=123
        self.__age=17
        super(S,self).__init__()
    def show(self):
        print(self.name)
        print(self.__age)
        print(self.ge)
        # print(self.__gene)
s=S('alex')
s.show()  #'S' object has no attribute '_S__gene'
print('========================================================')
#特殊成员
class foo:
    def __init__(self):
        print(123)
    def __call__(self, *args, **kwargs):
        print('call')
# obj=foo()
# obj()
# foo()() #对象加括号只执行call方法，或者是类加两个括号

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __add__(self, other):
        return 'ppp'
    # def __del__(self):
    #     print('析构方法') #对象被销毁时被自动执行
obj1=Foo('alex',12)
obj2=Foo('abc',13)
r=obj1+obj2 #两个对象相加时，自动执行第一个对象的__add__方法，并且将第二个对象当作参数传递进入
print(r)
#__dict__将成员以字典的形式显示
class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        self.n=123
obj=Foo('alex',12)
d=obj.__dict__
print(d)

li=[1,2,3,4,5]
# r=li[3]
li[3]=9
del li[2]
print(li)
#自定义方法对字典进行操作
class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    #__getitem__  __setitem__ __delitem__都没有返回值
    def __getitem__(self, item):
        # return item+10
        #如果item是基本类型，int，str,索引获取
        #如果是slice对象的话，切片
        if type(item)==slice:
            print('调用者希望内部做切片处理')
        else:
            # print(item.start)
            # print(item.end)
            # print(item.step)
            print('调用者希望内部做索引处理')
        # print(item,type(item))
    def __setitem__(self, key, value):
        print(key,value)
    def __delitem__(self, key):
        print(key)
li=Foo('alex',13)
r=li[8]  #自动执行li对象中的__getitem__方法，8当作参数传递给item
print(r)
li[100]=123  #自动执行__setitem__方法
li[1:4:2]
del li[999]

# class Slice:
#     def __init__(self,a,b,c):
#         self.start=a
#         self.end=b
#         self.step=c
# obj=Slice(1,4,2)
print('=================================================')
class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
        print(name,age)
    def __iter__(self):
        return iter([1,2,3,4])
li=Foo('alex',8)

#如果类中有__iter__方法，对象就叫做可迭代对象
#对象.__iter__方法的返回值：迭代器
#获取li对象的类中的__iter__方法,并获取其返回值
#循环上一步返回的对象
for i in li:
    print(i)
li=[1,2,3,4]
li=list([1,2,3,4])
metaclass和异常：

#在Python中一切事物都是对象
class Foo:
    pass
obj=Foo()
#obj是Foo对象，Foo类也是一个对象，是type的对象
#类都是type类的对象，对象都是以类的对象，类（）
class foo:
    def func(self):
        print(123)
obj=Foo()
#声明了一个类，类中有一个成员func
# foo=type('foo',(object,),{'func':function})
# obj=foo()

print('=====================================================')
#foo类的创建不用type创建，用Mytype创建foo类（用关键字metaclass）
class Mytype(type):
    #Mytype中的self代指foo类
    def __init__(self,*args,**kwargs):
        print(123)
        pass
    def __call__(self, *args, **kwargs):  #self代指foo类
        #self=foo
        obj=self.__new__(self, *args, **kwargs)
        self.__init__(obj)  #执行了new方法，创建了对象之后，然后才执行foo的 构造方法
        print(456)
class foo(object,metaclass=Mytype):
    def __init__(self):
        pass
    def __new__(cls, *args, **kwargs): #obj是在new里面创建的
        return object.__new__(cls,*args, **kwargs) #对象就是obj
    def func(self):
        print('hello world')
obj=foo()  #foo是Mytype的对象，foo（）执行Mytype的call方法
#此时只执行了Mytype的方法，还没有执行foo中的方法，要想执行foo的方法，需要用Mytype调用foo中的方法

print('=========================================================')


class Bar:
    def __init__(self):
        print(123)


obj = Bar()

# while True:
#     try:
#         # 代码块，逻辑
#         inp = input('请输入序号：')
#         i = int(inp)
#     except Exception as e:
#         # e是Exception对象，对象中封装了错误信息
#         # 上述代码块如果出错，自动执行当前块的内容
#         print(e)
#         i = 1
#     print(i)

#li = [11,22]
#li[999] # IndexError
# int('qwe') # ValueError

# def fun():
#     ret = 0
#     try:
#         li = [11, 22]
#         li[1]
#         int('w3r')
#
#     except IndexError as e:
#         print('IndexError',e)
#     except ValueError as e:
#         print('ValueError',e)
#     except Exception as e:
#         print('Exception',e)
#     else:
#         ret = 1
#         print('elese')
#     finally:
#         print('....')
#
#     return ret
# r = fun()
# if r == 0:
#     print('500')
# else:
#     pass
#
#
# class F:
#     def __init__(self):
#         self.__a = 132
#
#     def show(self):
#         # print(self.__a)
#         return self.__a
#
# class S(F):
#     def __init__(self):
#         self.name = 123
#         super(S, self).__init__()
# obj = S()
# r = obj.show()
# print(r)


try:
    # int('asdf')
    # 主动出发异常
     raise Exception('不过了...')
except Exception as e:
    print(e)

def db():
     # return True
     return False

def index():
    try:
        r = input(">>")
        int(r)
        result = db()
        if not result:
            # r = open('log','a',encoding='utf8')
            # r.write('数据库处理错误')
            # 打开文件，写日志
            raise Exception('数据库处理错误')
    except Exception as e:
        str_error = str(e)
        print(str_error)
        r = open('log', 'a',encoding='utf8')
        r.write(str_error)
        # 打开文件，写日志
index()

class OldBoyError(Exception):
    def __init__(self, msg):
        self.message = msg
    def __str__(self):
        return self.message
obj = OldBoyError('xxx')
print(obj)
try:
    raise OldBoyError('我错了...')
except OldBoyError as e:
    print(e) #执行e对象的__str__()方法，获取返回值

#assert 条件,断言，用于强制用户服从，不服从就报错，可补货，一般不补货
print(23)
assert 1==2
print(456)
反射：

#反射 getattr hasattr setattr delattr
class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        return "%s-%s"%(self.name,self.age)
obj=Foo('alex',12)
print(obj.name)  #name 是变量名，不是字符串
b='name'
print(obj.__dict__[b])
#去什么东西里面获取什么内容
r=getattr(obj,'name')
print(r)
# inp=input('>>>')
# v=getattr(obj,inp)
# print(v)
func=getattr(obj,'show')
print(func)
r=func()
print(r)
#hasattr()  判断对象中是否有字段
print(hasattr(obj,'name'))
setattr(obj,'k1','v1')
print(obj.k1)
print(obj.name)
# delattr(obj,'name')
obj.name

class Foo:
    stat='123'
    def __init__(self,name,age):
        self.name=name
        self.age=age
r=getattr(Foo,'stat')
print(r)

#模拟网站
import f1
inp=input("请输入要查看的URL:")
if hasattr(f1,inp):
    func=getattr(f1,inp)
    result=func()
    print(result)
else:
    print('404')
单例：

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def show(self):
        print(self.name,self.age)
obj=Foo('alex',15)  #obj对象，obj也称为Foo类的实例，（实例化）
#单例就是单个实例，永远使用同一份实例（对象）
# v=None  #依赖于全局变量
# while True:
#     if v:
#         v.show  #执行循环的时候永远用一个实例
#     else:
#         v=Foo('alex',123)
#         v.show()
#节省内存
class foo:
    __v=None
    @classmethod
    def get_instance(cls):
        if cls.__v:
            return cls.__v
        else:
            cls.__v=foo()
            return cls.__v
obj1=foo.get_instance()
print(obj1)
obj2=foo.get_instance()
print(obj2)