import requests
from lxml import etree

# 设置代理服务器
proxies = {
    'http': 'http://用户名:密码@代理服务器地址:端口',
    'https': 'https://用户名:密码@代理服务器地址:端口'
}

# 目标网页URL
url = 'https://maoyan.com/cs/boxoffice'

# 发送请求
response = requests.get(url, proxies=proxies)

# 确保网页请求成功
if response.status_code == 200:
    # 解析网页
    html = etree.HTML(response.text)

    # XPath表达式，提取专业评分数据
    xpath_expr = '//dl[@class="board-wrapper"]//dd/text()'
    scores = html.xpath(xpath_expr)

    # 打印专业评分数据
    for score in scores:
        print(score.strip())  # 去除可能的空白字符
else:
    print('网页请求失败，状态码：', response.status_code)

import torch
import torch.nn as nn
from transformers import AutoModel

class Autoformer(nn.Module):
    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6):
        super(Autoformer, self).__init__()
        self.encoder_layer = nn.TransformerEncoderLayer(d_model, nhead)
        self.transformer_encoder = nn.TransformerEncoder(self.encoder_layer, num_encoder_layers)
        self.linear = nn.Linear(d_model, 1)

    def forward(self, src):
        memory = self.transformer_encoder(src)
        output = self.linear(memory)
        return output

class FEDformer(nn.Module):
    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6):
        super(FEDformer, self).__init__()
        self.transformer = AutoModel.from_pretrained('google/electra-small-discriminator', output_loading=True)
        self.linear = nn.Linear(d_model, 1)

    def forward(self, src):
        memory = self.transformer(src)[0]  # Transformer output
        output = self.linear(memory)
        return output

class PatchTS(nn.Module):
    def __init__(self, d_model=512, nhead=8, num_encoder_layers=6):
        super(PatchTS, self).__init__()
        self.transformer = AutoModel.from_pretrained('google/electra-small-discriminator', output_loading=True)
        self.linear = nn.Linear(d_model, 1)

    def forward(self, src):
        memory = self.transformer(src)[0]  # Transformer output
        output = self.linear(memory)
        return output

# 示例：
# 假设 `src` 是一个Tensor，表示输入序列。
src = torch.randn(10, 8, 512)  # 假设batch size为10，序列长度为8，embedding大小为512
autoformer = Autoformer()
fedformer = FEDformer()
patchts = PatchTS()

# 预测股价
autoformer_output = autoformer(src)
fedformer_output = fedformer(src)
patchts_output = patchts(src)

my_list = [1, 2, 3, 4, 5]
length = len(my_list)
print(length)  # 输出列表长度

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

# 生成模拟数据
def make_data(n_samples, n_features, centers=3, random_state=0):
    np.random.seed(random_state)
    centers = np.random.rand(centers, n_features)
    cluster_std = 0.6
    clusters = np.zeros((n_samples, n_features))
    for i in range(centers.shape[0]):
        clusters += np.random.normal(centers[i], cluster_std, size=(n_samples, n_features))
    return clusters

# 绘制聚类散点图
def plot_clusters(X, y_pred, title=None):
    # 为不同的聚类分配颜色
    colors = np.array([x for _, x in plt.get_cmap('tab20b').colors])
    for i in range(len(colors)):
        plt.scatter(X[y_pred == i, 0], X[y_pred == i, 1], s=30, c=colors[i])
    plt.title(title)
    plt.show()

# 定义 K-means 聚类函数
def kmeans_cluster(X, n_clusters, max_iter=300):
    kmeans = KMeans(n_clusters=n_clusters, max_iter=max_iter)
    y_pred = kmeans.fit_predict(X)
    title = f"K-Means Clustering with n_clusters = {n_clusters}, Silhouette Score: {silhouette_score(X, y_pred)}"
    plot_clusters(X, y_pred, title)

# 使用函数进行聚类
n_samples = 3000
n_features = 2
n_clusters = 3
random_state = 1
X = make_data(n_samples, n_features, centers=n_clusters, random_state=random_state)
kmeans_cluster(X, n_clusters, max_iter=300)

