Pygame第11课——实现经典打方块小游戏

于 2025-08-19 13:41:49 发布
阅读量476 收藏 2
点赞数 16
CC 4.0 BY-SA版权
分类专栏： Pygame基础专栏 文章标签： python pygame 开发语言 pygame打方块 打方块小游戏 打方块
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42636075/article/details/150522808

在这里插入图片描述

目录

专栏导读

  • 🌸 欢迎来到Python办公自动化专栏—Python处理办公问题，解放您的双手

  • 🏳️‍🌈 博客主页：请点击——> 一晌小贪欢的博客主页求关注

  • 👍 该系列文章专栏：请点击——>Python办公自动化专栏求订阅

  • 🕷 此外还有爬虫专栏：请点击——>Python爬虫基础专栏求订阅

  • 📕 此外还有python基础专栏：请点击——>Python基础学习专栏求订阅

  • 文章作者技术和水平有限，如果文中出现错误，希望大家能指正🙏

  • ❤️ 欢迎各位佬关注！ ❤️

前言

  • 在这个项目中，我将带你从头开始实现一个经典的打方块（Breakout）小游戏。这个游戏不仅能让你体验到编程的乐趣，还能学到游戏开发的核心概念。

🎮 游戏预览

这是一个基于 pygame 的经典打方块游戏，包含：
  • 彩色方块阵列（6行10列，每行不同颜色）
  • 可控制的挡板（左右方向键）
  • 物理反弹的小球
  • 分数系统和生命值
  • Game Over 与重新开始机制
  • 通关后自动进入下一关并提升难度

🏗️ 项目架构

为了让代码结构清晰、易于维护，我将项目分为三个核心模块： 
打方块小游戏/
├── config.py      # 游戏配置与常量
├── entities.py    # 游戏实体类（挡板、小球、方块）
├── main.py        # 主游戏循环与逻辑
└── requirements.txt # 依赖管理

模块职责分工

  1. config.py - 集中管理所有配置参数
  2. entities.py - 定义游戏中的各种对象
  3. main.py - 处理游戏循环、事件、碰撞检测

🔧 技术实现详解

1. 配置管理 (config.py)

将所有游戏参数集中在配置文件中，便于调试和平衡性调整： 
# 窗口设置
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600
FPS = 60

# 挡板设置
PADDLE_WIDTH = 100
PADDLE_HEIGHT = 15
PADDLE_SPEED = 8

# 小球设置
BALL_RADIUS = 10
BALL_SPEED_X = 3
BALL_SPEED_Y = -3

# 方块阵列设置
BRICK_ROWS = 6
BRICK_COLS = 10
BRICK_COLORS = [RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE]

这种设计的好处是：

  • 易于调试：快速修改游戏参数无需深入代码
  • 平衡性调整：轻松测试不同的难度设置
  • 可维护性：避免魔法数字散布在代码各处

2. 游戏实体设计 (entities.py)

挡板类 (Paddle)

类实现了玩家控制的挡板：

class Paddle:
    def __init__(self):
        # 挡板初始位置：水平居中，距离底部40像素
        self.rect = Rect((WINDOW_WIDTH - PADDLE_WIDTH) // 2,
                         WINDOW_HEIGHT - 40,
                         PADDLE_WIDTH, PADDLE_HEIGHT)
    
    def move(self, dx):
        # 边界检测，确保挡板不会移出屏幕
        self.rect.x += dx * self.speed
        self.rect.x = max(0, min(self.rect.x, WINDOW_WIDTH - self.rect.width))

设计亮点：

  • 使用 pygame.Rect 简化碰撞检测
  • 内置边界检测防止挡板移出屏幕
  • 支持变速移动（通过 self.speed 调节）
小球类 (Ball)

类是游戏的核心，实现了物理运动和墙壁碰撞：

def update(self):
    # 更新位置
    self.rect.x += self.vx
    self.rect.y += self.vy
    
    # 墙壁碰撞检测
    if self.rect.left <= 0 or self.rect.right >= WINDOW_WIDTH:
        self.vx *= -1  # 水平反弹
    if self.rect.top <= 0:
        self.vy *= -1  # 垂直反弹

