Rect 矩形对象使用说明

如何在 Pygame 中创建、移动矩形，以及改变大小

视频演示 YouTube

如何在 Pygame 中创建、移动矩形，以及改变大小

视频演示 Bilibili

Pygame 中的 Rect 对象

矩形在游戏开发中具有重要的作用，除了可以用于定位和绘制，还可以进行高效的碰撞检测。在 Pygame 包中，Rect对象被用于表示游戏中的矩形，该对象包含一系列与矩形相关的变量，以及用于矩形运算的方法，以下是其构造器。

Rect(left, top, width, height)
Rect(left_top, width_height)
Rect(single_arg)

left 参数

left参数是一个表示矩形左边缘的 X 坐标的浮点数。

top 参数

top参数是一个表示矩形上边缘的 Y 坐标的浮点数。

width 参数

width参数是一个表示矩形宽度的浮点数。

height 参数

height参数是一个表示矩形高度的浮点数。

left_top 参数

left_top参数表示矩形左上角的坐标，他可以是一个依次包含 X 和 Y 坐标的 Python 浮点数序列对象，或一个 PygameVector2对象（对象的x变量对应 X 坐标，对象的y变量对应 Y 坐标）。比如，元组(10.5,20.5)。

width_height 参数

width_height参数表示矩形的大小，他可以是一个依次包含宽度和高度的 Python 浮点数序列对象，或一个 PygameVector2对象（对象的x变量对应宽度，对象的y变量对应高度）。比如，列表[100.25,9.75]。

single_arg 参数

single_arg参数为包含矩形信息的对象，他可以是另一个Rect对象，或者依次包含元素l,t,w,h或l_t,w_h的 Python 序列对象，其中l，t，w，h，l_t，w_h分别与参数left，top，width，height，left_top，width_height的取值和含义相同。比如，[10.5,20.5,100.25,9.75]，((10.5,20.5),[100.25,9.75])。

此外，参数single_arg还可以是一个拥有rect特性的对象，rect的返回值符合以上要求之一。

# 导入 Rect，Vector2 对象
from pygame import Rect, Vector2


# 创建不同的矩形，浮点数会被转换为整数
# X 坐标 10，Y 坐标 20，宽度 50，高度 99
r1 = Rect(10.5, 20.5, 50.9, 99.9)
# X 坐标 110，Y 坐标 100，宽度 20，高度 25
r2 = Rect((110, 100), [20, 25])
# X 坐标 200，Y 坐标 210，宽度 20，高度 50
r3 = Rect(Vector2(200, 210), Vector2(20, 50.5))
# X 坐标 300，Y 坐标 100，宽度 40，高度 45
r4 = Rect([(300, 100), [40, 45]])


# 创建游戏窗口，并使用矩形进行绘制
from pygame import display, draw
s = display.set_mode((800, 600))
draw.rect(s, 0xff0000, r1)
draw.rect(s, 0x00ff00, r2)
draw.rect(s, 0xff00ff, r3)
draw.rect(s, 0x0000ff, r4)
display.flip()


import time
time.sleep(2)

获取和设置矩形信息

Rect对象拥有一些表示矩形位置和大小的变量，其类型是整数或整数元组。当对表示矩形位置的变量进行修改时，矩形的大小保持不变。当对表示矩形大小的变量进行修改时，矩形的左上角坐标保持不变。

变量x和left表示矩形左边缘的 X 坐标，变量y和top表示矩形上边缘的 Y 坐标。变量right表示矩形右边缘的 X 坐标，变量bottom表示矩形下边缘的 Y 坐标。

rect.x
rect.left
rect.y
rect.top
rect.right
rect.bottom
rect.x = x
rect.left = left
rect.y = y
rect.top = top
rect.right = right
rect.bottom = bottom

x，left，y，top，right，bottom 值

x和left，y和top，right，bottom是一个整数，其含义与对应的变量相同。

变量width和w表示矩形的宽度，变量height和h表示矩形的高度，变量size是表示矩形大小的整数元组（依次包含宽度和高度）。

rect.width
rect.w
rect.height
rect.h
rect.size
rect.width = width
rect.w = w
rect.height = height
rect.h = h
rect.size = size

width，w，height，h，size 值

width和w，height和h是一个整数，size是一个整数元组，他们的含义与对应的变量相同。

