Python脚本-file_operations

2025-01-15

该脚本是一个强大的文件操作工具，支持在指定目录及其子目录下批量执行各种文件操作。功能涵盖了文件备份、查找替换、插入字符、文件权限修改、文件删除等多个方面，方便进行自动化的文件管理和处理

Souce Code

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Script Name: file_operations.py
# Author: ZLin
# Date: 2025-01-15
#
# Description:
# This script performs various file operations such as backing up files,
# inserting characters at specified intervals, replacing strings in files,
# modifying file permissions, deleting files and folders, and renaming files and folders.
# The script can be customized to operate on a specific directory and supports multiple file operations
# that can be controlled via command-line arguments.
#
# Usage:
# python file_operations.py [OPTIONS]
#
# Options:
#   -d, --directory           Directory to operate in (default: current directory)
#   --insert-char <CHAR>      Character to insert every n lines
#   --line-interval <N>       Interval for inserting character
#   --backup                  Create backup of the file before modifications
#   --append <TEXT>           Text to append to the file
#   --find-replace <FIND> <REPLACE>   Find and replace text in files
#   --chmod <PERMISSIONS>     File permissions to set (octal format)
#   --remove-empty            Remove empty lines from the file
#   --merge-files <FILES>     Files to merge into a single file
#   --count-string <STRING>   Count occurrences of a string in files
#   --compare-files <FILE1> <FILE2>  Compare two files
#   --remove-lines <START> <END>    Remove lines from file (START, END)
#   --create-file <PATH>      Create a new file with provided content
#   --delete-files-with-str <STRING>  Delete files containing specific string in name
#   --delete-folders-with-str <STRING> Delete folders containing specific string in name
#   --rename-files-with-str <STRING>  Substring to search for in filenames to rename
#   --rename-to-str <STRING>   Substring to rename the files to
#   --rename-folders-with-str <STRING> Substring to search for in folder names to rename
#   --rename-folders-to-str <STRING> Substring to rename the folders to

import os
import shutil
import argparse
import fileinput


