이제 반 지났다...

Python의 pandas 라이브러리에서 DataFrame 내에 특정 컬럼(열)이 존재하는지 확인하는 것은 데이터 분석 과정에서 자주 필요한 작업입니다. 이를 확인하는 방법은 여러 가지가 있지만, 가장 직관적이고 간단한 방법은 in 키워드를 사용하는 것입니다. 다음은 이 방법과 함께 몇 가지 다른 방법을 소개합니다.

1. in 키워드 사용

in 키워드는 Python의 기본 문법 중 하나로, 어떤 요소가 리스트나 문자열, 딕셔너리의 키 등에 존재하는지 여부를 반환합니다. pandas DataFrame의 컬럼은 내부적으로 리스트 형태로 관리되므로, 이 키워드를 사용하여 특정 컬럼이 존재하는지 쉽게 확인할 수 있습니다.

import pandas as pd

# 샘플 데이터 생성
data = {'Name': ['John', 'Anna'], 'Age': [28, 34], 'City': ['New York', 'Paris']}
df = pd.DataFrame(data)

# 'Age' 컬럼이 있는지 확인
if 'Age' in df:
    print('컬럼이 존재합니다.')
else:
    print('컬럼이 존재하지 않습니다.')

2. columns 속성과 in 키워드 사용

DataFrame.columns는 DataFrame의 모든 컬럼 이름을 포함하고 있습니다. 이 속성을 활용하여 in 키워드와 함께 특정 컬럼이 존재하는지 여부를 확인할 수 있습니다. 이 방법은 첫 번째 방법과 매우 유사합니다.

# 'City' 컬럼이 존재하는지 확인
if 'City' in df.columns:
    print('컬럼이 존재합니다.')
else:
    print('컬럼이 존재하지 않습니다.')

3. hasattr 함수 사용

hasattr 함수는 객체가 특정 속성(또는 메서드)을 가지고 있는지 여부를 확인할 때 사용됩니다. 하지만 DataFrame의 컬럼을 직접적인 속성으로 확인하는 데는 적합하지 않으므로, 이 방법은 DataFrame 컬럼을 확인하는 데 권장되지 않습니다.

4. try-except 구문 사용

특정 컬럼에 접근하려고 할 때, 그 컬럼이 존재하지 않으면 KeyError가 발생합니다. 이를 이용하여 try-except 구문으로도 컬럼의 존재 여부를 확인할 수 있지만, 이 방법은 특정 작업을 시도하면서 동시에 컬럼의 존재 여부를 확인할 때 주로 사용됩니다. 컬럼 존재 여부만을 확인하기 위해 권장되는 방법은 아닙니다.

try:
    df['NonexistentColumn']
    print('컬럼이 존재합니다.')
except KeyError:
    print('컬럼이 존재하지 않습니다.')

일반적으로, in 키워드를 사용하는 방법이 가장 직관적이고 간단하여 널리 사용됩니다.

DataFrame에서 특정 행이 없는 경우에 대처하는 방법은 상황에 따라 다르게 접근할 수 있습니다. 여기에는 몇 가지 일반적인 상황과 해결책을 소개하겠습니다.

1. 특정 조건을 만족하는 행이 없는 경우 확인

pandas를 사용하여 특정 조건을 만족하는 행을 필터링할 때, 만약 해당 조건을 만족하는 행이 없다면 결과는 빈 DataFrame이 됩니다. 이 경우 .empty 속성을 사용하여 DataFrame이 비어 있는지 확인할 수 있습니다.

import pandas as pd

# 샘플 데이터 생성
data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],
        'Age': [28, 34, 29, 32],
        'City': ['New York', 'Paris', 'Berlin', 'London']}
df = pd.DataFrame(data)

# 'Age'가 100 이상인 행 필터링
filtered_df = df[df['Age'] >= 100]

# 결과가 비어 있는지 확인
if filtered_df.empty:
    print('조건을 만족하는 행이 없습니다.')
else:
    print(filtered_df)

2. 특정 인덱스의 행이 존재하는지 확인

