用 Python 制作游戏和媒体项目的最简单方法。

导航

项目链接

统计数据

View statistics for this project via Libraries.io, or by using our public dataset on Google BigQuery

Meta

License: MIT License (MIT)

作者: Repl.it

Requires: Python >=3.5

Maintainers

Avatar for amasad from gravatar.com amasad Avatar for Glench from gravatar.com Glench

分类

项目描述

Python Play（测试版）

试试 repl.it

在 Python 中开始编码游戏和图形项目的最简单方法

Python Play 是一个用于 Python 编程语言的开源代码库，它使开始制作游戏变得尽可能容易。下面是使用 Play 制作简单游戏的代码：

import play

cat = play.new_text('=^.^=', font_size=70)

@play.repeat_forever
async def move_cat():
    cat.x = play.random_number(-200, 200)
    cat.y = play.random_number(-200, 200)
    cat.color = play.random_color()

    cat.show()

    await play.timer(seconds=0.4)

    cat.hide()

    await play.timer(seconds=0.4)

@cat.when_clicked
def win_function():
    cat.show()
    cat.words = 'You won!'

play.start_program()

上面的代码制作了一个游戏，你必须点击猫才能获胜：

点击猫游戏

您可以尝试在 repl.it 上玩和更改此游戏！

Python Play 是初学者开始图形编程的绝佳选择。它被设计为具有与MIT 的 Scratch相似的命令和简单性，并且与 Pygame、Arcade 或 Pygame Zero 等项目不同，因为它缺少样板代码、易于理解的纯英语命令和直观的 API。在本文档底部阅读有关其设计的更多信息。

如何安装 Python Play

在终端中运行以下命令：

pip install replit-play

或者你可以直接去repl.it并且你不需要安装任何东西 :)

如何使用 Python Play

所有 Python Play 程序都以 开头import play和结尾play.start_program()，如下所示：

import play # this is the first line in the program



play.start_program() # this is the last line in the program

所有其他命令都在这两个命令之间。

要尝试以下任何示例，请转到repl.it 并尝试将代码粘贴到.

命令

本文档的其余部分分为以下部分：

基本命令

要在屏幕上获取图像或文本，请使用以下命令。（复制并粘贴下面的代码进行尝试。）

play.new_box()

box = play.new_box(color='black', x=0, y=0, width=100, height=200, border_color="light blue", border_width=0)

这将在屏幕中间放置一个高大的黑框。

如果要更改图像在屏幕上的位置，请尝试更改x=0（水平位置）和y=0（垂直位置）。正 x 向右，正 y 向上。您还可以通过更改'black'为其他颜色名称来更改颜色，例如'orange'.

play.new_image()

character = play.new_image(image='character.png', x=0, y=0, angle=0, size=100, transparency=100)

这会将图像放置在屏幕中间。确保您的项目文件中有一个名为character.png的文件，以使上述代码能够正常工作。

play.new_text()

greeting = play.new_text(words='hi :)', x=0, y=0, angle=0, font=None, font_size=50, color='black', transparency=100)

这将在屏幕上放置一些文本。

如果你想改变字体，你Arial.ttf的项目文件中需要一个字体文件（通常命名为 ）。然后您可以更改font=None为font='Arial.ttf'.

play.new_circle()

ball = play.new_circle(color='black', x=0, y=0, radius=100, border_color="light blue", border_width=0, transparency=100)

这将在屏幕中间放置一个黑色圆圈。

play.new_line()

line = play.new_line(color='black', x=0, y=0, length=100, angle=0, thickness=1, x1=None, y1=None)

这将在屏幕上创建一条细线。

play.set_backdrop()

play.set_backdrop()您可以使用以下命令更改背景颜色：

play.set_backdrop('light blue')

有很多命名颜色可供选择。此外，如果您想通过 RGB（红绿蓝）值设置颜色，您可以这样做：

# Sets the background to white. Each number can go from 0 to 255
play.set_backdrop( (255, 255, 255) )

你可以在 Python Play 中设置颜色的任何地方，你可以使用命名颜色'red'或上面的 RGB 值，(255, 255, 255)甚至 RGBA 值(0, 0, 0, 127)（第四个数字是从 0 到 255 的透明度）。您可以使用 获取当前背景颜色play.backdrop。