class FileOperations:
  def __init__(self, directory='.', insert_char=None, line_interval=None, backup=False, append=None, find_replace=None, chmod=None, remove_empty=False, merge_files=None, count_string=None, compare_files=None, remove_lines=None, create_file=None, delete_files_with_str=None, delete_folders_with_str=None, rename_files_with_str=None, rename_to_str=None, rename_folders_with_str=None, rename_folders_to_str=None):
    self.directory = directory
    self.insert_char = insert_char
    self.line_interval = line_interval
    self.backup = backup
    self.append = append
    self.find_replace = find_replace
    self.chmod = chmod
    self.remove_empty = remove_empty
    self.merge_files = merge_files
    self.count_string = count_string
    self.compare_files = compare_files
    self.remove_lines = remove_lines
    self.create_file = create_file
    self.delete_files_with_str = delete_files_with_str
    self.delete_folders_with_str = delete_folders_with_str
    self.rename_files_with_str = rename_files_with_str
    self.rename_to_str = rename_to_str
    self.rename_folders_with_str = rename_folders_with_str
    self.rename_folders_to_str = rename_folders_to_str

  def backup_file(self, file_path):
    """Backup a file before making any changes."""
    if self.backup:
      if not os.path.exists(file_path):
        print(f"Error: {file_path} does not exist.")
        return
      backup_path = f"{file_path}.bak"
      shutil.copy(file_path, backup_path)
      print(f"Backup created: {backup_path}")

  def insert_char_every(self, file_path):
    """Insert a character every n lines."""
    if self.line_interval and self.insert_char:
      with open(file_path, 'r+') as f:
        lines = f.readlines()
        f.seek(0)  # Go back to the start of the file for writing
        for idx, line in enumerate(lines, start=1):
          f.write(line)
          if idx % self.line_interval == 0:
            f.write(f"{self.insert_char}\n")
      print(f"Inserted '{self.insert_char}' every {self.line_interval} lines in {file_path}")

  def replace_in_file(self, file_path):
    """Find and replace a string in a file."""
    if self.find_replace:
      search, replace = self.find_replace
      with fileinput.FileInput(file_path, inplace=True) as f:
        for line in f:
          print(line.replace(search, replace), end='')
      print(f"Replaced '{search}' with '{replace}' in {file_path}")

  def chmod_file(self, file_path):
    """Change file permissions."""
    if self.chmod:
      os.chmod(file_path, self.chmod)
      print(f"Changed permissions of {file_path} to {oct(self.chmod)}")

  def remove_empty_lines(self, file_path):
    """Remove empty lines from the file."""
    if self.remove_empty:
      with open(file_path, 'r') as f:
        lines = [line for line in f if line.strip()]
      with open(file_path, 'w') as f:
        f.writelines(lines)
      print(f"Removed empty lines from {file_path}")

  def merge_files(self, file_paths, output_path):
    """Merge multiple files into one."""
    if self.merge_files:
      with open(output_path, 'w') as outfile:
        for file_path in file_paths:
          with open(file_path, 'r') as infile:
            outfile.write(infile.read())
      print(f"Merged files into {output_path}")

  def count_string_occurrences(self, file_path):
    """Count occurrences of a specific string in the file."""
    if self.count_string:
      count = 0
      with open(file_path, 'r') as f:
        for line in f:
          count += line.count(self.count_string)
      print(f"'{self.count_string}' occurs {count} times in {file_path}")

  def compare_files(self, file_path1, file_path2):
    """Compare two files."""
    if self.compare_files:
      with open(file_path1, 'r') as f1, open(file_path2, 'r') as f2:
        lines1 = f1.readlines()
        lines2 = f2.readlines()
      differences = [(i+1, line1, line2) for i, (line1, line2) in enumerate(zip(lines1, lines2)) if line1 != line2]
      if differences:
        print(f"Differences between {file_path1} and {file_path2}:")
        for diff in differences:
          print(f"Line {diff[0]}: {diff[1].strip()} != {diff[2].strip()}")
      else:
        print(f"No differences between {file_path1} and {file_path2}")

  def remove_lines_from_file(self, file_path):
    """Remove specific lines from the file."""
    if self.remove_lines:
      with open(file_path, 'r') as f:
        lines = f.readlines()
      lines_to_remove = set(range(self.remove_lines[0], self.remove_lines[1] + 1))
      with open(file_path, 'w') as f:
        for idx, line in enumerate(lines):
          if idx not in lines_to_remove:
            f.write(line)
      print(f"Removed lines {self.remove_lines[0]} to {self.remove_lines[1]} from {file_path}")

  def create_file(self):
    """Create a new file with specified content."""
    if self.create_file:
      with open(self.create_file['path'], 'w') as f:
        f.write(self.create_file['content'])
      print(f"Created file {self.create_file['path']} with provided content.")

  def delete_files_by_name(self):
    """Delete files in the directory that contain a specific substring in their names."""
    if self.delete_files_with_str:
      for root, dirs, files in os.walk(self.directory):
        for file_name in files:
          if self.delete_files_with_str in file_name:
            file_path = os.path.join(root, file_name)
            os.remove(file_path)
            print(f"Deleted file: {file_path}")

  def delete_folders_by_name(self):
    """Delete folders in the directory that contain a specific substring in their names."""
    if self.delete_folders_with_str:
      for root, dirs, files in os.walk(self.directory, topdown=False):
        for dir_name in dirs:
          if self.delete_folders_with_str in dir_name:
            folder_path = os.path.join(root, dir_name)
            shutil.rmtree(folder_path)
            print(f"Deleted folder: {folder_path}")

  def rename_files(self):
    """Rename files that contain a specific substring in their names."""
    if self.rename_files_with_str and self.rename_to_str:
      for root, dirs, files in os.walk(self.directory):
        for file_name in files:
          if self.rename_files_with_str in file_name:
            old_file_path = os.path.join(root, file_name)
            new_file_name = file_name.replace(self.rename_files_with_str, self.rename_to_str)
            new_file_path = os.path.join(root, new_file_name)
            os.rename(old_file_path, new_file_path)
            print(f"Renamed file: {old_file_path} -> {new_file_path}")

  def rename_folders(self):
    """Rename folders that contain a specific substring in their names."""
    if self.rename_folders_with_str and self.rename_folders_to_str:
      for root, dirs, files in os.walk(self.directory):
        for dir_name in dirs:
          if self.rename_folders_with_str in dir_name:
            old_folder_path = os.path.join(root, dir_name)
            new_folder_name = dir_name.replace(self.rename_folders_with_str, self.rename_folders_to_str)
            new_folder_path = os.path.join(root, new_folder_name)
            os.rename(old_folder_path, new_folder_path)
            print(f"Renamed folder: {old_folder_path} -> {new_folder_path}")

  def process_files(self):
    """Process files based on the specified operations."""
    for root, dirs, files in os.walk(self.directory):
      for file_name in files:
        file_path = os.path.join(root, file_name)
        self.backup_file(file_path)
        self.insert_char_every(file_path)
        self.replace_in_file(file_path)
        self.chmod_file(file_path)
        self.remove_empty_lines(file_path)

    if self.merge_files:
      self.merge_files(self.merge_files, "merged_file.txt")

    if self.count_string:
      self.count_string_occurrences(file_path)

    if self.compare_files:
      self.compare_files(self.compare_files[0], self.compare_files[1])

    if self.remove_lines:
      self.remove_lines_from_file(file_path)

    if self.create_file:
      self.create_file()

    if self.delete_files_with_str:
      self.delete_files_by_name()

    if self.delete_folders_with_str:
      self.delete_folders_by_name()

    if self.rename_files_with_str and self.rename_to_str:
      self.rename_files()

    if self.rename_folders_with_str and self.rename_folders_to_str:
      self.rename_folders()


