System 发布的文章

2024-08-13




from openpyxl import Workbook, load_workbook
 
# 创建一个新的Excel工作簿并保存
wb = Workbook()
ws = wb.active
ws.title = "Sheet1"
ws['A1'] = "Hello"
wb.save("example.xlsx")
 
# 加载已存在的Excel工作簿
wb = load_workbook('example.xlsx')
ws = wb.active
 
# 读取A1单元格的数据
print(ws['A1'].value)
 
# 修改A1单元格的数据
ws['A1'] = "World"
wb.save("example.xlsx")
 
# 添加一个新的工作表
wb.create_sheet("Sheet2")
wb.save("example.xlsx")
 
# 遍历工作簿中所有工作表的名称
for sheet in wb:
    print(sheet.title)
 
# 关闭工作簿
wb.close()

这段代码展示了如何使用openpyxl库创建一个新的Excel工作簿，保存并读取数据，修改单元格数据，添加新的工作表，遍历工作表，并最终关闭工作簿。这是处理Excel文件的基本操作，非常适合作为学习openpyxl库的入门示例。

Python版【植物大战僵尸 +源码】

2024-08-13

本回答不包含完整的源代码，因为这需要数百行的Python代码。但我可以提供一个简化的Python版本的植物大战僵尸游戏的核心逻辑示例。




import pygame
import sys
import random
 
# 初始化pygame
pygame.init()
 
# 设置屏幕大小
screen = pygame.display.set_mode((800, 600))
 
# 设置游戏时钟
clock = pygame.time.Clock()
 