DataFrame에서 특정 인덱스의 행이 존재하는지 확인하려면, in 키워드를 사용하여 인덱스가 DataFrame의 인덱스 목록에 있는지 확인할 수 있습니다.

# 인덱스가 5인 행이 있는지 확인
if 5 in df.index:
    print('인덱스 5의 행이 존재합니다.')
else:
    print('인덱스 5의 행이 존재하지 않습니다.')

3. 특정 값이나 조건을 만족하는 행이 존재하는지 확인

any() 함수를 사용하여 DataFrame의 열에 대해 특정 조건을 만족하는 값이 하나라도 있는지 확인할 수 있습니다.

# 'City' 열에 'Seoul'이라는 값이 있는지 확인
if (df['City'] == 'Seoul').any():
    print('Seoul이 City 열에 존재합니다.')
else:
    print('Seoul이 City 열에 존재하지 않습니다.')

4. 특정 행이 없을 때 기본값 설정

DataFrame에서 특정 조건을 만족하는 행이 없을 때, 기본값을 설정하거나 대체하는 로직이 필요할 수 있습니다. 이 경우, 빈 DataFrame을 확인한 후 필요한 조치를 취할 수 있습니다.

예를 들어, 특정 조건을 만족하는 행이 없을 경우 새로운 행을 추가할 수 있습니다:

if filtered_df.empty:
    # 조건을 만족하는 행이 없으므로 새 행 추가
    new_row = {'Name': 'Default', 'Age': 0, 'City': 'Unknown'}
    df = df.append(new_row, ignore_index=True)
    print('새로운 행이 추가되었습니다.')
    print(df)

이러한 방법을 통해 DataFrame에서 특정 행이 없는 상황을 다룰 수 있으며, 상황에 따라 적절한 조치를 취할 수 있습니다.

Python에서 pandas 라이브러리를 사용하여 DataFrame의 특정 열(column) 값에 따라 데이터를 필터링하는 것은 매우 일반적인 작업입니다. 이를 위해 불리언 인덱싱(Boolean indexing)을 주로 사용합니다. 아래에서는 기본적인 예시를 통해 이 방법을 설명하겠습니다.

먼저, pandas가 설치되어 있어야 합니다. 설치되어 있지 않다면, 다음 명령어로 설치할 수 있습니다:

pip install pandas

이제, 예를 들어 DataFrame에서 특정 조건을 만족하는 행(row)만 필터링하는 방법을 살펴보겠습니다.

import pandas as pd

# 샘플 데이터 생성
data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],
        'Age': [28, 34, 29, 32],
        'City': ['New York', 'Paris', 'Berlin', 'London']}

df = pd.DataFrame(data)

# 'Age'가 30 이상인 행만 필터링
filtered_df = df[df['Age'] >= 30]

print(filtered_df)

이 예시에서는 'Age' 열의 값이 30 이상인 행만 선택하여 filtered_df라는 새로운 DataFrame에 저장합니다.

또한, 여러 조건을 조합하여 필터링할 수도 있습니다. 예를 들어 'Age'가 30 이상이고, 'City'가 'Paris'인 행을 필터링하려면 다음과 같이 작성할 수 있습니다:

# 'Age'가 30 이상이고, 'City'가 'Paris'인 행 필터링
filtered_df = df[(df['Age'] >= 30) & (df['City'] == 'Paris')]

print(filtered_df)

이 때, 각 조건을 괄호로 묶고 & (AND) 연산자를 사용하여 두 조건을 모두 만족하는 행을 필터링합니다. 만약 조건 중 하나라도 만족하는 행을 찾고 싶다면, | (OR) 연산자를 사용할 수 있습니다.

이러한 방법을 통해 pandas에서 다양한 조건에 따라 데이터를 효과적으로 필터링할 수 있습니다.

Python에서 Excel 파일을 DataFrame으로 변환하기 위해 pandas 라이브러리를 주로 사용합니다. 이 과정은 매우 간단하며, pandas의 read_excel 함수를 이용하여 수행할 수 있습니다. 다만, Excel 파일을 읽기 위해서는 openpyxl (.xlsx 파일용) 또는 xlrd (.xls 파일용) 같은 추가 라이브러리가 필요할 수 있습니다. 최근 버전의 pandas에서는 .xlsx 파일을 읽기 위해 openpyxl을 추천합니다.

