728x90
반응형
728x90
반응형
반응형

📂 PyInstaller에서 특정 폴더(하위 디렉터리 포함) 통째로 추가하는 방법

  • PyInstaller에서 특정 폴더(hello/ 이하의 모든 파일과 디렉터리)를 실행 파일(.exe)에 포함하려면 --add-data 옵션을 사용해야 합니다.


✅ 특정 폴더의 모든 파일 포함

pyinstaller --onefile --add-data "my_package/hello/*;my_package/hello" main.py

-🔹 위 명령어는 hello/ 폴더 내의 파일만 포함하며, 하위 폴더는 포함되지 않을 수 있음.



✅ 하위 폴더까지 포함하는 방법 (권장)

pyinstaller --onefile --add-data "my_package/hello;my_package/hello" main.py


🔹 디렉터리 자체를 포함하면 하위 폴더까지 자동으로 추가됨.



🔹 실행 시 리소스 접근 코드

pyhton

import sys
import os

def get_resource_path(relative_path):
    """ 실행 파일 내부 또는 개발 환경에서 리소스 파일의 경로를 찾음 """
    if getattr(sys, 'frozen', False):
        base_path = sys._MEIPASS  # PyInstaller 실행 환경
    else:
        base_path = os.path.dirname(__file__)  # 일반 실행 환경
    
    return os.path.join(base_path, relative_path)

# my_package/hello/ 아래의 특정 파일 접근
resource_path = get_resource_path("my_package/hello/config.json")

with open(resource_path, "r", encoding="utf-8") as f:
    print(f.read())


🔥 정리

  • --add-data 옵션에서 폴더 전체를 추가하려면 "my_package/hello;my_package/hello" 사용
  • ✅ 실행 시 sys._MEIPASS를 활용하여 .exe 내부의 리소스 파일에 접근
  • 하위 폴더까지 포함하려면 폴더 자체를 추가하는 것이 가장 깔끔한 방법

Github

728x90
반응형
반응형

Cycloid Curve Generator : 사이클로이드 곡선 생성

이 프로젝트는 사이클로이드 곡선을 생성하고 시각화하기 위한 Python 기반 도구입니다.

사이클로이드 는 원이 한 직선 위를 굴러갈 때, 원 위의 한 점이 그리는 궤적을 나타냅니다.

이 코드는 사용자가 다양한 파라미터를 통해 곡선을 생성하고 그래프로 시각화할 수 있도록 설계되었습니다.

주요 기능

  • 사이클로이드 곡선 생성: 사용자가 입력한 반지름, t 범위, 점의 개수를 기반으로 곡선을 계산합니다.
  • 곡선 시각화: 생성된 사이클로이드 곡선을 Matplotlib을 이용하여 시각화합니다.
  • 유연한 파라미터 설정: CLI를 통해 반지름, t 시작값, t 종료값, 점의 개수를 설정할 수 있습니다.

사용법

CLI 인터페이스

argparse를 이용하여 CLI 옵션을 제공합니다.

  • --radius: 원의 반지름 (기본값: 1)
  • --t_start: t의 시작값 (기본값: 0)
  • --t_end: t의 종료값 (기본값: 4pi)
  • --points: 생성할 점의 개수 (기본값: 1000)

기본 실행

python cycloid.py

파라미터 지정 실행

python cycloid.py --radius 2 --t_start 0 --t_end 2pi --points 500

요구 사항

이 프로젝트를 실행하려면 다음 Python 라이브러리가 필요합니다:

  • numpy
  • matplotlib

설치는 아래 명령어로 가능합니다:

pip install numpy matplotlib

결과 예시

위 코드를 통해 생성된 사이클로이드 곡선은 다양한 반지름과 범위에서 시각적으로 확인할 수 있습니다.

728x90
반응형
반응형

find_native_python : 파이썬 네이티브 패키지(native package) 사용여부 검사



네이티브 패키지

파이썬 표준 라이브러리는 네이티브 패키지와 비네이티브 패키지를 포함하며, 이 둘의 주요 차이는 다음과 같습니다:

네이티브 패키지 (Native Package)

  1. 특징

    • C 언어로 구현: 파이썬 인터프리터 내부에 C로 구현되어 있어 성능이 뛰어남.
    • 내장 모듈: 파이썬 설치 시 기본적으로 포함되어 있으며 별도 설치가 필요 없음.
    • 빠른 실행 속도: C의 낮은 레벨 접근과 최적화 덕분에 실행 속도가 빠름.
    • 직접적인 시스템 접근: 운영 체제와 깊이 통합된 기능을 제공.
  2. 예시

    • math: 고속 수학 연산(C 기반)
    • os: 운영 체제와 상호작용
    • datetime: 시간/날짜 관리
    • sys: 파이썬 인터프리터와 상호작용