变量topleft，topright，bottomright，bottomleft是表示矩形左上角，右上角，右下角，左下角坐标的整数元组。

rect.topleft
rect.topright
rect.bottomright
rect.bottomleft
rect.topleft = topleft
rect.topright = topright
rect.bottomright = bottomright
rect.bottomleft = bottomleft

topleft，topright，bottomright，bottomleft 值

topleft，topright，bottomright，bottomleft是一个整数元组，他们的含义与对应的变量相同。

变量midleft，midtop，midright，midbottom是表示矩形左边缘，上边缘，右边缘，下边缘中点坐标的整数元组。

rect.midleft
rect.midtop
rect.midright
rect.midbottom
rect.midleft = midleft
rect.midtop = midtop
rect.midright = midright
rect.midbottom = midbottom

midleft，midtop，midright，midbottom 值

midleft，midtop，midright，midbottom是一个整数元组，他们的含义与对应的变量相同。

变量centerx和centery表示矩形中心的 X 坐标和 Y 坐标，变量center是表示矩形中心坐标的整数元组。

rect.centerx
rect.centery
rect.center
rect.centerx = centerx
rect.centery = centery
rect.center = center

centerx，centery，center 值

centerx，centery是一个整数，center是一个整数元组，他们的含义与对应的变量相同。

from pygame import Rect


# 创建一个矩形
r = Rect(10, 20, 30, 40)


# 显示矩形的位置和大小
print(f'{r.x} {r.y} {r.right} {r.bottom}')
print(f'{r.w} {r.h} {r.size}')


# 显示矩形的四个顶点的坐标
print(f'{r.topleft} {r.topright} {r.bottomright} {r.bottomleft}')
# 显示矩形的四个边缘的中点的坐标
print(f'{r.midleft} {r.midtop} {r.midright} {r.midbottom}')
# 显示矩形中心的坐标
print(f'{r.centerx} {r.centery} {r.center}')


# 修改矩形的中心位置
r.center = (100, 100)
# 显示矩形的位置
print(f'{r.x} {r.y} {r.right} {r.bottom}')

# 位置和大小
10 20 40 60
30 40 (30, 40)
# 顶点坐标
(10, 20) (40, 20) (40, 60) (10, 60)
# 边缘中点坐标
(10, 40) (25, 20) (40, 40) (25, 60)
# 中心坐标
25 40 (25, 40)
# 修改后的位置
85 80 115 120

更新矩形信息

Rect对象的update方法可用于更新矩形的位置和大小，该方法的参数与Rect对象的构造器的参数类似，你可以查看Rect 对象一段来了解他们。

update(left, top, width, height)
update(left_top, width_height)
update(single_arg)

from pygame import Rect


# X 坐标 10，Y 坐标 20，宽度 30，高度 40
r = Rect(10, 20, 30, 40)
# 更新矩形位置和大小，X 和 Y 坐标为 0，宽度和高度为 10
r.update([0, 0], (10, 10))

复制矩形

Rect对象的copy方法返回一个新的Rect对象，新对象所表示的矩形的位置和大小，与原有的矩形相同，即新对象的所有变量的值与原有对象相同。

copy()

返回值

copy方法返回复制的Rect对象。

from pygame import Rect


# 创建一个矩形，然后复制他
r1 = Rect(0, 0, 100, 100)
r2 = r1.copy()
# 对第一个矩形进行修改，并不会影响第二个矩形
r1.bottomright = (200, 200)


print(f'第一个矩形：{r1}')
print(f'第二个矩形：{r2}')

第一个矩形：<rect(100, 100, 100, 100)>
第二个矩形：<rect(0, 0, 100, 100)>

移动矩形

Rect对象的move和move_ip方法可用于移动矩形，其中move_ip会移动当前的Rect对象，move会根据移动的位置创建并返回一个新的Rect对象，原有矩形不会发生变化。

move(x, y)
move(move_by)
move_ip(x, y)
move_ip(move_by)

x 参数

x参数是一个浮点数，表示矩形在 X 轴上的移动距离。

y 参数

y参数是一个浮点数，表示矩形在 Y 轴上的移动距离。

move_by 参数

move_by参数是一个依次包含 X 轴移动距离和 Y 轴移动距离的 Python 浮点数序列对象，或一个 PygameVector2对象（对象的x变量对应 X 轴移动距离，对象的y变量对应 Y 轴移动距离）。