物理模拟要点：

  • 简单的欧拉积分法更新位置
  • 完美弹性碰撞（速度分量取反）
  • 边界检测确保小球不会穿墙
方块类与关卡生成

类设计简洁，重点在于状态管理：

class Brick:
    def __init__(self, x, y, width=BRICK_WIDTH, height=BRICK_HEIGHT, color=(200, 200, 200)):
        self.rect = Rect(x, y, width, height)
        self.color = color
        self.alive = True  # 核心状态：是否还存在

函数负责生成整齐排列的方块阵列：

def create_bricks():
    bricks = []
    total_width = BRICK_COLS * BRICK_WIDTH + (BRICK_COLS - 1) * BRICK_PADDING
    start_x = (WINDOW_WIDTH - total_width) // 2  # 水平居中
    
    for row in range(BRICK_ROWS):
        color = BRICK_COLORS[row % len(BRICK_COLORS)]  # 每行不同颜色
        for col in range(BRICK_COLS):
            x = start_x + col * (BRICK_WIDTH + BRICK_PADDING)
            y = BRICK_TOP_MARGIN + row * (BRICK_HEIGHT + BRICK_PADDING)
            bricks.append(Brick(x, y, BRICK_WIDTH, BRICK_HEIGHT, color))
    return bricks

设计精髓：

  • 自动计算居中位置，适应不同屏幕尺寸
  • 颜色循环分配，创造视觉层次感
  • 规则网格布局，确保间距一致

3. 核心游戏逻辑 (main.py)

挡板-小球碰撞算法

函数实现了智能的挡板反弹：

def check_ball_paddle_collision(ball: Ball, paddle: Paddle):
    if ball.rect.colliderect(paddle.rect):
        if ball.vy > 0:  # 只在向下运动时反弹
            # 根据击中位置调整反弹角度
            offset = (ball.rect.centerx - paddle.rect.centerx) / (paddle.rect.width / 2)
            offset = max(-1, min(1, offset))  # 限制在 [-1, 1] 范围
            
            speed = abs(ball.vx) + abs(ball.vy)  # 保持总速度
            ball.vx = speed * offset
            ball.vy = -abs(ball.vy)
            
            # 防止穿透
            ball.rect.bottom = paddle.rect.top - 1

算法亮点：

  • 角度控制：根据击中位置改变反弹方向，增加策略性
  • 防粘连机制：只在小球向下时才反弹，避免卡住
  • 速度保持：维持总速度不变，确保游戏节奏
  • 穿透修正：强制调整位置防止物理穿透
方块碰撞与方向判断

函数处理复杂的方块碰撞：

def check_ball_bricks_collision(ball: Ball, bricks):
    score_gain = 0
    for brick in bricks:
        if brick.alive and ball.rect.colliderect(brick.rect):
            brick.alive = False
            score_gain += SCORE_PER_BRICK
            
            # 智能碰撞方向判断
            dx_left = ball.rect.right - brick.rect.left
            dx_right = brick.rect.right - ball.rect.left
            dy_top = ball.rect.bottom - brick.rect.top
            dy_bottom = brick.rect.bottom - ball.rect.top
            
            min_dx = min(dx_left, dx_right)
            min_dy = min(dy_top, dy_bottom)
            
            if min_dx < min_dy:
                ball.vx *= -1  # 水平反弹
            else:
                ball.vy *= -1  # 垂直反弹
            break
    return score_gain

碰撞方向算法解析：

  1. 计算小球与方块各边的重叠距离
  2. 比较水平和垂直方向的最小重叠
  3. 选择重叠更小的方向进行反弹
  4. 这样确保了物理上合理的反弹效果
主游戏循环架构

函数采用经典的游戏循环结构：

def main():
    # 初始化
    pygame.init()
    screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
    clock = pygame.time.Clock()
    
    # 游戏对象
    paddle = Paddle()
    ball = Ball()
    bricks = create_bricks()
    
    while running:
        clock.tick(FPS)  # 控制帧率
        
        # 1. 处理输入
        for event in pygame.event.get():
            # 事件处理...
        
        # 2. 更新游戏状态
        ball.update()
        check_ball_paddle_collision(ball, paddle)
        score += check_ball_bricks_collision(ball, bricks)
        
        # 3. 渲染画面
        screen.fill(BLACK)
        paddle.draw(screen)
        ball.draw(screen)
        # ...
        
        pygame.display.flip()