비네이티브 패키지 (Non-Native Package)

  1. 특징

    • 순수 파이썬 구현: Python 언어로 작성된 모듈이며, 네이티브 모듈보다 속도가 느릴 수 있음.
    • 확장성: 코드를 읽고 수정하기 쉬워 커스터마이징 가능.
    • 범용성: 파이썬 환경에 국한되지 않고, 다른 파이썬 구현체(예: PyPy)에서도 유사한 성능을 기대할 수 있음.
  2. 예시

    • json: JSON 데이터 처리 (순수 파이썬으로 구현)
    • configparser: 설정 파일 관리
    • csv: CSV 파일 읽기/쓰기
    • unittest: 단위 테스트 도구

주요 차이점

특징 네이티브 패키지 비네이티브 패키지
구현 언어 C 언어 파이썬
성능 빠름 느릴 수 있음
파이썬 환경 CPython에 최적화 범용적 (PyPy, Jython에서도 호환 가능)
확장/커스터마이징 코드 수정 어려움 수정/확장 용이
의존성 운영 체제 기능 또는 하드웨어 접근을 포함할 수 있음 순수 파이썬이므로 독립적

이러한 차이로 인해 네이티브 패키지는 성능과 시스템 통합이 중요한 경우 적합하며, 비네이티브 패키지는 더 쉽게 읽고 수정해야 하는 유연한 코드 작성 시 적합합니다.



사용 방법:

python find_native_python.py /home/sandbox/python
  • 경로 /home/sandbox/python 에 있는 파이썬 파일들(*.py)이 네이티브 패키지를 사용하는지 검사함.
728x90
반응형
반응형

poker_hand_probabilities : 포커(Poker) 확률 계산기

이 프로젝트는 포커 게임의 다양한 손패(hand)에 대한 확률을 계산하는 Python 프로그램입니다. 기본적인 카드 덱에서 특정 카드를 제외하거나 추가할 수 있으며, 이에 따른 확률 변화도 분석할 수 있습니다.


주요 기능

  1. 포커 확률 계산
    52장의 기본 카드 덱을 사용하여 아래의 손패 확률을 계산합니다:

    • High Card (하이 카드)
    • One Pair (원 페어)
    • Two Pair(투 페어)
    • Three of a Kind (트리플)
    • Straight (스트레이트)
    • Flush (플러쉬)
    • Full House (풀하우스)
    • Four of a Kind (포카드)
    • Straight Flush (스트레이트 플러쉬)
    • Royal Straight Flush (로얄 스트레이트 플러쉬)
  2. 카드 제외 및 추가

    • 특정 카드를 덱에서 제외하거나 새로운 카드를 추가하여 확률을 다시 계산할 수 있습니다.
    • 예: 퀸(Q) 4장을 제외하거나 에이스(A) 4장을 추가한 경우의 확률 계산.
  3. 사용법

    • calculate_poker_probabilities 함수는 입력받은 제외 카드 또는 추가 카드를 고려하여 확률을 반환합니다.
    • main 함수는 여러 시나리오(기본 덱, 카드 제외, 카드 추가)에 따른 확률을 출력합니다.

코드 예시

# 기본 52장 덱의 확률 계산
probabilities = calculate_poker_probabilities()

# 퀸(Q) 4장 제외
excluded_cards = ["QH", "QD", "QC", "QS"]
probabilities_excluded = calculate_poker_probabilities(excluded_cards=excluded_cards)

# 에이스 4장 추가
added_cards = ["Extra_A1", "Extra_A2", "Extra_A3", "Extra_A4"]
probabilities_added = calculate_poker_probabilities(added_cards=added_cards)

실행 방법

  1. Python 3.x 이상이 설치된 환경에서 사용 가능합니다.
  2. 아래 명령어로 프로그램을 실행하세요:
    python poker.py
    
  3. 실행 시 각 시나리오에 따른 확률이 출력됩니다.
728x90
반응형
반응형

find_native_python : 파이썬 네이티브 패키지 사용여부 검사

  • 홈페이지 https://github.com/JayTwoLab/find_native_python

  • 파이썬 소스코드를 검색하여, 네이티브 패키지(native package)를 사용하는지 여부를 검사

  • 사용 방법:

    • 경로 /home/sandbox/python 에 있는 파이썬 파일들이 네이티브 패키지를 사용하는지 검사함.
python find_native_python.py /home/sandbox/python
  • 코드 (main 함수)
if __name__ == "__main__" :
    # Getting a project directory as a command line factor
    project_dir = sys.argv[1] if len(sys.argv) > 1 else "."    
    
    results = analyze_directory(project_dir)

    if results:
        print("Native code related calls found:")
        for filepath, calls in results.items():
            for func, lineno in calls:
                print(f" - {filepath}: {func} (Line {lineno})")
    else:
        print("There are no native code related calls.")
728x90
반응형
반응형

Windows에서 명령 프롬프트(Command Prompt)와 파워쉘(PowerShell)로 pyenv 설치


공통 준비 작업

  1. 필수 소프트웨어 설치

    • Git: https://git-scm.com/ 에서 다운로드 및 설치.
    • Python은 별도로 설치하지 않아도 됩니다. pyenv가 이를 관리합니다.
  2. 설치 경로 확인

    • pyenv-win은 사용자 홈 디렉토리에 설치됩니다:
      기본 경로: C:\Users\<사용자 이름>\.pyenv\pyenv-win


