Making M & F

pattern_a = re.compile(rf"{file_key}_(\d{6})_(\d{6})\.xlsx")

pattern_b = re.compile(rf"{file_key}_(\d{{6}})_(\d{{6}})\.xlsx")

import os
import threading
import concurrent.futures
import multiprocessing
import asyncio
import gevent

import time

##################
#   공통 함수
###
def print_numbers():
    for i in range(1, 6):
        time.sleep(1)

def print_letters():
    for letter in ['A', 'B', 'C', 'D', 'E']:
        time.sleep(1)


##################
#   0) single_thread 에서 순차적으로 실행
###
def single_thread_module():
    start_time = time.time()

    print_numbers()
    print_letters()

    end_time = time.time()
    print(f"Single-thread execution time: {end_time - start_time:.2f} seconds")


##################
#   1) 표준 라이브러리의 threading 모듈을 사용
#   - 글로벌 인터프리터 락(GIL)로 인해 CPU 바운드 작업에는 한계가 있음.
###
def threading_module():

    start_time = time.time()

    # Thread 객체 생성
    t1 = threading.Thread(target=print_numbers)
    t2 = threading.Thread(target=print_letters)

    # Thread 시작
    t1.start()
    t2.start()

    # Thread 료될 때까지 대기
    t1.join()
    t2.join()

    end_time = time.time()
    print(f"Threading execution time: {end_time - start_time:.2f} seconds")


##################
#   2) concurrent.futures.ThreadPoolExecutor 사용
#   [비교]
#       쓰레드를 직접 관리하는 대신, 작업을 스레드 풀에 제출하고, 비동기적으로 처리
#       자동으로 쓰레드 종료를 관리
###
def concurrent_mudule():

    start_time = time.time()

    with concurrent.futures.ThreadPoolExecutor() as executor:
        future1 = executor.submit(print_numbers)
        future2 = executor.submit(print_letters)
        concurrent.futures.wait([future1, future2])

    end_time = time.time()
    print(f"ThreadPoolExecutor execution time: {end_time - start_time:.2f} seconds")


##################
#   3) multiprocessing 사용
#       - 파이썬 GIL(Global Interpreter Lock) 특성 때문에 CPU 바운드 작업경우 멀티 쓰레딩 성능 하락이 발생에 대한 해결책!
#       그 이유? 멀티 프로세싱을 하기때문에 간섭(?이 발생하지 않음
###
def multiprocessing_module():

    start_time = time.time()

    p1 = multiprocessing.Process(target=print_numbers)
    p2 = multiprocessing.Process(target=print_letters)

    p1.start()
    p2.start()

    p1.join()
    p2.join()

    end_time = time.time()
    print(f"Multiprocessing execution time: {end_time - start_time:.2f} seconds")


##################
#   4) asyncio 모듈을 사용한 비동기 프로그래맹(멀티 쓰레딩 하님)
#   - asyncio는 코루틴을 사용해 비동기적으로 I/O 바운드 작업을 수행(CPU 바운드 작업 비추)
#   - 단일 스레드에서 실행되지만, 비동기 방식으로 여러 작업을 동시에 처리(동시성 지원)
###
async def async_print_numbers():
    for i in range(1, 6):
        await asyncio.sleep(1)


async def async_print_letters():
    for letter in ['A', 'B', 'C', 'D', 'E']:
        await asyncio.sleep(1)


async def main():
    task1 = asyncio.create_task(async_print_numbers())
    task2 = asyncio.create_task(async_print_letters())

    await task1
    await task2

def asyncio_module():
    start_time = time.time()
    asyncio.run(main())
    end_time = time.time()
    print(f"Asyncio execution time: {end_time - start_time:.2f} seconds")