游戏循环最佳实践：

  • 固定时间步长：使用 clock.tick(FPS) 确保稳定帧率
  • 清晰的阶段划分：输入→更新→渲染，逻辑清晰
  • 状态管理：生命值、分数、游戏状态统一管理

🎯 核心特性实现

1. 生命系统与游戏重置

if ball.rect.top > WINDOW_HEIGHT:
    lives -= 1
    if lives <= 0:
        # 游戏结束逻辑
        draw_text(screen, "Game Over - 按回车重新开始", 36, WHITE, ...)
        # 等待重新开始
        while wait_restart:
            # 事件监听...
        # 重置所有游戏状态
        paddle = Paddle()
        ball = Ball()
        bricks = create_bricks()
        score = 0
        lives = LIVES
    else:
        ball.reset()  # 重置小球位置

2. 难度递增机制

# 通关检测
if all(not b.alive for b in bricks):
    bricks = create_bricks()  # 重新生成方块
    # 提升难度
    ball.vx *= 1.1
    ball.vy *= 1.1

简单而有效的难度提升：每通过一关，小球速度增加10%。

3. 用户界面与反馈

def draw_text(surface, text, size, color, center):
    font = pygame.font.SysFont(None, size)
    img = font.render(text, True, color)
    rect = img.get_rect(center=center)
    surface.blit(img, rect)

# HUD 显示
draw_text(screen, f"Score: {score}", 28, WHITE, (80, 20))
draw_text(screen, f"Lives: {lives}", 28, WHITE, (WINDOW_WIDTH - 80, 20))

🚀 运行与安装

环境要求

  • Python 3.7+
  • pygame-ce（兼容新版本Python的pygame社区版）

快速开始

# 3. 安装依赖
pip install -r requirements.txt

# 4. 运行游戏
python main.py

操作说明

  • 左右方向键：移动挡板
  • ESC：退出游戏
  • Enter：游戏结束后重新开始

完整代码

  • config.py 

# 游戏配置文件
import pygame

# 窗口设置
WINDOW_WIDTH = 800
WINDOW_HEIGHT = 600
FPS = 60

# 颜色定义 (RGB)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 0, 0)
GREEN = (0, 255, 0)
BLUE = (0, 0, 255)
YELLOW = (255, 255, 0)
ORANGE = (255, 165, 0)
PURPLE = (128, 0, 128)
CYAN = (0, 255, 255)
PINK = (255, 192, 203)
GRAY = (128, 128, 128)

# 挡板设置
PADDLE_WIDTH = 100
PADDLE_HEIGHT = 15
PADDLE_SPEED = 8
PADDLE_COLOR = WHITE

# 小球设置
BALL_RADIUS = 10
BALL_SPEED_X = 3
BALL_SPEED_Y = -3
BALL_COLOR = WHITE

# 方块设置
BRICK_WIDTH = 75
BRICK_HEIGHT = 30
BRICK_PADDING = 5
BRICK_ROWS = 6
BRICK_COLS = 10
BRICK_TOP_MARGIN = 80

# 方块颜色 (每行不同颜色)
BRICK_COLORS = [RED, ORANGE, YELLOW, GREEN, BLUE, PURPLE]

# 游戏设置
LIVES = 3
SCORE_PER_BRICK = 10

  • entities.py 

import pygame
from pygame import Rect
from config import (
    WINDOW_WIDTH, WINDOW_HEIGHT,
    PADDLE_WIDTH, PADDLE_HEIGHT, PADDLE_SPEED, PADDLE_COLOR,
    BALL_RADIUS, BALL_SPEED_X, BALL_SPEED_Y, BALL_COLOR,
    BRICK_WIDTH, BRICK_HEIGHT, BRICK_PADDING, BRICK_ROWS, BRICK_COLS, BRICK_TOP_MARGIN, BRICK_COLORS
)