1. Windows Command Prompt에서 설치

1.1. pyenv-win 저장소 클론

Command Prompt를 열고 다음 명령을 입력합니다:

git clone https://github.com/pyenv-win/pyenv-win.git %USERPROFILE%\.pyenv

1.2. 환경 변수 설정

PATH에 다음 경로를 추가합니다:

  • %USERPROFILE%\.pyenv\pyenv-win\bin
  • %USERPROFILE%\.pyenv\pyenv-win\shims

설정 방법:

  1. 환경 변수 설정 창 열기
    • Windows 검색창에 "환경 변수" 입력 후 "시스템 환경 변수 편집" 선택.
  2. 환경 변수 추가
    • 사용자 변수 또는 시스템 변수에서 Path 선택 → 편집 클릭.
    • 위 두 경로를 추가.
  3. 저장 후 닫기.

1.3. 환경 변수 적용

Command Prompt를 다시 열거나 아래 명령으로 적용합니다:

setx PATH "%PATH%;%USERPROFILE%\.pyenv\pyenv-win\bin;%USERPROFILE%\.pyenv\pyenv-win\shims"


2. PowerShell에서 설치

2.1. pyenv-win 저장소 클론

PowerShell을 열고 다음 명령을 입력합니다:

powershell

git clone https://github.com/pyenv-win/pyenv-win.git $HOME\.pyenv

2.2. 환경 변수 설정

PowerShell 프로필 파일($PROFILE)을 편집하여 PATH를 설정합니다.

  1. 프로필 파일 확인 및 생성

    powershell

    if (!(Test-Path -Path $PROFILE)) { New-Item -ItemType File -Path $PROFILE -Force }
    notepad $PROFILE
    
  2. 환경 변수 추가 아래 내용을 프로필 파일에 추가:

    powershell

    $env:PYENV = "$HOME\.pyenv\pyenv-win"
    $env:Path += ";$env:PYENV\bin;$env:PYENV\shims"
    
  3. 저장 후 PowerShell 재시작



3. 설치 확인

Command Prompt 또는 PowerShell에서 pyenv 명령을 입력해 설치가 완료되었는지 확인합니다:

pyenv --version


4. Python 관리

설치가 완료되었다면 Python 버전을 관리할 수 있습니다:

  • 설치 가능한 버전 확인:
    pyenv install --list
    
  • Python 버전 설치:
    pyenv install <버전>
    
  • 기본 Python 버전 설정:
    pyenv global <버전>
    
728x90
반응형
반응형

Windows에서 PYENV, PYENV_ROOT, PYENV_HOME 환경 변수 설정 방법


  • Windows에서 PYENV, PYENV_ROOT, PYENV_HOME 변수를 설정하려면 환경 변수를 추가해야 합니다.
  • 아래는 이 변수를 설정하는 방법입니다.

1. 환경 변수 값 확인

  • PYENV: 일반적으로 C:\Users\<사용자 이름>\.pyenv\pyenv-win
  • PYENV_ROOT: C:\Users\<사용자 이름>\.pyenv\pyenv-win
  • PYENV_HOME: C:\Users\<사용자 이름>\.pyenv\pyenv-win

<사용자 이름>은 자신의 Windows 사용자 계정을 의미합니다.


2. 환경 변수 설정 방법

2.1 Windows 환경 변수 GUI로 설정

  1. 시스템 환경 변수 편집 창 열기

    • Windows 검색창에서 "환경 변수"를 검색하고 시스템 환경 변수 편집 클릭.
  2. 새 환경 변수 추가

    • 아래 변수를 각각 추가합니다:
      • 변수 이름: PYENV 값: C:\Users\<사용자 이름>\.pyenv\pyenv-win
      • 변수 이름: PYENV_ROOT 값: C:\Users\<사용자 이름>\.pyenv\pyenv-win
      • 변수 이름: PYENV_HOME 값: C:\Users\<사용자 이름>\.pyenv\pyenv-win
  3. PATH 환경 변수에 추가

    • 사용자 변수 또는 시스템 변수에서 Path 선택 → 편집 클릭.
    • 아래 두 경로를 추가:
      • %PYENV%\bin
      • %PYENV%\shims
  4. 저장 후 모든 창 닫기.


2.2 명령 프롬프트(Command Prompt)로 설정

명령 프롬프트에서 환경 변수를 설정하려면 다음 명령을 입력합니다:

setx PYENV C:\Users\<사용자 이름>\.pyenv\pyenv-win
setx PYENV_ROOT C:\Users\<사용자 이름>\.pyenv\pyenv-win
setx PYENV_HOME C:\Users\<사용자 이름>\.pyenv\pyenv-win
setx PATH "%PATH%;%PYENV%\bin;%PYENV%\shims"

환경 변수 변경 사항은 명령 프롬프트를 다시 실행해야 적용됩니다.


2.3 PowerShell로 설정

