访问Python对象数据

我对python相当陌生（对python OO也完全陌生），但我使用的是一个相当复杂的类，我很难理解，但需要编辑。为了帮助理解发生了什么，我试图从对象中提取数据，但我所做的一切只是返回“地址处的classname对象”

有人能给我解释一下我该如何打印，比如说，这个物体的顶点场：

class Halfedge(object):
    def __init__(self, edge=None, marker=Edge.LEFT):
        self.left = None    # left Halfedge in the edge list
        self.right = None   # right Halfedge in the edge list
        self.qnext = None   # priority queue linked list pointer
        self.edge = edge    # edge list Edge
        self.marker = marker
        self.vertex = None  # Site()
        self.ystar = BIG_FLOAT

    def __eq__(self, other):
        return self.ystar == other.ystar and \
               self.vertex.x == other.vertex.x

    def __lt__(self, other):
        if self.ystar  == other.ystar:
            return self.vertex.x < other.vertex.x
        else:
            return self.ystar < other.ystar

    def left_reg(self, default):
        if not self.edge:
            return default
        elif self.marker == Edge.LEFT:
            return self.edge.reg[Edge.LEFT]
        else:
            return self.edge.reg[Edge.RIGHT]

    def right_reg(self, default):
        if not self.edge:
            return default
        elif self.marker == Edge.LEFT:
            return self.edge.reg[Edge.RIGHT]
        else:
            return self.edge.reg[Edge.LEFT]

    def is_point_right_of(self, point):
        """Returns True if <point> is to right of halfedge.
        """
        edge = self.edge
        topsite = edge.reg[1]
        right_of_site = point.x > topsite.x

        if(right_of_site and self.marker == Edge.LEFT):
            return True

        if(not right_of_site and self.marker == Edge.RIGHT):
            return False

        if(edge.a == 1.0):
            dyp = point.y - topsite.y
            dxp = point.x - topsite.x
            fast = 0
            if ((not right_of_site and edge.b < 0.0) or \
                (right_of_site and edge.b >= 0.0)):
                above = dyp >= edge.b * dxp
                fast = above
            else:
                above = point.x + point.y * edge.b > edge.c
                if(edge.b < 0.0):
                    above = not above
                if (not above):
                    fast = 1
            if (not fast):
                dxs = topsite.x - (edge.reg[0]).x
                above = (edge.b * (dxp*dxp - dyp*dyp)) < \
                        (dxs*dyp*(1.0+2.0*dxp/dxs + edge.b*edge.b))
                if(edge.b < 0.0):
                    above = not above
        else:  # edge.b == 1.0
            yl = edge.c - edge.a * point.x
            t1 = point.y - yl
            t2 = point.x - topsite.x
            t3 = yl - topsite.y
            above = t1*t1 > t2*t2 + t3*t3

        if(self.marker == Edge.LEFT):
            return above
        else:
            return not above

    def intersect(self, other):
        """Create a new site where the Halfedges edge1 and edge2 intersect.
        """
        edge1 = self.edge
        edge2 = other.edge
        if (edge1 is None) or (edge2 is None):
            return None

        # if the two edges bisect the same parent return None
        if edge1.reg[1] is edge2.reg[1]:
            return None

        d = edge1.a * edge2.b - edge1.b * edge2.a
        if almost_equal(d, 0.0):
            return None

        intersect_x = (edge1.c * edge2.b - edge2.c * edge1.b) / d
        intersect_y = (edge2.c * edge1.a - edge1.c * edge2.a) / d
        if edge1.reg[1] < edge2.reg[1]:
            halfedge = self
            edge = edge1
        else:
            halfedge = other
            edge = edge2

        right_of_site = intersect_x >= edge.reg[1].x
        if ((right_of_site and halfedge.marker == Edge.LEFT) or
            (not right_of_site and halfedge.marker == Edge.RIGHT)):
            return None

        # create a new site at the point of intersection - this is a new
        # vector event waiting to happen
        return Site((intersect_x, intersect_y))

