面向对象中的特殊的成员修饰符和几个特殊的方法

面向对象的成员修饰符

#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)

如果obj.item这个属性不存在，则会对象的执行__getattr__这个方法