PowerShell 프로필 파일을 수정해 환경 변수를 설정합니다:

  1. 프로필 파일 열기

    powershell

    if (!(Test-Path -Path $PROFILE)) { New-Item -ItemType File -Path $PROFILE -Force }
    notepad $PROFILE
    
  2. 변수 추가 아래 내용을 파일에 추가:

    powershell

    $env:PYENV = "$HOME\.pyenv\pyenv-win"
    $env:PYENV_ROOT = "$HOME\.pyenv\pyenv-win"
    $env:PYENV_HOME = "$HOME\.pyenv\pyenv-win"
    $env:Path += ";$env:PYENV\bin;$env:PYENV\shims"
    
  3. 파일 저장 후 PowerShell 재시작


3. 설정 확인

Command Prompt 또는 PowerShell에서 설정을 확인합니다:

echo %PYENV%
echo %PYENV_ROOT%
echo %PYENV_HOME%
728x90
반응형
반응형

Jinja: Python을 위한 강력한 템플릿(template) 엔진의 모든 것


  • JinjaPython을 위한 빠르고 표현력 있으며 확장 가능한 템플릿(template) 엔진으로, HTML, XML 및 기타 마크업 언어의 동적 생성을 간편하게 처리할 수 있습니다.
  • Flask를 비롯한 여러 프레임워크의 기본 템플릿 엔진으로 사용되며, Ansible, Trac, Salt와 같은 프로젝트에서도 활용됩니다.

Jinja의 주요 기능

  1. 템플릿 상속 및 포함
    템플릿 간 상속과 포함을 지원하여 코드 재사용성을 극대화합니다.

  2. 매크로 정의 및 가져오기
    반복되는 코드를 간편하게 관리할 수 있는 매크로 기능을 제공합니다.

  3. 자동 이스케이프
    HTML 템플릿에서 XSS 공격을 방지하는 자동 이스케이프 기능을 지원합니다.

  4. 샌드박스 환경
    신뢰할 수 없는 템플릿을 안전하게 렌더링할 수 있습니다.

  5. 비동기 지원
    동기 및 비동기 함수를 구문 변경 없이 자동으로 처리합니다.

  6. 국제화(I18N) 지원
    Babel을 통한 다국어 지원 기능을 제공합니다.

  7. 최적화된 Python 코드로 컴파일
    템플릿을 최적화된 Python 코드로 컴파일하여 캐시하거나 미리 컴파일할 수 있습니다.

  8. 디버깅 용이성
    예외 발생 시 템플릿의 정확한 줄 번호를 표시하여 디버깅을 용이하게 합니다.


설치 및 의존성

  • 설치 방법
    최신 Python(3.7 이상)과 가상 환경을 추천하며, 다음 명령어로 설치할 수 있습니다.

    $ pip install Jinja2
    
  • 기본 의존성

    • MarkupSafe: 사용자 입력의 이스케이프 처리로 보안을 강화합니다.
  • 선택적 의존성

    • Babel: 번역 지원을 위한 추가 라이브러리입니다.

예제 코드

  1. 기본 사용법

    python

    from jinja2 import Template
    
    template = Template('Hello, {{ name }}!')
    print(template.render(name='World'))
    

    - 출력 결과: `Hello, World!`

  1. 템플릿에서 변수 사용

    html

    <p>{{ 변수명 }}</p>
    

    - 변수에 해당하는 값이 텍스트로 출력됩니다.

  1. 조건문

    html

    {% if user.is_authenticated %}
      <p>Welcome, {{ user.name }}!</p>
    {% else %}
      <p>Please log in.</p>
    {% endif %}
    

  1. 반복문

    html

    <ul>
    {% for item in items %}
      <li>{{ item }}</li>
    {% endfor %}
    </ul>
    

  1. 템플릿 상속

    • 부모 템플릿:

    html

    <!-- base.html -->
    <html>
    <head>
      <title>{% block title %}My Website{% endblock %}</title>
    </head>
    <body>
      {% block content %}{% endblock %}
    </body>
    </html>
    

    • 자식 템플릿:

    html

    <!-- index.html -->
    {% extends "base.html" %}
    
    {% block title %}Home - My Website{% endblock %}
    
    {% block content %}
      <h1>Welcome to My Website</h1>
    {% endblock %}
    


Jinja의 활용 철학

  • Jinja는 템플릿 작성자가 강력한 기능을 사용할 수 있도록 돕는 한편, 복잡한 애플리케이션 로직은 Python 코드에 속해야 한다는 철학을 지향합니다.
  • 이를 통해 코드와 템플릿의 역할을 명확히 분리하면서도, 템플릿 디자이너에게 유연성을 제공합니다.
  • JinjaPython 웹 애플리케이션 개발자 및 디자이너 모두에게 매우 유용한 도구로, 프로젝트의 생산성과 유지보수성을 크게 향상시킬 수 있습니다.
728x90
반응형
반응형

pylint: Python 코드 분석 도구

  • pylint는 Python 코드의 품질을 자동으로 점검하고, 잠재적인 문제와 스타일 가이드 위반을 보고하는 도구입니다.
  • PEP 8(Python Enhancement Proposal 8) 스타일 가이드를 기반으로 동작하며, 가독성과 유지보수성을 개선하는 데 유용합니다.