动画和控制命令

@play.repeat_forever

要让事情四处移动，您可以从使用 开始@play.repeat_forever，如下所示：

cat = play.new_text('=^.^=')

@play.repeat_forever
def do():

    cat.turn(10)

上面的代码将使猫永远转身。Sprite 有其他命令，您可以在下一节称为 Sprite 命令中看到。

@play.when_program_starts

要让一些代码在项目开始时运行，请使用@play.when_program_starts，如下所示：

cat = play.new_text('=^.^=')

@play.when_program_starts
def do():

    cat.turn(180)

这将使猫在程序启动时立即倒转。

await play.timer(seconds=1)

要在等待一段时间后运行代码，可以使用如下await play.timer()命令：

cat = play.new_text('=^.^=')

@play.when_program_starts
async def do():

    cat.turn(180)  
    await play.timer(seconds=2)
    cat.turn(180)

这将使程序启动时猫立即倒转，等待 2 秒，然后再次转回。

play.repeat()和await play.animate()

要平滑地为角色设置一定次数的动画，您可以使用play.repeat()with await play.animate()，如下所示：

cat = play.new_text('=^.^=')

@play.when_program_starts
async def do():
    for count in play.repeat(180):
        cat.turn(1)
        await play.animate()

当程序启动时，这段代码将动画猫平稳地倒立。

分解代码：

  • for count in play.repeat(180):运行代码 180 次。
  • cat.turn(1)每次把那只猫转 1 度。
  • await play.animate()使猫动画流畅。如果没有这个命令，猫就会立刻倒过来。

注意：要使用await play.animate()and await play.timer()，这个词async必须包含def在你的函数定义中。

精灵命令

简单的命令

精灵（图像和文本）有一些简单的命令：

  • sprite.move(10)— 将精灵向其面向的方向移动 10 个像素（开始面向右侧）。使用负数 (-10) 向后退。
  • sprite.turn(20)— 将精灵逆时针旋转 20 度。使用负数 (-20) 转向另一个方向。
  • sprite.go_to(other_sprite)—sprite跳转到另一个名为other_sprite' 的精灵在屏幕上的位置。也可用于使精灵跟随鼠标：sprite.go_to(play.mouse).
  • sprite.go_to(x=100, y=50)—sprite跳转到 x=100, y=50（向右和向上一点）。
  • sprite.point_towards(other_sprite)— 转向sprite，因此它指向另一个名为 的精灵other_sprite。
  • sprite.point_towards(x=100, y=50)— 转向sprite使其指向 x=100，y=50（向右并向上一点）。
  • sprite.hide()— 隐藏sprite。隐藏时无法点击。
  • sprite.show()— 显示sprite它是否隐藏。
  • sprite.clone()— 制作 sprite 的副本或克隆并将其返回。
  • sprite.remove()— 从屏幕上永久删除一个精灵。在移除的精灵上调用精灵命令不会做任何事情。
  • sprite.start_physics()— 打开精灵的物理。有关详细信息，请参阅物理命令部分。
  • sprite.stop_physics()— 关闭精灵的物理特性。有关详细信息，请参阅物理命令部分。

特性

精灵也有可以改变的属性来改变精灵的外观。他们来了：

  • sprite.x— 精灵在屏幕上的水平位置。正数在右边，负数在左边。默认值为 0。
  • sprite.y— 精灵在屏幕上的垂直位置。正数上升，负数下降。默认值为 0。
  • sprite.size— 精灵有多大。默认值为 100，但可以更大或更小。
  • sprite.angle— 精灵转动了多少。正数是逆时针的。默认值为 0 度（指向右侧）。
  • sprite.transparency— 精灵的透明程度从 0 到 100。0 是完全透明的，100 是完全不透明的。默认值为 100。
  • sprite.is_hidden—True如果精灵已被sprite.hide()命令隐藏。否则False。
  • sprite.is_shown—True如果精灵没有被sprite.hide()命令隐藏。否则False。
  • sprite.left— 精灵最左侧的 x 位置。
  • sprite.right— 精灵最右侧部分的 x 位置。
  • sprite.top— 精灵最顶部的 y 位置。
  • sprite.bottom— 精灵最底部的 y 位置。
  • sprite.physics- 如果物理已打开，则包含对象的物理属性。默认值为None. 有关详细信息，请参阅物理命令部分。

