pygame小游戏

news2025/1/12 12:28:42

         代码存在一些bug，感兴趣可自行修改，游戏运行后玩法与吃金币游戏类似。（代码及结果比较粗糙，仅供参考）

注：（图片、音乐、音效文件老是上传上传不上，想要可私，也可以自己找【自己找喜欢的图和音乐就行】）

1.运行效果图：

开始界面：

游戏中： 

 游戏结束：

 2.完整代码：

import os.path
import pickle
import random
import time

import pygame

WIDTH, HEIGHT = 800, 600
FOOD_BORN = pygame.USEREVENT + 3000
PROTECT_BORN = pygame.USEREVENT + 100
BOMB_BORN = pygame.USEREVENT + 1200
TOTAL_TIME = 60

n = 1


# 背景音乐
class AudioManage:
    @staticmethod
    def play_bg_music():
        pygame.mixer.music.load("./tu/1/bjm/ayd.mp3")
        pygame.mixer.music.set_volume(0.2)
        pygame.mixer.music.play(-1)

    # 音效
    @staticmethod
    def play_sound(name):
        sound = pygame.mixer.Sound(name)
        sound.play()


# 引入精灵父类  所有子类都有image(外观)和rect(位置)
class BaseSprite(pygame.sprite.Sprite):
    def __init__(self, image_name):
        super().__init__()
        self.image = pygame.image.load(image_name)
        self.rect = self.image.get_rect()


# 炸弹精灵类
class BombSprite(BaseSprite):
    def __init__(self, image_name, start_x, gm, speed=6):
        super().__init__(image_name)
        self.rect.bottom = 0
        self.rect.left = start_x
        self.speed = speed
        self.gm = gm

    # 炸弹移动及消亡
    def update(self):
        self.rect.top += self.speed
        if self.rect.top > HEIGHT:
            self.kill()


# 炸弹管理类
class BombManage:
    def __init__(self, gm):
        self.gm = gm
        self.bomb_group = pygame.sprite.Group()

    # 炸弹生成
    def born(self):
        for center in range(n):
            center = random.randint(0, WIDTH - 100)
            self.bomb = BombSprite("./tu/1/xwz/11.png", center, self.gm)
        self.bomb.add(self.bomb_group)

    # 炸弹清空
    def clear(self):
        self.bomb_group.empty()

    # 更新
    def update(self):
        self.bomb_group.draw(self.gm.screen)
        self.bomb_group.update()


# 食物精灵类
class FoodSprite(BaseSprite):
    def __init__(self, image_name, start_x, gm, speed=6):
        super().__init__(image_name)
        self.rect.bottom = 0
        self.rect.left = start_x
        self.speed = speed
        self.gm = gm

    # 食物移动
    def update(self):
        self.rect.top += self.speed
        if self.rect.top > HEIGHT:
            self.kill()


# 食物管理类
class FoodManage:
    def __init__(self, gm):
        self.gm = gm
        self.food_group = pygame.sprite.Group()

    # 食物随机生成
    def born(self):
        image_name = random.choice(
            ["./tu/1/xwz/2.png", "./tu/1/xwz/3.png", "./tu/1/xwz/4.png"])
        start_x = random.randint(0, WIDTH - 100)
        self.food = FoodSprite(image_name, start_x, self.gm)
        self.food.add(self.food_group)

    # 食物清空
    def clear(self):
        self.food_group.empty()

    # 更新
    def update(self):
        self.food_group.draw(self.gm.screen)
        self.food_group.update()


# 护盾精灵类（保护玩家, 生成保护罩）
class ShieldSprite(BaseSprite):
    def __init__(self, image_name):
        super().__init__(image_name)


# 保护罩精灵类（生成护盾的食物类）
class ProtectSprite(BaseSprite):
    def __init__(self, image_name, gm, start_x, speed=7):
        super().__init__(image_name)
        self.rect.bottom = 0
        self.rect.left = start_x
        self.gm = gm
        self.speed = speed

    # 移动
    def update(self):
        self.rect.top += self.speed
        if self.rect.top > HEIGHT:
            self.kill()