pylint 주요 기능

  1. 코드 품질 점검:

    • 비효율적인 코드, 반복 코드, 불필요한 코드를 감지.
    • 불필요한 import 문이나 사용되지 않는 변수 등을 알려줌.
  2. 코드 스타일 검사:

    • PEP 8 스타일 가이드 준수 여부를 확인.
    • 변수명, 함수명, 클래스명 등 네이밍 규칙 위반 감지.
  3. 버그 탐지:

    • 정의되지 않은 변수 사용, 모듈 임포트 오류, 잘못된 함수 호출 등을 탐지.
  4. 리팩토링 제안:

    • 더 효율적이고 깔끔한 코드 작성을 위한 리팩토링 힌트 제공.
  5. 코드 복잡성 분석:

    • 코드의 복잡도를 점수화하여, 지나치게 복잡한 함수나 클래스를 알려줌.


설치

pylint는 Python 패키지 관리 도구인 pip를 사용해 설치할 수 있습니다.

pip install pylint


사용 방법

  1. 단일 파일 검사:

    pylint your_file.py
    
  2. 모듈 또는 프로젝트 검사:

    pylint your_project/
    
  3. 결과 출력: 실행하면 아래와 같은 형태로 분석 결과를 출력합니다:

    ************* Module your_file
    your_file.py:1:0: C0114: Missing module docstring (missing-module-docstring)
    your_file.py:5:4: W0612: Unused variable 'x' (unused-variable)
    
    • 메시지 코드:
      • C (Convention): 코딩 스타일 문제.
      • R (Refactor): 리팩토링이 필요한 코드.
      • W (Warning): 경고.
      • E (Error): 심각한 에러.
      • F (Fatal): 실행 불가능한 코드.
  4. 점수 출력: pylint는 코드 품질을 0~10 점 사이로 점수화합니다. 점수가 높을수록 코드 품질이 좋습니다.



결과 무시 또는 설정 커스터마이징

  1. 특정 경고 무시: 특정 경고 메시지를 무시하려면, 명령에 --disable 옵션을 사용합니다.

    pylint your_file.py --disable=W0612
    
  2. 설정 파일 사용: 프로젝트별 설정을 위해 .pylintrc 파일을 생성하고 원하는 설정을 추가할 수 있습니다.

    pylint --generate-rcfile > .pylintrc
    
  3. 코드 내에서 무시: 코드에서 특정 줄의 경고를 무시하려면, 주석을 추가합니다.

    python

    x = 42  # pylint: disable=unused-variable
    


장점

  • 프로젝트 초기부터 코드 품질을 유지하도록 도움.
  • 대규모 팀에서 코드 스타일 일관성을 유지 가능.
  • 잠재적 버그와 성능 문제를 미리 발견.

단점

  • 과도한 경고: 일부 경고는 중요하지 않거나 상황에 따라 무시해도 되는 경우가 많음.
  • 초기 설정 필요: 프로젝트 요구사항에 맞춰 경고를 조정해야 함.


설정 파일 생성 및 사용

  1. 설정 파일 생성: pylint는 명령어로 기본 설정 파일을 생성할 수 있습니다.

    pylint --generate-rcfile > .pylintrc
    

    이 명령어는 현재 디렉터리에 .pylintrc 파일을 생성하며, 이 파일은 기본값이 포함된 설정 파일입니다.

  2. 설정 파일 위치:

    • pylint는 아래 순서로 설정 파일을 탐색합니다:
      1. 명시적으로 제공된 설정 파일 (--rcfile 옵션).
      2. 현재 디렉터리의 .pylintrc.
      3. 홈 디렉터리 (~/.pylintrc).
      4. 전역 환경 설정 (/etc/pylintrc).
  3. 설정 파일 사용: 설정 파일이 있는 디렉터리에서 pylint를 실행하면 해당 설정이 적용됩니다.



설정 파일 주요 항목

.pylintrc 파일에는 다양한 설정 옵션이 있습니다. 아래는 주요 항목들입니다.

1. 비활성화할 메시지

  • 특정 메시지(규칙)를 비활성화하려면 disable 항목을 수정합니다.
  • 예:

    ini

    [MESSAGES CONTROL]
    disable=
        missing-module-docstring,
        missing-class-docstring,
        missing-function-docstring
    

2. 코드 스타일

  • 코드 스타일 관련 설정을 변경할 수 있습니다.
  • 예:

    ini

    [FORMAT]
    max-line-length=100  # 최대 줄 길이를 100자로 제한
    indent-string='    ' # 공백 4칸을 들여쓰기 기본값으로 설정
    

3. 네이밍 규칙

  • 변수, 함수, 클래스 등 이름 규칙을 설정할 수 있습니다.
  • 예:

    ini

    [BASIC]
    variable-rgx=[a-z_][a-z0-9_]{2,30}$  # 소문자와 밑줄로 이루어진 변수 이름
    function-rgx=[a-z_][a-z0-9_]{2,30}$  # 함수 이름 규칙
    argument-rgx=[a-z_][a-z0-9_]{2,30}$  # 인자 이름 규칙
    

