python——面向对象（三）

"""""
一成员修饰符
1.共有
2.私有成员，__字段名:无法直接访问，只能间接访问

私有字段是无法继承的 也就是说只在方法内部有效
即使继承了也不能调用
"""
#2.字段私有与公有

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age = age
        self.__age=age
        #私有，外部无法直接访问
    def show(self):
        return self.__age

obj=Foo(‘lin‘,19)
print(obj.name)
print(obj.age)
#p0rint(obj.__age)
#访问不到
ret=obj.show()
print(ret)

#同理静态字段也是可以的

#2.方法私有与公有

class Foo:
    def __f1(self):
        return 123
    def f2(self):
        r=self.__f1()
        return r

obj=Foo()
r=obj.f2()
print(r)

"""""
二、特殊
__init__ 类()自动执行
__del__  对象()被销毁时，执行
__dict__  将对象中封装的所有内容通过字典形式返回
__call__ 对象() 类() 自动执行
__int__   int(对象)
__str__    str()

__add__    加
__getitem__
"""
class Foo:
    def __init__(self):
        print(‘123‘)
    def __call__(self, *args, **kwargs):
        print(‘abc‘)
obj=Foo()
obj()#abc
Foo()()#与上方相等

class Foo:
    def __init__(self,n,a):
        self.name=n
        self.age=a

    def __str__(self):
        return ‘%s-%s‘ %(self.name,self.age)
    #若没有这句会报错

obj=Foo(‘alex‘,18)
print(obj)

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __add__(self, other):
        return self.age+other.age

obj1=Foo(‘lin‘,19)
obj2=Foo(‘lin‘,66)
r=obj1+obj2
#两对象相加时，自动执行第一个对象的__add__方法，并将第二个对象当作参数传递
print(r)#85

class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __getitem__(self, item):
        print(item)
        return item+2
    def __setitem__(self, key, value):
        print(key,value)
    def __delitem__(self, key):
        print(key)
#字典
obj=Foo(‘lin‘,20)
d=obj.__dict__
print(d)#{‘age‘: 20, ‘name‘: ‘lin‘}

#取
li=Foo(‘lin‘,20)
r=li[8]
print(r)

#赋值
li[100]=‘asdf‘

#删除
del li[999]

#如何进行遍历
class Foo:
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __iter__(self):
        #1.执行li对象的类F类中的iter方法，并获取返回值
        #2.循环上一步返回的对象
        #3.可如果类中由__iter__方法，则对象为可迭代对象
        #4.对象.__iter__()的返回值：迭代器
        #5.for循环 可迭代对象
        return iter([1,2,3])
li=Foo(‘lin‘,20)
for i in li:
    print(i)
"""""
三metclass类的
a python中一切事物都是对象
b
  class Foo:
      pass
obj =Foo()
#obj是对象,Foo类
#Foo类也是一个对象，type的对象

c.
   类都是type类创建的对象 type(..)
   “对象”都是以类的对象 类()
"""

#类的创建
class Foo(object):
    def dunc(self):
        print(123)
obj=Foo()
#============
"""""
type(‘Foo‘,(object,),(‘func‘:lambda x:123))
声明一个类，类里面有一个成员func
Foo=type(‘Foo‘,(object,),(‘func‘:lambda x:123))
Foo()
"""
#让foo不再通过type类型创建 而是通过自定义的mytype类进行创建
class mytype(type):
    def __init__(self,*args,**kwargs):
        print(‘123‘)
        pass
    def __call__(self, *args, **kwargs):
        print(456)
class foo(object,metaclass=mytype):
    def func(self):
        print(‘abc‘)

obj=foo()#456
#foo=mytpe()