먼저 필요한 라이브러리를 설치해야 합니다. 아직 pandas와 openpyxl을 설치하지 않았다면, 다음 명령어를 통해 설치할 수 있습니다:

% pip install pandas openpyxl

# 설치확인
% pip list | grep openpyxl      
openpyxl                      3.0.10
%

그 후, Excel 파일을 DataFrame으로 변환하는 과정은 다음과 같습니다:

import pandas as pd

# Excel 파일 경로
file_path = 'path_to_your_excel_file.xlsx'

# Excel 파일을 DataFrame으로 읽기
df = pd.read_excel(file_path)

# DataFrame 확인
print(df)

read_excel 함수는 여러 매개변수를 제공하는데, 이를 통해 다양한 요구 사항에 맞게 Excel 파일을 읽을 수 있습니다. 예를 들어, 특정 시트를 읽거나, 열의 범위를 지정하거나, 특정 행을 헤더로 사용하는 등의 설정이 가능합니다.

특정 시트를 읽으려면 sheet_name 매개변수를 사용합니다:

# 'Sheet2'라는 이름의 시트를 읽기
df = pd.read_excel(file_path, sheet_name='Sheet2')

sheet_name에 시트의 인덱스를 전달할 수도 있으며, None을 전달하면 모든 시트를 사전 형태로 읽어옵니다.

헤더가 없는 Excel 파일을 읽으려면, header=None을 설정합니다:

# 헤더가 없는 Excel 파일을 읽기
df = pd.read_excel(file_path, header=None)

특정 컬럼만 읽으려면 usecols 매개변수에 열 이름이나 열 번호의 범위를 지정합니다:

# A열과 C열만 읽기
df = pd.read_excel(file_path, usecols='A,C')
# 또는 열 번호로 지정(0부터 시작)
df = pd.read_excel(file_path, usecols=[0, 2])

이러한 방법을 통해 Python에서 Excel 파일을 쉽게 DataFrame으로 변환하고, pandas를 활용하여 다양한 데이터 분석 작업을 수행할 수 있습니다.

파이썬에서 특정 디렉토리와 그 하위 디렉토리를 포함하여 모든 Excel 파일(예: .xlsx, .xls)을 찾으려면 os 모듈과 glob 모듈을 사용할 수 있습니다. 여기에서는 두 가지 방법을 소개합니다: os 모듈의 walk() 함수를 사용하는 방법과 pathlib 모듈의 Path.rglob() 메서드를 사용하는 방법입니다.

첫번째, os.walk()를 사용하는 방법

import os

def find_excel_files(root_dir):
    excel_files = []
    for dirpath, dirnames, filenames in os.walk(root_dir):
        for filename in filenames:
            if filename.endswith(('.xlsx', '.xls')):
                excel_files.append(os.path.join(dirpath, filename))
    return excel_files

# 사용 예
root_directory = 'your_directory_path_here'
excel_files = find_excel_files(root_directory)
for file in excel_files:
    print(file)

이 코드는 지정된 루트 디렉토리(root_directory)와 그 하위 디렉토리를 모두 탐색하여 .xlsx 또는 .xls 확장자를 가진 파일의 전체 경로를 리스트로 반환합니다.

두번째, pathlib.Path.rglob()를 사용하는 방법

pathlib은 Python 3.4 이상에서 사용할 수 있으며, 파일 시스템 경로를 객체 지향적으로 쉽게 다룰 수 있게 해 줍니다.

from pathlib import Path

def find_excel_files(root_dir):
    excel_files = list(Path(root_dir).rglob('*.xlsx')) + list(Path(root_dir).rglob('*.xls'))
    return [str(file) for file in excel_files]

# 사용 예
root_directory = 'your_directory_path_here'
excel_files = find_excel_files(root_directory)
for file in excel_files:
    print(file)

