2단계 : 6. 실습 : 파이썬 파일 관리 시스템

1. 전체 개요

 

이 코드는 파이썬으로 구현한 간단한 파일 관리 시스템입니다. 다양한 파일 유형(txt, csv, json)을 읽고 쓰며, 디렉터리 생성 및 삭제, 파일 검색, 수정 등의 기능까지 포함되어 있어 학습용 프로젝트나 업무 자동화 스크립트로 활용하기 적합합니다.

 

 

주요 클래스 설명

 

㉮ FileManager

  • 기능: 파일의 기본 정보를 가져오고, 이름 변경, 복사, 삭제 등의 기능 제공

  • 주요 메서드:

      • get_file_info() – 파일 경로, 이름, 크기 등 반환

      • rename() – 파일 이름 변경

      • copy() – 파일 복사

      • delete() – 파일 삭제

class FileManager:
    # 파일 관리 기본 클래스
    def __init__(self, file_path: str):
        # FileManager 초기화
        # Args: file_path (str): 처리할 파일 경로
        self.file_path = file_path
        self.file_name = os.path.basename(file_path)
        self.directory = os.path.dirname(file_path)
        self.extension = os.path.splitext(file_path)[1].lower()
        self.update_file_stats()
        
    def update_file_stats(self) -> None:
        # 파일 통계 정보 업데이트
        if os.path.exists(self.file_path):
            stats = os.stat(self.file_path)
            self.file_stats = {
                "size": stats.st_size,
                "modified": datetime.datetime.fromtimestamp(stats.st_mtime),
                "exists": True
            }
        else:
            self.file_stats = {"exists": False}
            
    def get_file_info(self) -> Dict[str, Any]:
        # 파일 정보 반환
        # Returns: Dict[str, Any]: 파일 정보를 담은 딕셔너리
        self.update_file_stats()
        return {
            "path": self.file_path,
            "name": self.file_name,
            "directory": self.directory,
            "extension": self.extension,
            "stats": self.file_stats
        }
    
    def rename(self, new_name: str) -> bool:
        # 파일 이름 변경
        # Args: new_name (str): 새 파일 이름 
        # Returns: bool: 성공 여부
        try:
            new_path = os.path.join(self.directory, new_name)
            os.rename(self.file_path, new_path)
            logger.info(f"파일 이름 변경: {self.file_path} -> {new_path}")
            
            # 객체 속성 업데이트
            self.file_path = new_path
            self.file_name = new_name
            self.extension = os.path.splitext(new_path)[1].lower()
            self.update_file_stats()
            
            return True
        except Exception as e:
            logger.error(f"파일 이름 변경 중 오류 발생: {e}")
            return False
    
    def copy(self, new_path: str) -> bool:
        # 파일 복사
        # Args: new_path (str): 새 파일 경로  
        # Returns: bool: 성공 여부
        try:
            # 대상 디렉터리가 없으면 생성
            target_dir = os.path.dirname(new_path)
            if target_dir and not os.path.exists(target_dir):
                os.makedirs(target_dir)
                
            shutil.copy2(self.file_path, new_path)
            logger.info(f"파일 복사: {self.file_path} -> {new_path}")
            return True
        except Exception as e:
            logger.error(f"파일 복사 중 오류 발생: {e}")
            return False
    
    def delete(self) -> bool:
        # 파일 삭제
        # Returns: bool: 성공 여부
        try:
            if os.path.exists(self.file_path):
                os.remove(self.file_path)
                logger.info(f"파일 삭제: {self.file_path}")
                self.update_file_stats()
                return True
            else:
                logger.warning(f"삭제할 파일이 존재하지 않음: {self.file_path}")
                return False
        except Exception as e:
            logger.error(f"파일 삭제 중 오류 발생: {e}")
            return False

 

㉯ TextFileManager

  • 기능: 텍스트 파일 읽기/쓰기/검색/수정 처리

  • 상속: FileManager로부터 상속

  • 주요 메서드:

      • read() – 파일 전체 내용 읽기

      • read_lines() – 줄 단위로 읽기

      • search(pattern) – 특정 문자열 검색 (정규표현식 포함)

      • replace(pattern, replacement) – 특정 문자열 치환