仅图像精灵属性：

  • sprite.image— 显示的图像的文件名。如果None最初提供，将显示空白图像。

纯文本精灵属性：

  • text.words— 显示的文本内容。默认值为'hi :)'.
  • text.font— 字体的文件名，例如“Arial.ttf”。默认值为None，它将使用内置字体。
  • text.font_size— 文本的大小。默认值为50(pt)。
  • text.color— 文本的颜色。默认为黑色。

Box-sprite-only 属性：

  • box.color— 填充框的颜色。默认值为black.
  • box.width— 盒子的宽度。默认为100像素。
  • box.height— 盒子的高度。默认为200像素。
  • box.border_width— 框边框的宽度，它周围的线。默认值为0.
  • box.border_color— 框边框的颜色。默认值为'light blue'.

如果框有边框，则框的总宽度（包括边框）将是该width属性定义的宽度。

仅限圆形精灵的属性：

  • circle.color— 填充圆圈的颜色。默认值为black.
  • circle.radius— 圆圈有多大，从中间到外面测量。默认为100像素，形成一个 200 像素宽的圆圈。
  • circle.border_width— 圆圈边界的宽度，围绕它的线。默认值为0.
  • circle.border_color— 圆圈边框的颜色。默认值为'light blue'.

如果圆有边框，则圆的总宽度（包括边框）将是该radius属性定义的宽度。

Line-sprite-only 属性：

  • line.color— 线条的颜色。默认值为black.
  • line.length— 线路有多长。默认为100（像素）。
  • line.angle— 线指向的角度。默认为0（度）。
  • line.x1—x线的终点坐标。
  • line.y1—y线的终点坐标。

对于线条，x和y坐标是线条的起点。您可以设置lengthandangle或x1andy1属性来更改线指向的位置。如果您更新一个，其他的将自动更新。

这些属性可以更改为与上面的 sprite 命令执行相同的操作。例如，

sprite.go_to(other_sprite)

# the line above is the same as the two lines below

sprite.x = other_sprite.x
sprite.y = other_sprite.y

您可以更改属性以动画精灵。下面的代码使猫转身。

cat = play.new_text('=^.^=')

@play.repeat_forever
def do():
    cat.angle += 1
    # the line above is the same as cat.turn(1)

其他信息

Sprites 还有一些其他有用的信息：

  • sprite.width— 获取精灵的宽度（以像素为单位）。
  • sprite.height— 获取精灵的高度（以像素为单位）。
  • sprite.distance_to(other_sprite)— 获取到 的距离（以像素为单位）other_sprite。
  • sprite.distance_to(x=100, y=100)— 获取到点 x=100, y=100 的距离。
  • sprite.is_clicked—True如果精灵刚刚被点击，否则False。
  • sprite.is_touching(other_sprite)sprite— 如果正在触摸 ，则返回 True other_sprite。否则False。
  • sprite.is_touching(point)— 如果精灵正在接触点（任何带有x和y坐标的东西），则返回 True。例如：sprite.is_touching(play.mouse)

鼠标命令

在 Python Play 中使用鼠标很容易。这是一个将精灵指向鼠标的简单程序：

arrow = play.new_text('-->', font_size=100)

@play.repeat_forever
def do():
    arrow.point_towards(play.mouse)

play.mouse具有以下属性：

  • play.mouse.x— 鼠标的水平 x 位置。
  • play.mouse.y— 鼠标的垂直 y 位置。
  • play.mouse.is_clicked—True如果鼠标被按下，或者False没有被按下。
  • play.mouse.is_touching(sprite)—True如果鼠标正在触摸精灵，则返回，否则返回False。

@sprite.when_clicked

检测点击的最简单方法可能是使用@sprite.when_clicked.

在下面的程序中，当面部被点击时，它会改变 1 秒钟然后恢复正常：

face = play.new_text('^.^', font_size=100)

@face.when_clicked
async def do():
    face.words = '*o*'
    await play.timer(seconds=1)
    face.words = '^.^'

