面向对象进阶——内置方法(二)

七、__setitem__, __getitem__, __delitem__

  item系列

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

    def __getitem__(self, item):
        # print(‘getitem...‘)
        #print(item)

        return self.__dict__.get(item)  # 字典get方法有则取值,无也不会报错

    def __setitem__(self, key, value):
        # print(‘setitem...‘)
        # print(key,value)
        self.__dict__[key] = value

    def __delitem__(self, key):
        # print(‘delitem...‘)
        # print(key)
        # self.__dict__.pop(key)
        del self.__dict__[key]

obj = Foo(‘egon‘)

# 1、查看属性
# obj.属性名
# item系列就是为了把对象模拟成像字典一样,就可以像字典一样访问
obj[‘name‘]   # 以这种形式完成 obj.name取值的效果
"""
getitem...
name
"""
print(obj[‘name‘])

# 2、设置属性
# obj.sex = ‘male‘
obj[‘sex‘] = ‘male‘

print(obj.__dict__)
print(obj.sex)

# 3、删除属性
# del obj.name
del obj[‘name‘]
print(obj.__dict__)
"""
{‘sex‘: ‘male‘}
"""
八、__str__, __repr__,  __format__

  改变对象的字符串显示__str__,__repr__
  自定制格式化字符串__format__

d = dict({‘name‘ : ‘egon‘})
print(isinstance(d, dict))  # True,d是dict类的实例
print(d)

class Foo:
    pass
obj = Foo()
print(obj)
""" 同样是打印对象,显示形式完全不同,打印总是希望像前一种有提示功能。
{‘name‘: ‘egon‘}
<__main__.Foo object at 0x10401ad68>
"""

# __str__方法定义后,会在打印对象的时候,触发这个对象下的__str__方法,把字符串的结果作为打印的结果
class People:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):  # 必须return一个字符串
        # print("触发__str__方法:")
        return ‘<name:%s,age:%s>‘ %(self.name, self.age)

obj = People(‘egon‘, 18)
print(obj)
"""
<name:egon,age:18>
"""

细究__str__

format_dict={
    ‘nat‘:‘{obj.name}-{obj.addr}-{obj.type}‘,#学校名-学校地址-学校类型
    ‘tna‘:‘{obj.type}:{obj.name}:{obj.addr}‘,#学校类型:学校名:学校地址
    ‘tan‘:‘{obj.type}/{obj.addr}/{obj.name}‘,#学校类型/学校地址/学校名
}
class School:
    def __init__(self,name,addr,type):
        self.name=name
        self.addr=addr
        self.type=type

    def __repr__(self):
        return ‘School(%s,%s)‘ %(self.name,self.addr)
    def __str__(self):
        return ‘(%s,%s)‘ %(self.name,self.addr)

    def __format__(self, format_spec):
        # if format_spec
        if not format_spec or format_spec not in format_dict:
            format_spec=‘nat‘
        fmt=format_dict[format_spec]
        return fmt.format(obj=self)

s1=School(‘oldboy1‘,‘北京‘,‘私立‘)
print(‘from repr: ‘,repr(s1))
print(‘from str: ‘,str(s1))
print(s1)

‘‘‘
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
‘‘‘
print(format(s1,‘nat‘))
print(format(s1,‘tna‘))
print(format(s1,‘tan‘))
print(format(s1,‘asfdasdffd‘))

学校类

date_dic={
    ‘ymd‘:‘{0.year}:{0.month}:{0.day}‘,
    ‘dmy‘:‘{0.day}/{0.month}/{0.year}‘,
    ‘mdy‘:‘{0.month}-{0.day}-{0.year}‘,
}
class Date:
    def __init__(self,year,month,day):
        self.year=year
        self.month=month
        self.day=day

    def __format__(self, format_spec):
        if not format_spec or format_spec not in date_dic:
            format_spec=‘ymd‘
        fmt=date_dic[format_spec]
        return fmt.format(self)

d1=Date(2016,12,29)
print(format(d1))
print(‘{:mdy}‘.format(d1))

自定义format练习

class A:
    pass

class B(A):
    pass

print(issubclass(B,A)) #B是A的子类,返回True

a1=A()
print(isinstance(a1,A)) #a1是A的实例

issubclass和isinstance

九、slots

原文地址:https://www.cnblogs.com/xiugeng/p/8940714.html

时间: 2024-10-09 02:02:13