move 返回值

move方法返回移动后的新的Rect对象。

from pygame import Rect, Vector2


# 创建一个矩形，并计算移动后的矩形
r1 = Rect(0, 0, 10, 20)
r2 = r1.move(11, 9)
print(r2)


# 移动矩形 r1 自身
r1.move_ip(Vector2(5, 5))
print(r1)

<rect(11, 9, 10, 20)>
<rect(5, 5, 10, 20)>

判断矩形是否包含另一矩形

Rect对象的contains方法可用于判断矩形是否能够完全包含另一个矩形（由参数表示的目标矩形）。

contains方法的参数，与Rect对象的构造器的参数类似（其中参数rect等同于参数single_arg），你可以查看Rect 对象一段来了解他们。

contains(rect)
contains(left_top, width_height)
contains(left, top, width, height)

返回值

如果contains方法返回True，那么表示可以完全包含目标矩形。

from pygame import Rect


# 判断矩形 r1 是否能够完全包含其他矩形
r1 = Rect(0, 0, 10, 10)
r2 = Rect(-10, -10, 10, 10)
print(r1.contains(r2))
print(r1.contains([5, 5], [10, 10]))
print(r1.contains(2, 2, 6, 6))

False
False
True

保持中心不变并更改矩形大小

当你希望改变矩形的大小并保持矩形的中心不变时，可以使用Rect对象的inflate，inflate_ip，scale_by，scale_by_ip方法。

Rect对象的inflate和inflate_ip方法可用于调整矩形的大小，并尽可能确保矩形的中心不发生改变，其中inflate_ip会改变当前的Rect对象，inflate会根据调整结果创建并返回一个新的Rect对象，原有矩形不会发生变化。

inflate(x, y)
inflate(inflate_by)
inflate_ip(x, y)
inflate_ip(inflate_by)

x 参数

x参数是一个浮点数，表示矩形增加的宽度，如果为负数则宽度减小。

y 参数

y参数是一个浮点数，表示矩形增加的高度，如果为负数则高度减小。

inflate_by 参数

inflate_by参数是一个依次包含增加的宽度和增加的高度的 Python 浮点数序列对象，或一个 PygameVector2对象（对象的x变量对应增加的宽度，对象的y变量对应增加的高度）。

inflate 返回值

inflate方法返回大小改变后的新的Rect对象。

Rect对象的scale_by和scale_by_ip方法可用于缩放矩形，并尽可能确保矩形的中心不发生改变，其中scale_by_ip会改变当前的Rect对象，scale_by会根据缩放结果创建并返回一个新的Rect对象，原有矩形不会发生变化。

scale_by(x, y)
scale_by_ip(x, y)

x 参数

x参数是一个浮点数，表示矩形宽度的缩放比例。

y 参数

y参数是一个浮点数，表示矩形高度的缩放比例，如果仅提供参数x，那么视参数y与参数x相同。

scale 返回值

scale方法返回缩放后的新的Rect对象。

from pygame import Rect


# 创建一个矩形
r1 = Rect(0, 0, 10, 10)
# 矩形的宽度增加 3，高度增加 2
r2 = r1.inflate(3, 2)
print(r2)
# 调整矩形 r1 自身的大小
r1.inflate_ip((-20, -30))
print(r1)


# 创建一个矩形
r3 = Rect(0, 0, 10, 10)
# 矩形的宽度和高度增加一倍
r4 = r3.scale_by(2)
print(r4)
# 缩放矩形 r3 自身
r3.scale_by_ip(2.5, 3.5)
print(r3)

# 宽度加 3，高度加 2
<rect(-1, -1, 13, 12)>
# 宽度减 20，高度减 30
<rect(10, 15, -10, -20)>
# 宽度和高度扩大至 2 倍
<rect(-5, -5, 20, 20)>
# 宽度扩大至 2.5 倍，高度扩大至 3.5 倍
<rect(-7, -12, 25, 35)>

将矩形固定到另一矩形中

Rect对象的clamp和clamp_ip方法可用于将矩形固定到另一个矩形（由参数表示的目标矩形）的内部，如果已经处于内部（不包括两个矩形部分重叠的情况），那么矩形的位置不会产生变化。方法clamp会改变当前的Rect对象，方法clamp_ip会根据固定结果创建并返回一个新的Rect对象，原有矩形不会发生变化。