# 定义游戏元素的类
class Plant(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.image = pygame.Surface((50, 50))
        self.image.fill((255, 0, 0))
        self.rect = self.image.get_rect(center=(x, y))
 
    def update(self):
        # 植物的更新方法，比如移动等
        pass
 
class Zombie(pygame.sprite.Sprite):
    def __init__(self, x, y):
        super().__init__()
        self.image = pygame.Surface((50, 50))
        self.image.fill((0, 255, 0))
        self.rect = self.image.get_rect(center=(x, y))
 
    def update(self):
        # 僵尸的更新方法，比如移动等
        pass
 
# 创建植物和僵尸的群组
plants_group = pygame.sprite.Group()
zombies_group = pygame.sprite.Group()
 
# 创建一些植物和僵尸
for i in range(10):
    plants_group.add(Plant(50 + i * 100, 50))
    zombies_group.add(Zombie(50 + i * 100, 200))
 
# 游戏循环
running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
 
    # 更新游戏元素
    plants_group.update()
    zombies_group.update()
 
    # 检查植物和僵尸是否被打中
    # 这里省略具体的碰撞检测代码
 
    # 清除屏幕
    screen.fill((0, 0, 0))
 
    # 绘制植物和僵尸
    plants_group.draw(screen)
    zombies_group.draw(screen)
 
    # 更新屏幕显示
    pygame.display.flip()
 
    # 控制游戏速度
    clock.tick(60)
 
# 游戏结束，关闭pygame
pygame.quit()

这个代码示例提供了如何使用pygame库创建一个简单的植物大战僵尸游戏的框架。你需要添加具体的游戏逻辑，比如移动功能、碰撞检测和分数计算等。

python 字符串驻留机制

2024-08-13

在Python中，字符串的驻留机制是通过在字符串前面加上r或R来实现的。这样做可以防止字符串在构造时进行特殊字符的转义，从而保留字符串原始的字面值。

例如：




path = r'C:\Program Files\Some Folder'

在这个例子中，path字符串中的反斜杠\没有被转义，所以它代表的是一个反斜杠而不是字符串插值的特殊字符（如换行符\n）。这在处理文件路径或正则表达式时非常有用。

另一个例子是处理正则表达式：




import re
 
# 使用字符串驻留机制
regex = r'http:\/\/([\w.]+)\/([\w]+)\/([\w]+)\.([\w]+)'
 
# 或者直接写成
regex = 'http:\\/\\/([\\w.]+)\\/([\\w]+)\\/([\\w]+)\\.([\\w]+)'
 
# 使用原始字符串和转义的字符串都可以表示相同的正则表达式
raw_regex = R'http:\/\/([\w.]+)\/([\w]+)\/([\w]+)\.([\w]+)'
 
# 使用re模块进行匹配
match = re.match(regex, 'http://www.example.com/hello/world.html')
 
if match:
    print(match.groups())  # 输出: ('www.example.com', 'hello', 'world', 'html')

在这个例子中，我们定义了一个正则表达式来匹配URL的不同部分。使用字符串驻留机制可以使正则表达式看起来更清晰，也避免了转义字符带来的混淆。

【Vue】Vue 路由的配置及使用

2024-08-13

所有,vue.js




// 引入Vue和VueRouter
import Vue from 'vue'
import VueRouter from 'vue-router'
 
// 引入组件
import HomePage from './components/HomePage.vue'
import LoginPage from './components/LoginPage.vue'
import RegisterPage from './components/RegisterPage.vue'
 
// 使用VueRouter插件
Vue.use(VueRouter);
 
// 创建路由实例
const router = new VueRouter({
  mode: 'history', // 使用HTML5 History模式
  routes: [ // 路由配置
    { path: '/', component: HomePage },
    { path: '/login', component: LoginPage },
    { path: '/register', component: RegisterPage }
  ]
});
 
// 创建Vue实例，并将router作为选项传入
new Vue({
  router, // 使用解构赋值简化代码
  // 挂载点
  el: '#app',
  // 渲染模板
  template: `
    <div>
      <h1>Vue Router Demo</h1>
      <nav>
        <ul>
          <li><router-link to="/">Home</router-link></li>
          <li><router-link to="/login">Login</router-link></li>
          <li><router-link to="/register">Register</router-link></li>
        </ul>
      </nav>
      <router-view></router-view>
    </div>
  `
});

这段代码展示了如何在Vue应用中配置Vue Router，并且使用<router-link>和<router-view>组件来渲染导航链接和视图。这是Vue路由的基本用法，对于初学者来说具有很好的教育价值。

python GUI开发: tkinter事件处理的几种方式详解与应用实战

2024-08-13

在Python中，使用Tkinter进行GUI开发时，可以通过以下几种方式来处理事件：

使用command参数直接绑定函数。
使用bind方法绑定事件和处理函数。

以下是两种方式的示例代码：




import tkinter as tk
 
# 方法1: 使用command参数
def button_clicked():
    print("按钮被点击了!")
 
root = tk.Tk()
button = tk.Button(root, text="点击我", command=button_clicked)
button.pack()
 
root.mainloop()
 
 
# 方法2: 使用bind方法
def key_press(event):
    print("键盘被按下，键为:", event.char)
 
root = tk.Tk()
root.bind("<Key>", key_press)  # 绑定键盘按下事件
 
root.mainloop()

在第一种方法中，我们通过command参数将函数button_clicked绑定到按钮的点击事件上。当按钮被点击时，会自动调用button_clicked函数。

在第二种方法中，我们使用root.bind方法将键盘按下事件<Key>绑定到key_press函数上。当用户按下键盘上的任意键时，会触发key_press函数，并将事件对象event传递给它，其中event.char属性表示按下的键。

这两种方式是Tkinter中处理事件的常用方法，可以根据实际需求选择合适的方式来进行事件的绑定和处理。

分布式 - 消息队列Kafka：Kafka 消费者的消费位移

2024-08-13

在Kafka中，消费者的消费位移（consumer offset）是指消费者消费的特定分区中的消息的位置。Kafka为每个消费者维护消费位移，以便在消费者失败时能够恢复消费状态。

消费位移可以通过以下方式提交：

自动提交：消费者定期自动提交消费位移到Kafka。
手动提交：消费者在适当的时候手动调用API提交消费位移。

以下是一个简单的示例，展示了如何在手动提交模式下使用Java Kafka消费者API提交消费位移：




import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import java.util.Arrays;
import java.util.Properties;
 
public class ManualOffsetCommitExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test");
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false"); // 关闭自动提交
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
 
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("topic"));
 
        try {
            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(100);
                for (ConsumerRecord<String, String> record : records) {
                    // 处理消息
                    System.out.println(record.value());
                }
                // 在处理完所有消息之后手动提交位移
                consumer.commitSync();
            }
        } finally {
            consumer.close();
        }
    }
}

在这个例子中，我们关闭了消费者的自动位移提交，并在处理完所有消息后通过调用commitSync()方法手动同步提交位移。这确保了在消费者崩溃的情况下，我们不会丢失任何消息。

linux————ceph分布式部署

2024-08-13

要在Linux上部署Ceph，您可以遵循以下步骤：

安装Ceph：




sudo apt-update
sudo apt-install ceph

配置Ceph集群：
首先，确保所有节点的主机名是唯一和正确配置的。然后，在一个节点上生成Ceph配置文件，例如ceph.conf。
配置monitor节点：




ceph-deploy new <monitor-node-ip>

配置其他节点：




ceph-deploy install <node1-ip> <node2-ip> ...
ceph-deploy mon create-initial
ceph-deploy admin <node1-ip> <node2-ip> ...