def main():
  parser = argparse.ArgumentParser(description="File operations script")

  # Arguments for the script
  parser.add_argument('-f', '--file', nargs='?', type=str, help="Specify the file to operate on")
  parser.add_argument('-d', '--directory', default='.', help="Directory to operate in")
  parser.add_argument('--insert-char', type=str, help="Character to insert every n lines")
  parser.add_argument('--line-interval', type=int, help="Interval for inserting character")
  parser.add_argument('--backup', action='store_true', help="Create backup of the file before modifications")
  parser.add_argument('--append', type=str, help="Text to append to the file")
  parser.add_argument('--find-replace', nargs=2, metavar=('FIND', 'REPLACE'), help="Find and replace text in files")
  parser.add_argument('--chmod', type=int, help="File permissions to set (octal format)")
  parser.add_argument('--remove-empty', action='store_true', help="Remove empty lines from the file")
  parser.add_argument('--merge-files', nargs='+', metavar='FILE', help="Files to merge into a single file")
  parser.add_argument('--count-string', type=str, help="Count occurrences of a string in files")
  parser.add_argument('--compare-files', nargs=2, metavar=('FILE1', 'FILE2'), help="Compare two files")
  parser.add_argument('--remove-lines', nargs=2, type=int, metavar=('START', 'END'), help="Remove lines from file (START, END)")
  parser.add_argument('--create-file', type=str, help="Create a new file with provided content")
  parser.add_argument('--delete-files-with-str', type=str, help="Delete files containing specific string in name")
  parser.add_argument('--delete-folders-with-str', type=str, help="Delete folders containing specific string in name")
  parser.add_argument('--rename-files-with-str', type=str, help="Substring to search for in filenames to rename")
  parser.add_argument('--rename-to-str', type=str, help="Substring to rename the files to")
  parser.add_argument('--rename-folders-with-str', type=str, help="Substring to search for in folder names to rename")
  parser.add_argument('--rename-folders-to-str', type=str, help="Substring to rename the folders to")

  args = parser.parse_args()
  
  if args.file and args.directory:
    print("Error: Cannot specify both --file and --directory arguments.")
    sys.exit(1)

  file_ops = FileOperations(
    file=args.file,
    directory=args.directory,
    insert_char=args.insert_char,
    line_interval=args.line_interval,
    backup=args.backup,
    append=args.append,
    find_replace=args.find_replace,
    chmod=args.chmod,
    remove_empty=args.remove_empty,
    merge_files=args.merge_files,
    count_string=args.count_string,
    compare_files=args.compare_files,
    remove_lines=args.remove_lines,
    create_file={'path': args.create_file, 'content': 'sample content'} if args.create_file else None,
    delete_files_with_str=args.delete_files_with_str,
    delete_folders_with_str=args.delete_folders_with_str,
    rename_files_with_str=args.rename_files_with_str,
    rename_to_str=args.rename_to_str,
    rename_folders_with_str=args.rename_folders_with_str,
    rename_folders_to_str=args.rename_folders_to_str
  )

    
  file_ops.process_files()