class TextFileManager(FileManager):
    # 텍스트 파일 처리 클래스
    
    def __init__(self, file_path: str, encoding: str = "utf-8"):
        # TextFileManager 초기화
        # Args: file_path (str): 텍스트 파일 경로 , encoding (str): 파일 인코딩 (기본값: utf-8)
        super().__init__(file_path)
        self.encoding = encoding
    
    def read(self) -> str:
        # 텍스트 파일 전체 읽기
        # Returns: str: 파일 내용
        try:
            with open(self.file_path, 'r', encoding=self.encoding) as f:
                content = f.read()
            logger.info(f"파일 읽기 완료: {self.file_path}")
            return content
        except Exception as e:
            logger.error(f"파일 읽기 중 오류 발생: {e}")
            raise
    
    def read_lines(self) -> List[str]:
        # 텍스트 파일을 줄 단위로 읽기
        # Returns: List[str]: 줄 목록
        try:
            with open(self.file_path, 'r', encoding=self.encoding) as f:
                lines = f.readlines()
            logger.info(f"파일 줄 단위 읽기 완료: {self.file_path}, 총 {len(lines)}줄")
            return [line.rstrip('\n') for line in lines]  # 줄바꿈 문자 제거
        except Exception as e:
            logger.error(f"파일 줄 단위 읽기 중 오류 발생: {e}")
            raise
    
    def write(self, content: str, mode: str = 'w') -> bool:
        # 텍스트 파일 쓰기
        # Args: content (str): 쓸 내용 , 
        #       mode (str): 쓰기 모드 ('w': 덮어쓰기, 'a': 추가)
        # Returns: bool: 성공 여부
        try:
            # 디렉터리가 없으면 생성
            if self.directory and not os.path.exists(self.directory):
                os.makedirs(self.directory)
                
            with open(self.file_path, mode, encoding=self.encoding) as f:
                f.write(content)
            
            self.update_file_stats()
            logger.info(f"파일 쓰기 완료: {self.file_path}, 모드: {mode}")
            return True
        except Exception as e:
            logger.error(f"파일 쓰기 중 오류 발생: {e}")
            return False
    
    def search(self, pattern: str, case_sensitive: bool = True) -> List[Tuple[int, str]]:
        # 텍스트 파일에서 패턴 검색
        # Args: pattern (str): 검색할 패턴 , 
        #       case_sensitive (bool): 대소문자 구분 여부   
        # Returns: List[Tuple[int, str]]: (줄 번호, 줄 내용) 튜플의 목록
        results = []
        
        try:
            # 정규식 컴파일
            flags = 0 if case_sensitive else re.IGNORECASE
            regex = re.compile(pattern, flags)
            
            with open(self.file_path, 'r', encoding=self.encoding) as f:
                for i, line in enumerate(f, 1):  # 1부터 시작하는 줄 번호
                    if regex.search(line):
                        results.append((i, line.rstrip('\n')))
            
            logger.info(f"패턴 '{pattern}' 검색 완료: {len(results)}개 일치")
            return results
        except Exception as e:
            logger.error(f"패턴 검색 중 오류 발생: {e}")
            raise
    
    def replace(self, pattern: str, replacement: str, case_sensitive: bool = True) -> int:
        # 텍스트 파일에서 패턴 찾아 바꾸기
        # Args: pattern (str): 찾을 패턴 , 
        #       replacement (str): 바꿀 내용 , 
        #       case_sensitive (bool): 대소문자 구분 여부 
        # Returns: int: 변경된 횟수
        try:
            # 정규식 컴파일
            flags = 0 if case_sensitive else re.IGNORECASE
            regex = re.compile(pattern, flags)
            
            # 모든 내용 읽기
            with open(self.file_path, 'r', encoding=self.encoding) as f:
                content = f.read()
            
            # 패턴 바꾸기
            new_content, count = regex.subn(replacement, content)
            
            # 변경된 내용 쓰기
            if count > 0:
                with open(self.file_path, 'w', encoding=self.encoding) as f:
                    f.write(new_content)
                
                self.update_file_stats()
                logger.info(f"패턴 '{pattern}' 바꾸기 완료: 변경 {count}개")
            else:
                logger.info(f"패턴 '{pattern}'에 해당하는 내용 없음")
                
            return count
        except Exception as e:
            logger.error(f"패턴 바꾸기 중 오류 발생: {e}")
            raise

 

