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

面向对象的成员修饰符

#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循环中循环这个返回值
# ======================================================================================================

原文地址:https://www.cnblogs.com/xiaohei001/p/9787890.html

时间: 2024-10-14 07:01:48

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

文成小盆友python-num8 面向对象中的成员,成员修饰符,特殊成员,异常处理,设计模式之单例模式

本节主要内容: 1.面向对象中的成员 2.成员修饰符 3.特殊成员 4.异常处理 5.设计模式之单例模式 一.面向对象中的成员(类的成员) 类的成员总共可以分为3大类,每类中有不同的分支. 1.总述,基本分类 如下图所示: 类成员包括字段,方法,和属性 2.字段 如上图字段分为普通字段和静态字段,两者的使用有区别,但是最大的区别在于两者在内存中的保存位置有区别. 普通字段属于对象而静态字段属于类,在使用过程中谁的字段就由谁来调用. 静态字段和普通字段的定义如下: 在调用时分各自调用 #####类

Python_day8_面向对象(多态、成员修饰符、类中特殊方法、对象边缘知识)、异常处理之篇

一.面向对象之多态 1.多态:简而言子就是多种形态或多种类型 python中不支持多态也用不到多态,多态的概念是应用与java/C#中指定传参的数据类型, java多态传参:必须是传参数的数据类型或传参的子类类型 面向对象总结: 面向对象是一种编程方式,此编程方式的实现是基于类和对象的使用 类:是一个模板,模板中包含了多个函数共使用,即类中可包含多个函数(类中的函数即叫做方法) 一般疑问: 1)什么样的代码才是面向对象? 简单来说,如果程序中的所有功能否是由 “类”和“对象”实现,那么就是面向对

python学习笔记-Day8 上(pickle补充、字段、面向对象成员、成员修饰符、特殊方法)

pickle 序列化补充 # pickle load # 现在有两个python程序,调用关系如下 # s1.py class foo: …. Obj = foo(x,y) Pickle.dump(obj, open(‘db’,’wb’)) S2.py # s2.py from s1 import foo pickle.load(db) # s2.py 反序列化加载包含对象,一定要先导入对象对应的类,否则Pickle load将会报错 类多继承关系 有共同父类的继承关系如下 如图,如果我们有两个

面向对象之成员修饰符

一.成员修饰符 1.方法名带下划线例  __name() 即属性私有化,就表明该函数不可以通过对象或者类调用(简称外部调用),只能通过类的内部其他方法间接的调用. 2.类中的静态字段.普通字段.静态方法.普通方法.类方法,都适用. 3.儿子孙子继承者也不能访问. class Foo: __xo = "xo" def __init__(self,name,age): __dog = "cat" self.n = name self.a = age def f1(sel

Python学习:17.Python面向对象(四、属性(特性),成员修饰符,类的特殊成员)

一.属性(特性) 普通方法去执行的时候,后面需要加括号,特性方法执行的时候和静态字段一样不需要不需要加括号. 特性方法不和字段同名. 特性方法不能传参数. 在我们定义数据库字段类的时候,往往需要对其中的类属性做一些限制,一般用get和set方法来写,那在python中,我们该怎么做能够少写代码,又能优雅的实现想要的限制,减少错误的发生呢,这时候就需要我们的@property. 获取特性 class Foo: def __init__(self,name): self.name = name #

Python学习 :面向对象 -- 成员修饰符

成员修饰符 两种成员 - 公有成员 - 私有成员, __字段名 - 无法直接访问,只能通过内部方法来间接访问私有成员 简例:公有成员与私有成员  class Info: country = '中国' # 静态字段 __gender = '男' # 静态字段私有化 def __init__(self,name,age): self.name = name self.__age = age # age字段为私有的,外部无法直接访问 def show(self): return self.__age,

Python面向对象成员修饰符

成员修饰符就是设置类的成员有些是公开的有些是私有的,公开的是在外部通过对象或者类可以调用,但是私有的只能通过类的内部才可以调用. 静态字段修饰 #!/usr/bin/env python # _*_coding:utf-8 _*_ class Foo:    # 公有的静态字段    ClassMembers = "公开的"    # 私有的静态字段    __ClassMembers = "私有的" # 执行公有的静态字段 print(Foo.ClassMembe

Python类成员及类成员修饰符

13.面向对象:多态.继承.封装成员:字段:普通字段.静态字段方法:普通方法.静态方法.类方法特性:property,将方法伪造为字段,可以直接使用类.方法名调用,不用加() 成员修饰符:公有和私有,私有的字段和方法可以通过对象中的其他普通方法间接进行调用私有字段:__field, 以__双下划线开头的字段,私有字段只能在自己的对象中才能使用,继承后也无法使用私有方法:__function, 以__双下划线开头的方法,私有字段只能在自己的对象中才能使用,继

python入门第二十四天----成员修饰符 类的特殊成员

1 #成员修饰符 修饰符可以规定内部的字段.属性.方法等 是共有的成员,私有的成员 2 class Foo: 3 def __init__(self,name,age): 4 self.name=name 5 self.age=age #可以在外部直接访问 6 7 obj=Foo('Jack',22) 8 print(obj.name) 9 print(obj.age) 共有字段 1 #成员修饰符 修饰符可以规定内部的字段.属性.方法等 是共有的成员,私有的成员 2 class Foo: 3 d