class Paddle:
    def __init__(self):
        self.rect = Rect((WINDOW_WIDTH - PADDLE_WIDTH) // 2,
                         WINDOW_HEIGHT - 40,
                         PADDLE_WIDTH, PADDLE_HEIGHT)
        self.speed = PADDLE_SPEED
        self.color = PADDLE_COLOR

    def move(self, dx):
        self.rect.x += dx * self.speed
        self.rect.x = max(0, min(self.rect.x, WINDOW_WIDTH - self.rect.width))

    def draw(self, surface):
        pygame.draw.rect(surface, self.color, self.rect)

class Ball:
    def __init__(self):
        self.radius = BALL_RADIUS
        self.color = BALL_COLOR
        self.reset()

    def reset(self):
        self.rect = Rect(WINDOW_WIDTH // 2 - self.radius,
                         WINDOW_HEIGHT // 2 - self.radius,
                         self.radius * 2, self.radius * 2)
        self.vx = BALL_SPEED_X
        self.vy = BALL_SPEED_Y

    def update(self):
        self.rect.x += self.vx
        self.rect.y += self.vy

        # 碰撞墙壁
        if self.rect.left <= 0 or self.rect.right >= WINDOW_WIDTH:
            self.vx *= -1
        if self.rect.top <= 0:
            self.vy *= -1

    def draw(self, surface):
        pygame.draw.ellipse(surface, self.color, self.rect)

class Brick:
    def __init__(self, x, y, width=BRICK_WIDTH, height=BRICK_HEIGHT, color=(200, 200, 200)):
        self.rect = Rect(x, y, width, height)
        self.color = color
        self.alive = True

    def draw(self, surface):
        if self.alive:
            pygame.draw.rect(surface, self.color, self.rect)
            # 描边
            pygame.draw.rect(surface, (50, 50, 50), self.rect, 2)


def create_bricks():
    bricks = []
    total_width = BRICK_COLS * BRICK_WIDTH + (BRICK_COLS - 1) * BRICK_PADDING
    start_x = (WINDOW_WIDTH - total_width) // 2

    for row in range(BRICK_ROWS):
        color = BRICK_COLORS[row % len(BRICK_COLORS)]
        for col in range(BRICK_COLS):
            x = start_x + col * (BRICK_WIDTH + BRICK_PADDING)
            y = BRICK_TOP_MARGIN + row * (BRICK_HEIGHT + BRICK_PADDING)
            bricks.append(Brick(x, y, BRICK_WIDTH, BRICK_HEIGHT, color))
    return bricks

  • main.py 

import sys
import pygame
from pygame.locals import QUIT, KEYDOWN, K_LEFT, K_RIGHT

from config import (
    WINDOW_WIDTH, WINDOW_HEIGHT, FPS,
    BLACK, WHITE, RED,
    LIVES, SCORE_PER_BRICK
)
from entities import Paddle, Ball, create_bricks


def check_ball_paddle_collision(ball: Ball, paddle: Paddle):
    if ball.rect.colliderect(paddle.rect):
        # 只在小球向下运动时反弹，避免粘连
        if ball.vy > 0:
            offset = (ball.rect.centerx - paddle.rect.centerx) / (paddle.rect.width / 2)
            offset = max(-1, min(1, offset))
            speed = abs(ball.vx) + abs(ball.vy)
            ball.vx = speed * offset
            ball.vy = -abs(ball.vy)
            # 调整位置避免穿透
            ball.rect.bottom = paddle.rect.top - 1


def check_ball_bricks_collision(ball: Ball, bricks):
    score_gain = 0
    for brick in bricks:
        if brick.alive and ball.rect.colliderect(brick.rect):
            brick.alive = False
            score_gain += SCORE_PER_BRICK

            # 碰撞方向判断
            dx_left = ball.rect.right - brick.rect.left
            dx_right = brick.rect.right - ball.rect.left
            dy_top = ball.rect.bottom - brick.rect.top
            dy_bottom = brick.rect.bottom - ball.rect.top
            min_dx = min(dx_left, dx_right)
            min_dy = min(dy_top, dy_bottom)
            if min_dx < min_dy:
                ball.vx *= -1
            else:
                ball.vy *= -1
            break
    return score_gain


