1.定义一个桌子类（Desk），包含长（length）、宽（width）、高（height）属性，包含一个打印桌子信息属性的方法（showInfo）。实例化2个桌子对象，为其赋予不同的属性值，并调用showInfo方法，输出每个桌子的信息。

class Desk:

    def __init__(self, length, width, height):
        self.length = length
        self.width = width
        self.height = height

    def showInfo(self):
        print(f"桌子的长为{self.length},宽度为{self.width},高度为{self.height}")

A = Desk(10, 20, 10)
B = Desk(10, 30, 50)
A.showInfo()
B.showInfo()

2.定义一个用户类(User),用户名(username)和密码(password)是这个类的属性。

（1）实例化两个用户,分别有不同的用户名和密码。
（2）设计一个方法 修改密码 

class User:

    def __init__(self, username, password):
        self.username = username
        self.password = password
        print(f"用户名：{self.username},密码：{self.password}")

    def reset_password(self, password_new):
        self.password = password_new
        print(f"用户名：{self.username},新密码为：{password_new}")

A = User("liuao", 12345)
B = User("hwh", 12345)
A.reset_password(12347)

3.创建一个列表，其中存储了3个Point对象。每个点（Point)都在与x,y轴夹角为45度的直线上（意思是x和y的值相同）。打印输出这些点的坐标。例如：

>x坐标：1，y坐标：1
>x坐标：2，y坐标：2
>x坐标：3，y坐标：3

 **提示**：先定义Point类型，生成三个对象。然后将对象放入列表中。最后打印输入出对象中的属性值。

class Point:
    equality = False

    def __new__(cls, *args):
        return object.__new__(cls)

    def __init__(self, x, y):
        self.x = x
        self.y = y
        if x == y :
            self.equality = True

    def saveInfo(self):
        if self.equality:
            return self.x, self.y
        else:
            return None

p1 = Point(1, 1)
p2 = Point(2, 2)
p3 = Point(3, 3)
lst = [p1, p2, p3]

for p in lst:
    if p.equality:
        l = p.saveInfo()
        print(f"x坐标：{l[0]}，y坐标：{l[1]}")

4.交换Point数组中任意两个元素的位置，并打印输出交换后的列表元素（坐标点信息）

class Point:

    def __init__(self, x, y):
        self.__x = x
        self.__y = y

    @property
    def getX(self):
        return self.__x

    @property
    def getY(self):
        return self.__y


# 打印坐标函数
def pintInfo(lst):
    '''
    打印坐标函数
    :param lst: 对象存储列表
    :return: 无
    '''
    for l in lst:
        print(f"({l.getX}, {l.getY})")


# 交换坐标对象函数
def swap(lst):
    '''
    交换坐标对象
    :param lst: 对象存储列表
    :return: 无
    '''
    i = 0
    while i < len(lst) - 1:
        lst[i], lst[i + 1] = lst[i + 1], lst[i]
        i += 1


# 实例化3个 Point 对象
p1 = Point(1, 1)
p2 = Point(2, 2)
p3 = Point(3, 3)
# 将对象存储到列表中
lst = [p1, p2, p3]
# 交换前
print("交换前".center(20, '='))
pintInfo(lst)
# 交换元素
swap(lst)
# 交换后
print("交换后".center(20, '='))
pintInfo(lst)

5.创建一个列表，其中存储了3个Circle对象，要求每一个圆（Circle类型）的半径构成等差数列，差项为2，首项为1。每个圆的圆心（Point类型)都在与x，y轴夹角为45度的直线上。

class Point:

    def __init__(self, p):
        self.__x = p
        self.__y = p

    @property
    def getX(self):
        return self.__x

    @property
    def getY(self):
        return self.__y


class Radius:

    def __init__(self):
        self.radius = 1

    def setRadius(self, cls):
        cls.radius = self.radius  # 保存前一个对象的半径
        cls.radius += 2  # 设置下一对象的半径
        return cls.radius  # 返回半径

    @property
    def getRadius(self):
        return self.radius


class Circle:
    def __init__(self, point, radius):
        self.point = point
        self.radius = radius

    @property
    def getCircle(self):
        return f"(圆心：{self.point.getX},{self.point.getY}),半径：{self.radius.getRadius}"

# 实例化Point()对象
p1 = Point(1)
p2 = Point(2)
p3 = Point(3)
# 实例化Radius()对象
r1 = Radius()
r2 = Radius()
r3 = Radius()

r1.setRadius(r2)
r2.setRadius(r3)
# print(r1.getRadius)
# print(r2.getRadius)
# print(r3.getRadius)
c1 = Circle(p1, r1)
c2 = Circle(p2, r2)
c3 = Circle(p3, r3)
lst = [c1, c2, c3]
for l in lst:
    print(l.getCircle)

6.为Circle类设计一个方法，传入另一个圆（Circle）对象，计算并输出两个圆的状态。例如：相交、相切、相离等。

提示：根据2个圆的圆心间距离，与两圆半径和进行比较。相等则“相切”，圆心距离小于半径和则"相交"，大于半径为”相离“。如果圆心距离为0，半径相等则为"重合"；半径不相等则为"包含"。

class Point:

    def __init__(self, x, y):
        self.__x = x
        self.__y = y

    @property
    def getX(self):
        return self.__x

    @property
    def getY(self):
        return self.__y


class Radius:

    def __init__(self, radius):
        self.__radius = radius

    @property
    def getRadius(self):
        return self.__radius


class Circle:

    def __init__(self, point, radius):
        self.point = point
        self.radius = radius

    def distJduge(self, cls):
        # d =√[（x2 - x1）²+（y2 - y1）²]
        self.__c_dist = pow((self.point.getX - cls.point.getX) ** 2 + (self.point.getY - cls.point.getY) ** 2, 0.5)
        self.__r_dist = abs(self.radius.getRadius - cls.radius.getRadius)
        self.__r_dist2 = abs(self.radius.getRadius + cls.radius.getRadius)
        print(f"圆心距：{self.__c_dist},半径差：{self.__r_dist},半径和{self.__r_dist2}")
        # (1)d>r1+r2时，两圆外离;
        if self.__r_dist2 < self.__c_dist:
            return "两圆外离"
        # (2)d=r1+r2时，两圆外切;
        elif self.__r_dist2 == self.__c_dist:
            return "两圆外切"
        # (3) r1-r2<d<r1+r2时，两圆相交。;
        elif self.__r_dist < self.__c_dist and self.__c_dist < self.__r_dist2:
            return "两圆相交"
        # （4）d=r1-r2时，两圆内切
        elif self.__c_dist == self.__r_dist:
            return "两圆内切"
        # (5)d<r1-r2时，两圆内含
        elif self.__c_dist < self.__r_dist:
            return "两圆内含"

# 实例化两个圆心
p1 = Point(0, 0)
p2 = Point(0, 0)
# 实例化两个半径
r1 = Radius(2)
r2 = Radius(4)
# 实例化两个Circle对象
c1 = Circle(p1, r1)
c2 = Circle(p2, r2)
# 调用distJduge()方法
result = c1.distJduge(c2)
print(result)