rglob() 메서드는 지정된 패턴과 일치하는 모든 파일의 경로를 재귀적으로 검색합니다. 이 예제에서는 *.xlsx와 *.xls 패턴을 사용하여 Excel 파일을 찾습니다.

두 방법 모두 지정된 디렉토리와 그 하위 디렉토리에서 Excel 파일을 찾는 데 사용할 수 있으며, 사용자의 필요와 선호도에 따라 선택할 수 있습니다.

< 참조 >

https://zephyrus1111.tistory.com/460

https://nck2.github.io/%EC%97%85%EB%AC%B4%EC%9E%90%EB%8F%99%ED%99%94/excelpython/

https://dataleader.tistory.com/24

https://mingchin.tistory.com/168

파이썬의 logging 모듈을 사용하여 로그 파일을 일자별로 생성하려면, TimedRotatingFileHandler를 사용하는 것이 좋습니다. 이 핸들러는 지정된 간격에 따라 로그 파일을 새로 만들고, 이전 로그 파일의 이름 뒤에 타임스탬프를 붙여 구분합니다. 일자별 로그 파일 생성을 위한 사용자 정의 로깅 클래스 예시는 다음과 같습니다.

import logging
from logging.handlers import TimedRotatingFileHandler
import os

class DailyLogger:
    def __init__(self, name, log_dir='logs', level=logging.DEBUG):
        # 로그 파일 디렉터리 확인 및 생성
        if not os.path.exists(log_dir):
            os.makedirs(log_dir)
        
        # 로그 파일 경로 설정
        log_file_path = os.path.join(log_dir, f"{name}.log")
        
        # 로거 생성 및 레벨 설정
        self.logger = logging.getLogger(name)
        self.logger.setLevel(level)
        
        # 일자별로 로그 파일을 생성하는 핸들러 설정
        file_handler = TimedRotatingFileHandler(log_file_path, when="midnight", interval=1, backupCount=7)
        file_handler.setLevel(level)
        
        # 로그 포맷 설정
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        file_handler.setFormatter(formatter)
        
        # 핸들러를 로거에 추가
        self.logger.addHandler(file_handler)
        
    def get_logger(self):
        """
        구성된 로거 객체 반환
        """
        return self.logger

이 클래스는 로그 파일을 매일 자정에 새로 생성하도록 설정됩니다. backupCount=7은 로그 파일을 최대 7개까지 보관하고, 이를 초과하면 가장 오래된 파일부터 삭제한다는 것을 의미합니다. 로그 디렉터리는 생성자에서 log_dir 인자를 통해 지정할 수 있으며, 기본값은 현재 작업 디렉터리 내의 logs 폴더입니다.

사용 예시는 다음과 같습니다:

# DailyLogger 인스턴스 생성 및 로거 가져오기
daily_logger = DailyLogger(name='MyDailyLogger', log_dir='my_logs', level=logging.INFO).get_logger()

# 로깅 메시지 기록
daily_logger.info('정보 메시지입니다.')

이 코드를 실행하면, my_logs 디렉터리 내에 MyDailyLogger.log 파일이 생성되고, 매일 자정마다 새로운 로그 파일로 전환됩니다. 파일 이름은 자동으로 날짜가 추가되어 구분됩니다.

파이썬에서 로깅(logging)은 애플리케이션의 실행 상태에 대한 정보를 기록하는 중요한 기능입니다. logging 모듈을 사용하면 콘솔, 파일, 웹 서버 등 다양한 대상에 로그를 출력할 수 있습니다. 사용자 정의 로깅 클래스를 만드는 기본적인 예시입니다.

먼저, 파이썬의 logging 모듈을 사용하여 로거(logger), 핸들러(handler), 포매터(formatter)를 설정하는 사용자 정의 클래스를 만듭니다. 이 클래스는 로깅을 쉽게 설정하고 사용할 수 있도록 도와줍니다.

import logging