@play.when_sprite_clicked()

如果您想在单击多个精灵时运行相同的代码，您可以使用@play.when_sprite_clicked()：

face1 = play.new_text('^.^', x=-100, font_size=100)
face2 = play.new_text('^_^', x=100, font_size=100)

@play.when_sprite_clicked(face1, face2) # takes as many sprites as you want
async def do(sprite):
    starting_words = sprite.words
    sprite.words = '*o*'
    await play.timer(seconds=1)
    sprite.words = starting_words

在上述程序中，单击face1或face2将分别运行每个精灵的代码。请注意，该函数是使用参数定义的，例如def do(sprite):，而不是仅def do():.

@play.mouse.when_clicked或者@play.when_mouse_clicked

要在鼠标在任何地方单击时运行代码，请使用@play.mouse.when_clicked或@play.when_mouse_clicked（它们执行相同的操作）。

在下面的代码中，当检测到点击时，文本将移动到点击位置并显示坐标：

text = play.new_text('0, 0')

@play.mouse.when_clicked
def do():
    text.words = f'{play.mouse.x}, {play.mouse.y}'
    text.go_to(play.mouse)

@play.mouse.when_click_released或者@play.when_click_released

要在释放鼠标按钮时运行代码，请使用@play.mouse.when_click_released @play.when_click_released（它们执行相同的操作）。

在下面的代码中，当猫被鼠标点击时，它可以被拖动：

cat = play.new_text('=^.^= drag me!')
cat.is_being_dragged = False

@cat.when_clicked
def do():
    cat.is_being_dragged = True

@play.mouse.when_click_released
def do():
    cat.is_being_dragged = False

@play.repeat_forever
def do():
    if cat.is_being_dragged:
        cat.go_to(play.mouse)

键盘命令

play.key_is_pressed()

您可以使用play.key_is_pressed()来检测按键。

在下面的代码中，按arrow或 键w/a/s/d将使猫朝所需的方向移动。

cat = play.new_text('=^.^=')

@play.repeat_forever
def do():
    if play.key_is_pressed('up', 'w'):
        cat.y += 15
    if play.key_is_pressed('down', 's'):
        cat.y -= 15

    if play.key_is_pressed('right', 'd'):
        cat.x += 15
    if play.key_is_pressed('left', 'a'):
        cat.x -= 15

@play.when_key_pressed()

您可以@play.when_key_pressed()在按下特定键时运行代码。

在下面的代码中，按下space键会改变猫的脸，按下enter键会改变它的脸。

cat = play.new_text('=^.^=')

@play.when_key_pressed('space', 'enter') # if either the space key or enter key are pressed...
def do(key):
    if key == 'enter':
        cat.words = '=-.-='
    if key == 'space':
        cat.words = '=*_*='

@play.when_any_key_pressed

如果您只想检测何时按下任何键，您可以使用@play.when_any_key_pressed.

在下面的代码中，您按下的任何键都将显示在屏幕上：

text = play.new_text('')

@play.when_any_key_pressed
def do(key):
    text.words = f'{key} pressed!'

@play.when_key_released()

完全一样@play.when_key_pressed()，但在释放特定键时运行代码。

up在下面的代码中，只有按下箭头时，文本才会出现在屏幕上。

text = play.new_text('')

@play.when_key_released('up')
async def do(key):
    text.words = 'up arrow released!'
    await play.timer(seconds=1)
    text.words = ''

@play.when_any_key_released

完全一样@play.when_any_key_pressed，但在释放任何键时运行代码。

在下面的代码中，最近释放的键的名称将显示在屏幕上。

text = play.new_text('')

@play.when_any_key_pressed
def do(key):
    text.words = f'{key} key released!''

物理命令

Python Play 使用Pymunk物理库将精灵转换为可以相互碰撞、随重力下落等的物理对象。

sprite.start_physics()

要将精灵变成物理对象，请使用以下start_physics()命令：

sprite.start_physics(can_move=True, stable=False, x_speed=0, y_speed=0, obeys_gravity=True, bounciness=1, mass=10, friction=0.1)

这将导致精灵开始受到重力的影响，与其他具有物理特性的精灵发生碰撞等等。

sprite.physics特性