类半边（对象）：
定义初始化（self，edge=None，marker=edge.LEFT）：
self.left=无#边列表中的左半边
self.right=无#边列表中的右半边
self.qnext=None#优先级队列链表指针
self.edge=边#边列表边
self.marker=标记器
self.vertex=None#Site（）
self.ystar=大浮点数
定义（自身、其他）：
返回self.ystar==other.ystar和\
self.vertex.x==其他.vertex.x
定义（自身、其他）：
如果self.ystar==other.ystar：
返回self.vertex.x<其他.vertex.x
其他：
返回self.ystar表土.x
如果（站点的右\u和self.marker==Edge.LEFT）：
返回真值
如果（不在\u站点的\u右侧，且self.marker==Edge.right）：
返回错误
如果（edge.a==1.0）：
dyp=点y-表土y
dxp=点.x-表土.x
快速=0
如果（（不在位置和边缘的右侧）。b<0.0）或\
（站点和边缘的右\u.b>=0.0））：
上方=dyp>=edge.b*dxp
快速=以上
其他：
上方=点.x+点.y*边.b>边.c
如果（边缘b<0.0）：
高于=不高于
如果（不在上面）：
快速=1
如果（不快）：
dxs=表土.x-（边缘.reg[0]）.x
上面=（edge.b*（dxp*dxp-dyp*dyp））<\
（dxs*dyp*（1.0+2.0*dxp/dxs+edge.b*edge.b））
如果（边缘b<0.0）：
高于=不高于
其他：#edge.b==1.0
yl=边.c-边.a*点.x
t1=点y-yl
t2=点x-表土x
t3=yl-表土。y
以上=t1*t1>t2*t2+t3*t3
如果（self.marker==Edge.LEFT）：
返回上方
其他：
返回不高于
def intersect（自身、其他）：
“”“在半边边1和边2相交的位置创建新场地。
"""
edge1=自边
edge2=其他.edge
如果（edge1为无）或（edge2为无）：
一无所获
#如果两条边平分同一父边，则返回“无”
如果edge1.reg[1]是edge2.reg[1]：
一无所获
d=边1.a*边2.b-边1.b*边2.a
如果几乎相等（d，0.0）：
一无所获
intersect_x=（edge1.c*edge2.b-edge2.c*edge1.b）/d
intersect_y=（edge2.c*edge1.a-edge1.c*edge2.a）/d
如果edge1.reg[1]=edge.reg[1].x
如果（（站点的右\u和halfedge.marker==Edge.LEFT）或
（不在_站点和halfedge.marker==Edge.right的_的右侧）：
一无所获
#在交叉点处创建一个新场地-这是一个新场地
#等待发生的向量事件
返回站点（（相交x，相交y））

我知道这很简单，但是谢谢你的帮助

编辑：我使用的整个类可以在以下位置找到：

---

假设您有一个半边实例-我们称之为

my_Halfedge

-您可以使用点符号访问它的任何属性。因此，对于

vertex

属性，您可以使用

my_halfedge.vertex

来创建halfedge do的实例，例如

he2 = Halfedge()

要打印此实例的顶点值，请执行以下操作：

print he2.vertex

---

这就是你想要的吗？

那么，到目前为止你尝试了什么？还有，什么“向量变量”？只有一个“顶点”字段（不是“变量”）。对不起，输入错误，这是我要返回的顶点字段。如果我理解正确，它应该返回，或者是指向OO坐标的指针。我将编辑主帖子，使其链接到整个类。嗯，我尝试使用类创建的平分线。它返回“地址处的voronoi.Site对象”。然后，我是否必须在站点对象中找到要添加到打印语句末尾的属性？要找到对象的属性，您可以执行

dir（my\u halfedge.vertex）

-然后只需在另一个点后添加属性，例如

my\u halfedge.vertex.my\u attribute

。啊，这似乎已经成功了。谢谢。尽管花了相当多的时间在python上，我还是设法完全避免了在python中进行面向对象编程。