# 保护罩管理类
class ProtectManage:
    def __init__(self, gm):
        self.gm = gm
        self.protect_group = pygame.sprite.Group()

    # 生成可产生护盾的食物
    def born(self):
        start_x = random.randint(0, WIDTH - 100)
        self.protect = ProtectSprite("./tu/1/xwz/5.png", self.gm, start_x)
        self.protect.add(self.protect_group)

    # 清空
    def clear(self):
        self.protect_group.empty()

    # 更新
    def update(self):
        self.protect_group.draw(self.gm.screen)
        self.protect_group.update()


# 玩家精灵类
class PlayerSprite(BaseSprite):
    def __init__(self, player_names, speed=12):
        super().__init__(player_names[0])
        self.rect.center = (WIDTH / 2, HEIGHT - 50)
        self.current_index = 0
        self.images = [pygame.image.load(player_image) for player_image in player_names]
        self.speed = speed
        self.shield = None

    # 玩家移动
    def update(self):
        # gif图片速度控制
        self.current_index += 1
        if self.current_index >= len(self.images) * 5:
            self.current_index = 0
        self.image = self.images[self.current_index // 5]

        key_pressed = pygame.key.get_pressed()
        # 左移
        if key_pressed[pygame.K_LEFT] or key_pressed[pygame.K_a]:
            self.rect.left -= self.speed
            if self.rect.left < 0:
                self.rect.left = 0
        # 右移
        elif key_pressed[pygame.K_RIGHT] or key_pressed[pygame.K_d]:
            self.rect.right += self.speed
            if self.rect.right > WIDTH:
                self.rect.right = WIDTH
        # 上移
        elif key_pressed[pygame.K_UP] or key_pressed[pygame.K_w]:
            self.rect.top -= self.speed
            if self.rect.top < 0:
                self.rect.top = 0
        # 下移
        elif key_pressed[pygame.K_DOWN] or key_pressed[pygame.K_s]:
            self.rect.bottom += self.speed
            if self.rect.bottom > HEIGHT:
                self.rect.bottom = HEIGHT
        # 保护罩跟随玩家移动（更新中心坐标）
        if self.shield:
            self.shield.rect.center = self.rect.center


# 玩家管理类
class PlayerManage:
    def __init__(self, gm):
        self.gm = gm
        self.player_group = pygame.sprite.Group()
        self.shield_group = pygame.sprite.Group()

    # 保护罩
    def create_shield(self):
        # 玩家没有保护罩则生成
        if not self.player.shield:
            # 创建保护罩精灵
            shield = ShieldSprite("./tu/1/xwz/10.png")
            # 保护罩中心与玩家中心重合包裹住玩家
            shield.rect.center = self.player.rect.center
            # 将保护罩精灵添加到保护罩组
            self.shield_group.add(shield)
            # 关联玩家与保护罩精灵
            self.player.shield = shield

    # 玩家有护盾则不再生成
    def clear_shield(self):
        # 玩家有保护罩
        if self.player.shield:
            # 将保护罩精灵移除保护罩精灵族
            self.shield_group.remove(self.player.shield)
            # 保护罩破碎
            self.player.shield.kill()
            self.player.shield = None

    # 清空
    def clear(self):
        self.shield_group.empty()

    # 玩家生成
    def born(self):
        self.player = PlayerSprite([f"./tu/1/gif1/{i}.png" for i in range(1, 10)])
        # self.player = PlayerSprite("./tu/1/xwz/1.png")
        self.player.add(self.player_group)

    # 玩家死亡清空
    def die(self):
        self.player_group.empty()

    # 玩家及保护罩更新
    def update(self):
        # 玩家
        self.player_group.draw(self.gm.screen)
        self.player_group.update()
        # 保护罩
        self.shield_group.draw(self.gm.screen)
        self.shield_group.update()


# 背景精灵类
class BgSprite(BaseSprite):
    def __init__(self, image_name, start_y, speed=5):
        super().__init__(image_name)
        self.rect.top = start_y
        self.speed = speed

    # 背景移动
    def update(self):
        self.rect.top += self.speed
        if self.rect.top >= HEIGHT:
            self.rect.top = -HEIGHT


# GIF图片精灵类
class GIFSprite(BaseSprite):
    def __init__(self, bg_images):
        super().__init__(bg_images[0])
        self.bg_images = [pygame.image.load(bg_image) for bg_image in bg_images]
        self.current_index = 0

    # 图片改变规则，生成动态图
    def update(self):
        self.current_index += 1
        if self.current_index == len(self.bg_images * 25):
            self.current_index = 0
        self.image = self.bg_images[self.current_index // 25]


# 背景管理类
class BgManage:
    def __init__(self, gm):
        self.gm = gm
        # 游戏开始背景图（gif图片）
        self.ready_group = pygame.sprite.Group()
        # self.bg0 = GIFSprite([f"./tu/1/gif/{i}.jpg" for i in range(1, 32)])
        self.bg0 = GIFSprite([f"./tu/1/gif3/{i}.jpg" for i in range(1, 3)])
        self.bg0.add(self.ready_group)

        self.gaming_group = pygame.sprite.Group()
        # 游戏中背景图（滚动）
        # self.bg1 = BgSprite("./tu/1/xwz/3.jpg", 0, 5)
        # self.bg1.add(self.gaming_group)
        # self.bg2 = BgSprite("./tu/1/xwz/4.jpg", -HEIGHT, 5)
        # self.bg2.add(self.gaming_group)
        # gif背景图
        self.bg1 = GIFSprite([f"./tu/1/gif3/{i}.jpg" for i in range(3, 5)])
        self.bg1.add(self.gaming_group)

        # 游戏结束背景图（静态）
        self.end_group = pygame.sprite.Group()
        self.bg3 = BgSprite("./tu/1/xwz/30.jpg", 0, 0)
        self.bg3.add(self.end_group)

        # 背景音乐播放
        AudioManage.play_bg_music()

    # 绘制并更新
    def update(self):
        # 游戏开始准备阶段
        if self.gm.game_state == "ready":
            # 绘制并更新准备阶段元素
            self.ready_group.draw(self.gm.screen)
            self.ready_group.update()

        # 游戏开始阶段
        elif self.gm.game_state == "gaming":
            # 绘制并更新游戏中的游戏元素
            self.gaming_group.draw(self.gm.screen)
            self.gaming_group.update()

        # 游戏结束阶段
        elif self.gm.game_state == "end":
            # 绘制并更新结束阶段游戏元素
            self.end_group.draw(self.gm.screen)
            self.end_group.update()


# UI精灵类
class UISprite(BaseSprite):
    def __init__(self, image_name, center):
        super().__init__(image_name)
        self.rect.center = center

    # 鼠标点击检测
    def is_collide(self):
        # 获取当前鼠标位置
        mouse_pos = pygame.mouse.get_pos()
        # 检测鼠标位置是否与对象的矩形区域发生碰撞
        if self.rect.collidepoint(mouse_pos):
            # 如果发生碰撞 返回True
            return True


# UI管理类
class UIManage:
    def __init__(self, gm):
        self.gm = gm
        # 准备阶段UI元素初始化（游戏开始界面开始按钮图片）
        self.ready_group = pygame.sprite.Group()
        self.start_btn = UISprite("./tu/1/xwz/7.png", (WIDTH / 2, HEIGHT - 50))
        self.start_btn.add(self.ready_group)
        self.title_btn = UISprite("./tu/1/xwz/12.png", (WIDTH / 2, HEIGHT - 500))
        self.title_btn.add(self.ready_group)

        # 分数显示初始化（定义初始值为0、字体、字号、颜色）
        self.score_value = 0
        self.font = pygame.font.Font("./tu/1/字体/2.ttf", size=32)
        self.score_label = self.font.render(f"Score: {self.score_value}", True, "red")

        # 时间显示初始化（定义时间、字体、字号、颜色）
        self.total_time = TOTAL_TIME
        self.timer = self.font.render(f"time:{self.total_time}", True, "gold")

        # 结束阶段UI元素初始化（结束界面重新开始按钮图）
        self.end_group = pygame.sprite.Group()
        self.restart_btn = UISprite("./tu/1/xwz/9.png", (WIDTH / 2, HEIGHT - 100))
        self.restart_btn.add(self.end_group)

        # 初始化最高分
        self.high_score = 0

    # 序列化
    def save_score(self, score):
        """
        保存分数到文件并更新最高分
        score：要保存的分数
        如果给定的分数高于当前记录的最高分数，更新最高分数并保存到文件中。
        """
        if score > self.high_score:
            self.high_score = score
        with open("./princeling.txt", "wb") as f:
            pickle.dump(self.high_score, f)

    # 反序列化
    def load_score(self):
        """
        加载之前保存的最高分数。
        int: 加载的最高分数值，如果文件不存在则返回默认值0。
        如果保存分数的文件存在，从文件中加载并返回最高分数值；否则返回默认值0。
        """
        if os.path.exists("./princeling.txt"):
            with open("./princeling.txt", "rb") as f:
                return pickle.load(f)

    # 增加分数并更新显示
    def add_score(self):
        # 将当前分数增加1并更新显示文本和保存最高分数
        self.score_value += 1
        self.score_label = self.font.render(f"Score: {self.score_value}", True, "gold")
        self.save_score(self.score_value)

    # 减少剩余时间并更新显示
    def reduce_time(self):
        # 如果时间大于0  时间减少1  更新显示文本
        if self.total_time > 0:
            self.total_time -= 1
        self.timer = self.font.render(f"time:{self.total_time}", True, "gold")

    # 重置游戏状态和显示
    def reset_game(self):
        # 将分数重置为0
        self.score_value = 0
        # 将时间重置为指定时间
        self.total_time = TOTAL_TIME
        # 更新显示文本
        self.score_label = self.font.render(f"score:{self.score_value}", True, "gold")
        self.time_label = self.font.render(f"time:{self.total_time}", True, "gold")
        self.gm.player_manage.die()
        self.gm.player_manage.clear()
        self.gm.food_manage.clear()
        self.gm.protec_manage.clear()
        self.gm.bomb_manage.clear()

    # 根据游戏状态更新屏幕内容（更新屏幕显示内容）
    def update(self):
        # 游戏准备阶段
        if self.gm.game_state == "ready":
            # 显示准备界面和开始按钮
            self.ready_group.draw(self.gm.screen)
            self.ready_group.update()

            # 重置总时间
            self.total_time = TOTAL_TIME

            # 在开始按钮图片上显示start
            # 显示字体、字号
            self.font2 = pygame.font.Font("./tu/1/字体/2.ttf", size=40)
            # 显示内容
            self.start = self.font2.render("start", True, "gold")
            # 显示位置、颜色
            self.gm.screen.blit(self.start, (WIDTH / 2 - 50, HEIGHT - 100))

        # 游戏进行阶段
        elif self.gm.game_state == "gaming":
            # 显示游戏进行中的计时器和分数
            self.gm.screen.blit(self.timer, (WIDTH // 2 - 350, 30))
            self.gm.screen.blit(self.score_label, (WIDTH - 150, 30))

        # 游戏结束阶段
        elif self.gm.game_state == "end":
            # 游戏结束时间为0  显示victory
            if self.total_time == 0:
                self.font2 = pygame.font.Font("./tu/1/字体/2.ttf", size=52)
                self.start = self.font2.render("victory", True, "gold")
                self.gm.screen.blit(self.start, (WIDTH / 2 - 100, HEIGHT / 2))
            # 游戏结束时间不为0  显示lose out
            else:
                self.font2 = pygame.font.Font("./tu/1/字体/2.ttf", size=52)
                self.start = self.font2.render("lose out", True, "red")
                self.gm.screen.blit(self.start, (WIDTH / 2 - 100, HEIGHT / 2))

            # 显示最高分
            self.high = self.font.render(f"hight score:{self.high_score}", True, "gold")
            self.gm.screen.blit(self.high, (WIDTH / 2 - 100, HEIGHT - 600))

            # 显示结束界面组件
            self.end_group.draw(self.gm.screen)
            self.end_group.update()
            self.gm.screen.blit(self.score_label, (WIDTH / 2 - 65, HEIGHT - 200))

    # 处理游戏中鼠标点击事件
    def check_click(self):
        # 游戏准备阶段
        if self.gm.game_state == "ready":
            # 点击了开始按钮
            if self.start_btn.is_collide():
                self.gm.game_state = "gaming"
                # 设置炸弹出现计时器
                pygame.time.set_timer(BOMB_BORN, 3000)
                # 生成玩家
                self.gm.player_manage.born()
                # 设置食物出现计时器
                pygame.time.set_timer(FOOD_BORN, 1000)
                # 设置总时间计时器
                pygame.time.set_timer(TOTAL_TIME, 1000)
                # 设置保护罩出现计时器
                pygame.time.set_timer(PROTECT_BORN, 5000)
        # 游戏结束状态
        elif self.gm.game_state == "end":
            self.gm.player_manage.die()
            self.gm.player_manage.die()
            self.gm.food_manage.clear()
            self.gm.protec_manage.clear()
            self.gm.bomb_manage.clear()

            # 点击重新开始按钮进入游戏准备阶段
            if self.restart_btn.is_collide():
                self.gm.game_state = "ready"
                # 重置游戏状态
                self.reset_game()


# 游戏管理类
class GameManage:
    def __init__(self):
        # 初始化模块
        pygame.init()
        # 设置窗口标题
        pygame.display.set_caption("princeling")
        # 创建窗体大小
        self.screen = pygame.display.set_mode((WIDTH, HEIGHT))
        # 创建时钟对象
        self.clock = pygame.time.Clock()
        # 初始化游戏状态为准备状态
        self.game_state = "ready"
        # 初始化各管理类对象
        self.ui_manage = UIManage(self)
        self.bg_manage = BgManage(self)
        self.food_manage = FoodManage(self)
        self.player_manage = PlayerManage(self)
        self.bomb_manage = BombManage(self)
        self.protec_manage = ProtectManage(self)
        # 初始化保护罩生成的时间戳
        self.protec_last_time = time.time()

    # 检查和处理pygame事件
    def check_event(self):
        # 循环检查所有的pygame事件
        for event in pygame.event.get():
            # 检测到窗口关闭事件 调用pygame.quit() 关闭pygame 退出程序
            if event.type == pygame.QUIT:
                pygame.quit()
                exit()

            # 处理鼠标按钮释放事件
            if event.type == pygame.MOUSEBUTTONUP:
                # 左键释放
                if event.button == 1:
                    # 调用UI管理器的点击检查方法
                    self.ui_manage.check_click()

            # 处理总时间事件（假设 TOTAL_TIME 是自定义的事件类型）
            if event.type == TOTAL_TIME:
                # 调用 UI 管理器的减少时间方法
                self.ui_manage.reduce_time()
                # 如果总时间减少到0
                if self.ui_manage.total_time == 0:
                    # 设置游戏状态为结束
                    self.game_state = "end"
                    # 调用玩家管理器的死亡方法

            # 处理食物生成事件
            if event.type == FOOD_BORN:
                # 调用食物管理器的生成方法
                self.food_manage.born()

            # 处理炸弹生成事件
            elif event.type == BOMB_BORN:
                # 调用炸弹管理器的生成方法
                self.bomb_manage.born()

            # 处理保护生成事件
            elif event.type == PROTECT_BORN:
                # 调用保护管理器的生成方法
                self.protec_manage.born()

    def update_draw(self):
        # 更新背景管理类
        self.bg_manage.update()
        # 更新ui管理类
        self.ui_manage.update()
        if self.game_state == "gaming":
            # 更新食物管理类
            self.food_manage.update()
            # 更新炸弹管理类
            self.bomb_manage.update()
            # 更新保护罩管理类
            self.protec_manage.update()
            # 更新玩家管理类
            self.player_manage.update()
            # 更新ui管理类（使文字显示在最上层）
            self.ui_manage.update()
        # 更新绘制
        pygame.display.flip()

    def check_collide(self):
        # 玩家与食物碰撞检测
        r0 = pygame.sprite.groupcollide(self.player_manage.player_group, self.food_manage.food_group, False, False)
        if r0:
            # 两者碰撞时播放音效
            AudioManage.play_sound("./tu/1/bjm/lx.mp3")
            # 食物被碰到消失玩家得分
            for foods in r0.values():
                for food in foods:
                    food.kill()
                    self.ui_manage.add_score()

        # 玩家与保护罩碰撞检测
        r1 = pygame.sprite.spritecollide(self.player_manage.player, self.protec_manage.protect_group, True)
        # 碰撞
        if r1:
            # 记录两者相碰时的初始时间
            self.protec_last_time = time.time()
            # 碰撞后生成保护罩
            self.player_manage.create_shield()
        # 未碰撞
        elif not r1:
            # （有保护罩状态下）未再碰倒可生成保护罩的食物则保护罩在5秒后消失
            if self.player_manage.player.shield:
                current_time = time.time()
                if current_time - self.protec_last_time > 5:
                    self.player_manage.clear_shield()

        # 玩家与炸弹碰撞检测
        r2 = pygame.sprite.spritecollide(self.player_manage.player, self.bomb_manage.bomb_group, True)
        if r2:
            # 有保护罩则玩家存活保护罩破碎
            if self.player_manage.player.shield:
                # 两者碰撞时播放音效
                AudioManage.play_sound("./tu/1/bjm/pz.mp3")
                self.player_manage.clear_shield()

            # 没有保护罩玩家死亡
            elif not self.player_manage.player.shield:
                # 两者碰撞时播放音效
                AudioManage.play_sound("./tu/1/bjm/zq.mp3")
                # 游戏结束 玩家死亡 食物、炸弹、保护罩清空
                self.game_state = "end"
                self.player_manage.die()
                self.food_manage.clear()
                self.protec_manage.clear()
                self.bomb_manage.clear()
                pygame.time.set_timer(BOMB_BORN, 0)

    def run(self):
        # 反序列化分数
        self.ui_manage.load_score()
        while True:
            self.clock.tick(20)
            self.check_event()
            self.update_draw()
            if self.game_state == "gaming":
                self.check_collide()


gm = GameManage()
gm.run()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2038728.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

CentOS 7 安装详细教程

CentOS 7 安装详细教程

​ 大家好&#xff0c;我是程序员小羊&#xff01; 前言&#xff1a; CentOS 7 是一个稳定的企业级 Linux 发行版&#xff0c;广泛用于服务器环境。CentOS 7 是基于 Red Hat Enterprise Linux (RHEL) 构建的企业级 Linux 发行版&#xff0c;提供免费的、开源的操作系统&#xf…
阅读更多...
JVM-Java虚拟机-一文读懂-小白秒懂，老鸟进阶，必考面经

JVM-Java虚拟机-一文读懂-小白秒懂，老鸟进阶，必考面经

目录 JVM定义 Java Virtual Machine组成结构 各部分详解 0、类加载器 1、栈是运行的单位&#xff0c;堆是存储的单位 2、栈中存放各个栈帧 3、方法区——多线程共享区域 JVM定义 运行Java程序的平台内存结构、 垃圾回收、 类加载、 性能调优、 JVM 自身优化技术、 执行引…
阅读更多...
【Web前端】vue3整合eslint约束代码格式

【Web前端】vue3整合eslint约束代码格式

一、整合eslint 整合eslint的两种方式&#xff1a; 在已有项目中整合eslint&#xff1a;# 安装eslint及其vue插件即可 npm i -D eslint eslint-plugin-vue创建项目时整合eslint&#xff1a; 提示 是否引入ESLint用于代码质量检测 时选择 是# 创建vue3项目 npx create-vue # 下…
阅读更多...
sqlserver同一数据库还原实例冲突可以用[文件和文件组]来备份解决

sqlserver同一数据库还原实例冲突可以用[文件和文件组]来备份解决

1.将数据库恢复模式改为完整 2.备份 在数据库右键--任务--备份 选择文件和文件组 选择位置备份 3.还原 在数据库上右键--还原文件和文件组 或者还原时修改实例名称&#xff08;没试过&#xff09;
阅读更多...
2024年8月14日（haproxy）

2024年8月14日（haproxy）

一、haproxy简介 官网https://www.haproxy.com/ 自由及开放源代码软件 HAProxy是一个使用C语言编写的自由及开放源代码软件,其提供高可用性、负我均衡,以及基TCP和HTTP的应用程序代理。 HAProxy特别适用于那些负载特大的veb站点,这些站点通常又需要会活保或七层处理。HAProxy运…
阅读更多...
【Qt】QWidget的geometry属性

【Qt】QWidget的geometry属性

geometry&#xff0c;意思是“几何”。可以将geometry视为是四个属性的统称。 x&#xff1a;横坐标 y&#xff1a;纵坐标 width&#xff1a;宽度 height&#xff1a;高度 API说明 geometry() 获取到控件的位置和尺⼨. 返回结果是⼀个 QRect, 包含了 x, y, width, height. 其中…
阅读更多...
jar包扫描不到，idea如何通过Project Structure设置

jar包扫描不到，idea如何通过Project Structure设置

目录 一、进入Project Structure二、添加你的项目进来三、手动添加依赖 很多时候jar包文件已经存在&#xff0c;但是无法使用&#xff0c;需要通过Project Structure设置 一、进入Project Structure 选择Modules->点击 二、添加你的项目进来 一直next&#xff0c;最后点…
阅读更多...
论文阅读笔记：ST-MetaNet-2

论文阅读笔记：ST-MetaNet-2

目录 预备知识 定义1&#xff1a;城市交通 定义2&#xff1a;Geo-graph属性 问题1 方法 RNN 元学习器 元图注意力网络 元循环神经网络 预备知识 在本节中&#xff0c;我们介绍定义和问题陈述。为简洁起见&#xff0c;我们在表1中提供了一个注释表。 假设有个位置&…
阅读更多...
Java - API

Java - API

API全称"Application Programming Interface"&#xff0c;指应用程序编程接口 API&#xff08;JDK17.0&#xff09;链接如下 : Overview (Java SE 17 & JDK 17) (oracle.com)https://docs.oracle.com/en/java/javase/17/docs/api/中文版&#xff1a; Java17中…
阅读更多...
C++内存泄露检测-Windows平台VLD

C++内存泄露检测-Windows平台VLD

一、安装Visual Leak Detector 下载地址&#xff1a;https://kinddragon.github.io/vld/ 安装过程就一路next即可&#xff0c;如果自定义安装目录的话&#xff0c;需要记住安装的目录&#xff0c;默认目录 C:\Program Files (x86)\Visual Leak Detector&#xff0c;这个目录下…
阅读更多...
[独家原创]基于(牛顿拉夫逊)NRBO-TCN多变量回归预测(多输入单输出) Matlab代码

[独家原创]基于(牛顿拉夫逊)NRBO-TCN多变量回归预测(多输入单输出) Matlab代码

[独家原创]基于(牛顿拉夫逊)NRBO-TCN多变量回归预测(多输入单输出) Matlab代码 NRBO优化的超参数为&#xff1a;卷积核个数、正则化系数、初始化学习率 1.程序已经调试好&#xff0c;无需更改代码替换数据集即可运行&#xff01;&#xff01;&#xff01;数据格式为excel&…
阅读更多...
色轮在数据可视化中的应用

色轮在数据可视化中的应用

在数据可视化中&#xff0c;色彩的运用不仅仅是为了美观&#xff0c;更是为了传达信息、区分数据和提升图表的易读性。本文探讨色轮及其色彩公式的应用&#xff0c;帮助大家更好地运用色彩来提升数据可视化的效果。 1、色轮的基础概念 色轮是一个用于表示颜色之间关系的图形工…
阅读更多...
Linux自动构建工具——make/makefile

Linux自动构建工具——make/makefile

目录 一、make/makefile是什么&#xff1f; 二、深入了解 1.基本命令 提示&#xff1a;以下是本篇文章正文内容&#xff0c;下面案例可供参考 一、make/makefile是什么&#xff1f; 在Linux中make是一条指令&#xff0c;makefile是文件。make的核心功能就是读取一个或者多个…
阅读更多...
解决问题：Arcgis10.8“数据“-“导出至CAD“时就卡死了

解决问题：Arcgis10.8“数据“-“导出至CAD“时就卡死了

问题现象&#xff1a;我们在使用Arcgis10.8软件&#xff0c;执行 “数据导出至CAD”操作时&#xff0c;会出现卡死的情况&#xff0c;步骤如下图所示&#xff1a; 解决方案&#xff1a;在菜单栏依次选择“地理处理”-“地理处理选项”&#xff0c;然后在“后台处理”和“发生错…
阅读更多...
黄金市场展望：CPI数据引发关注，技术面看涨

黄金市场展望：CPI数据引发关注，技术面看涨

亚市现货黄金行情 8月14日周三&#xff0c;亚市盘中现货黄金价格小幅下跌&#xff0c;目前交投在2462美元/盎司附近。投资者将重点关注即将公布的美国消费者物价指数&#xff08;CPI&#xff09;数据&#xff0c;预计这将对黄金市场产生重大影响。 美联储政策预期与CPI数据 市场…
阅读更多...
IIC电路详细设计

IIC电路详细设计

下面我们来聊一聊IIC。 首先要知道，为什么IIC需要接上拉电阻？这里就需要承接到上一部分的内容：三极管。 注意到这样一句话：「连接到总线的器件输出级必须是漏极开路或集电极开路才能执行线与的功能 」，这里就涉及到「漏极/集电极开路」、「上拉电阻」和「线与」两个概念…
阅读更多...
ReetrantReadWriteLock 读写锁原理

ReetrantReadWriteLock 读写锁原理

一、为什么要出现读写锁&#xff1f; 我们知道synchronizer 和 ReentrantLock 都是互斥锁 但现实很多业务场景都是读多写少&#xff0c;针对这种场景在并发中若采用 synchronizer 和 ReentrantLock 来保证原子性&#xff0c;但会降低代码的性能。这种场景&#xff0c;就可以…
阅读更多...
数据库技术核心：迭代逻辑思考

数据库技术核心：迭代逻辑思考

文章目录 数据库演进史第一阶段&#xff1a;早期文件系统第二阶段&#xff1a;关系数据库&#xff08;RDBMS&#xff09;第三阶段&#xff1a;面向对象数据库&#xff08;OODBMS&#xff09;第四阶段&#xff1a;分布式数据库和 NoSQL 数据库第五阶段&#xff1a;NewSQL 数据库…
阅读更多...
广告资料库是什么？如何正确使用Facebook广告资料库？一文解决你的烦恼！

广告资料库是什么？如何正确使用Facebook广告资料库？一文解决你的烦恼！

什么是广告资料库 广告营销领域&#xff0c;创意和策略的更新速度极快。为了跟上这种节奏&#xff0c;广告资料库应运而生&#xff0c;成为广告人和营销专家的重要工具。广告资料库是一个集中存储和管理广告素材、创意案例、市场数据和用户反馈的平台。它不仅帮助用户获得灵感…
阅读更多...
Redis集群：概念和部署示例

Redis集群：概念和部署示例

目录 Redis 集群的优点 集群模式 主从模式 缺陷 哨兵模式 缺陷 集群模式&#xff08;Redis Cluster&#xff09; 数据分片原理 添加节点 删除节点 Redis集群的分片方式 故障转移机制 如果Master只有一个Slave 如果Master有多个Slave 如果两个Slave票数一样呢&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023