一旦sprite.start_physics()被调用，精灵就会有一个sprite.physics属性。sprite.physics具有以下属性：

  • sprite.physics.can_move— 精灵是否可以在屏幕上移动 ( True) 或卡在原地 ( False)。默认为True.
  • sprite.physics.stable— 精灵是否是一个稳定的物体（不能被敲打的物体）。乒乓球拍是一个稳定的物体（True），但可以敲击的盒子或球不是（False）。默认为False.
  • sprite.physics.x_speed— 精灵水平移动的速度（负数表示精灵向左移动，正数表示精灵向右移动）。默认为0.
  • sprite.physics.y_speed— 精灵垂直移动的速度（负数表示精灵向下移动，正数表示精灵向上移动）。默认为0.
  • sprite.physics.obeys_gravity— 如果精灵受重力影响。默认为True.
  • sprite.physics.bounciness— 精灵的弹性从 0（根本不反弹）到 1（反弹很多）。默认为1.
  • sprite.physics.mass— 精灵有多重。默认为10. 较重的物体会更多地撞击较轻的物体。
  • sprite.physics.friction— 精灵在其他对象上滑动的程度。从 0 开始（像在冰上一样滑动）到大数字（非常粗糙的精灵，根本不会滑动）。默认为0.1.

更改这些属性中的任何一个都会立即改变精灵作为物理对象的方式。如果您不完全理解它们，请尝试使用所有这些属性。

sprite.physics还有两个可能有用的命令：

  • sprite.physics.pause()— 暂时停止精灵成为物理对象。精灵的速度和其他物理属性将被保存，直到unpause()使用该命令。
  • sprite.physics.unpause()— 在已暂停的精灵上恢复物理。它将继续使用之前physics.pause()调用的精确速度和物理设置。

调用sprite.stop_physics()将立即停止精灵移动和碰撞，sprite.physics并将设置为None.

sprite.stop_physics()

要让精灵停止四处移动和碰撞，您可以调用sprite.stop_physics：

sprite.stop_physics()

这将立即停止精灵。

play.set_gravity()

要为start_physics()调用它们的精灵设置多少重力，请使用以下play.set_gravity()命令：

play.set_gravity(vertical=-100, horizontal=None)

play.gravity.vertical您可以使用（默认为-100）和play.gravity.horizontal（默认为）访问当前重力0。

其他有用的命令

play.screen

获取有关屏幕信息的方式。play.screen具有以下属性：

  • play.screen.width- 默认为 800（总像素）。改变它会改变屏幕的大小。
  • play.screen.height- 默认为 600（总像素）。改变它会改变屏幕的大小。
  • play.screen.left-x屏幕左边缘的坐标。
  • play.screen.right-x屏幕右边缘的坐标。
  • play.screen.top-y屏幕顶部的坐标。
  • play.screen.bottom-y屏幕底部的坐标。

play.all_sprites

程序中所有精灵（图像、形状、文本）的列表。

play.random_number()

产生随机数的函数。

如果给出两个整数，play.random_number()将返回一个整数：

play.random_number(lowest=0, highest=100)

# example return value: 42

（你也可以play.random_number(0, 100)不用lowestand highest。）

如果给出非整数，则返回非整数：

play.random_number(0, 1.0)
# example return value: 0.84

play.random_number()也包括在内，这意味着play.random_number(0,1)将返回0和1。

play.random_color()

返回随机的 RGB 颜色，包括白色和黑色。

play.random_color()
# example return value: (201, 17, 142)

每个值从 0 到 255 不等。

play.random_position()

返回屏幕上的随机位置。一个位置对象有一个x和y组件。

text = play.text('WOO')
@play.repeat_forever
def do():
    text.go_to(play.random_position())

    # the above is equivalent to:
    position = play.random_position()
    text.x = position.x
    text.y = position.y

play.repeat()

play.repeat()与 Python 的内置range函数相同，只是它从 1 开始。“重复”只是比“范围”更友好、更具描述性的名称。

list(play.repeat(10))
# return value: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

await play.animate()

在循环中使用时，此命令将为发生的任何精灵更改设置动画。

cat = play.new_text('=^.^=')

@play.when_program_starts
async def do():
    for count in play.repeat(360):
        cat.turn(1)
        await play.animate()