4. 모듈 제외

  • 특정 모듈이나 파일을 검사에서 제외할 수 있습니다.
  • 예:

    ini

    [MASTER]
    ignore=setup.py, migrations  # setup.py와 migrations 디렉터리 제외
    

5. 개별 메시지 설정

  • 특정 메시지의 심각도나 동작을 조정할 수 있습니다.
  • 예:

    ini

    [REPORTS]
    output-format=text  # 출력 형식 설정
    reports=no          # 리포트 생성 비활성화
    


명령어로 설정 파일 지정

명령어 실행 시 특정 설정 파일을 명시적으로 지정할 수 있습니다.

pylint your_file.py --rcfile=path/to/.pylintrc


자주 사용하는 설정 항목 예시

ini

[MASTER]
# 제외할 디렉터리와 파일
ignore=migrations, tests
ignore-patterns=.*_test\.py$

[MESSAGES CONTROL]
# 비활성화할 규칙
disable=missing-docstring, invalid-name, line-too-long

[FORMAT]
# 줄 길이와 들여쓰기
max-line-length=88
indent-string='    '

[BASIC]
# 변수, 함수, 클래스 이름 규칙
variable-rgx=[a-z_][a-z0-9_]{2,30}$
function-rgx=[a-z_][a-z0-9_]{2,30}$
class-rgx=[A-Z_][a-zA-Z0-9]+$
728x90
반응형
반응형

Python 버전(version) 호환성 유지

  • Python에서는 다양한 도구와 방법을 통해 특정 버전과의 호환성을 유지하거나 검증할 수 있습니다.
  • 아래의 방법들을 활용하면 여러 Python 버전에서 안정적으로 코드를 실행하고 관리할 수 있습니다.


1. __future__ 모듈: 향후 기능 테스트

  • Python의 __future__ 모듈은 최신 Python 기능을 이전 버전에서도 사용할 수 있도록 제공합니다.
  • 이를 통해 코드가 향후 Python 버전에서 예상되는 동작을 미리 구현하거나 테스트할 수 있습니다.

예:

python

from __future__ import print_function  # Python 2에서 Python 3 스타일의 print 사용

print("Hello, Python 3 style!")
  • Python 2와 3에서 모두 실행 가능하며, 새로운 기능과의 호환성을 확보할 수 있습니다.

__future__ 모듈에서 설정 가능한 값

  • __future__ 모듈은 이전 버전에서 사용할 수 없던 기능을 활성화하거나, Python의 향후 릴리스에서 기본 동작이 될 기능을 미리 사용할 수 있도록 제공합니다.
  • 아래는 설정 가능한 주요 값들입니다:
설정 값 설명 도입된 버전
print_function Python 3 스타일의 print() 함수를 활성화. Python 2에서 print를 함수처럼 사용 가능. Python 2.6
division Python 3 스타일의 나눗셈(/)을 활성화. 정수 나눗셈도 실수 결과를 반환하도록 변경. Python 2.2
absolute_import Python 3 스타일의 절대 임포트를 활성화. 모듈 이름 충돌 방지. Python 2.5
unicode_literals 모든 문자열 리터럴을 기본적으로 유니코드로 처리 (u"string" 없이도 유니코드로 인식). Python 2.6
generators yield 키워드를 사용해 제너레이터 기능을 활성화. Python 2.3
nested_scopes 중첩된 함수에서 외부 함수의 변수를 참조 가능하게 만듦 (Python 2.1 이전에는 불가능). Python 2.1
annotations Python 3 스타일의 함수 주석 문법(->, :)을 활성화. Python 3.7
barry_as_FLUFL <> 연산자를 활성화 (Python 2 스타일). 농담으로 추가된 기능. Python 3.1


2. pyenv를 활용한 멀티 버전 관리

  • pyenv는 Python의 여러 버전을 관리하고, 특정 버전에서 코드를 실행하거나 테스트할 수 있는 도구입니다.
  • 이를 통해 다양한 Python 버전과의 호환성을 쉽게 테스트할 수 있습니다.

설치 및 사용 예:

pyenv install 3.8.10  # Python 3.8.10 설치
pyenv install 3.10.9  # Python 3.10.9 설치
pyenv global 3.8.10   # 기본 Python 버전 설정
python script.py      # Python 3.8에서 코드 실행


3. Docker 컨테이너로 환경 설정

  • Docker를 사용하면 Python 버전별로 완전히 격리된 실행 환경을 설정할 수 있습니다.
  • 다양한 버전에서 코드를 실행해 호환성을 검증할 수 있습니다.

Dockerfile 예:

dockerfile

FROM python:3.9-slim

WORKDIR /app
COPY . /app
RUN pip install -r requirements.txt

CMD ["python", "script.py"]
  • 각 Python 버전별로 Docker 이미지를 사용하여 환경을 설정합니다.