##################
#   5) gevent
#   - gevent는 코루틴을 기반으로 한 라이브러리로, 네트워크 작업 등에서 동시성을 극대화할
#   - 비동기 방식이지만, 코드가 매우 간결해지는 장점
###
def gevent_module():

    start_time = time.time()

    g1 = gevent.spawn(print_numbers)
    g2 = gevent.spawn(print_letters)

    gevent.joinall([g1, g2])

    end_time = time.time()
    print(f"Gevent execution time: {end_time - start_time:.2f} seconds")


if __name__ == '__main__':
    print(f'{__file__}')
    print(f'{os.path.dirname(__file__)}')

    single_thread_module()
    threading_module()
    concurrent_mudule()
    multiprocessing_module()
    asyncio_module()
    gevent_module()

[실행 결과]
D:\mmPRJ\64B\mmFNAVI\mmThread_Work.py
Single-thread execution time: 10.07 seconds
Threading execution time: 5.03 seconds
ThreadPoolExecutor execution time: 5.04 seconds
Multiprocessing execution time: 5.31 seconds
Asyncio execution time: 5.02 seconds
Gevent execution time: 10.06 seconds

import pandas as pd

# 여러 개의 DataFrame 예시 (빈 값 또는 전부 NA인 열 포함)
df1 = pd.DataFrame({'A': [1, 2, 3], 'B': [None, None, None]})
df2 = pd.DataFrame({'A': [4, 5, 6], 'B': [None, None, None]})

# DataFrame들을 결합하기 전에 모든-NA 열 제거
df1_cleaned = df1.dropna(axis=1, how='all')
df2_cleaned = df2.dropna(axis=1, how='all')

# 결합
combined_df = pd.concat([df1_cleaned, df2_cleaned], ignore_index=True)

# 결과 출력
print(combined_df)

import pandas as pd

data = {
    'time': ['09:05:43', '12:30:00', '15:45:20', '08:15:10', '10:30:00']
}
df = pd.DataFrame(data)

# 시간 문자열을 datetime으로 변환 (시간 형식 명시)
df['time'] = pd.to_datetime(df['time'], format='%H:%M:%S').dt.time

# 필터링할 시간 범위 설정
start_time = pd.to_datetime('09:00:00', format='%H:%M:%S').time()
end_time = pd.to_datetime('12:00:00', format='%H:%M:%S').time()

# 시간 범위로 필터링
filtered_df = df[(df['time'] >= start_time) & (df['time'] <= end_time)]

print(filtered_df)

a = "hello"
b = "hello"
c = "world"

print(a is not b)  # 이것은 False를 출력합니다. (같은 메모리 위치를 참조하기 때문)
print(a != c)  # 이것은 True를 출력합니다. (값이 다르기 때문)

webDriverPath = 'D:/Dev/chromedriver/chromedriver.exe'

# 브라우저 꺼짐 방지
chrome_options = Options()
chrome_options.add_experimental_option("detach", True)

# 브라우저 생성
browser = webdriver.Chrome(webDriverPath,options=chrome_options)

# 사이트 열기
browser.get('https://www.naver.com/')
browser.implicitly_wait(10) # 로딩 10초


#
#browser.close() # 브라우저 현재 tab(화면)만 종료
#browser.quit()  # 브라우저 모든 tab(화면) 종료
print(f'[trassWebCrawler] Day:{strPivotDay} Period:{nPeriod} is done')

#concatDf['dates'] = pd.to_datetime(concatDf['시간'])

(수정) concatDf['dates'] = pd.to_datetime(concatDf['시간'], format='%H:%M:%S')

data = {'key': ['A', 'B', 'A', 'B', 'C'],
        '날짜': ['2024-01-01', '2024-02-01', '2024-03-01', '2024-02-15', '2024-04-01'],
        '값': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)
print(df)

   key       날짜   값
0   A  2024-01-01  10
1   B  2024-02-01  20
2   A  2024-03-01  30
3   B  2024-02-15  40
4   C  2024-04-01  50

result_df = df.sort_values(by='날짜').drop_duplicates('key', keep='last')
print(result_df)

  key   날짜        값
3   B  2024-02-15  40
2   A  2024-03-01  30
4   C  2024-04-01  50