def draw_text(surface, text, size, color, center):
    font = pygame.font.SysFont(None, size)
    img = font.render(text, True, color)
    rect = img.get_rect(center=center)
    surface.blit(img, rect)


def main():
    pygame.init()
    screen = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT))
    pygame.display.set_caption("打方块小游戏")
    clock = pygame.time.Clock()

    paddle = Paddle()
    ball = Ball()
    bricks = create_bricks()

    score = 0
    lives = LIVES
    running = True

    while running:
        clock.tick(FPS)
        # 事件处理
        for event in pygame.event.get():
            if event.type == QUIT:
                running = False
            elif event.type == KEYDOWN and event.key == pygame.K_ESCAPE:
                running = False

        # 键盘连续输入
        keys = pygame.key.get_pressed()
        dx = (keys[K_RIGHT] - keys[K_LEFT])
        if dx != 0:
            paddle.move(dx)

        # 更新小球
        ball.update()

        # 碰撞检测
        check_ball_paddle_collision(ball, paddle)
        score += check_ball_bricks_collision(ball, bricks)

        # 掉出底部
        if ball.rect.top > WINDOW_HEIGHT:
            lives -= 1
            if lives <= 0:
                # 游戏结束，重置
                draw_text(screen, "Game Over - 按回车重新开始", 36, WHITE, (WINDOW_WIDTH//2, WINDOW_HEIGHT//2))
                pygame.display.flip()
                wait_restart = True
                while wait_restart:
                    for event in pygame.event.get():
                        if event.type == QUIT:
                            pygame.quit()
                            sys.exit()
                        elif event.type == KEYDOWN and event.key == pygame.K_RETURN:
                            wait_restart = False
                # 重置游戏
                paddle = Paddle()
                ball = Ball()
                bricks = create_bricks()
                score = 0
                lives = LIVES
            else:
                ball.reset()

        # 全部方块清空，进入下一关（简单处理：重新生成方块，速度稍增）
        if all(not b.alive for b in bricks):
            bricks = create_bricks()
            # 提升难度
            ball.vx *= 1.1
            ball.vy *= 1.1

        # 绘制
        screen.fill(BLACK)
        paddle.draw(screen)
        ball.draw(screen)
        for brick in bricks:
            brick.draw(screen)

        # HUD
        draw_text(screen, f"Score: {score}", 28, WHITE, (80, 20))
        draw_text(screen, f"Lives: {lives}", 28, WHITE, (WINDOW_WIDTH - 80, 20))

        pygame.display.flip()

    pygame.quit()


if __name__ == "__main__":
    main()

🎨 扩展思路

这个基础版本为进一步扩展奠定了良好基础：

游戏性扩展

  • 道具系统：加长挡板、多球、穿透球等
  • 特殊方块：需要多次击打、爆炸方块、移动方块
  • 关卡编辑器：自定义方块布局和颜色

技术优化

  • 粒子效果：方块破碎、小球轨迹特效
  • 音效系统：碰撞音效、背景音乐
  • 存档系统：最高分记录、关卡进度保存

平台适配

  • 移动端适配：触摸控制、屏幕适配
  • Web版本：使用 Pygame Web 或 Panda3D
  • 多人模式：本地或网络对战

📚 学习收获

通过这个项目，你将掌握：

  1. 游戏开发基础：游戏循环、状态管理、碰撞检测
  2. 面向对象设计：类的设计与交互、模块化编程
  3. 物理模拟：简单的运动学、弹性碰撞
  4. 用户交互：键盘输入处理、实时反馈
  5. 项目结构：配置管理、代码组织、依赖管理

🏆 结语

这个打方块游戏虽然简单，但包含了游戏开发的核心要素。从配置管理到物理模拟，从碰撞检测到用户界面，每一个部分都值得深入研究。
更重要的是，这个项目展示了如何用清晰的架构和合理的设计模式来构建一个完整的应用程序。无论你是游戏开发新手还是想要回顾经典，这个项目都能给你带来启发。
现在就开始游戏，看看你能坚持多少关吧！🎮

  • 希望对初学者有帮助；致力于办公自动化的小小程序员一枚

  • 希望能得到大家的【❤️一个免费关注❤️】感谢！

  • 求个 🤞 关注 🤞 +❤️ 喜欢 ❤️ +👍 收藏 👍

  • 此外还有办公自动化专栏，欢迎大家订阅：Python办公自动化专栏

  • 此外还有爬虫专栏，欢迎大家订阅：Python爬虫基础专栏

  • 此外还有Python基础专栏，欢迎大家订阅：Python基础学习专栏

基于pygame的小游戏开发
qq_42862946的博客
07-05 1万+
** “大龟吃小鱼”小游戏开发 ** 摘要 “大龟吃小鱼”游戏是基于python语言的pygame模块，尝试模拟实现网络小游戏“大鱼吃小鱼”的运行效果而进行的实践性单机小游戏项目。旨在对本段时间里的python学习效果进行考查与检验。本项目完全由本人对python基础知识以及pygame模块基础知识学习后独立完成开发。该小游戏项目模拟实现了添加背景音乐、对事件添加音效，游戏暂停、开始，随机生成游动小鱼，乌龟位置随光标移动，乌龟面向移动的方向，鲨鱼吃乌龟和其他鱼类，乌龟吃较小鱼、被较大鱼吃等功能。 1 引言
【pygame游戏开发】这几个经典游戏，勾起了少年的快乐
轻松学python的博客
02-25 2万+
给大家分享几个好玩有趣的小游戏，既提升了学习的兴趣，又提升了学习效率，告别枯燥的学习。 一、飞机大战 1、源码部分 模块导入 import sys import cfg import pygame from modules import * 游戏界面 def GamingInterface(num_player, screen): # 初始化 pygame.mixer.music.load(cfg.SOUNDPATHS['Cool Space Music']) pygame.mi
python小游戏——俄罗斯方块
m0_50162049的博客
11-26 1万+
python小游戏，pygame库俄罗斯方块完整代码及详细介绍。
30个Python小游戏，上班摸鱼我能玩一天【内附源码】
热门推荐
五包辣条的博客
09-19 30万+
一、接金币（1分） 普通难度：❤ 玩法介绍：吃金币，控制左右键，有手就行。 源码分享 import os import cfg import sys import pygame import random from modules import * '''游戏初始化''' def initGame(): # 初始化pygame, 设置展示窗口 pygame.init() screen = pygame.display.set_mode(cfg.SCREE...
用PyGame实现贪吃蛇游戏
Ruins_LEE的博客
04-18 2693
使用PyGame实现了贪吃蛇小游戏。 本文包含的内容包括（1）前期准备工作；（2）游戏开发；（3）游戏打包三部分内容。 最后，提供了小游戏的源码、使用到的图片和音乐。
14个py小游戏第三弹
m0_69043821的博客
04-25 1879
8俄罗斯方块 玩法:童年经典 应该都会玩 在这里就不多介绍了 源代码分享: import os import sys import random from modules import * from PyQt5.QtGui import * from PyQt5.QtCore import * from PyQt5.QtWidgets import * '''定义俄罗斯方块游戏类''' class TetrisGame(QMainWindow): def __init__
30个Python小游戏，学Python每天一练必成大神
2301_78095812的博客
04-14 1893
玩法详解：小时候很爱玩，先出是有必胜方法的，后面才知道会有禁手这个规则，就比较复杂了，大家可以学一下先出必胜的开局，有浦月、流星、丘月、游星、慧星等等。学习资料：含Python、爬虫、数据分析、算法等学习视频和文档，添加获取，大佬指点迷津，你的问题往往有人遇到过，技术互助交流。玩法详解：这是经典中的经典，我喜欢玩双人模式，后面有一些改版的模式，这是我觉得少数几个现在玩都不过时的游戏。攻略大全：以前的那个手机上都有的游戏，越推到后面的关卡越难，我好像是玩到二十多关就玩不下去了。游戏体验：可太难控制了。
基于Python的PyGame的俄罗斯方块游戏设计与实现
12-04 1737
基于Python的PyGame的俄罗斯方块游戏设计与实现
30个Python小游戏，小白练手，我都能玩一天
nnn0245的博客
12-05 6597
30个Python小游戏 ,原来这么简单
上篇丨摸鱼也能摸出月薪3w？我不过是会做这18个小游戏【附源码】
阿星的Python技术分享博客
05-17 1623
游戏源码+玩法详解...💡和阿星一起，合理使用Python，努力做时间的主人🏆如果觉得博主的文章还不错，请点赞👍+收藏⭐️+留言📝支持一下博主哦🤞
＜rtde＞＜UR＞＜python＞windows系统下，使用python安装ur-rtde库的一些问题
用沸腾的热血，支付我们的人生吧！
08-18 751
本文介绍了在Windows 10系统中安装Python库ur-rtde的详细过程。ur-rtde是用于控制UR机器人的实时通讯库，安装前需先配置cmake、boost和pybind11等依赖项。文章详细记录了安装过程中可能遇到的编码错误、依赖缺失等问题，并提供了通过conda创建虚拟环境来简化安装的解决方案。最终通过conda安装依赖后，成功使用pip完成了ur-rtde的安装。
Python循环语句 从入门到精通
weixin_74414860的博客
08-18 531
1.while循环的语法格式2.while循环的注意事项 条件需提供布尔类型结果，True继续，False停止 空格缩进不能忘 请规划好循环终止条件，否则将无限循环1.嵌套循环的语法格式： 见下图2. 嵌套循环需要注意的地方: 注意条件的控制，避免无限循环 多层嵌套，主要空格缩进来确定层次关系3. 嵌套循环的使用难点： 循环条件的控制，层次越多越复杂，需要细心+耐心1. for循环的语法格式是：2. for循环的注意点 无法定义循环条件，只能被动取出数据处理 要注意，循环内的语句，需要有空格缩进。
Python函数:装饰器
最新发布
2403_86719076的博客
08-18 1066
本章介绍了python函数中的装饰器
Scrapy 基础框架搭建教程：从环境配置到爬虫实现（附实例）
weixin_43883508的博客
08-14 1475
本文详细介绍了Scrapy爬虫框架的搭建流程，从环境配置到完整爬虫实现。主要内容包括：1）Python环境准备与Scrapy安装；2）项目结构创建与核心文件功能解析；3）通过图书爬虫实例演示数据提取与页面跳转；4）数据模型定义与JSON存储管道实现；5）关键配置参数与调试技巧。文章提供完整代码示例，帮助开发者30分钟内搭建可扩展的爬虫框架，并给出反爬处理、性能优化等实用建议，适合Python开发者快速上手网页数据采集。
关于Win系统使用venv创建和管理虚拟环境
qq_43449643的博客
08-15 446
venv配置虚拟环境
yolo安装
a1111111111ss的博客
08-15 662
我在cmd一直更新不了pip 一直说错误。我扭头去anaconda成功。
Docker镜像构建常见坑点及解决方案
鹏哥的博客
08-18 243
本文分析了Docker容器化部署中的三个典型问题：1）CeleryBeat进程重复执行导致任务重复，建议统一通过Docker管理服务；2）Docker守护进程连接失败问题，需检查并重启Docker服务；3）Dockerfile启动命令中的语法错误，需修正命令连接符使用。针对这些问题，文章提供了具体解决方案，并提出了统一服务管理、定期检查进程、语法验证等预防措施，帮助开发者提高Docker使用的稳定性和可靠性。
探究云服务器所适配的各类安装环境
now_cn的博客
08-18 632
摘要： 云服务器作为数字化转型的核心基础设施，其环境搭建需系统规划五大关键模块：1）操作系统选型（CentOS/Ubuntu/Windows Server）；2）Web服务引擎配置（Apache/Nginx/Tomcat）；3）数据库部署（MySQL/PostgreSQL/SQL Server）；4）开发环境定制（Java/Python/PHP运行时优化）；5）安全防护体系。不同业务场景需针对性选择技术组合，如高并发优选Nginx，金融系统适用PostgreSQL。建议通过测试环境验证后再实施生产部署
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小庄-Python办公

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值