clamp与clamp_ip方法的参数，与Rect对象的构造器的参数类似（其中参数rect等同于参数single_arg），你可以查看Rect 对象一段来了解他们。

clamp(rect)
clamp(left_top, width_height)
clamp(left, top, width, height)
clamp_ip(rect)
clamp_ip(left_top, width_height)
clamp_ip(left, top, width, height)

clamp 返回值

clamp方法返回固定后的新的Rect对象。

from pygame import Rect


# 矩形 r1 作为容器
r1 = Rect(0, 0, 100, 100)


# 矩形 r2 位于 r1 的右上方
r2 = Rect(500, -500, 50, 50)
# 固定在 r1 内部（右上角）
print(r2.clamp(r1))


# 矩形 r3 位于 r1 的左下方
r3 = Rect(-500, 500, 50, 50)
# 固定在 r1 内部（左下角）
print(r3.clamp(r1))


# 矩形 r4 的一部分与 r1 重合
r4 = Rect(-10, -10, 50, 50)
# 固定在 r1 内部（左上角）
print(r4.clamp(r1))


# 矩形 r5 位于 r1 内部，但中心不相同
r5 = Rect(10, 10, 20, 20)
# 不会发生变化
print(r5.clamp(r1))


# 矩形 r6 比 r1 大
r6 = Rect(-1000, -1000, 200, 200)
# r6 的中心将于 r1 相同
r6.clamp_ip(r1)
print(r6.center, r1.center)

# 固定在右上角
<rect(50, 0, 50, 50)>
# 固定在左下角
<rect(0, 50, 50, 50)>
# 固定在左上角
<rect(0, 0, 50, 50)>
# 没有变化
<rect(10, 10, 20, 20)>
# 中心相同
(50, 50) (50, 50)

调整并移动矩形以填充另一矩形

Rect对象的fit方法可以移动矩形并按照原有宽高比例调整大小，以将其填充到另一个矩形（由参数表示的目标矩形）中，两个矩形的中心位置相同，而计算的结果将作为新的Rect对象返回，原有的矩形不会发生变化。

fit方法的参数，与Rect对象的构造器的参数类似（其中参数rect等同于参数single_arg），你可以查看Rect 对象一段来了解他们。

fit(rect)
fit(left_top, width_height)
fit(left, top, width, height)

返回值

fit方法返回移动并调整大小后的新的Rect对象。

from pygame import Rect


# 创建一个矩形，并填充到其他几个矩形中
r1 = Rect(0, 0, 100, 100)
print(r1.fit(100, 100, 100, 50))
print(r1.fit((-20, -50), (200, 300)))

<rect(125, 100, 50, 50)>
<rect(-20, 0, 200, 200)>

剪裁矩形与另一矩形的重叠部分

Rect对象的clip方法可以计算矩形与另一个矩形（由参数表示的目标矩形）的重叠部分，并将重叠部分作为新的Rect对象返回。

clip方法的参数，与Rect对象的构造器的参数类似（其中参数rect等同于参数single_arg），你可以查看Rect 对象一段来了解他们。

clip(rect)
clip(left_top, width_height)
clip(left, top, width, height)

返回值

clip方法返回表示两个矩形重叠部分的Rect对象。

from pygame import Rect


# 创建两个矩形并计算他们重叠的部分
r1 = Rect(0, 0, 100, 100)
r2 = Rect(-50, -50, 100, 100)
print(r2.clip(r1))


# 矩形 r2 与参数表示的矩形不重叠
print(r2.clip([100, 100], [10, 10]))

<rect(0, 0, 50, 50)>
# 宽度和高度为零
<rect(-50, -50, 0, 0)>

剪裁线段在矩形中的部分

Rect对象的clipline方法可以计算线段在矩形中的部分，并返回该部分的端点坐标。

clipline(x1, x2, x3, x4)
clipline(first_coordinate, second_coordinate)
clipline(rect_arg)

x1 参数

x1参数是一个浮点数，表示线段起点的 X 坐标。

x2 参数

x2参数是一个浮点数，表示线段起点的 Y 坐标。

x3 参数

x3参数是一个浮点数，表示线段终点的 X 坐标。

x4 参数

x4参数是一个浮点数，表示线段终点的 Y 坐标。

first_coordinate 参数