if __name__ == "__main__":
  main()

脚本使用说明

简介

该脚本是一个强大的文件操作工具，支持在指定目录及其子目录下批量执行各种文件操作。功能涵盖了文件备份、查找替换、插入字符、文件权限修改、文件删除等多个方面，方便进行自动化的文件管理和处理。

功能

1. 备份文件（Backup File）

该功能会在修改文件之前，自动创建一个 .bak 扩展名的备份文件，避免丢失重要数据。

2. 每隔n行插入字符（Insert Character Every n Lines）

在文件的指定行数间隔处插入指定字符，可以帮助你在代码文件中插入注释、分隔符等内容。

3. 追加文本（Append Text）

可以将指定的文本追加到文件的末尾，适用于日志文件、配置文件等需要持续追加内容的场景。

4. 查找并替换文本（Find and Replace Text）

脚本可以在指定文件中查找并替换文本，适用于批量修改配置文件、代码文件中的常量等。

5. 更改文件权限（Change File Permissions）

该功能允许你为文件设置特定的权限，使用八进制表示法（例如 755）。

6. 删除空行（Remove Empty Lines）

可以清除文件中的所有空行，常用于格式化代码文件、清理日志文件。

7. 合并文件（Merge Files）

将多个文件的内容合并成一个文件，适用于需要汇总多个文件数据的场景。

8. 统计字符串出现次数（Count String Occurrences）

脚本可以统计指定字符串在文件中的出现次数，适用于分析日志文件中某个关键字的出现频率。

9. 比较文件（Compare Files）

比较两个文件的内容，并输出差异，适用于版本控制、配置文件对比等场景。

10. 删除指定行（Remove Specific Lines from File）

删除文件中的特定行，可以按行号范围删除，适用于清理不需要的注释、空行等。

11. 创建文件（Create File with Specific Content）

在指定路径创建一个新文件，并可以写入初始内容，适用于批量创建配置文件等。

12. 删除包含特定字符串的文件（Delete Files Containing Specific String）

删除文件名中包含指定字符串的文件，适用于清理多余的文件。

13. 删除包含特定字符串的文件夹（Delete Folders Containing Specific String）

删除文件夹名中包含指定字符串的文件夹。

14. 重命名文件（Rename Files）

批量修改文件名中的特定字符，可以将文件名中的某一部分替换为新的字符串，适用于批量重命名文件。

15. 重命名文件夹（Rename Folders）

批量修改文件夹名中的特定字符，适用于重命名文件夹。

使用方法

1. 备份文件

使用 --backup 参数可以在操作文件之前创建备份。

1	python script.py --backup -d /path/to/directory

2. 每隔n行插入字符

