import pandas as pd

# 假设我们有一个CSV文件，包含了员工的姓名和薪水
employees_data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Salary': [50000, 60000, 65000]
}
employees_df = pd.DataFrame(employees_data)

# 将DataFrame导出到Excel文件
employees_df.to_excel('employees.xlsx', index=False)

# 使用Python脚本自动发送邮件
import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.header import Header

# 邮件发送函数
def send_email(subject, body, recipient):
    # 配置SMTP服务器信息
    smtp_server = 'smtp.example.com'
    port = 587  # 或465（SSL）
    username = 'your_email@example.com'
    password = 'your_password'

    # 创建邮件对象并添加信息
    msg = MIMEMultipart()
    msg['From'] = Header('Your Name', 'utf-8')
    msg['To'] = Header(recipient, 'utf-8')
    msg['Subject'] = Header(subject, 'utf-8')

    # 添加邮件正文
    msg.attach(MIMEText(body, 'plain', 'utf-8'))

    # 登录SMTP服务器并发送邮件
    server = smtplib.SMTP(smtp_server, port)
    server.starttls()  # 启用TLS
    server.login(username, password)
    server.sendmail(username, recipient, msg.as_string())
    server.quit()

# 使用函数发送邮件
send_email('Employees Salary Report', 'Attached is the salary report for employees.', 'manager@example.com')

# 导入Selenium库中的webdriver
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
from time import sleep

# 初始化WebDriver
driver = webdriver.Chrome()

# 打开网站
driver.get('https://www.geetest.com/expire-pin')

# 找到滑块
slider = driver.find_element_by_id('gt_slider_button')

# 对滑块进行拖动
ActionChains(driver).click_and_hold(slider).perform()

# 移动滑块到指定位置
for x in range(100, 200):
    ActionChains(driver).move_by_offset(xoffset=x, yoffset=0).perform()
    sleep(0.5)  # 暂停0.5秒，以模拟人的滑动动作

# 释放滑块
ActionChains(driver).release().perform()

# 等待验证结果
sleep(3)

# 关闭浏览器
driver.quit()

from pywinauto.application import Application

# 连接到一个已经打开的应用程序
app = Application().connect(title_re='.*- 记事本')

# 获取记事本的窗口并输入文本
dlg = app[u'无标题 - 记事本']
dlg.type_keys('这里是pywinauto的示例文本。')

# 保存文件
dlg.menu_select('文件->保存')

# 断开连接
app.kill()

import pygame
import random
import time

# 初始化pygame
pygame.init()

# 设置窗口大小
screen_width = 600
screen_height = 600

# 设置蛇的初始长度
snake_length = 3

# 设置蛇的初始位置
snake_x = [250, 240, 230]
snake_y = [250, 250, 250]

# 蛇的移动方向
direction = 'right'

# 蛇的每一个格子大小
size = 10

# 食物的初始位置
food_x = round(random.randrange(0, screen_width - size) / 10.0) * 10.0
food_y = round(random.randrange(0, screen_height - size) / 10.0) * 10.0

# 设置背景颜色
bg_color = (255, 255, 255)

# 设置蛇的颜色
snake_color = (20, 20, 200)

# 设置食物的颜色
food_color = (200, 20, 20)

# 设置得分和速度
score = 0
speed = 10

# 设置游戏是否结束的标志
game_over = False

# 设置游戏是否暂停的标志
pause = False

# 设置游戏是否开始的标志
start = False

# 设置游戏是否重置的标志
reset = False

# 设置游戏的字体
font = pygame.font.SysFont('arial', 20)

# 设置游戏窗口
screen = pygame.display.set_mode((screen_width, screen_height))

# 设置游戏窗口标题
pygame.display.set_caption('贪吃蛇游戏')

# 定义按键处理函数
def key_handle():
    global direction, snake_x, snake_y, food_x, food_y, speed, score, game_over, pause, start, reset
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game_over = True
        elif event.type == pygame.KEYDOWN:
            if not start:
                start = True
            elif pause:
                if event.key == pygame.K_p:
                    pause = False
            else:
                if event.key == pygame.K_p:
                    pause = True
                elif event.key == pygame.K_r:
                    reset = True
                elif event.key == pygame.K_UP and direction != 'down':
                    direction = 'up'
                elif event.key == pygame.K_DOWN and direction != 'up':
                    direction = 'down'
                elif event.key == pygame.K_LEFT and direction != 'right':
                    direction = 'left'
                elif event.key == pygame.K_RIGHT and direction != 'left':
                    direction = 'right'

# 定义蛇移动函数
def snake_move():
    global snake_x, snake_y, food_x, food_y, score, game_over, direction, reset
    if not pause and not game_over and not reset:
        if direction == 'right':
            snake_x.insert(0, snake_x[0] + size)
        if direction == 'left

[global]
index-url = https://pypi.tuna.tsinghua.edu.cn/simple

pip install --index-url https://pypi.tuna.tsinghua.edu.cn/simple some-package

# 导入Python内置模块
import collections

# 定义一个元组序列
tuple_sequence = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

# 使用collections.defaultdict创建一个字典，其键是元组的前两个元素，值是一个计数器
tuple_counter = collections.defaultdict(collections.Counter)

# 遍历元组序列，更新字典
for t in tuple_sequence:
    tuple_counter[t[:2]].update([t[2]])

# 打印结果
print(tuple_counter)

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler

# 读取数据
data = pd.read_csv('data.csv')

# 使用z-score标准化
def z_score_normalize(data):
    return (data - data.mean()) / data.std()

# 使用MinMaxScaler进行归一化
def min_max_normalize(data):
    scaler = MinMaxScaler()
    return scaler.fit_transform(data)

# 处理数据中的缺失值
def handle_missing_values(data):
    # 假设我们用每列的平均值填充缺失值
    return data.fillna(data.mean())

# 应用z-score标准化
data_zscore = z_score_normalize(data)

# 应用MinMaxScaler归一化
data_minmax = min_max_normalize(data)

# 处理数据中的缺失值
data_handled = handle_missing_values(data)

# 输出结果
print("Z-score 标准化后的数据:\n", data_zscore)
print("Min-max 归一化后的数据:\n", data_minmax)
print("处理缺失值后的数据:\n", data_handled)

import torch
import torch.nn as nn
import torch.optim as optim

# 定义神经网络模型
class NeuralNetwork(nn.Module):
    def __init__(self):
        super(NeuralNetwork, self).__init__()
        self.fc1 = nn.Linear(100, 50)
        self.fc2 = nn.Linear(50, 10)
        self.fc3 = nn.Linear(10, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 准备数据
x = torch.randn(100, 100)
y = torch.randn(100, 1)

# 实例化模型、损失函数和优化器
model = NeuralNetwork()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# 训练模型
for epoch in range(100):
    # 前向传播
    y_pred = model(x)
    loss = criterion(y_pred, y)

    # 反向传播
    optimizer.zero_grad()
    loss.backward()

    # 优化参数
    optimizer.step()

print("训练完成")

python -m pip install --upgrade pip

python3 -m pip install --upgrade pip

/path/to/specific/python -m pip install --upgrade pip