first_coordinate参数表示线段的起点坐标，他可以是一个依次包含 X 和 Y 坐标的 Python 浮点数序列对象，或一个 PygameVector2对象（对象的x变量对应 X 坐标，对象的y变量对应 Y 坐标）。

second_coordinate 参数

second_coordinate参数表示线段的终点坐标，他可以是一个依次包含 X 和 Y 坐标的 Python 浮点数序列对象，或一个 PygameVector2对象（对象的x变量对应 X 坐标，对象的y变量对应 Y 坐标）。

rect_arg 参数

rect_arg参数与Rect构造器的rect参数类似，你可以查看Rect 对象一段来了解他。如果将该参数视为矩形信息，那么矩形的左上角为线段的起点，矩形的宽度和高度分别为线段终点的 X 坐标和 Y 坐标。

返回值

clipline方法返回一个形式类似于((sx,sy),(ex,ey))的元组（其中(sx,sy)为线段在矩形中的部分的起点坐标，(ex,ey)为线段在矩形中的部分的终点坐标），或者返回一个空的元组，当线段在矩形之外时。

from pygame import Rect, Vector2


# 创建一个矩形，并计算线段在该矩形中的部分
r = Rect(0, 0, 100, 100)
# 线段的一部分在矩形中
print(r.clipline(-1, -1, 50, 50))
# 线段完全在矩形中
print(r.clipline((50, 50), [60, 60]))
# 线段穿过了矩形
print(r.clipline(Rect(10, -10, 10, 110)))
# 线段在矩形外
print(r.clipline(Vector2(-1, 0), Vector2(0, 100)))

# 线段的一部分在矩形中
((0, 0), (50, 50))
# 线段完全在矩形中
((50, 50), (60, 60))
# 线段穿过了矩形
((10, 0), (10, 99))
# 线段在矩形外
()

合并矩形

Rect对象的union和union_ip方法可以计算矩形与另一个矩形（由参数表示的目标矩形）的并集，即可以包含两个矩形的最小矩形。方法union会将并集保存在当前的Rect对象中，方法union_ip会将并集作为新的Rect对象返回，原有矩形不会发生变化。

union与union_ip方法的参数，与Rect对象的构造器的参数类似（其中参数rect等同于参数single_arg），你可以查看Rect 对象一段来了解他们。

union(rect)
union(left_top, width_height)
union(left, top, width, height)
union_ip(rect)
union_ip(left_top, width_height)
union_ip(left, top, width, height)

union 返回值

union方法返回作为矩形并集的新的Rect对象。

Rect对象的unionall和unionall_ip方法可以计算矩形与多个矩形的并集，即可以包含这些矩形的最小矩形。方法unionall会将并集保存在当前的Rect对象中，方法unionall_ip会将并集作为新的Rect对象返回，原有矩形不会发生变化。

union(rects)
union_ip(rects)

rects 参数

rects参数是一个 Python 序列对象，序列中的每一个元素都表示了一个矩形，他们的书写格式类似于Rect对象的构造器的single_arg参数，你可以查看Rect 对象一段来了解更多。

union 返回值

union方法返回作为多个矩形并集的新的Rect对象。

from pygame import Rect


# 创建一个矩形，并计算与其他矩形的并集
r = Rect(0, 0, 10, 10)
print(r.union(30, 30, 10, 10))
print(r.unionall([(30, 30, 10, 10), [[-10, -10], [5, 5]]]))
r.union_ip((-10, -10, 15, 15))
print(r)

<rect(0, 0, 40, 40)>
<rect(-10, -10, 50, 50)>
<rect(-10, -10, 20, 20)>

更正大小为负数的矩形

如果一个Rect对象所表示的矩形的大小为负数，那么可以调用其normalize方法将大小更正为正数，这会导致矩形的宽度或高度（或两者）发生变化。

需要指出的是，虽然normalize方法不会改变原有矩形的位置，但Rect对象的一些变量会发生变化，比如topleft（因其原本表示的并非真正的左上角）。

normalize()

from pygame import Rect


# 创建一个矩形，并更正错误的矩形大小
r = Rect(0, 0, -30, -40)
r.normalize()
print(r)

<rect(-30, -40, 30, 40)>

源码

src/zh/rect·codebeatme/pygame·GitHub

讲解视频

如何在 Pygame 中创建、移动矩形，以及改变大小·YouTube如何在 Pygame 中创建、移动矩形，以及改变大小·Bilibili