㉰ CSVFileManager

  • 기능: CSV 파일 읽기/쓰기

  • 상속: TextFileManager로부터 상속

  • 주요 메서드:

      • read_csv() – 리스트 형태로 읽기

      • read_csv_dict() – 딕셔너리 형태로 읽기

      • write_csv() – 리스트 형태로 쓰기

      • write_csv_dict() – 딕셔너리 형태로 쓰기

class CSVFileManager(TextFileManager):
    # CSV 파일 처리 클래스
    def __init__(self, file_path: str, encoding: str = "utf-8", delimiter: str = ","):
        # CSVFileManager 초기화
        # Args: file_path (str): CSV 파일 경로 , 
        #       encoding (str): 파일 인코딩 (기본값: utf-8) , 
        #       delimiter (str): 필드 구분자 (기본값: ',')
        super().__init__(file_path, encoding)
        self.delimiter = delimiter
    
    def read_csv(self) -> List[List[str]]:
        # CSV 파일 읽기
        # Returns: List[List[str]]: CSV 데이터 (행의 목록)
        try:
            data = []
            with open(self.file_path, 'r', encoding=self.encoding, newline='') as f:
                csv_reader = csv.reader(f, delimiter=self.delimiter)
                for row in csv_reader:
                    data.append(row)
            
            logger.info(f"CSV 파일 읽기 완료: {self.file_path}, 총 {len(data)}행")
            return data
        except Exception as e:
            logger.error(f"CSV 파일 읽기 중 오류 발생: {e}")
            raise
    
    def read_csv_dict(self) -> List[Dict[str, str]]:
        # CSV 파일을 딕셔너리 목록으로 읽기 (첫 행은 헤더로 사용)
        # Returns: List[Dict[str, str]]: 딕셔너리 목록
        try:
            data = []
            with open(self.file_path, 'r', encoding=self.encoding, newline='') as f:
                csv_reader = csv.DictReader(f, delimiter=self.delimiter)
                for row in csv_reader:
                    data.append(dict(row))
            
            logger.info(f"CSV 파일 딕셔너리로 읽기 완료: {self.file_path}, 총 {len(data)}행")
            return data
        except Exception as e:
            logger.error(f"CSV 파일 딕셔너리로 읽기 중 오류 발생: {e}")
            raise
    
    def write_csv(self, data: List[List[str]], mode: str = 'w') -> bool:
        # CSV 파일 쓰기
        # Args: data (List[List[str]]): CSV 데이터 (행의 목록), 
        #       mode (str): 쓰기 모드 ('w': 덮어쓰기, 'a': 추가)
        # Returns: bool: 성공 여부
        try:
            # 디렉터리가 없으면 생성
            if self.directory and not os.path.exists(self.directory):
                os.makedirs(self.directory)
                
            with open(self.file_path, mode, encoding=self.encoding, newline='') as f:
                csv_writer = csv.writer(f, delimiter=self.delimiter)
                csv_writer.writerows(data)
            
            self.update_file_stats()
            logger.info(f"CSV 파일 쓰기 완료: {self.file_path}, 총 {len(data)}행")
            return True
        except Exception as e:
            logger.error(f"CSV 파일 쓰기 중 오류 발생: {e}")
            return False
    
    def write_csv_dict(self, data: List[Dict[str, str]], fieldnames: List[str] = None, mode: str = 'w') -> bool:
        # CSV 파일을 딕셔너리 목록에서 쓰기
        # Args: data (List[Dict[str, str]]): 딕셔너리 목록, 
        #       fieldnames (List[str]): 필드 이름 목록 (None이면 첫 번째 딕셔너리에서 추출)
        #       mode (str): 쓰기 모드 ('w': 덮어쓰기, 'a': 추가)
        # Returns: bool: 성공 여부
        try:
            # 디렉터리가 없으면 생성
            if self.directory and not os.path.exists(self.directory):
                os.makedirs(self.directory)
            
            # 필드 이름이 지정되지 않은 경우 첫 번째 딕셔너리에서 추출
            if fieldnames is None and data:
                fieldnames = list(data[0].keys())
            
            with open(self.file_path, mode, encoding=self.encoding, newline='') as f:
                csv_writer = csv.DictWriter(f, fieldnames=fieldnames, delimiter=self.delimiter)
                
                # 새 파일이거나 덮어쓰기 모드인 경우 헤더 쓰기
                if mode == 'w' or not os.path.exists(self.file_path):
                    csv_writer.writeheader()
                
                csv_writer.writerows(data)
            
            self.update_file_stats()
            logger.info(f"CSV 파일 딕셔너리로 쓰기 완료: {self.file_path}, 총 {len(data)}행")
            return True
        except Exception as e:
            logger.error(f"CSV 파일 딕셔너리로 쓰기 중 오류 발생: {e}")
            return False

 