4. tox를 사용한 다중 환경 테스트

  • tox는 여러 Python 버전에서 코드를 자동으로 테스트할 수 있는 도구입니다.
  • 이를 사용하면 프로젝트가 다양한 버전과 호환되는지 손쉽게 확인할 수 있습니다.

tox.ini 설정 예:

ini

[tox]
envlist = py36, py37, py38, py39

[testenv]
deps = pytest
commands = pytest

실행:

tox
  • 설정된 모든 Python 버전(예: 3.6, 3.7 등)에서 테스트가 실행됩니다.


5. 코드 분석 및 호환성 검토 도구

  • pylint, mypy, flake8 : Python 코드를 분석해 특정 버전과의 호환성을 검토합니다.
  • caniusepython3 : 프로젝트가 Python 3와 호환되는지 확인합니다.

728x90
반응형
반응형

물병 문제


수수께끼:

두 개의 물병이 있습니다:

  • 5리터 물병과 3리터 물병.

이 두 물병을 사용해 정확히 4리터의 물을 만들려면 어떻게 해야 할까요?


알고리즘:

  1. 각 물병의 현재 상태(물의 양)를 정의합니다.
  2. 가능한 물 붓기 동작(채우기, 비우기, 물 붓기)을 시뮬레이션합니다.
  3. 상태를 반복하지 않도록 방문한 상태를 저장합니다.
  4. 목표 상태(한 병에 정확히 4리터)를 찾으면 종료합니다.

Python 코드:

python

from collections import deque

class WaterJugSolver:
    def __init__(self, jug1_capacity, jug2_capacity, goal):
        self.jug1_capacity = jug1_capacity
        self.jug2_capacity = jug2_capacity
        self.goal = goal

    def solve(self):
        start_state = (0, 0)
        visited = set()
        queue = deque([(start_state, [])])  # Store state and path
        visited.add(start_state)

        while queue:
            current_state, path = queue.popleft()
            a, b = current_state

            # Check if goal state is reached
            if a == self.goal or b == self.goal:
                return path + [current_state]

            # Explore next states
            for next_state in self.get_next_states(current_state):
                if next_state not in visited:
                    visited.add(next_state)
                    queue.append((next_state, path + [current_state]))
        return None  # No solution

    def get_next_states(self, state):
        a, b = state  # a is the first jug, b is the second jug
        max_a, max_b = self.jug1_capacity, self.jug2_capacity
        next_states = []

        # Define actions
        next_states.append((max_a, b))          # Fill the first jug
        next_states.append((a, max_b))          # Fill the second jug
        next_states.append((0, b))              # Empty the first jug
        next_states.append((a, 0))              # Empty the second jug

        # Pour water from the first jug to the second jug
        pour_to_b = min(a, max_b - b)
        next_states.append((a - pour_to_b, b + pour_to_b))

        # Pour water from the second jug to the first jug
        pour_to_a = min(b, max_a - a)
        next_states.append((a + pour_to_a, b - pour_to_a))

        return next_states

# Run the solver
if __name__ == "__main__":
    solver = WaterJugSolver(jug1_capacity=5, jug2_capacity=3, goal=4)
    solution = solver.solve()

    if solution:
        for step, state in enumerate(solution, 1):
            print(f"Step {step}: {solver.jug1_capacity}L = {state[0]}, {solver.jug2_capacity}L = {state[1]}")
    else:
        print("No solution")

알고리즘 설명:

  1. 상태 표현: (5리터 병의 물, 3리터 병의 물) 쌍으로 물병의 상태를 나타냅니다.
  2. 가능한 동작 생성: 물병을 채우거나, 비우거나, 한 병에서 다른 병으로 물을 붓는 동작을 구현합니다.
  3. BFS 탐색: 가장 효율적인 경로를 찾기 위해 너비 우선 탐색을 사용합니다.
  4. 목표 상태 확인: 5리터 병이나 3리터 병 중 하나에 정확히 4리터의 물이 있는지 확인합니다.

실행 결과:

Step 1: 5L = 0, 3L = 0
Step 2: 5L = 5, 3L = 0
Step 3: 5L = 2, 3L = 3
Step 4: 5L = 2, 3L = 0
Step 5: 5L = 0, 3L = 2
Step 6: 5L = 5, 3L = 2
Step 7: 5L = 4, 3L = 3

코드

728x90
반응형

'Python' 카테고리의 다른 글

pylint: Python 코드 분석 도구  (0) 2025.01.09
Python 버전(version) 호환성 유지  (0) 2025.01.09
CAN 버스  (0) 2024.12.13
마스크 이미지를 활용한 Word Cloud 생성 가이드  (0) 2024.12.08
파이썬(Python) 집합(set)  (0) 2024.12.03
반응형

CAN 버스

  • CAN BUS (Controller Area Network)는 차량 내부의 전자제어장치(ECU) 들 간에 데이터를 빠르고 안정적으로 교환하기 위해 설계된 통신 네트워크 프로토콜입니다.
  • 1980년대 초반 독일의 보쉬(Bosch)에서 개발하였으며, 차량뿐만 아니라 산업 자동화 및 의료 장비 등에서도 사용됩니다. 현재는 대부분의 자동차 제조사에서 표준으로 채택하고 있습니다.