class MyLogger:
    def __init__(self, name, level=logging.DEBUG, file_name='app.log'):
        # 로거 생성
        self.logger = logging.getLogger(name)
        self.logger.setLevel(level)  # 로그 레벨 설정
        
        # 파일 핸들러 생성 및 설정
        file_handler = logging.FileHandler(file_name)
        file_handler.setLevel(level)
        
        # 콘솔 핸들러 생성 및 설정
        console_handler = logging.StreamHandler()
        console_handler.setLevel(level)
        
        # 로그 포맷 설정
        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        file_handler.setFormatter(formatter)
        console_handler.setFormatter(formatter)
        
        # 핸들러를 로거에 추가
        self.logger.addHandler(file_handler)
        self.logger.addHandler(console_handler)
    
    def get_logger(self):
        """
        구성된 로거 객체 반환
        """
        return self.logger

이 클래스를 사용하여 로깅을 설정하고 메시지를 기록하는 방법은 다음과 같습니다:

# MyLogger 인스턴스 생성
my_logger = MyLogger(name='MyAppLogger', level=logging.INFO).get_logger()

# 로깅 메시지 기록
my_logger.debug('디버그 메시지입니다.')
my_logger.info('정보 메시지입니다.')
my_logger.warning('경고 메시지입니다.')
my_logger.error('에러 메시지입니다.')
my_logger.critical('치명적인 에러 메시지입니다.')

이 코드는 MyAppLogger라는 이름의 로거를 생성하고, 로그 메시지를 파일(app.log)과 콘솔에 출력합니다. 로그 메시지에는 발생 시간, 로거 이름, 로그 레벨, 메시지가 포함됩니다.

로깅 레벨은 다음과 같은 순서로 정의됩니다: DEBUG < INFO < WARNING < ERROR < CRITICAL. level 파라미터를 통해 설정한 레벨 이상의 메시지만 출력됩니다. 위 예시에서는 level=logging.INFO로 설정했기 때문에, debug 메시지는 출력되지 않습니다.

Python에서 파일이 존재하는지 확인

Python에서 파일이 존재하는지 확인하려면 os.path.exists() 함수를 사용할 수 있습니다. 이 함수를 사용하여 파일 경로를 전달하고 파일이 존재하는지 여부를 확인할 수 있습니다.

예를 들어, 다음은 주어진 파일 경로가 존재하는지 확인하는 방법입니다:

import os

file_path = "/path/to/file.txt"

if os.path.exists(file_path):
    print("File exists.")
else:
    print("File does not exist.")

위 코드에서 /path/to/file.txt는 확인하려는 파일 경로를 나타내는 문자열로 대체되어야 합니다. 이 코드는 해당 경로에 파일이 존재하는지 여부를 확인하고 결과를 출력합니다.

파일의 절대 경로에서 파일 이름만 추출하는 방법

파일의 절대 경로에서 파일 이름만 추출하는 방법은 os.path.basename() 함수를 사용하는 것입니다. 이 함수를 사용하여 파일의 전체 경로에서 파일 이름만 추출할 수 있습니다.

예를 들어, 다음은 주어진 파일의 절대 경로에서 파일 이름만 추출하는 방법입니다:

import os

file_path = "/path/to/file.txt"

file_name = os.path.basename(file_path)
print("File name:", file_name)

위 코드에서 /path/to/file.txt는 파일의 절대 경로를 나타내는 문자열로 대체됩니다. os.path.basename() 함수를 사용하여 이 경로에서 파일 이름만 추출하고 그것을 출력합니다. 출력 결과는 파일의 이름만 포함하게 됩니다.

1. Python 파일에서 직접 로깅을 사용하는 방법 

먼저, logging 모듈을 임포트합니다:

import logging

로깅을 설정합니다. 이는 로그 파일의 경로, 로그 레벨, 출력 형식 등을 지정하는 것입니다. 예를 들어, 다음과 같이 설정할 수 있습니다:

logging.basicConfig(filename='example.log',
      level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

위 코드는 로그를 파일 example.log에 기록하며, 로그 레벨은 DEBUG부터 표시됩니다. 로그의 포맷은 시간, 로그 레벨, 메시지를 포함합니다.

로그 메시지를 출력합니다. 이는 logging 모듈의 다양한 함수를 사용하여 수행할 수 있습니다. 예를 들어

logging.debug('이것은 디버그 메시지입니다.')
logging.info('이것은 정보 메시지입니다.')
logging.warning('이것은 경고 메시지입니다.')
logging.error('이것은 에러 메시지입니다.')
logging.critical('이것은 심각한 에러 메시지입니다.')

위와 같이 로깅을 설정하고 메시지를 출력하면, 각 메시지는 설정한 로그 레벨에 따라 출력됩니다. 예를 들어, 위 코드에서는 DEBUG 레벨부터 심각한 에러인 CRITICAL 레벨까지 모든 메시지가 출력됩니다.

로깅에 대한 더 자세한 정보는 Python 공식 문서를 참조하십시오: https://docs.python.org/3/library/logging.html

2. logging 을 파일과 콘솔 두군데 동시에 출력하기

logging 모듈을 사용하여 로그를 파일과 콘솔에 동시에 출력하는 방법은 다음과 같습니다:

먼저, logging 모듈을 임포트합니다

import logging

로깅을 설정합니다. 이는 로그 파일의 경로, 로그 레벨, 출력 형식 등을 지정하는 것입니다. 예를 들어, 다음과 같이 설정할 수 있습니다

# 기본 로거 생성
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)

# 파일 핸들러 추가 (파일로 로그를 기록)
file_handler = logging.FileHandler('example.log')
file_handler.setLevel(logging.DEBUG)

# 콘솔 핸들러 추가 (콘솔에 로그를 출력)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

# 로그 포맷 설정
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 핸들러 추가
logger.addHandler(file_handler)
logger.addHandler(console_handler)

이제 로그 메시지를 출력할 수 있습니다. 예를 들어

logger.debug('이것은 디버그 메시지입니다.')
logger.info('이것은 정보 메시지입니다.')
logger.warning('이것은 경고 메시지입니다.')
logger.error('이것은 에러 메시지입니다.')
logger.critical('이것은 심각한 에러 메시지입니다.')

위 코드에서는 기본 로거를 생성하고, 파일 핸들러와 콘솔 핸들러를 추가하여 로그를 파일과 콘솔에 동시에 출력합니다. 로그 포맷과 로그 레벨은 각 핸들러에서 설정됩니다.

이렇게 하면 로그가 파일과 콘솔에 동시에 출력되어 프로그램의 디버깅 및 모니터링에 도움이 됩니다.

3. 로깅을 설정하는 별도의 모듈을 만들고 전체 프로젝트에서 사용하는 방법

import logging

# 기본 로거 생성
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)

# 파일 핸들러 추가 (파일로 로그를 기록)
file_handler = logging.FileHandler('example.log')
file_handler.setLevel(logging.DEBUG)

# 콘솔 핸들러 추가 (콘솔에 로그를 출력)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

# 로그 포맷 설정
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 핸들러 추가
logger.addHandler(file_handler)
logger.addHandler(console_handler)

from logger import logger

# 로그 메시지 출력
logger.debug('이것은 디버그 메시지입니다.')
logger.info('이것은 정보 메시지입니다.')
logger.warning('이것은 경고 메시지입니다.')
logger.error('이것은 에러 메시지입니다.')
logger.critical('이것은 심각한 에러 메시지입니다.')

import logging

# 기본 로거 생성
logger = logging.getLogger()

# 파일 핸들러 추가 (파일로 로그를 기록)
file_handler = logging.FileHandler('example.log')
file_handler.setLevel(logging.DEBUG)

# 콘솔 핸들러 추가 (콘솔에 로그를 출력)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)

# 로그 포맷 설정
formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 핸들러 추가
logger.addHandler(file_handler)
logger.addHandler(console_handler)

def set_log_level(level):
    logger.setLevel(level)
    file_handler.setLevel(level)
    console_handler.setLevel(level)

import logging
from logger import set_log_level, logger

# 로그 레벨을 변경합니다.
set_log_level(logging.INFO)

# 로그 메시지 출력
logger.debug('디버그 메시지는 출력되지 않습니다.')
logger.info('이것은 정보 메시지입니다.')