㉱ JSONFileManager

  • 기능: JSON 파일 읽기/쓰기

  • 상속: TextFileManager로부터 상속

  • 주요 메서드:

      • read_json() – JSON 파싱 후 반환

      • write_json() – JSON 객체를 파일로 저장

class JSONFileManager(TextFileManager):
    # JSON 파일 처리 클래스
    
    def read_json(self) -> Any:
        # JSON 파일 읽기
        # Returns: Any: 파싱된 JSON 데이터
        try:
            with open(self.file_path, 'r', encoding=self.encoding) as f:
                data = json.load(f)
            logger.info(f"JSON 파일 읽기 완료: {self.file_path}")
            return data
        except Exception as e:
            logger.error(f"JSON 파일 읽기 중 오류 발생: {e}")
            raise
    
    def write_json(self, data: Any, indent: int = 4) -> bool:
        # JSON 파일 쓰기
        # Args: data (Any): JSON으로 직렬화할 데이터
        #       indent (int): 들여쓰기 공백 수
        # Returns: bool: 성공 여부
        try:
            # 디렉터리가 없으면 생성
            if self.directory and not os.path.exists(self.directory):
                os.makedirs(self.directory)
                
            with open(self.file_path, 'w', encoding=self.encoding) as f:
                json.dump(data, f, indent=indent, ensure_ascii=False)
            
            self.update_file_stats()
            logger.info(f"JSON 파일 쓰기 완료: {self.file_path}")
            return True
        except Exception as e:
            logger.error(f"JSON 파일 쓰기 중 오류 발생: {e}")
            return False

 

㉲ DirectoryManager

  • 기능: 디렉터리 생성, 삭제, 특정 확장자 탐색, 파일 목록 조회

  • 주요 메서드:

      • create() – 디렉터리 생성

      • delete() – 삭제 (옵션으로 재귀 포함)

      • list_files() – 파일 목록 가져오기 (glob 사용)

      • find_files_by_extension() – 특정 확장자의 파일 검색

