Python基础-面向对象-方法

2019独角兽企业重金招聘Python工程师标准>>>

控制输出

__str__()

自定义控制信息

# -*- coding:utf8 -*-
class Text1:                                #定义类1
    pass
class Text2:                                #定义类2
    def __str__(self):                      #定义自制对象显示方式
        return "这是自定制的对象显示方式！" #返回显示方式
P1 = Text1()                                #实例化1
P2 = Text2()                                #实例化2
print(P1)                                   #查看实例化对象1
print(P2)                                   #查看实例化对象2

<__main__.Text1 object at 0x0000020055563710>
这是自定制的对象显示方式！

__repr__()

自定义控制信息

# -*- coding:utf8 -*-
if __name__ == '__main__':
    class Text1:                                #定义类1
        pass
    class Text2:                                #定义类2
        def __repr__(self):                     #定义自制对象显示方式
            return "132" #返回显示方式
P1 = Text1()                                #实例化1
P2 = Text2()                                #实例化2
print(P1)                                   #查看实例化对象1
print(P2)                                   #查看实例化对象2

<__main__.Text1 object at 0x000001752F213710>
这是自定制的对象显示方式！

__format__()

格式化控制输出

# -*- coding:utf8 -*-
#指定格式字典
format_dic={
    'ymd':'{0.year}{0.mon}{0.day}',
    'm-d-y':'{0.mon}-{0.day}-{0.year}',
    'y:m:d':'{0.year}:{0.mon}:{0.day}'
}
class Date:                                 #定义格式类
    def __init__(self,year,mon,day):        #初始化函数
        self.year=year
        self.mon=mon
        self.day=day
    def __format__(self, format_spec):      #定义格式
        if not format_spec or format_spec not in format_dic:    #判断是否符合格式
            format_spec='ymd'               #指定默认格式
        fm=format_dic[format_spec]          #调取格式类型
        return fm.format(self)              #返回格式类型
d1=Date(2016,12,26)                         #实例化
print(format(d1,'ymd'))                     #实例化输出1
print(format(d1,'y:m:d'))                   #实例化输出2
print(format(d1,'m-d-y'))                   #实例化输出3

20161226
2016:12:26
12-26-2016

raise

抛出异常,实现菲波那切数列

# -*- coding:utf8 -*-
class Text:                                         #定义类
    def __init__(self):                   #初始化函数
        self.A = 1
        self.B = 2
    def __iter__(self):                             #迭代转换
        return self
    def __next__(self):                             #定义迭代方法
        if self.A > 100:
            raise StopIteration("程序终止！")       #判断方法抛出异常终止程序
        self.A,self.B = self.B,self.A + self.B      #迭代方法
        return self.A                               #返回值
Num = Text()                                        #实例化
for i in Num:                                       #for循环迭代
    print(i)

2
3
5
8
13
21
34
55
89
144

类变量

变量值可以是列表、元组、迭代对象、字符串等，一般实例很多但数据较少时候用来替代类字典而达到节省内存提升运行速度的效果.可以理解为内存优化的工具。

__slots__

一般用于不长修改,但长使用多实例化的特殊场景

class Text:
    __slots__ = ['name','age']
P = Text()

P.name = '小明'
P.age = '18'
print(P.name,"已经",P.age,"了")

P.name = '小黑'
P.age = '9'
print(P.age,'岁的',P.name,'还很淘气~')

小明 已经 18 了
9 岁的 小黑 还很淘气~

析构方法

__del__()

# -*- coding:utf8 -*-
class Animal:                                   #定义类
    def __init__(self,species,name):            #定义属性
        self.Species = species
        self.Name = name
    def dynamic(self):                          #定义方法
        print("%s是%s动物" %(self.Name,self.Species))
    def __del__(self):
        print(del_methods,"内存回收触发！")
P = Animal("猫科","老虎")                       #实例化
del_methods = P.Name
print(P.__dict__)                               #删除前字典
del P.Name                                      #删除属性
print(P.__dict__)                               #删除后字典

{'Species': '猫科', 'Name': '老虎'}
{'Species': '猫科'}
老虎 内存回收触发！

实例执行

__call__

对象后边加括号，触发执行

class Text:
    def __call__(self, *args, **kwargs):
        print("This is test !!!")
P = Text()
P()

This is test !!!

上下文管理协议

• 没有异常的情况下，整个代码块运行晚班后去触发__exit__,它的三个参数都None
• 没有异常的情况下，从异常出现的位置直接触发__exit__,__exit__返回值为True，吞掉异常。反之吐出异常

__enter__ & __exit__

with触发__enter__，with的返回值触发__exit__

# -*- coding:utf8 -*-
class Text:                                             #定义测试类
    def __init__(self,name):                            #初始化函数
        self.Name = name
    def __enter__(self):                                #定义程序开始执行
        print("程序开始执行！")
        return self                                     #返回默认值
    def __exit__(self, exc_type, exc_val, exc_tb):      #定义程序结束执行(异常类，异常值，追踪信息)
        print("程序执行完毕！")
with Text("测试") as f:                                 #实例化返回对象，赋值相当于 f=Text('测试')
    print(f.Name)                                       #实例化内容打印
    print("这是一个测试程序！！！")

程序开始执行！
测试
这是一个测试程序！！！
程序执行完毕！

__exit__ 简单异常处理

# -*- coding:utf8 -*-
class Text:                                             #定义测试类
    def __init__(self,name):                            #初始化函数
        self.Name = name
    def __enter__(self):                                #定义程序开始执行
        print("程序开始执行！")
        return self                                     #返回默认值
    def __exit__(self, exc_type, exc_val, exc_tb):      #定义程序结束执行(异常类，异常值，追踪信息)
        print("程序执行完毕！")
        return Text                                     #程序异常直接(吃异常)跳过且不执行异常后的代码
with Text("测试") as f:                                 #实例化返回对象，赋值相当于 f=Text('测试')
    print(f.Name)                                       #实例化内容打印
    print("这是一个测试程序！！！")
    print(A)                                            #打印不存在内容模拟程序异常
    print("with异常代码下的程序是不执行的~")

程序开始执行！
测试
这是一个测试程序！！！
程序执行完毕！

转载于:https://my.oschina.net/zhaojunhui/blog/1793997