使用 --insert-char 和 --line-interval 参数指定插入字符和行间隔。

1	python script.py --insert-char "#" --line-interval 5 -d /path/to/directory

3. 追加文本

使用 --append 参数指定要追加的文本。

1	python script.py --append "This is an appended text" -d /path/to/directory

4. 查找并替换文本

使用 --find-replace 参数指定要查找的字符串和要替换的字符串。

1	python script.py --find-replace "oldText" "newText" -d /path/to/directory

5. 更改文件权限

使用 --chmod 参数指定文件权限。

1	python script.py --chmod 755 -d /path/to/directory

6. 删除空行

使用 --remove-empty 参数删除文件中的空行。

1	python script.py --remove-empty -d /path/to/directory

7. 合并文件

使用 --merge-files 参数指定要合并的文件。

1	python script.py --merge-files file1.txt file2.txt -d /path/to/directory

8. 统计字符串出现次数

使用 --count-string 参数统计指定字符串的出现次数。

1	python script.py --count-string "ERROR" -d /path/to/directory

9. 比较文件

使用 --compare-files 参数指定要比较的文件。

1	python script.py --compare-files file1.txt file2.txt -d /path/to/directory

10. 删除指定行

使用 --remove-lines 参数指定要删除的行范围。

1	python script.py --remove-lines 5 10 -d /path/to/directory

11. 创建文件

使用 --create-file 参数创建新文件，并指定文件内容。

1	python script.py --create-file new_file.txt -d /path/to/directory

12. 删除包含特定字符串的文件

使用 --delete-files-with-str 参数删除文件名中包含特定字符串的文件。

1	python script.py --delete-files-with-str "test" -d /path/to/directory

13. 删除包含特定字符串的文件夹

使用 --delete-folders-with-str 参数删除文件夹名中包含特定字符串的文件夹。

1	python script.py --delete-folders-with-str "test" -d /path/to/directory

14. 重命名文件

使用 --rename-files-with-str 和 --rename-to-str 参数重命名文件。

1	python script.py --rename-files-with-str "old" --rename-to-str "new" -d /path/to/directory

15. 重命名文件夹

使用 --rename-folders-with-str 和 --rename-folders-to-str 参数重命名文件夹。

1	python script.py --rename-folders-with-str "old" --rename-folders-to-str "new" -d /path/to/directory

参数说明

参数	说明
`-d`, `--directory`	指定操作的目录（默认为当前目录）
`--backup`	在文件操作前创建备份
`--insert-char`	指定插入的字符
`--line-interval`	每隔多少行插入字符
`--append`	指定要追加到文件末尾的文本
`--find-replace`	查找并替换文本，格式为 `"oldText newText"`
`--chmod`	更改文件权限，传入八进制权限值
`--remove-empty`	删除文件中的空行
`--merge-files`	合并多个文件为一个文件
`--count-string`	统计文件中某个字符串的出现次数
`--compare-files`	比较两个文件的差异
`--remove-lines`	删除指定行范围的内容，格式为 `"start end"`
`--create-file`	创建新文件并指定内容
`--delete-files-with-str`	删除文件名中包含指定字符串的文件
`--delete-folders-with-str`	删除文件夹名中包含指定字符串的文件夹
`--rename-files-with-str`	重命名文件名中的特定字符串
`--rename-to-str`	替换为的新字符串
`--rename-folders-with-str`	重命名文件夹中的特定字符串
`--rename-folders-to-str`	替换文件夹名中的字符串

注意事项

请确保操作前对文件进行了备份，尤其是在执行删除或修改操作时。
文件路径和文件夹路径可以是相对路径或绝对路径。
操作过程中会打印日志信息，帮助你了解脚本的执行状态。

本文作者： ICXNM-ZLin
本文链接： https://talent-tudou.github.io/2025/01/15/Programming/Python脚本-file_operations/
版权声明： 本作品采用 CC BY-NC-SA 4.0 进行许可。转载请注明出处！