class DirectoryManager:
    # 디렉터리 처리 클래스
    
    def __init__(self, directory_path: str):
        # DirectoryManager 초기화
        # Args: directory_path (str): 디렉터리 경로
        self.directory_path = os.path.abspath(directory_path)
        self.name = os.path.basename(self.directory_path)
    
    def create(self) -> bool:
        # 디렉터리 생성
        # Returns: bool: 성공 여부
        try:
            if not os.path.exists(self.directory_path):
                os.makedirs(self.directory_path)
                logger.info(f"디렉터리 생성 완료: {self.directory_path}")
                return True
            else:
                logger.info(f"디렉터리가 이미 존재함: {self.directory_path}")
                return True
        except Exception as e:
            logger.error(f"디렉터리 생성 중 오류 발생: {e}")
            return False
    
    def delete(self, recursive: bool = False) -> bool:
        # 디렉터리 삭제
        # Args: recursive (bool): 재귀적 삭제 여부
        # Returns: bool: 성공 여부
        try:
            if os.path.exists(self.directory_path):
                if recursive:
                    shutil.rmtree(self.directory_path)
                    logger.info(f"디렉터리 재귀적 삭제 완료: {self.directory_path}")
                else:
                    os.rmdir(self.directory_path)
                    logger.info(f"디렉터리 삭제 완료: {self.directory_path}")
                return True
            else:
                logger.warning(f"삭제할 디렉터리가 존재하지 않음: {self.directory_path}")
                return False
        except Exception as e:
            logger.error(f"디렉터리 삭제 중 오류 발생: {e}")
            return False
    
    def list_files(self, pattern: str = "*") -> List[str]:
        # 디렉터리 내 파일 목록 가져오기
        # Args: pattern (str): 파일 이름 패턴 (glob 패턴)
        # Returns: List[str]: 파일 경로 목록
        try:
            import glob
            file_list = []
            for item in glob.glob(os.path.join(self.directory_path, pattern)):
                if os.path.isfile(item):
                    file_list.append(item)
            
            logger.info(f"파일 목록 추출 완료: {len(file_list)}개")
            return file_list
        except Exception as e:
            logger.error(f"파일 목록 추출 중 오류 발생: {e}")
            raise
    
    def find_files_by_extension(self, extension: str) -> List[str]:
        # 특정 확장자를 가진 파일 찾기
        # Args: extension (str): 파일 확장자 (점 포함 또는 미포함)
        # Returns: List[str]: 파일 경로 목록
        # 확장자 형식 정규화 (점 포함)
        if not extension.startswith('.'):
            extension = '.' + extension
            
        import glob
        return [f for f in glob.glob(os.path.join(self.directory_path, f"*{extension}"))]

 

㉳ create_file_manager()

  • 기능: 파일 확장자에 따라 자동으로 알맞은 매니저 클래스 반환

  • .csv이면 CSVFileManager, .json이면 JSONFileManager 등 자동 매핑됨

def create_file_manager(file_path: str, encoding: str = "utf-8") -> FileManager:
    # 파일 확장자에 따라 적절한 파일 관리자 생성
    # Args: file_path (str): 파일 경로
    #       encoding (str): 텍스트 파일 인코딩
    # Returns: FileManager: 파일 관리자 객체
    extension = os.path.splitext(file_path)[1].lower()
    
    # 확장자별 관리자 선택
    if extension in ['.csv', '.tsv']:
        delimiter = '\t' if extension == '.tsv' else ','
        return CSVFileManager(file_path, encoding, delimiter)
    elif extension == '.json':
        return JSONFileManager(file_path, encoding)
    elif extension in ['.txt', '.log', '.md', '.py', '.js', '.html', '.css', '.xml']:
        return TextFileManager(file_path, encoding)
    else:
        # 기본적으로 텍스트 파일로 시도
        return TextFileManager(file_path, encoding)

 

㉴ main()

  • 기능: 전체 기능을 데모하는 예제 실행

  • 텍스트, CSV, JSON 파일을 각각 생성 및 처리하고, 디렉터리도 생성하여 목록을 출력함

