符合Python风格的对象

from array import array


def create_bytes():

    type_code = ‘f‘

    # ord函数返回字符的编码
    print(‘type_code:‘,ord(type_code))

    ar = array(type_code,[0.19,0.23])

    # bytes构造函数接受一个可迭代对象作为参数
    # 它依次遍历可迭代对象，将每个元素拆成字节
    # type_code1个字节，float4个字节，一共9个字节
    by = bytes([ord(type_code)]) + bytes(ar)

    print(‘bytes(len:%d):‘ % len(by), by)

    return by


def from_bytes(by):

    # 将第一个字节转换为字符
    type_code = chr(by[0])

    # 以后的每4个字节转换为一个float
    # 先用type_code构造一个Array
    arr = array(type_code)
    # 再把字节序列按type_code转换成Array
    arr.frombytes(by[1:])

    print(arr)


bytes = create_bytes()

from_bytes(bytes)

输出：
type_code: 102
bytes(len:9): b‘f\\\x8fB>\x1f\x85k>‘
array(‘f‘, [0.1899999976158142, 0.23000000417232513])

class Demo:

    @classmethod
    def klassmethod(*args):
        print(args)

    @staticmethod
    def statmethod(*args):
        print(args)


# classmethod自动将类作为第一个参数传入
Demo.klassmethod()
Demo.klassmethod(‘param‘)

# staticmethod只是定义在类中的一个普通方法
Demo.statmethod()
Demo.statmethod(‘param‘)

输出:
(<class ‘__main__.Demo‘>,)
(<class ‘__main__.Demo‘>, ‘param‘)
()
(‘param‘,)

class Vector2d:

    def __init__(self,_x,_y):

        self._x = float(_x)
        self._y = float(_y)

    def __iter__(self):

        return (item for item in (self.x,self.y))

    # 用propery装饰器设置只读属性，保持对象的不可变
    @property
    def x(self):

        return self._x

    @property
    def y(self):

        return self._y

    # 使对象可散列
    def __hash__(self):

        return hash(self.x) ^ hash(self.y)

    # 可散列的同时，还要实现相等方法
    def __eq__(self, other):

        return self.x == other.x and self.y == other.y


v1 = Vector2d(3,4)

v2 = Vector2d(3,4)


print(hash(v1),hash(v2),v1==v2)

输出：
7 7 True

class Dog:

    def __init__(self,name):

        # 如果以__var的形式命名实例属性，Python会把属性名存入实例的__dict__属性中
        # 而且会在前面加上一个下划线和类名
        self.__name = name

dog = Dog(‘Bob‘)

print(dog.__dict__)

# ‘Dog‘ object has no attribute ‘__name‘
# print(dog.__name)

print(dog._Dog__name)

输出：
{‘_Dog__name‘: ‘Bob‘}
Bob

class Vector2d:

    __slots__ = (‘_x‘,‘_y‘)

    def __init__(self,_x,_y):

        self._x = float(_x)
        self._y = float(_y)


v2d = Vector2d(1,2)

# ‘Vector2d‘ object has no attribute ‘__dict__‘
# print(v2d.__dict__)

# ‘Vector2d‘ object has no attribute ‘z‘
# v2d.z = ‘z‘

class Vector2d:

    __slots__ = (‘_x‘,‘_y‘,‘__dict__‘)

    def __init__(self,_x,_y):

        self._x = float(_x)
        self._y = float(_y)


v2d = Vector2d(1,2)

v2d.z = ‘z‘

print(v2d.__dict__)

输出：
{‘z‘: ‘z‘}