CAN 버스의 주요 특징

  1. 효율적 데이터 통신:

    • 단일 케이블로 여러 장치 간의 데이터 교환을 가능하게 하여 배선 복잡성을 줄임.
  2. 실시간 데이터 전송:

    • 데이터 전송 속도가 빠르고, 우선순위 기반 데이터 처리로 중요한 메시지를 실시간으로 전달.
  3. 신뢰성:

    • 오류 감지 메커니즘이 내장되어 있어 데이터 전송 중 발생할 수 있는 오류를 자동으로 검출 및 복구.
  4. 낮은 전력 소모:

    • 전력 소모가 적어 차량과 같이 제한적인 전력 환경에서 적합.

CAN 버스의 구조

CAN 버스는 다음과 같은 주요 요소로 구성됩니다:

  1. 노드(ECU):

    • 차량 내의 각 전자 장치(예: 엔진 제어, ABS, 에어백 시스템, 창문 제어 등)가 노드로 작동.
    • 각 노드는 CAN 컨트롤러와 트랜시버를 통해 네트워크에 연결.
  2. 버스(bus):

    • 각 노드가 연결되는 물리적 통신선.
    • 트위스티드 페어 케이블(twisted pair)을 사용하여 노이즈를 최소화.
  3. 메시지 프레임:

    • CAN 버스는 데이터 전송 시 메시지를 프레임으로 전송.
    • 각 메시지에는 식별자(ID) 가 포함되어 우선순위를 정합니다.

CAN 버스의 작동 방식

  1. 브로드캐스트 방식:

    • 모든 노드가 동일한 데이터를 수신하지만, ID에 따라 필요한 데이터만 처리.
  2. 우선순위 기반:

    • 메시지의 ID를 통해 전송 우선순위를 결정.
    • 낮은 ID 값을 가진 메시지가 더 높은 우선순위를 가짐.
  3. 오류 감지:

    • CRC(Cyclic Redundancy Check) 같은 오류 검출 메커니즘으로 데이터의 무결성을 확인.

CAN 버스의 응용 사례

  1. 자동차:

    • 엔진 제어 장치(ECU), ABS, 에어백 시스템, 차량 정보 시스템, 센서 데이터 통합 등.
  2. 산업 자동화:

    • 로봇 간의 통신, 제조 공정의 제어 및 모니터링.
  3. 의료 장비:

    • 환자 모니터링 시스템, 의료용 로봇.
  4. 철도 시스템:

    • 열차 내부의 신호 처리 및 장치 간 데이터 교환.

CAN 버스의 데이터 프레임 구조

CAN 데이터 프레임은 일반적으로 다음과 같은 구조를 가집니다:

필드 설명
Start of Frame 프레임의 시작 표시
Identifier 메시지의 고유 식별자 (우선순위 결정)
Control Field 데이터 길이 정보
Data Field 실제 데이터 (최대 8바이트)
CRC 오류 검출 코드
Acknowledge 수신 확인 신호
End of Frame 프레임 종료 표시

파이썬을 이용한 CAN 버스 통신 예제

파이썬에서는 python-can 라이브러리를 이용하여 CAN 버스와 통신할 수 있습니다.

예제 코드: CAN 메시지 송수신

python

import can

# CAN 버스 인터페이스 생성
bus = can.interface.Bus(bustype='socketcan', channel='can0', bitrate=500000)

# CAN 메시지 송신
message = can.Message(arbitration_id=0x123, data=[0x01, 0x02, 0x03, 0x04], is_extended_id=False)
bus.send(message)
print("Message sent on CAN bus")

# CAN 메시지 수신
received_message = bus.recv(timeout=10)
if received_message:
    print(f"Received message: {received_message}")
else:
    print("No message received")

CAN 버스의 한계

  1. 데이터 속도 제한:

    • 일반적으로 1Mbps의 속도를 제공하므로 대규모 데이터 전송에는 적합하지 않음.
  2. 확장성 제한:

    • 노드 수가 많아지면 충돌 가능성이 증가.
  3. 보안 취약성:

    • 초기 설계에는 보안 기능이 없으므로, 외부 공격에 취약.

CAN 버스의 발전: CAN-FD

기존 CAN 버스의 한계를 개선한 **CAN-FD(Flexible Data-Rate)**는 데이터 전송 속도와 용량을 증가시킨 새로운 표준으로, 최신 차량에서 점점 더 많이 사용되고 있습니다.

  • 데이터 길이: 최대 64바이트로 확장.
  • 전송 속도: 기존 CAN보다 빠름.

결론

  • CAN 버스는 신뢰성 있고 효율적인 통신 프로토콜로, 차량을 포함한 다양한 산업 분야에서 널리 사용됩니다.
  • 특히 파이썬과 같은 고급 언어를 통해 CAN 버스를 손쉽게 테스트하고 시뮬레이션할 수 있습니다.
728x90
반응형

+ Recent posts