def main():
    # 메인 함수: 간단한 예시 실행
    # 텍스트 파일 처리 예시
    text_file = "example.txt"
    text_manager = TextFileManager(text_file)
    
    # 텍스트 파일 쓰기
    text_manager.write("Hello, World!\n파이썬 파일 관리 시스템 예시입니다.\nThis is an example.")
    print(f"텍스트 파일 작성 완료: {text_file}")
    
    # 텍스트 파일 읽기
    content = text_manager.read()
    print("\n=== 파일 내용 ===")
    print(content)
    
    # 패턴 검색
    results = text_manager.search("파이썬")
    print("\n=== 검색 결과 ===")
    for line_num, line in results:
        print(f"{line_num}행: {line}")
    
    # 패턴 바꾸기
    count = text_manager.replace("example", "샘플")
    print(f"\n'example'을 '샘플'로 {count}번 변경했습니다.")
    
    # 변경된 내용 확인
    updated_content = text_manager.read()
    print("\n=== 변경된 내용 ===")
    print(updated_content)
    
    # CSV 파일 처리 예시
    csv_file = "sample.csv"
    csv_manager = CSVFileManager(csv_file)
    
    # CSV 데이터 생성 및 쓰기
    csv_data = [
        ['이름', '나이', '도시'],
        ['홍길동', '30', '서울'],
        ['김철수', '25', '부산'],
        ['이영희', '28', '인천']
    ]
    csv_manager.write_csv(csv_data)
    print(f"\nCSV 파일 작성 완료: {csv_file}")
    
    # CSV 파일 읽기
    read_data = csv_manager.read_csv()
    print("\n=== CSV 내용 ===")
    for row in read_data:
        print(", ".join(row))
    
    # JSON 파일 처리 예시
    json_file = "config.json"
    json_manager = JSONFileManager(json_file)
    
    # JSON 데이터 생성 및 쓰기
    json_data = {
        "name": "파일 관리 시스템",
        "version": "1.0",
        "settings": {
            "debug": True,
            "max_files": 100,
            "extensions": [".txt", ".csv", ".json"]
        }
    }
    json_manager.write_json(json_data)
    print(f"\nJSON 파일 작성 완료: {json_file}")
    
    # JSON 파일 읽기
    config = json_manager.read_json()
    print("\n=== JSON 내용 ===")
    print(f"이름: {config['name']}")
    print(f"버전: {config['version']}")
    print(f"설정: {config['settings']}")
    
    # 디렉터리 처리 예시
    dir_path = "example_dir"
    dir_manager = DirectoryManager(dir_path)
    
    # 디렉터리 생성
    dir_manager.create()
    print(f"\n디렉터리 생성 완료: {dir_path}")
    
    # 현재 디렉터리의 모든 파일 목록
    current_dir = DirectoryManager(".")
    files = current_dir.list_files()
    print("\n=== 현재 디렉터리 파일 목록 ===")
    for file in files:
        print(os.path.basename(file))


if __name__ == "__main__":
    main()

 

출력결과

2025-03-23 18:57:05,356 - INFO - 파일 쓰기 완료: example.txt, 모드: w
텍스트 파일 작성 완료: example.txt
2025-03-23 18:57:05,356 - INFO - 파일 읽기 완료: example.txt

=== 파일 내용 ===
Hello, World!
파이썬 파일 관리 시스템 예시입니다.
This is an example.
2025-03-23 18:57:05,356 - INFO - 패턴 '파이썬' 검색 완료: 1개 일치

=== 검색 결과 ===
2행: 파이썬 파일 관리 시스템 예시입니다.
2025-03-23 18:57:05,357 - INFO - 패턴 'example' 바꾸기 완료: 변경 1개

'example'을 '샘플'로 1번 변경했습니다.
2025-03-23 18:57:05,357 - INFO - 파일 읽기 완료: example.txt

=== 변경된 내용 ===
Hello, World!
파이썬 파일 관리 시스템 예시입니다.
This is an 샘플.
2025-03-23 18:57:05,357 - INFO - CSV 파일 쓰기 완료: sample.csv, 총 4행

CSV 파일 작성 완료: sample.csv
2025-03-23 18:57:05,357 - INFO - CSV 파일 읽기 완료: sample.csv, 총 4행

=== CSV 내용 ===
이름, 나이, 도시
홍길동, 30, 서울
김철수, 25, 부산
이영희, 28, 인천
2025-03-23 18:57:05,358 - INFO - JSON 파일 쓰기 완료: config.json

JSON 파일 작성 완료: config.json
2025-03-23 18:57:05,358 - INFO - JSON 파일 읽기 완료: config.json

=== JSON 내용 ===
이름: 파일 관리 시스템
버전: 1.0
설정: {'debug': True, 'max_files': 100, 'extensions': ['.txt', '.csv', '.json']}
2025-03-23 18:57:05,358 - INFO - 디렉터리가 이미 존재함: /config/workspace/Python_test/example_dir

디렉터리 생성 완료: example_dir
2025-03-23 18:57:05,359 - INFO - 파일 목록 추출 완료: 8개

=== 현재 디렉터리 파일 목록 ===
main.py
main2.py
books.py
book_management.py
file_inout.py
example.txt
sample.csv
config.json

 

위 클래스를 참조해서 수정해서 사용하면 될 것이다.