Python包装之对象处理

目录

• 概念
• 一、基础
• 1.1、toString方法
• 1.2、格式化输出
• 1.3、创建大对象
• 二、高级用法
• 2.1、通过字符串式调用函数
• 2.2、上下文管理器

概念

所有Python的对象都是扩展的PyObject，python的垃圾回收机制是计算引用，这个对象中定义了py_ssize就是用来做这个事的。类型对象可以理解为就是自定义的class。在Python中函数间传递的是都是泛型指针，所以可以通过PyObject的ob_type属性来判断实际的类型，这也是多态的一种表现。

在Python中的垃圾回收机制比较特殊，它采用了内存对象池技术，对象释放的空间归还给内存池，如果再使用可以从内存池中获取如果确实不再使用时再回收，与java比较相似。所有的内置对象都有自己所特有的对象缓冲池机制。这种缓冲池中的对象都是不可变对象，池中的对象是共享的，但也不会引起多并发的问题。

一、基础

1.1、toString方法

class FormatChange:
def __init__(self, x, y):
self.x = x
self.y = y

def __repr__(self):
return f'use repr method: ({self.x}, {self.y})'

def __str__(self):
return f'use str method: ({self.x}, {self.y})'
fc = FormatChange(5, 7)
print(fc.__repr__()) # use repr method: (5, 7)
print(fc) # use str method: (5, 7)
print(f'fc is {fc!r}') #!r表示用repr方法代替str方法输出

1.2、格式化输出

format_dict = {
'ymd': '{d.year}-{d.month}-{d.day}',
'mdy': '{d.month}/{d.day}/{d.year}',
'dmy': '{d.day}/{d.month}/{d.year}'
}
class Date:
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day

def __format__(self, format_type='ymd'):
#format_type: 格式化类型，默认使用 ymd 方式
if not format_type:
format_type = 'ymd'
fmt = format_dict[format_type]
return fmt.format(d=self)#这里的format是一个钩子函数
curr_data = Date(2020, 5, 6)
#这处其实调用的format是一个类库中的方法，然后反向调用了自定义覆写的format方法
print(f'default format: {format(curr_data)}') #2020-5-6
print(f"use mdy format: {format(curr_data, 'mdy')}") #5/6/2020

1.3、创建大对象

用slots创建的对象，其内存占用会减少2/3左右。但缺点是不能再给对象添加新的属性了，也不能实现继承，所以一般时候只把他做为内存优化工具，用于存储大量的数据使用。

class Date:
__slots__ = ['year', 'month', 'day']
def __init__(self, year, month, day):
self.year = year
self.month = month
self.day = day

二、高级用法

2.1、通过字符串式调用函数

import math
class Point:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f'Point({self.x!r:},{self.y!r:})'
def distance(self, x, y):
return math.hypot(self.x - x, self.y - y)
#第一种方式：这种方式感觉用处不是太大，前面还是得new一个对象
p = Point(2, 3)
d = getattr(p, 'distance')(0, 0)
import operator
operator.methodcaller('distance', 0, 0)(p)
#用相同的参数多次调用某个方法时
points = [
Point(1, 2),
Point(3, 0),
Point(10, -3),
Point(-5, -7),
Point(-1, 8),
Point(3, 2)
]
#第二种使用方法： Sort by distance from origin (0, 0)
points.sort(key=operator.methodcaller('distance', 0, 0))
p = Point(3, 4)
d = operator.methodcaller('distance', 0, 0)
print(f'd(p) = {d(p)}')#5.0

2.2、上下文管理器

需要自定义实现enter和exit方法。一般用于网络连接等工具类中，代码放在with语句中执行，当出现with时enter方法被调用，返回的值赋值给as后的变量。然后with中的语句开始执行。最后exit被执行进行一些清理工作。在exit方法中自带了异常处理，如果忽略异常可返回None，如果返回True那么异常会被清空。下面是两个实现：一个是工具类，另一个是允许嵌套的工厂类：

简单实现：

from socket import socket, AF_INET, SOCK_STREAM
class LazyConnection:
def __init__(self, address, family=AF_INET, type=SOCK_STREAM):
self.address = address
self.family = family
self.type = type
self.sock = None
def __enter__(self):
if self.sock is not None:
raise RuntimeError('Already connected')
self.sock = socket(self.family, self.type)
self.sock.connect(self.address)
return self.sock
def __exit__(self, exc_ty, exc_val, tb):
self.sock.close()
self.sock = None
from functools import partial
conn = LazyConnection(('www.python.org', 80))
# Connection closed
with conn as s:
# conn.__enter__() executes: connection open
s.send(b'GET /index.html HTTP/1.0\r\n')
s.send(b'Host: www.python.org\r\n')
s.send(b'\r\n')
resp = b''.join(iter(partial(s.recv, 8192), b''))

到此这篇关于Python包装之对象处理的文章就介绍到这了,更多相关Python 对象处理内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！