python跨服务器实现复制，剪切的功能需求

想实现一个需求，用python实现2个功能
1.定时查询某个文件夹当天产生的文件并将新生成的文件自动拷贝值另一台windows系统的指定文件夹内，

 import os
   import shutil

   src_dir = "/path/to/source/directory"
   dst_dir = "/path/to/destination/directory"
#获取当天日期：

today = datetime.date.today()
#遍历源目录中的文件，找到当天生成的文件，并将其复制到目标目录中：
 for file_name in os.listdir(src_dir):
     file_path = os.path.join(src_dir, file_name)
         if os.path.isfile(file_path):
           file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
                 if file_time == today:
                      shutil.copy2(file_path, dst_dir)

参考网上能实现本地拷贝，跨服务器不知道怎么实现。

2.另一个需求是查询文件夹中指定日期前的文件（比如90天前)（文件夹文件有几十G的），查询结果剪切到一个固定本地文件夹里并完成压缩

该回答引用于gpt与OKX安生共同编写：

该回答引用于gpt与OKX安生共同编写：

好的，以下是代码实现：

将文件拷贝到另一台Windows系统的指定文件夹内

如果要将文件拷贝到另一台Windows系统上的指定文件夹内，可以使用SMB/CIFS协议进行网络共享。

首先需要安装samba客户端库（pysmb）：

pip install pysmb

然后可以使用以下代码实现：

from smb.SMBConnection import SMBConnection
import os
import shutil
import datetime

# 源目录和目标目录信息
src_dir = "/path/to/source/directory"
dst_dir = "\\\\server-name\\share-name\\destination-directory"

# 获取当天日期：
today = datetime.date.today()

# 遍历源目录中的文件，找到当天生成的文件，并将其复制到目标目录中：
for file_name in os.listdir(src_dir):
    file_path = os.path.join(src_dir, file_name)
    if os.path.isfile(file_path):
        file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
        if file_time == today:
            # 连接远程共享
            conn = SMBConnection('username', 'password', 'client-name', 'server-name')
            conn.connect('server-ip', 139)
            # 复制文件到远程共享
            with open(file_path, 'rb') as f:
                conn.storeFile('share-name', dst_dir, f)
            # 关闭连接
            conn.close()

在上面的代码中，需要替换'username'、'password'、'client-name'、'server-name'和'server-ip'为实际的SMB/CIFS连接信息。

查询文件夹中指定日期前的文件并剪切到固定本地文件夹里

可以使用os.path.getmtime()函数获取文件的最后修改时间，然后计算出指定日期前的时间戳，再与每个文件的最后修改时间比较，选择需要剪切的文件。

以下是代码：

import os
import shutil
import datetime
import zipfile

# 源目录和目标目录信息
src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"

# 计算指定日期前的时间戳（这里以90天前为例）
delta_days = 90
cutoff_time = time.time() - delta_days * 86400

# 遍历源目录中的文件，找到指定日期前的文件，并将其移动到目标目录中：
for file_name in os.listdir(src_dir):
    file_path = os.path.join(src_dir, file_name)
    if os.path.isfile(file_path):
        file_time = os.path.getmtime(file_path)
        if file_time < cutoff_time:
            # 移动文件到目标目录
            shutil.move(file_path, dst_dir)