面向对象进阶——内置方法(二)的相关文章

4-19 面向对象 的内置方法

1,__str__ 和 __repr__ __str__就是改变对象的字符串显示. Python有一个内置的函数叫repr,它能把一个对象用字符串的形式表达出来以便辨认,这就是"字符串表示形式".repr就是通过__repr__这个特殊方法来得到一个对象的字符串表示形式.如果没有实现__repr__,当我们再控制台里打印一个变量的实例时,得到的字符串可能会是<__main__.Object at 0x14af07dbe80>,这个表示的是打印的对象,以及对象的内存地址. s

面向对象进阶------&gt;内置函数 str repr new

__new__方法: 我们来讲个非常非常重要的内置函数和init一样重要__new__其实在实例话对象的开始  是先继承父类中的new方法再执行init的  就好比你生孩子 先要把孩子生出来才能对孩子穿衣服的  new就是生孩子 init是给孩子穿衣服 new()是在新式类中新出现的方法,它作用在构造方法init()建造实例之前,可以这么理解,在Python 中存在于类里面的构造方法init()负责将类的实例化,而在init()调用之前,new()决定是否要使用该init()方法,因为new()

python面向对象常用内置方法

class Person(): #构造函数 def __init__(self,name,age=None): self.name=name self.age=age self.lists=[1,3,5] self.dicts={} #打印函数,类似java中的toSring() def __str__(self): return 'Peason(%s)'%self.name #对象的字典表示 def __dict__(self): return {'name':self.name} #对象相加

Python_021(内置方法讲解二)

一.内置方法二 1.__del__方法: a:构造方法:创建一个空间,  析构方法;释放一个空间; b:触发del的情况:Python解释器的垃圾回收机制,和遇到 del 对象名 c:析构方法的思想: class A: def __del__(self): print(self) a = A() del a #这里先执行了__del__方法,再删除对象a,因为执行__del__方法时还要传入self; print(a) #输出结果: <__main__.A object at 0x0000013

python-面向对象速查表-内置方法-内置函数-内置属性(只整理了部分内容)

今日临时总结的内容,可能还有些不正确的地方,初步当做个速查表吧. 类的内置函数(继承object的,自己重写) 内置函数 执行时机 注意点 调用案例 __init__ 实例化对象时 不允许写返回值(return None和不返回没区别)子类重写了__init__()方法要在子类中的__init__()方法调用父类的__init__方法(super(当前类, self).__init__(参数)) stu = Student() __new__ 类实例化被调用时 stu = Studetn() _

基本数据类型及内置方法

一.数字类型int与float 1.基本方法: 用途: int一般用于定义整数:年龄.身份证号.手机号等 float一般用于记录小数:身高.体重等 定义方法: age = 18      #      age = int(18) high = 1.87   #     high = float(1.87) 2.类型总结: 有序or无序(有索引的都是有序的): int类型无序,float类型也是无序 可变or不可变: 值改变id不变就是可变类型,值改变id也变就是不可变类型 int类型是不可变类型

面向对象的进阶---反射--一些内置方法

反射 反射和一些类的内置方法 1 isinstance ---- issubclass type()--判断 是不是 ininstance(object,cls) 判断 是不是类的对象 如果这个类有父类 这个对象也是这个父类的对象 issubclaaa(cls,cls) 判断一个类是不是另一个类的子类 ============================= 反射 ================================= 把一个字符串 类型的变量 变成一个 真实存在这个程序中的变量名

Python之路(第二十六篇) 面向对象进阶:内置方法

一.__getattribute__ object.__getattribute__(self, name) 无条件被调用,通过实例访问属性.如果class中定义了__getattr__(),则__getattr__()不会被调用(除非显示调用或引发AttributeError异常) class Foo: ? def __init__(self,x): self.x = x ? def __getattr__(self, item): print("执行__getattr__") ?

Python之路(第二十七篇) 面向对象进阶:内置方法、描述符

一.__call__ 对象后面加括号,触发执行类下面的__call__方法. 创建对象时,对象 = 类名() :而对于 __call__ 方法的执行是由对象后加括号触发的,即:对象() 或者 类()() class Foo: ? def __call__(self, *args, **kwargs): print("我执行啦") ? f = Foo() f() #对象加括号调用执行类下的__call__方法 #输出结果 我执行啦 二.__next__和__iter__实现迭代器协议 迭