配置OSDs（物理存储单元）：
对于每个OSD，你需要选择一个磁盘并执行以下命令：




ceph-deploy osd create --data /dev/sdx <host-ip>

检查Ceph状态：




ceph -s

配置CephFS（可选）：




ceph-deploy mds create <metadata-node-ip>

配置对象存储网关（可选）：




ceph-deploy rgw create <rgw-node-ip>

这是一个非常基础的Ceph分布式部署指南。根据您的具体需求和环境，您可能需要调整这些步骤。

2024-08-13




import com.dangdang.ddframe.job.api.simple.SimpleJob;
import com.dangdang.ddframe.job.config.JobCoreConfiguration;
import com.dangdang.ddframe.job.config.simple.SimpleJobConfiguration;
import com.dangdang.ddframe.job.lite.api.JobScheduler;
import com.dangdang.ddframe.job.lite.config.LiteJobConfiguration;
import com.dangdang.ddframe.job.reg.base.CoordinatorRegistryCenter;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperConfiguration;
import com.dangdang.ddframe.job.reg.zookeeper.ZookeeperRegistryCenter;
 
public class ElasticJobDemo {
 
    public static void main(final String[] args) {
        // 配置作业注册中心.
        CoordinatorRegistryCenter regCenter = new ZookeeperRegistryCenter(new ZookeeperConfiguration("localhost:2181", "elastic-job-demo"));
        // 初始化作业
        SimpleJob simpleJob = new MyElasticJob();
        // 定义作业核心配置
        JobCoreConfiguration simpleCoreConfig = JobCoreConfiguration.newBuilder("demoSimpleJob", "0/15 * * * * ?", 10).build();
        // 定义作业根配置
        SimpleJobConfiguration simpleJobConfig = new SimpleJobConfiguration(simpleCoreConfig, simpleJob.getClass().getCanonicalName());
        // 创建作业调度器
        JobScheduler simpleJobScheduler = new JobScheduler(simpleJob, regCenter, LiteJobConfiguration.newBuilder(simpleJobConfig).build());
        // 启动调度器
        simpleJobScheduler.init();
    }
}
 
class MyElasticJob implements SimpleJob {
    @Override
    public void execute(ShardingContext context) {
        // 实现作业的具体逻辑
        System.out.println("作业执行，分片项：" + context.getShardingItem());
    }
}

这段代码展示了如何在Elastic Job中创建和启动一个简单的分布式定时任务。首先，我们配置了注册中心，并初始化了作业。然后，我们定义了作业的核心配置，包括作业的名称、执行时间和分片数量。最后，我们创建了作业调度器并启动它。在MyElasticJob类中，我们实现了SimpleJob接口，并在execute方法中编写了作业的具体逻辑。这个例子简单明了地展示了如何使用Elastic Job来进行分布式任务的调度。

ClickHouse分布式查询和分布式表

2024-08-13

在ClickHouse中，分布式查询通常是针对分布式表进行的。分布式表是由一组分布在不同节点上的本地表组成的逻辑表。

以下是一个简单的例子，演示如何在ClickHouse中创建分布式表和执行分布式查询。

假设你已经在多个节点上创建了本地表。




CREATE TABLE local_table_on_node1 (
  EventDate Date,
  EventTime DateTime,
  UserID Int32
) ENGINE = MergeTree()
PARTITION BY toYYYYMM(EventDate)
ORDER BY (EventDate, EventTime, UserID);

在其他节点上创建相同结构的本地表，只是表名不同。




CREATE TABLE local_table_on_node2 (
  EventDate Date,
  EventTime DateTime,
  UserID Int32
) ENGINE = MergeTree()
PARTITION BY toYYYYMM(EventDate)
ORDER BY (EventDate, EventTime, UserID);

创建一个分布式表，它将合并这些本地表。




CREATE TABLE distributed_table_on_node1 (
  EventDate Date,
  EventTime DateTime,
  UserID Int32
) ENGINE = Distributed(cluster_name, database_name, local_table_prefix, [sharding_key])

其中cluster_name是在config.xml中定义的集群名称，database_name是数据库名称，local_table_prefix是本地表名的前缀，这些本地表通过前缀进行分组，sharding_key是用于数据分片的可选字段。

使用分布式表执行查询。




SELECT EventDate, count(UserID) FROM distributed_table_on_node1 GROUP BY EventDate;

这个查询会在所有节点上的本地表上自动执行，并聚合结果。

注意：在实际操作中，你需要在config.xml中配置集群信息，并确保所有节点都能够通信。