# 压缩目标目录中的所有文件
zip_file_path = "/path/to/archive.zip"
with zipfile.ZipFile(zip_file_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
    for file_name in os.listdir(dst_dir):
        file_path = os.path.join(dst_dir, file_name)
        if os.path.isfile(file_path):
            zipf.write(file_path, arcname=file_name)
            # 删除原始文件
            os.remove(file_path)

在上面的代码中，需要替换'/path/to/source/directory'、'/path/to/destination/directory'和'/path/to/archive.zip'为实际的目录和文件名。需要注意的是，以上代码只能跑一次，因为文件已经被移动或压缩。

根据您提供的信息，这里给出Python实现方法。希望对你有所帮助，希望采纳哈💕
可以使用os和shutil库实现文件的本地复制。对于跨服务器文件复制，可以使用paramiko库实现SSH连接。首先需要安装paramiko库，可以使用以下命令：

pip install paramiko

然后，可以使用以下代码实现文件的跨服务器复制：

import os
import datetime
import shutil
import paramiko

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"
today = datetime.date.today()

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('remote_server_ip', username='your_username', password='your_password')
sftp = ssh.open_sftp()

for file_name in os.listdir(src_dir):
    file_path = os.path.join(src_dir, file_name)
    if os.path.isfile(file_path):
        file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
        if file_time == today:
            sftp.put(file_path, os.path.join(dst_dir, file_name))

sftp.close()
ssh.close()

请注意替换remote_server_ip，your_username和your_password为实际的远程服务器信息。

实现功能二，可以使用以下代码查询指定日期前的文件，并将它们剪切到一个本地文件夹，并压缩：

import os
import datetime
import shutil
import zipfile

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"
days_before = 90
today = datetime.date.today()
cut_off_date = today - datetime.timedelta(days=days_before)

# 创建压缩文件
zip_file_path = os.path.join(dst_dir, f"archive_{today}.zip")
zip_file = zipfile.ZipFile(zip_file_path, 'w', zipfile.ZIP_DEFLATED)

# 遍历源目录中的文件，找到指定日期前的文件

python实现查询某个文件夹下指定日期前的文件，并移动到某个文件夹内的代码：

import datetime
import os
import shutil

import zipfile

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"
zip_dir = "/path/to/destination/zipdirectory"


'''
@des 实现从源文件夹移动n天前的文件到目标文件夹
@param src_dir 原文件夹
@param dst_dir 目标文件夹
@param days_ago 多少天前的文件
'''
def move_files(src_dir,dst_dir,days_ago):
    file_zips = [] #记录今天移动的文件，用于压缩
    for root, dirs, files in os.walk(src_dir):
        for file in files:
            file_path = os.path.join(root, file)
            file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
            #如果文件日期在days_ago之前，则移动文件到指定文件夹
            if (datetime.date.today()-datetime.timedelta(days=days_ago)) > file_time:
                shutil.move(file_path, os.path.join(dst_dir, file))
                file_zips.append(os.path.join(dst_dir, file)) #记录需要压缩的文件
    return file_zips

'''
@des 压缩文件到指定目录下，压缩文件名称为
@param zip_fileName 压缩后的文件夹名称
@param zip_dir 压缩文件存放目录
@param zip_file_name 压缩文件名称。含.zip后缀

'''
def zip_files(file_zips,zip_dir,zip_file_name):

    #将目标文件中的文件进行压缩
    try:
        zip_file =os.path.join(zip_dir, zip_file_name)
        zip = zipfile.ZipFile(zip_file, "w", zipfile.ZIP_DEFLATED)
        for file in file_zips:
            zip.write(file)
    except:
        print('压缩失败!')
    finally:
        if zip:
            zip.close()


files = move_files(src_dir,dst_dir,90)
if files:
    zip_files(files,zip_dir,'out.zip')

其中move_files为查询指定日期前的文件，zip_files为压缩文件到指定文件夹下，最后调用

两台服务器分别部署一个http服务，用windows服务器请求生成文件的服务器，然后生成文件的服务器计算需要同步的文件生成http路径，返回给windows服务器，然后windows服务器按路径抓取文件就可以了。

基于最新版ChatGPT4的回答，望采纳!!!有其他问题也可以询问我哦、”(最新版更智能，功能更加强大)

要实现这两个功能，我们需要对你的代码进行一些修改。

跨服务器复制文件：

要在Python中跨服务器复制文件，可以使用paramiko库进行SSH连接并使用scp协议传输文件。首先，你需要安装paramiko和scp库：

pip install paramiko scp

然后，可以使用以下代码跨服务器复制文件：

import os
import datetime
import paramiko
from scp import SCPClient

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"

# SSH连接信息
hostname = "remote_server_ip_or_hostname"
port = 22  # 默认SSH端口
username = "username"
password = "password"

# 获取当天日期
today = datetime.date.today()

# 遍历源目录中的文件，找到当天生成的文件
for file_name in os.listdir(src_dir):
    file_path = os.path.join(src_dir, file_name)
    if os.path.isfile(file_path):
        file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
        if file_time == today:
            # 使用paramiko连接到远程服务器
            ssh = paramiko.SSHClient()
            ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
            ssh.connect(hostname, port, username, password)

            # 使用SCPClient传输文件
            with SCPClient(ssh.get_transport()) as scp:
                scp.put(file_path, dst_dir)

            # 关闭SSH连接
            ssh.close()

2.查询指定日期前的文件，剪切到本地文件夹并压缩：

import os
import datetime
import shutil
import zipfile

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"

# 计算指定日期（如90天前）
days_before = 90
date_threshold = datetime.date.today() - datetime.timedelta(days=days_before)

# 遍历源目录中的文件，找到指定日期前的文件
for file_name in os.listdir(src_dir):
    file_path = os.path.join(src_dir, file_name)
    if os.path.isfile(file_path):
        file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
        if file_time < date_threshold:
            # 将文件移动到目标目录
            shutil.move(file_path, dst_dir)

# 压缩目标目录
zip_file_name = os.path.join(dst_dir, "archive.zip")
with zipfile.ZipFile(zip_file_name, 'w', zipfile.ZIP_DEFLATED) as zipf:
    for root, _, files in os.walk(dst_dir):
        for file in files:
            if file != "archive.zip":  # 避免压缩zip文件本身
                zipf.write(os.path.join(root, file), os.path.relpath(os.path.join(root, file), dst_dir))

通过以上修改，你可以实现跨服务器复制文件的功能以及将指定日期前的文件剪切到本地文件夹并压缩的功能。

可以使用pysmb库来实现这一点。以下是实现上述两个功能的示例代码：

1.自动拷贝新生成的文件到远程系统

import os
import datetime
from smb.SMBConnection import SMBConnection

# 连接到远程系统
conn = SMBConnection('username', 'password', 'localhost', 'remote_server_name', domain='domain_name', use_ntlm_v2=True)
conn.connect('remote_server_ip', 139)

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"

# 获取当天日期
today = datetime.date.today()

# 遍历源目录中的文件，找到当天生成的文件，并将其复制到目标目录中
for file_name in os.listdir(src_dir):
    file_path = os.path.join(src_dir, file_name)
    if os.path.isfile(file_path):
        file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
        if file_time == today:
            with open(file_path, 'rb') as file:
                file_contents = file.read()
                conn.storeFile('remote_share_name', os.path.join(dst_dir, file_name), file_contents)

# 断开连接
conn.close()

2.查询文件夹中指定日期前的文件并剪切到本地文件夹

import os
import datetime
import shutil
import zipfile

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"
cut_dir = "/path/to/cut/directory"
cut_date = datetime.date.today() - datetime.timedelta(days=90)

# 遍历源目录中的文件，找到指定日期前的文件，并将其剪切到目标目录中
for file_name in os.listdir(src_dir):
    file_path = os.path.join(src_dir, file_name)
    if os.path.isfile(file_path):
        file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
        if file_time < cut_date:
            shutil.move(file_path, cut_dir)

# 压缩移动后的文件
zip_file = os.path.join(dst_dir, 'cut_files.zip')
with zipfile.ZipFile(zip_file, 'w') as zip:
    for file_name in os.listdir(cut_dir):
        file_path = os.path.join(cut_dir, file_name)
        if os.path.isfile(file_path):
            zip.write(file_path, file_name)

# 删除移动后的文件
shutil.rmtree(cut_dir)

希望这可以帮助您实现您的需求。

该回答引用ChatGPT GPT-4

以下是一个示例代码，每天定时将新生成的文件从一个服务器拷贝到另一个Windows服务器：


import os
import datetime
import shutil
from smbprotocol.create_context import CreateContext
from smbprotocol.smb2 import SMB2Connection
from smbprotocol.smb2 import SMB2Command
from smbprotocol.smb2 import SMB2Session

def copy_files_over_smb(src_dir, dst_dir, remote_server, remote_username, remote_password):
    with SMB2Connection(remote_server, username=remote_username, password=remote_password) as conn:
        with SMB2Session(conn) as session:
            for file_name in os.listdir(src_dir):
                file_path = os.path.join(src_dir, file_name)
                if os.path.isfile(file_path):
                    file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
                    if file_time == today:
                        with CreateContext(session, dst_dir, create_options=SMB2Command.FILE_OPEN_IF) as dst_file:
                            with open(file_path, "rb") as src_file:
                                data = src_file.read()
                                dst_file.write(data, 0)

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"
remote_server = "remote_server_address"
remote_username = "remote_username"
remote_password = "remote_password"
today = datetime.date.today()

copy_files_over_smb(src_dir, dst_dir, remote_server, remote_username, remote_password)

查询指定日期前的文件，将结果剪切到本地文件夹并压缩：


import os
import datetime
import shutil
import zipfile

src_dir = "/path/to/source/directory"
dst_dir = "/path/to/destination/directory"
zip_file_path = "/path/to/zip/file.zip"

def archive_and_move_old_files(src_dir, dst_dir, zip_file_path, days_before):
    today = datetime.date.today()
    cutoff_date = today - datetime.timedelta(days=days_before)

    with zipfile.ZipFile(zip_file_path, "w", zipfile.ZIP_DEFLATED) as zip_file:
        for file_name in os.listdir(src_dir):
            file_path = os.path.join(src_dir, file_name)
            if os.path.isfile(file_path):
                file_time = datetime.date.fromtimestamp(os.path.getmtime(file_path))
                if file_time < cutoff_date:
                    zip_file.write(file_path, os.path.relpath(file_path, src_dir))
                    shutil.move(file_path, os.path.join(dst_dir, file_name))

days_before = 90
archive_and_move_old_files(src_dir, dst_dir, zip_file_path, days_before)

这个脚本将在源目录中查找指定日期（如90天）前的文件，将它们压缩到一个ZIP文件中，并将原始文件移动到目标目录中。

python跨服务器实现复制 ，剪切的功能需求

python跨服务器实现复制，剪切的功能需求