import pandas as pd

# 读取 CSV 文件，默认分隔符为逗号，有标题行，索引为第一列
df = pd.read_csv('example.csv')

# 指定分隔符为制表符，没有标题行，第一列作为索引
df = pd.read_csv('example.csv', sep='\t', header=None)

# 指定标题行为第二行，第三列作为索引
df = pd.read_csv('example.csv', header=1, index_col=2)

# 指定列名
df = pd.read_csv('example.csv', names=['column1', 'column2', 'column3'])

# 只读取第一列和第三列
df = pd.read_csv('example.csv', usecols=[0, 2])

# 跳过前三行
df = pd.read_csv('example.csv', skiprows=3)

# 只读取前三行
df = pd.read_csv('example.csv', nrows=3)

# 指定编码为 utf-8
df = pd.read_csv('example.csv', encoding='utf-8')

import xlwt

# 创建一个workbook对象
workbook = xlwt.Workbook()

# 添加一个sheet页
sheet = workbook.add_sheet('Sheet1')

# 往sheet中写入数据
sheet.write(0, 0, 'Hello')
sheet.write(0, 1, 'World')

# 保存这个workbook到文件
workbook.save('example.xls')

import xlsxwriter

# 创建一个workbook对象
workbook = xlsxwriter.Workbook('example.xlsx')

# 添加一个sheet页
sheet = workbook.add_worksheet()

# 往sheet中写入数据
sheet.write('A1', 'Hello')
sheet.write('B1', 'World')

# 关闭workbook，保存文件
workbook.close()

from openpyxl import Workbook

# 创建一个workbook对象
workbook = Workbook()

# 获取第一个sheet页
sheet = workbook.active

# 往sheet中写入数据
sheet['A1'] = 'Hello'
sheet['B1'] = 'World'

# 保存这个workbook到文件
workbook.save('example.xlsx')

import pandas as pd

# 创建一个DataFrame
df = pd.DataFrame({
    'Column1': ['Hello'],
    'Column2': ['World']
})

# 将DataFrame写入到Excel文件
df.to_excel('example.xlsx', index=False)

import requests
from bs4 import BeautifulSoup
import re

def get_page(url):
    try:
        headers = {
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
        response = requests.get(url, headers=headers)
        if response.status_code == 200:
            return response.text
        return None
    except requests.RequestException:
        return None

def parse_page(html):
    soup = BeautifulSoup(html, 'html.parser')
    title = soup.select('.product_name')[0].text
    price = soup.select('.price_sale')[0].text
    return {
        'title': title,
        'price': price
    }

def main(url):
    html = get_page(url)
    if html:
        data = parse_page(html)
        print(f"商品名称: {data['title']}")
        print(f"商品价格: {data['price']}")

if __name__ == '__main__':
    url = 'https://www.example.com/product/12345'
    main(url)

import subprocess

# 使用subprocess.run()来运行命令
completed_process = subprocess.run(['ls', '-l'], capture_output=True, text=True)

# 打印输出结果
print("stdout:", completed_process.stdout)

# 打印错误信息
print("stderr:", completed_process.stderr)

import subprocess

# 使用subprocess.Popen()来运行命令
p = subprocess.Popen(['ls', '-l'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
out, err = p.communicate()

# 打印输出结果
print("stdout:", out)

# 打印错误信息
print("stderr:", err)

import os
import shutil

def delete_folder_contents(folder):
    for filename in os.listdir(folder):
        file_path = os.path.join(folder, filename)
        try:
            if os.path.isfile(file_path) or os.path.islink(file_path):
                os.unlink(file_path)
            elif os.path.isdir(file_path):
                shutil.rmtree(file_path)
        except Exception as e:
            print(f'Failed to delete {file_path}. Reason: {e}')

# 使用示例
folder_to_delete = '/path/to/your/folder'
delete_folder_contents(folder_to_delete)