await play.animate()await asyncio.sleep(0)除了它对初学者有一个更友好的名称外，其余相同。

所有这些async/await东西是怎么回事？这是蟒蛇吗？

是的，这就是 Python！Python在 Python 3.7 中添加了async和作为特殊关键字。await它是asyncio 模块的一部分。

使用异步函数意味着我们可以使用await play.timer()andawait play.animate()函数，这使得一些代码更简单，并且看起来可以并行运行，新程序员觉得这很直观。

进口 剧

猫 = 玩。新文本（'=^.^=' ）

# 此代码块使用异步，因此它可以使用 'await play.timer()' 函数
@play 。repeat_forever 
async  def  change_bg (): 
    play . set_backdrop ( 'pink' )
    等待 播放。计时器（秒= 1 ）

    玩。set_backdrop ( 'purple' )
    等待 播放。计时器（秒= 1 ）

    play.set_backdrop('light blue')
    等待 播放。计时器（秒= 1 ）

# 这个代码块不需要异步，因为它没有 `await play.timer()` 或 `await play.animate()` 
@play 。repeat_forever 
def  do (): 
    cat . 转（1 ）

玩。启动程序（）

在上面的程序中，即使代码是单线程运行的，背景也会发生变化，猫也会同时转动。

除非您想使用函数async，否则不必编写关键字。await如果您尝试await在非异步函数中使用命令，Python 将向您显示如下错误：

  File "example.py", line 31
    await play.timer(seconds=1)
    ^
SyntaxError: 'await' outside async function

要修复该错误，只需async将def.

如果您不了解这些，通常只包含asyncbefore是安全的def。

为什么要使用 Python Play？

Python Play 旨在成为全新程序员的绝佳起点。该项目的目标是让从未编程过的人在编程的最初几分钟内获得令人信服和成功的体验。我们的目标是让尽可能年轻的观众尽可能地接触到图形编程。

我们发现许多现有的编程语言和图形库给新程序员带来了不必要的困难——难以完成简单的事情、令人困惑的语言、令人困惑的程序流程、无法解释的概念等。我们知道，即使是最初的一次不愉快的经历也会让人们永远远离编程，我们希望尽可能地防止这种结果。

Python Play 的灵感来自麻省理工学院的 Scratch，该项目已将数百万儿童和成人引入编程，并帮助他们创建和分享个人有意义的计算项目。事实上，Python Play 的主要设计师在 Scratch 上工作过一段时间。但是我们发现，对于一些学习者来说，Scratch——它的图形块和丰富多彩的界面——并不像“真正的编程”。对于那些希望使用主流文本编程语言同时消除使用这些语言进行图形编程的困难的学习者，我们制作了 Python Play。

Python Play 的设计考虑了以下原则：

  • 没有样板——每一行代码都应该做一些有意义和可以理解的事情。我们希望限制学习者需要问“为什么我们必须包含这行代码？”的次数。

  • 命令应尽可能具有即时的视觉效果。例如，如果程序员键入new_image命令，精灵应该立即出现在屏幕上。他们不需要理解初始化精灵和绘制精灵之间的无形区别。

  • 代码行应该很容易复制和粘贴。

  • 命令值应具有描述性标签，使值的含义尽可能清晰。而不是play.new_image('character.png', 50, 100), play.new_image(image='character.png', x=50, y=100)。

  • 尽可能使用简单的英语。对于数学概念，尝试使用程序员可能在数学课上看到的语言。尝试使用更容易让年轻人打字和拼写的短名称。使错误尽可能清晰和有建设性。许多命令和名称都是从 Scratch 借来的，Scratch 的设计师花了几十年的时间与孩子们一起工作，并观察什么语言对他们来说是有意义的。

Python Play 在设计时还考虑到了一个定制的 Repl.it IDE（即将推出），它显着降低了编程的可用性问题（安装语言、使用文本编辑器、使用终端、运行程序、显示哪些命令可用， ETC）。

虽然 Python 和 Python Play 的学习曲线对于新程序员来说仍然很不理想，但我们仍然认为 Python Play 为新程序员开始使用图形编程提供了一种很好的方式。

<3

项目详情

项目链接

统计数据