面向对象中的特殊的成员修饰符和几个特殊的方法详解编程语言

#Auther Bob 
#--*--conding:utf-8 --*-- 
 
# 成员修饰符 
#     共有成员 
#     私有成员 
        # 1、私有字段 
        #         私有的普通字段 
        #         私有的静态字段 
 
        # 2、私有方法 
        #         私有的方法 
 
# 默认情况下，类的字段和方法都是共有的，通过对象和类就直接可以访问，但是如果我们在字段或者方法名字的前面加2个下划线，那么我们就不能在外部访问这些字段和方法，这些 
# 方法和字段只能内部方法 
""" 
 
 
 
""" 
 
 
class person(object): 
    name = "diandian" 
    __age = 3 
    def __init__(self,address,phone): 
        self.address = address 
        self.__phone = phone 
    def func_print1(self): 
        print(self.name,self.__age) 
        print(self.address,self.__phone) 
    def __func_print2(self): 
        print(self.name,self.__age) 
        print(self.address,self.__phone) 
        return self.__phone 
 
    def func_print2(self): 
        return self.__func_print2() 
 
p1 = person("shenzhen","123456789") 
print(p1.name) 
# 这里的name是共有静态字段，在外部可以直接访问 
 
# print(p1.__age) 
# 这里的__age是私有的静态字段，在外部不可以直接访问 
 
 
 
print(p1.address) 
# 这里address是共有的普通字段,在外部可以直接访问 
 
# print(p1.__phone) 
# 这里的__phone是私有的普通字段，在外部不可以直接访问 
 
p1.func_print1() 
# func_print1是共有的方法，在外部可以直接访问 
 
# p1.__func_print2() 
# __func_print2是私有的方法，在外部不可以直接访问 
 
ret = p1.func_print2() 
print(ret) 
 
# 私有方法可以在内部通过共有的方法调用直接，可以间接的达到在外部执行内部私有的方法 
 
# 子类也可以执行父类的私有方法 
# 子类不可以使用父类的私有的字段 
 
class cuihongyan(person): 
    def __init__(self,address,phone,emill): 
        super(cuihongyan,self).__init__(address,phone) 
        self.emill = emill 
    def test_cuihongyan(self): 
        # self.__func_print2 
        print("---------------") 
        print(self.emill) 
        super(cuihongyan, self).func_print1() 
        # super(cuihongyan,self).__func_print2() 
        # print(self.__phone) 
        # print(self.__age) 
# __phone和__age都属于是父类的私有的普通字段和静态字段，这里在子类中都不可以访问 

#Auther Bob 
#--*--conding:utf-8 --*-- 
 
class test(object): 
    def __init__(self,name): 
        self.name = name 
    def __call__(self, *args, **kwargs): 
        print("xxxx") 
    def __int__(self): 
        return 345 
    def __str__(self): 
        return "aaaaaaa" 
t = test("cui") 
 
# ====================================================================================================== 
t() 
# 对象+括号就会执行__call__方法 
# ====================================================================================================== 
print(int(t)) 
 
# int(对象)就会自动执行对象中的__int__方法,然后把好这个方法的返回值接收到 
# ====================================================================================================== 
print(str(t)) 
 
# str（对象）就会自动执行对象中的__str__方法，然后把这个方法的返回值接收到 
 
print(t) 
# print（对象)这个方法也是默认会执行对象中的str方法，然后接受str方法的返回值接收到，效果等同于print(str(对象)) 
# ====================================================================================================== 
 
class test1(object): 
    def __init__(self,age): 
        self.age = age 
 
    def __add__(self, other): 
        return self.age + other.age 
 
 
t1 = test1(20) 
t2 = test1(30) 
 
print(t1 + t2) 
# 我这里定义了一个__add__这个函数，那么如果object1+object2相加,那么就会调用object1对象的__add__方法，然后把第二个对象当做参数传递给__add__这个 
# 函数,用other来接受 
 
# 同样加减乘除的效果都和加是一样的 
 
# ====================================================================================================== 
class test2(object): 
    def __init__(self,age): 
        self.age = age 
 
    def __add__(self, other): 
        return self.age + other.age 
    def __del__(self): 
        print("对象被销毁了") 
 
t1 = test2(20) 
 
# 对象的__del__方法，就是对象被销毁的时候自动执行的，由python自动执行的. 
# ====================================================================================================== 
class test3(object): 
 
    name = "alex" 
    def __init__(self,age): 
        self.age = age 
 
    def __add__(self, other): 
        return self.age + other.age 
 
 
t1 = test3(20) 
 
print(t1.__dict__) 
print(test3.__dict__) 
 
# __dict__打印对象中的的字段，而只打印普通字段，而不打印静态字段 
#__dict__打印类中的成员 
# ====================================================================================================== 
 
class test3(object): 
    name = "alex" 
 
    def __init__(self, age): 
        self.age = age 
 
    def __add__(self, other): 
        return self.age + other.age 
    def __getitem__(self, item): 
        return item * 10 
t = test3(20) 
 
print(t[20]) 
 
# 使用对象[item]的方式，就会自动调用类的__getitem__方法 
 
# ====================================================================================================== 
class test3(object): 
    name = "alex" 
 
    def __init__(self, age): 
        self.age = age 
 
    def __add__(self, other): 
        return self.age + other.age 
    def __getitem__(self, item): 
        return item * 10 
    def __setitem__(self, key, value): 
        print(key,value) 
 
t = test3(30) 
t["ke"] = "v1" 
 
# 使用  对象["k"] = "v"就会自动执行对象中的__setitem__方法 
# ====================================================================================================== 
class test3(object): 
    name = "alex" 
 
    def __init__(self, age): 
        self.age = age 
 
    def __add__(self, other): 
        return self.age + other.age 
    def __getitem__(self, item): 
        return item * 10 
    def __setitem__(self, key, value): 
        print(key,value) 
    def __delitem__(self, key): 
        print(key) 
 
t = test3(20) 
 
del t[39] 
 
 
# del 对象[值] 就会自动调用类的__delitem方法 
# ====================================================================================================== 
class test3(object): 
    name = "alex" 
 
    def __init__(self, age): 
        self.age = age 
 
    def __add__(self, other): 
        return self.age + other.age 
    def __getitem__(self, item): 
        return item * 10 
    def __setitem__(self, key, value): 
        print(key,value) 
    def __delitem__(self, key): 
        print(key) 
    def __iter__(self): 
        return iter(["a","b","c","d"]) 
 
t = test3("30") 
for i in t: 
    print(i) 
 
# 如果对象中有__iter__方法，那么说明这个对象是一个可迭代的对象 
 
 
# 如果对对象执行for循环进行可迭代对象 
# 1、执行类的__iter__方法，然后获取他的返回值,这里要用iter来返回 
# 2、然后在for循环中循环这个返回值 
# ====================================================================================================== 

#     def __getattr__(self, item): 
#         return "item 不存在".format(item = item)