목차

• 모듈이란?
  1. 모듈의 정의
  2. 모둘 생성
  3. __name__
  4. if __name__ == "__main__":
• 패키지란?
  1. 엔트리 포인트(entry point)
  2. 패키지
  3. 패키지 관리 시스템
  4. 패키지 생성

엔트리 포인트(entry point)

엔트리 포인트(entry point)는 프로그램이 실행될 때 실행되는 첫 번째 코드 줄입니다. main 함수 또는 'main'은 종종 많은 프로그래밍 언어에서 엔트리 포인트(entry point) 역할을 합니다. 그러나 Python에는 C, C++ 또는 Java와 같은 다른 프로그래밍 언어와 같은 기본 제공 main 기능이 없습니다.

대신 Python은 특수 변수 __name__을 사용하여 스크립트가 기본 프로그램으로 실행되고 있는지 또는 다른 스크립트에 모듈로 가져오고 있는지를 결정합니다. Python 스크립트가 실행될 때 스크립트가 기본 프로그램으로 실행되는 경우 인터프리터는 __name__ 변수를 "__main__"으로 설정합니다. 이 경우 스크립트의 엔트리 포인트(entry point)는 if __name__ == "__main__": 블록 다음 코드의 첫 번째 줄입니다.

Python 스크립트의 일반적인 패턴은 프로그램의 기본 논리를 포함하는 main() 함수를 정의한 다음 if __name__ == "__main__": 블록을 사용하여 스크립트가 실행될 때 해당 함수를 호출하는 것입니다. 메인 프로그램으로. 예를 들면 다음과 같습니다.

def main():
    print("This is the main function of the script.")

def another_function():
    print("This is another function.")

if __name__ == "__main__":
    main()

이 예제에서 main() 함수는 메인 프로그램으로 실행될 때 스크립트의 엔트리 포인트(entry point) 역할을 합니다. 스크립트를 모듈로 가져오면 main() 함수가 자동으로 실행되지 않지만 필요한 경우 명시적으로 호출할 수 있습니다.

이러한 방식으로 코드를 구성하면 모듈로 가져올 때 실행되는 코드와 프로그램의 기본 논리를 분리하여 스크립트를 더 모듈화하고 이해하기 쉽게 만들 수 있습니다.

패키지

패키지(package)는 파이썬의 모듈을 구조화하고 조직화하는 데 사용되는 방법입니다. 패키지는 여러 모듈을 하나의 디렉토리에 그룹화하여 관리할 수 있게 합니다. 이를 통해 복잡한 프로젝트를 더 간결하게 관리하고, 다른 프로젝트에서 패키지를 재사용하기 쉽게 만듭니다.

패키지를 생성하는 방법은 다음과 같습니다.

1. 패키지 디렉토리 생성
먼저 패키지를 포함할 디렉토리를 생성합니다. 예를 들어, my_package라는 이름의 디렉토리를 생성할 수 있습니다.

2. __init__.py 파일 생성
패키지 디렉토리에 __init__.py 파일을 생성합니다. 이 파일은 패키지가 로드될 때 초기화 코드를 실행할 수 있도록 합니다. 또한 이 파일이 있어야 파이썬이 해당 디렉토리를 패키지로 인식합니다. 이 파일은 비워 둘 수도 있습니다.

3. 패키지에 모듈 추가
패키지 디렉토리에 모듈 파일(.py 파일)을 추가합니다. 예를 들어, my_package 디렉토리에 module1.py, module2.py와 같은 모듈을 추가할 수 있습니다.

4. 패키지 구조 예시

my_package/
    __init__.py
    module1.py
    module2.py

5. 패키지를 사용하는 방법

# 다른 파이썬 코드에서 패키지 사용
import my_package.module1
import my_package.module2

# 또는
from my_package import module1, module2

# 모듈 내 함수 사용 예시
result = my_package.module1.some_function()

패키지를 사용하면 여러 모듈을 하나의 디렉토리로 묶어 관리할 수 있으며, 관련된 기능을 한 곳에서 관리할 수 있어 프로젝트 구조를 더욱 체계적으로 만들 수 있습니다.

패키지 관리 시스템

Python은 pip(Pip Installs Packages)라는 패키지 관리 시스템을 사용하여 타사 패키지 또는 라이브러리를 설치하고 관리합니다. pip는 Python의 기본 패키지 관리자이며 Python 3.4부터 Python 설치와 함께 번들로 제공됩니다.

pip를 사용하면 무엇보다도 패키지를 검색하고 패키지를 설치, 제거 및 업데이트할 수 있습니다. Python Package Index(PyPI)를 기본 리포지토리로 사용하여 패키지를 찾고 다운로드합니다. PyPI는 커뮤니티에서 기여한 방대한 Python 패키지 모음이며 대부분의 Python 패키지에 대한 중앙 리포지토리 역할을 합니다.

다음은 pip와 함께 사용할 수 있는 몇 가지 기본 명령입니다.

1. 패키지 설치

pip install package_name

2. 패키지 제거

pip uninstall package_name

3. 패키지 업그레이드

pip install --upgrade package_name

4. 설치된 패키지 나열

pip list

5. 패키지 검색

pip search package_name

6. 패키지 정보 표시

pip show package_name

pip를 사용하려면 시스템에 Python이 설치되어 있어야 하며 명령 프롬프트, 터미널 또는 셸에서 pip를 사용할 수 있어야 합니다. 시스템 전체에 패키지를 설치하려면 관리자 또는 루트 권한이 필요할 수 있습니다. 또는 가상 환경을 사용하여 시스템 Python 설치에 영향을 주지 않고 특정 프로젝트에 대한 패키지를 설치할 수 있습니다.

패키지 생성

Python 패키지를 만드는 것은 코드를 정리하고 공유할 수 있는 좋은 방법입니다. 다음은 간단한 패키지를 만드는 단계별 가이드입니다.

1. 패키지 이름을 선택하고 디렉토리 구조를 만듭니다.
패키지를 설명할 수 있는 고유한 이름을 선택합니다. 이 예에서는 my_package를 사용하겠습니다. 같은 이름의 디렉터리를 만든 다음 그 안에 my_package라는 하위 디렉터리를 만듭니다.

my_package/
    my_package/

2. __init__.py 파일을 추가합니다.
__init__.py 파일은 디렉터리를 파이썬 패키지로 표시하여 인터프리터가 이를 모듈로 취급할 수 있도록 하는 데 사용됩니다. my_package 하위 디렉토리에 빈 __init__.py 파일을 추가합니다.

my_package/
    my_package/
        __init__.py

3. 코드를 추가합니다.
이제 Python 코드 파일(모듈)을 my_package 하위 디렉터리에 추가합니다. 이 예제에서는 say_hello 함수가 있는 간단한 hello.py 모듈을 추가하겠습니다.

hello.py:

def say_hello(name):
    print(f"안녕하세요, {이름}!")

이제 패키지 구조가 다음과 같이 보일 것입니다.

my_package/
    my_package/
        __init__.py
        hello.py

4. (선택 사항) README.md 파일을 추가합니다.
패키지 루트 디렉터리에 README.md 파일을 포함하는 것이 좋습니다. 이 파일에는 패키지에 대한 설명, 목적, 사용 방법이 포함되어야 합니다.

5. (선택 사항) LICENSE 파일을 추가합니다.
패키지 루트 디렉터리에 LICENSE 파일을 포함시켜 코드를 사용, 수정 및 배포할 수 있는 조건을 지정해야합니다.

6. (선택 사항) setup.py 파일을 추가합니다.
패키지를 배포하려는 경우(예: PyPI에 업로드) 패키지 루트 디렉터리에 setup.py 파일을 생성해야합니다. 이 파일은 패키지에 대한 메타데이터와 설치 지침을 제공합니다.

기본 setup.py 파일은 다음과 같습니다.

from setuptools import setup, find_packages

setup(
    name="my_package",
    version="0.1.0",
    packages=find_packages(),
    install_requires=[],
)

이 과정을 통해 간단한 Python 패키지를 만들었습니다. 이제 패키지 루트 디렉터리를 PYTHONPATH에 추가하거나 pip로 설치하여 다른 Python 프로젝트에서 이 패키지를 사용할 수 있습니다. 배포 가능한 패키지를 만들려면 setuptools를 사용하여 소스 배포 또는 휠 배포를 생성한 다음 다른 사람이 pip를 사용하여 설치할 수 있습니다. 이렇게 하려면 터미널에서 다음 명령을 실행합니다.

# 설치도구 및 휠 설치(아직 설치되지 않은 경우)
pip install setuptools wheel

# 패키지 배포를 생성합니다(.tar.gz 및 .whl 파일 생성).
python setup.py sdist bdist_wheel

이제 프로젝트에서 사용하거나 다른 사람들과 공유하거나 PyPI와 같은 패키지 리포지토리를 통해 배포할 수 있는 Python 패키지가 생겼습니다. 패키지를 더욱 유용하고 유지 관리하기 쉽게 만들려면 깔끔하고 잘 문서화되고 테스트된 코드를 작성하기 위한 모범 사례를 따르는 것을 잊지 말아야합니다.

목차

• 모듈이란?
  1. 모듈의 정의
  2. 모둘 생성
  3. __name__
  4. if __name__ == "__main__":
• 패키지란?
  1. 패키지
  2. 엔트리 포인트(entry point)
  3. 패키지 관리 시스템
  4. 패키지 생성

모듈의 정의

Python에서 모듈은 일반적으로 함수, 클래스, 변수로 구성된 Python 코드를 포함하는 파일로, 다른 Python 스크립트에서 가져와서 사용할 수 있습니다. 모듈은 코드를 더 작은 독립된 조각으로 나누어 정리하고 재사용하는 방법입니다. 모듈을 사용하면 코드를 복제하지 않고도 여러 스크립트나 프로젝트에서 기능을 공유할 수 있으므로 유지 관리와 업데이트가 더 쉬워집니다.

모듈의 주요 목적은 코드 재사용성, 모듈성 및 유지보수성을 가능하게 하는 것입니다. 모듈을 가져오면 해당 모듈의 모든 함수, 클래스, 변수에 액세스할 수 있으므로 자체 스크립트에서 사용할 수 있습니다.

모듈은 파일명으로 식별되며 Python 모듈의 파일 확장자는 .py입니다. 스크립트에서 모듈을 사용하려면 파일 확장자 없이 모듈 이름 뒤에 import 문을 사용해야 합니다. 예를 들어 example_module.py라는 이름의 모듈이 있는 경우 다음과 같이 스크립트로 가져올 수 있습니다:

import example_module

모듈을 가져온 후에는 모듈 이름 앞에 점 하나를 붙여서 모듈의 함수, 클래스, 변수를 사용할 수 있습니다. 예를 들어

result = example_module.some_function()

모듈에서 특정 함수나 클래스를 가져오려면 from 키워드를 사용하거나, 편의를 위해 모듈이나 그 멤버에 별칭을 지정하려면 as 키워드를 사용할 수도 있습니다.

모둘 생성

Python에서 모듈은 간단하게 만들 수 있습니다. 모듈은 기본적으로 파이썬 코드가 저장된 .py 파일입니다. 이 파일에 함수, 클래스, 변수 등을 정의하면 다른 파이썬 코드에서 이 모듈을 사용할 수 있습니다. 다음은 모듈을 만드는 방법과 예시입니다.

1. 모듈 파일 생성
먼저 새로운 .py 파일을 만들어 봅시다. 예를 들어, mymodule.py라는 이름으로 파일을 생성할 수 있습니다.

2. 모듈에 코드 추가
mymodule.py 파일에 함수, 클래스, 변수 등을 정의합니다.

예시:

# mymodule.py

def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

pi = 3.141592

위의 예시에서는 두 개의 함수(add, subtract)와 하나의 변수(pi)를 정의했습니다.

3. 다른 파이썬 코드에서 모듈 사용
이제 다른 파이썬 코드에서 mymodule.py를 사용할 수 있습니다. import 문을 사용하여 모듈을 불러올 수 있습니다.
예시:

# main.py

import mymodule

result1 = mymodule.add(1, 2)
print(result1)  # 출력: 3

result2 = mymodule.subtract(5, 3)
print(result2)  # 출력: 2

print(mymodule.pi)  # 출력: 3.141592

위의 예시에서는 main.py 파일에서 mymodule을 import하여 정의된 함수와 변수를 사용했습니다.

모듈을 만들고 사용하는 방법은 이처럼 간단하며, 코드를 재사용하고 조직화하는 데 도움이 됩니다. 다양한 기능을 모듈별로 분리하여 관리하면 유지 보수성도 향상됩니다.

__name__

Python에서 특수 변수 __name__은 Python 스크립트가 기본 프로그램으로 실행되는지 또는 다른 스크립트에 모듈로 가져오는지 결정하는 데 사용됩니다. Python 스크립트가 실행될 때 스크립트가 기본 프로그램으로 실행되는 경우 인터프리터는 __name__ 변수를 "__main__"으로 설정합니다. 스크립트를 다른 스크립트에 모듈로 가져오는 경우 __name__ 변수는 스크립트 이름으로 설정됩니다(.py 확장자 없음).

이는 스크립트가 모듈로 가져올 때가 아니라 기본 프로그램으로 실행될 때만 실행되어야 하는 일부 코드를 스크립트에 포함하려는 경우에 유용합니다. 예를 들면 다음과 같습니다.

def my_function():
    print("This is my function.")

if __name__ == "__main__":
    print("This script is being run as the main program.")
    my_function()
else:
    print("This script is being imported as a module.")

이 예에서 if __name__ == "__main__": 블록 내부의 print 문과 my_function()에 대한 호출은 스크립트가 기본 프로그램으로 실행될 때만 실행됩니다. 스크립트를 모듈로 가져오면 print 문과 함수 호출을 건너뛰고 else 블록만 실행합니다.

if __name__ == "__main__"

if __name__ == "__main__":은 스크립트가 기본 프로그램으로 실행되는지 또는 다른 스크립트에 모듈로 가져오는지 결정하는 데 사용되는 일반적인 Python 관용구입니다. 이렇게 하면 스크립트를 모듈로 가져올 때 실행되는 코드에서 프로그램의 기본 논리를 분리할 수 있습니다.

Python 스크립트가 실행될 때 스크립트가 기본 프로그램으로 실행되는 경우 인터프리터는 __name__ 변수를 "__main__"으로 설정합니다. 스크립트를 다른 스크립트에 모듈로 가져오는 경우 __name__은 스크립트 이름(파일 확장자 없음)으로 설정됩니다.

if __name__ == "__main__":을 사용하는 방법은 다음과 같습니다.

1. main() 함수 또는 프로그램의 기본 논리를 캡슐화하는 유사한 함수를 정의합니다.

def main():
    print("This is the main function of the script.")

2. 스크립트의 일부인 다른 함수나 클래스를 작성합니다.

def another_function():
    print("This is another function.")

3. 스크립트 끝에 if __name__ == "__main__": 블록을 추가하고 main() 함수 또는 1단계에서 정의한 함수를 호출합니다.

if __name__ == "__main__":
    main()

스크립트를 메인 프로그램으로 실행하면 main() 함수가 실행되고 "This is the main function of the script"라는 출력이 표시됩니다. 스크립트를 모듈로 다른 스크립트로 가져오면 main() 함수가 자동으로 실행되지 않지만 필요한 경우 여전히 명시적으로 호출할 수 있습니다.

if __name__ == "__main__":을 사용하면 스크립트의 기본 논리가 기본 프로그램으로 실행될 때만 실행되도록 할 수 있습니다. 이렇게 하면 코드를 보다 효과적으로 구성하고 모듈식으로 만들 수 있습니다. 이해하기 쉽습니다.

목차

• 외부 모듈 설치 방법과 예시
  1. 외부 모듈 설치
  2. Beautiful Soup
  3. Flask
  4. Django
  5. Django와 Flask
• 외부 모듈 세부 사항
  1. 라이브러리
  2. 프레임워크
  3. 제어 역전
  4. 함수 데코레이터

라이브러리

라이브러리는 프로젝트에서 가져오고 사용할 수 있는 미리 작성된 코드, 함수, 클래스 및 기타 리소스의 모음입니다. 라이브러리는 개발자에게 재사용 가능한 코드를 제공하여 일반적인 작업과 기능을 위해 바퀴를 재발명하지 않아도 되므로 시간과 노력을 절약할 수 있습니다.

라이브러리는 두 가지 주요 유형으로 분류할 수 있습니다.

• 표준 라이브러리
  기본적으로 프로그래밍 언어와 함께 제공되는 라이브러리입니다. 예를 들어 Python의 표준 라이브러리에는 파일 처리(os, shutil), 정규식(re), 수학 함수(math) 등을 위한 모듈이 포함되어 있습니다. 이러한 라이브러리는 프로그래밍 언어를 설치할 때 즉시 사용할 수 있으므로 별도로 설치할 필요가 없습니다.
  
  
• 외부 라이브러리
  타사에서 개발한 라이브러리이며 기본적으로 프로그래밍 언어에 포함되어 있지 않습니다. 개발자는 일반적으로 Python용 pip, JavaScript용 npm 또는 Ruby용 gem과 같은 패키지 관리자를 사용하여 외부 라이브러리를 별도로 설치해야 합니다. 외부 라이브러리의 예로는 수치 컴퓨팅을 위한 NumPy, 웹 개발을 위한 Flask, Python의 기계 학습을 위한 TensorFlow가 있습니다.
  
  

코드에서 라이브러리를 사용하려면 일반적으로 import 문을 사용하여 라이브러리를 가져와야 합니다. 예를 들어 파이썬에서는 다음과 같습니다.

import os

이렇게 하면 Python의 표준 라이브러리에서 os 모듈을 가져와 함수와 클래스에 액세스할 수 있습니다.

라이브러리는 개발자에게 사전 구축된 솔루션과 모범 사례를 제공하여 효율적이고 유지 관리 가능하며 확장 가능한 코드를 쉽게 작성할 수 있도록 함으로써 소프트웨어 개발에서 중요한 역할을 합니다. 또한 개발자가 기존 라이브러리를 기반으로 새로운 기능을 생성할 수 있으므로 코드 재사용성과 모듈성을 촉진합니다.

프레임워크

프레임워크(framework)는 소프트웨어 개발에 필요한 기본 구조와 코드를 제공하는 템플릿입니다. 프레임워크는 개발자가 일반적인 프로그래밍 문제를 효과적으로 해결하고, 빠르게 신뢰할 수 있는 소프트웨어를 개발하는 데 도움이 됩니다.

프레임워크의 주요 목적은 다음과 같습니다.

• 코드 재사용성
  프레임워크는 공통적인 기능 및 구조를 제공함으로써 개발자들이 중복 코드를 최소화하고 공통 작업을 재사용할 수 있게 돕습니다.
  
  
• 개발 속도 향상
  프레임워크를 사용하면 개발자가 효과적인 구조와 기본 기능을 갖춘 애플리케이션을 빠르게 구축할 수 있습니다.
  
  
• 유지 관리와 확장성
  프레임워크는 일관된 구조와 디자인 패턴을 제공하여 소프트웨어를 쉽게 유지 관리하고 확장할 수 있는 기반을 제공합니다.

프레임워크는 다양한 프로그래밍 언어와 사용 사례에 적용할 수 있습니다. 웹 개발, 모바일 애플리케이션, 데이터베이스 관리, 기계 학습 등 다양한 분야에서 프레임워크가 활용되고 있습니다.

프레임워크의 예시는 다음과 같습니다.

• 웹 개발
  
  • Python: Django, Flask
  • JavaScript: Angular, React, Vue.js
  • Ruby: Ruby on Rails
  • PHP: Laravel, Symfony
• 모바일 애플리케이션 개발
  
  • iOS: Swift, Objective-C
  • Android: Java, Kotlin
• 기계 학습 및 데이터 분석
  
  • Python: TensorFlow, PyTorch, Scikit-learn, Pandas

프레임워크를 사용하면 개발자는 표준화된 방식으로 문제를 해결할 수 있으며, 쉽게 이해할 수 있는 코드와 효율적인 개발 프로세스를 구현할 수 있습니다. 프레임워크는 개발자가 새로운 기능 및 기술을 쉽게 통합하고, 소프트웨어의 안정성 및 성능을 높일 수 있도록 지원합니다.

제어 역전

제어 역전(Inversion of Control, IoC)은 소프트웨어 개발에서 객체 지향 디자인 원칙 중 하나로, 컴포넌트 간의 제어 흐름과 종속성을 역전시키는 것을 의미합니다. 일반적으로, 프로그램의 제어 흐름은 메인 함수나 전역 프로시저가 결정합니다. 제어 역전은 이러한 메인 함수나 전역 프로시저의 역할을 프레임워크나 라이브러리로 이동시켜, 프레임워크가 개발자가 작성한 컴포넌트의 실행 순서와 타이밍을 결정합니다.

제어 역전의 주요 목적은 다음과 같습니다.

• 모듈 간의 결합도를 낮추기
  제어 역전을 사용하면 의존성이 라이브러리나 프레임워크에 위임되므로, 개별 모듈 간의 결합도를 낮출 수 있습니다.
  
  
• 코드의 재사용성 향상
  제어 역전을 사용하면 공통 기능을 분리하고 중앙에서 관리할 수 있어, 코드 재사용성이 향상됩니다.
  
  
• 유지 보수성 개선
  모듈 간 결합도가 낮아지면 유지 보수성이 향상되며, 개발자는 개별 모듈에 집중할 수 있습니다.

제어 역전은 종종 의존성 주입(Dependency Injection, DI)과 혼동되곤 합니다. 의존성 주입은 제어 역전을 구현하는 한 가지 방법으로, 컴포넌트 간의 의존성을 외부에서 주입해주는 기술입니다. 의존성 주입을 통해 개별 컴포넌트가 직접 의존성을 생성하거나 찾는 대신 외부에서 의존성을 주입받으므로, 결합도를 낮추고 유연성과 테스트 용이성을 높일 수 있습니다. 

함수 데코레이터

함수 데코레이터는 Python의 고급 기능 중 하나로, 함수의 기능을 수정하거나 확장할 때 사용됩니다. 데코레이터는 다른 함수를 인자로 받는 callable 객체(일반적으로 함수)입니다. 이 callable 객체는 원래 함수를 감싸고 추가 기능을 제공하거나 기존 기능을 수정하는 역할을 합니다.

데코레이터는 다음과 같은 구문으로 사용됩니다.

@decorator
def function_to_decorate():
    pass

이 구문은 다음 코드와 동일한 작업을 수행합니다:

function_to_decorate = decorator(function_to_decorate)

데코레이터를 사용하는 이유는 다양하며, 일반적으로 다음과 같은 경우에 사용됩니다.

• 코드 재사용: 데코레이터를 사용하면 공통 기능을 여러 함수에서 쉽게 재사용할 수 있습니다.
• 코드 분리: 데코레이터를 사용하면 함수의 주요 기능과 추가 기능을 분리하여 코드를 더 쉽게 이해하고 유지 관리할 수 있습니다.
• 기능 추가: 기존 함수를 수정하지 않고도 새로운 기능을 추가할 수 있습니다.

데코레이터 예시

def simple_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

@simple_decorator
def say_hello():
    print("Hello!")

say_hello()

이 코드의 출력 결과는 다음과 같습니다:

Something is happening before the function is called.
Hello!
Something is happening after the function is called.

이 예시에서 simple_decorator는 데코레이터 함수이며, say_hello 함수를 인자로 받아 wrapper 함수를 반환합니다. wrapper 함수는 원래 함수인 say_hello가 호출되기 전후에 추가적인 작업을 수행합니다. 데코레이터를 사용하면 기존 함수의 기능을 수정하거나 확장할 수 있으며, 코드 재사용성과 유지 관리성을 높일 수 있습니다.

목차

• 외부 모듈 설치 방법과 예시
  1. 외부 모듈 설치
  2. Beautiful Soup
  3. Flask
  4. Django
  5. Django와 Flask
• 외부 모듈 세부 사항
  1. 라이브러리
  2. 프레임워크
  3. 제어 역전
  4. 함수 데코레이터

외부 모듈 설치

파이썬에서 외부 모듈을 설치하려면 일반적으로 파이썬 패키지 설치 관리자(pip)를 사용합니다. pip를 사용하여 외부 모듈을 설치하는 방법은 다음과 같습니다.

1. 명령 프롬프트(Windows) 또는 터미널(macOS 및 Linux)을 엽니다.

2. 다음 명령어를 입력하고 Enter 키를 누릅니다.

pip install module_name

3. "module_name"을 설치하려는 외부 모듈의 이름으로 바꿉니다. 예를 들어, 인기있는 "requests" 모듈을 설치하려면 명령은 다음과 같습니다.

pip install requests

4. 설치 과정이 완료될 때까지 기다립니다. 모듈이 설치되면 파이썬 스크립트에서 가져와서 사용할 수 있습니다.

Beautiful Soup

Beautiful Soup은 HTML 및 XML 문서에서 데이터를 추출하기 위해 웹 스크래핑 목적으로 사용되는 Python 라이브러리입니다. HTML 및 XML 파일에서 구문 분석 트리를 생성하여 데이터를 쉽게 추출하는 데 사용할 수 있습니다. Beautiful Soup은 구문 분석 트리를 탐색, 검색 및 수정하기 위한 몇 가지 간단한 메서드와 Python 관용구를 제공합니다.

Beautiful Soup을 사용하려면 먼저 설치해야 합니다.

pip install beautifulsoup4

Beautiful Soup을 설치한 후 라이브러리를 가져오고 HTML 콘텐츠를 가져오기 위해 requests와 같은 HTTP 라이브러리와 결합하여 Python 스크립트에서 사용할 수 있습니다.

import requests
from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)

soup = BeautifulSoup(response.text, "html.parser")

이제 BeautifulSoup 개체를 만들었으므로 라이브러리에서 제공하는 다양한 메서드를 사용하여 HTML 콘텐츠에서 특정 요소에 액세스하고 추출할 수 있습니다. 몇 가지 일반적인 방법은 다음과 같습니다.

• find(): 주어진 속성과 일치하는 태그의 첫 번째 항목을 검색합니다.
• find_all(): 주어진 속성과 일치하는 태그의 모든 항목을 검색합니다.
• select(): 주어진 CSS 선택자와 일치하는 태그를 검색합니다.
• get_text(): 태그에서 텍스트 콘텐츠를 추출합니다.

다음은 웹페이지에서 모든 링크를 추출하는 간단한 예입니다.

import requests
from bs4 import BeautifulSoup

url = "https://example.com"
response = requests.get(url)

soup = BeautifulSoup(response.text, "html.parser")

# Find all 'a' tags
links = soup.find_all('a')

# Extract and print the 'href' attribute of each link
for link in links:
    print(link.get('href'))

Beautiful Soup은 사용하기 쉽고 잘못된 마크업을 우아하게 처리할 수 있기 때문에 웹 스크래핑 작업에 널리 사용됩니다.

Flask

Flask는 웹 애플리케이션을 쉽게 만들 수 있는 가볍고 유연한 Python 웹 프레임워크입니다. Flask는 도구, 라이브러리 및 간단한 API를 제공하여 최소한의 설정 및 상용구 코드로 웹 애플리케이션을 만드는 데 도움을 줍니다. 마이크로 프레임워크로 간주되며, 이는 작고 집중적이며 외부 라이브러리 및 플러그인으로 쉽게 확장할 수 있음을 의미합니다.

1. Flask의 일부 주요 기능은 다음과 같습니다.

• 라우팅
  Flask를 사용하면 들어오는 요청을 처리하고 응답을 생성하는 Python 함수에 URL을 매핑하여 웹 애플리케이션에 대한 경로를 간단하게 정의할 수 있습니다.
  
  
• 템플릿
  Flask는 간단한 템플릿 구문을 사용하여 동적 HTML 페이지를 생성할 수 있는 Jinja2 템플릿 엔진을 사용합니다.
  
  
• 양식 및 입력 처리
  Flask는 제출된 데이터의 유효성 검사 및 처리를 포함하여 웹 양식에서 사용자 입력을 처리하기 위한 기본 제공 지원을 제공합니다.
  
  
• 세션 및 쿠키
  Flask를 사용하면 세션 변수 및 쿠키를 사용하여 사용자별 데이터를 저장하고 관리할 수 있습니다.
  
  
• 확장 및 플러그인
  Flask에는 데이터베이스 통합, 사용자 인증 등과 같은 기능을 웹 애플리케이션에 추가하는 데 사용할 수 있는 확장 및 플러그인의 풍부한 생태계가 있습니다.

2. Flask를 시작하려면 먼저 Flask를 설치해야 합니다.

pip install Flask

3. 설치 후 위의 예제 코드로 새 Python 파일을 만들고 실행하여 Flask 웹 애플리케이션을 시작할 수 있습니다. 다음은 Flask 웹 애플리케이션의 간단한 예입니다.

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run(debug=True)

이 코드는 루트 URL("/")에 매핑되는 단일 경로가 있는 기본 Flask 웹 애플리케이션을 만듭니다. 사용자가 이 URL을 방문하면 hello 함수가 호출되어 "Hello, World!" 메시지. app.run(debug=True) 라인은 디버그 모드가 활성화된 상태로 개발 서버를 시작하여 문제가 발생할 경우 자세한 오류 메시지를 볼 수 있습니다.

Django

Django는 빠른 개발과 깨끗하고 실용적인 디자인을 장려하는 높은 수준의 오픈 소스 Python 웹 프레임워크입니다. MVT(Model-View-Template) 아키텍처 패턴을 따르며 개발자가 확장 가능하고 유지 관리 가능한 웹 애플리케이션을 구축하는 데 도움을 주는 것을 목표로 합니다. Django는 강력하고 내장된 기능으로 유명하므로 복잡한 데이터 기반 웹 애플리케이션을 만드는 데 탁월한 선택입니다.

1. Django의 몇 가지 주요 기능은 다음과 같습니다.

• 관리 인터페이스
  Django는 애플리케이션 데이터 관리를 위한 기본 제공 관리 인터페이스를 제공하므로 모델에서 CRUD(만들기, 읽기, 업데이트, 삭제) 작업을 쉽게 수행할 수 있습니다.
  
  
• URL 라우팅
  Django를 사용하면 웹 애플리케이션의 URL 패턴을 정의하고 해당 보기에 매핑할 수 있습니다.
  
  
• ORM(Object-Relational Mapping)
  Django의 ORM을 사용하면 원시 SQL 쿼리를 작성하는 대신 Python 클래스 및 객체를 사용하여 데이터베이스와 상호 작용할 수 있습니다. PostgreSQL, MySQL, SQLite 및 Oracle을 포함한 다양한 데이터베이스 시스템을 지원합니다.
  
  
• 양식 및 입력 처리
  Django는 사용자 입력, 유효성 검사 및 HTML 양식 렌더링을 단순화하는 강력한 양식 시스템을 제공합니다.
  
  
• 템플릿
  Django는 자체 템플릿 엔진을 사용하여 동적 HTML 페이지를 생성합니다. 템플릿 구문은 배우기 쉽고 유연하여 재사용 가능한 템플릿과 구성 요소를 만들 수 있습니다.
  
  
• 인증 및 권한 부여
  Django에는 사용자 인증 및 권한 부여 지원 기능이 내장되어 있어 애플리케이션에서 사용자 계정, 권한 및 액세스 제어를 쉽게 관리할 수 있습니다.
  
  
• 미들웨어
  Django의 미들웨어 시스템을 사용하면 요청과 응답이 보기에 도달하기 전이나 보기를 떠난 후에 전역적으로 처리할 수 있으므로 보안, 세션 관리 및 캐싱과 같은 측면을 처리할 수 있습니다.
  
  
• 확장성
  Django에는 타사 앱과 플러그인의 풍부한 생태계가 있어 애플리케이션의 기능을 쉽게 확장할 수 있습니다.
  
  

2. Django를 시작하려면 먼저 Django를 설치해야 합니다.

pip install Django

일단 설치되면 Django의 명령줄 도구를 사용하여 새 프로젝트를 만들고 웹 애플리케이션 구축을 시작할 수 있습니다.

Django와 Flask

Django와 Flask는 둘 다 널리 사용되는 Python 웹 프레임워크이지만 서로 다른 디자인 철학을 가지고 있으며 서로 다른 요구 사항을 충족합니다. 기능을 비교하면 다음과 같습니다.

1. 디자인 철학
Django는 "batteries-included" 접근 방식을 따르며 일반적인 작업을 위한 내장 기능 및 도구가 포함된 전체 스택 솔루션을 제공합니다. MVT(Model-View-Template) 아키텍처 패턴을 준수합니다.

반면 Flask는 단순성과 유연성을 강조하는 마이크로 프레임워크입니다. 구성 요소를 선택하고 원하는 방식으로 애플리케이션을 빌드할 수 있습니다. Flask는 WSGI(Web Server Gateway Interface) 표준을 따릅니다.

2. 학습 곡선
Django는 광범위한 기능과 구성 요소로 인해 초보자가 배우기에 더 어려울 수 있습니다. 그러나 규칙에 익숙해지면 개발 프로세스 속도를 높일 수 있습니다.

Flask는 최소한의 접근 방식을 사용하고 따라야 할 규칙이 적기 때문에 특히 웹 개발을 처음 접하는 사람들이 배우기 쉽습니다.

3. 유연성
Django는 독단적이며 응용 프로그램을 구성하고 구축하는 특정 방법을 권장합니다. 이것은 일관성을 유지하고 모범 사례를 따르는 데 도움이 될 수 있지만 일부 개발자에게는 제한적으로 느껴질 수 있습니다.

Flask는 구성 요소를 선택하고 응용 프로그램을 구성하는 데 더 많은 자유를 제공합니다. 이러한 유연성은 처음부터 응용 프로그램을 구축하는 것을 선호하는 숙련된 개발자에게 매력적일 수 있습니다.

4. 내장 기능
Django는 관리 인터페이스, ORM, 인증 및 양식 처리와 같은 강력한 내장 기능 세트와 함께 제공됩니다.

마이크로 프레임워크인 Flask는 기본 제공 기능이 적습니다. 그러나 타사 확장 및 라이브러리를 사용하여 기능을 확장할 수 있습니다.

5. 확장성
Django와 Flask 모두 확장 가능한 애플리케이션을 구축하는 데 사용할 수 있지만 접근 방식이 다릅니다. Django의 내장 기

능을 사용하면 복잡한 기능을 가진 대규모 애플리케이션을 더 쉽게 구축할 수 있습니다.

Flask의 모듈 방식을 사용하면 필요에 따라 개별 구성 요소를 최적화하고 확장할 수 있으므로 애플리케이션 성능을 더 잘 제어할 수 있습니다.

6. 커뮤니티 및 생태계
Django와 Flask 모두 대규모의 활동적인 커뮤니티와 풍부한 타사 패키지 및 플러그인을 사용할 수 있습니다. Django는 더 오래되었고 더 광범위한 생태계를 가지고 있지만 Flask는 인기가 빠르게 증가하고 있으며 확장 범위도 넓습니다.

Django와 Flask 중에서 선택하는 것은 프로젝트 요구 사항, 개발 경험 및 개인 선호도에 따라 다릅니다. 개발 속도를 높이는 완전한 기능을 갖춘 독창적인 프레임워크가 필요한 경우 Django가 더 탁월한 선택입니다. 처음부터 응용 프로그램을 빌드할 수 있는 가볍고 유연한 프레임워크를 선호한다면 Flask가 더 훌륭한 옵션입니다.

목차

• PART1
  1. math 모듈
  2. math 함수에 from, as 구문 함께 사용하기
  3. random 모듈
  4. sys 모듈
  5. os 모듈
• PART2
  1. datetime 모듈
  2. time 모듈
  3. urllib 모듈
  4. urlopen 함수
  5. operator.itemgetter 함수

datetime 모듈

Python의 날짜/시간 모듈은 날짜와 시간 작업에 사용됩니다. 날짜, 시간 및 간격을 조작하기 위한 클래스를 제공합니다. 다음은 날짜/시간 모듈에 대한 개요입니다:

1. 날짜/시간 모듈을 가져옵니다.
날짜/시간 모듈을 사용하려면 먼저 모듈을 임포트해야 합니다:

import datetime

2. 날짜/시간 모듈의 일반적인 용도

  1) 현재 날짜와 시간 가져오기

datetime.datetime.now() 함수를 사용하여 현재 날짜와 시간을 가져올 수 있습니다.

import datetime

# 현재 날짜 및 시간 가져오기
current_datetime = datetime.datetime.now()
print(current_datetime)

  2) 사용자 정의 날짜 생성

datetime.date 클래스를 사용하여 사용자 정의 날짜를 만들 수 있습니다.

import datetime

# 사용자 정의 날짜 만들기
custom_date = datetime.date(2023, 5, 2)
print(custom_date)

  3) 사용자 정의 시간 생성

datetime.time 클래스를 사용하여 사용자 정의 시간을 만들 수 있습니다.

import datetime

# 사용자 정의 시간 만들기
custom_time = datetime.time(12, 30, 45)
print(custom_time)

  4) 사용자 정의 날짜/시간 생성

datetime.datetime 클래스를 사용하여 사용자 정의 날짜/시간을 만들 수 있습니다.

import datetime

# 사용자 정의 날짜 시간 만들기
custom_datetime = datetime.datetime(2023, 5, 2, 12, 30, 45)
print(custom_datetime)

  5) 날짜와 시간으로 산술 수행

datetime.timedelta 클래스를 사용하여 날짜 및 시간으로 산술을 수행할 수 있습니다.

import datetime

# 현재 날짜 및 시간 가져오기
current_datetime = datetime.datetime.now()

# 현재 날짜와 시간에 하루를 추가합니다.
one_day = datetime.timedelta(days=1)
tomorrow = current_datetime + one_day
print(tomorrow)

# 현재 날짜와 시간에서 하루를 뺍니다.
yesterday = current_datetime - one_day
print(yesterday)

  6) 날짜와 시간 서식을 지정합니다:

strftime() 메서드를 사용하여 날짜와 시간을 문자열로 서식을 지정할 수 있습니다.

import datetime

# 현재 날짜 및 시간 가져오기
current_datetime = datetime.datetime.now()

# 날짜와 시간을 문자열로 포맷
formatted_datetime = current_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(formatted_datetime)

time 모듈

파이썬의 시간 모듈은 시간 관련 함수로 작업하는 데 사용됩니다. 현재 시간 가져오기, 코드 실행 지연, 시간 서식 지정 등 시간 관련 작업을 위한 다양한 함수를 제공합니다.

1. 시간 모듈을 가져옵니다.
시간 모듈을 사용하려면 먼저 시간 모듈을 가져와야 합니다.

import time

2. 시간 모듈의 일반적인 용도

  1) 현재 시간을 가져옵니다.

time.time() 함수를 사용하여 에포크(1970년 1월 1일, 00:00:00 UTC) 이후의 현재 시간(초)을 가져올 수 있습니다.

import time

# 에포크 이후 현재 시간(초)을 가져옵니다.
current_time = time.time()
print(current_time)

  2) 코드 실행 지연

time.sleep() 함수를 사용하여 지정된 시간(초) 동안 코드 실행을 일시 중지할 수 있습니다.

import time

# 5초 동안 코드 실행을 지연합니다.
print("Start")
time.sleep(5)
print("End")

  3) 다른 시간 표현 사이를 변환

시간 모듈은 time.gmtime(), time.localtime(), time.mktime()과 같이 서로 다른 시간 표현을 변환하는 함수를 제공합니다.

import time

# 에포크 이후 초를 UTC의 구조시간으로 변환합니다.
utc_time = time.gmtime()
print(utc_time)

# 에포크 이후 초를 현지 시간대의 struct_time으로 변환합니다.
local_time = time.localtime()
print(local_time)

# 구조 시간을 에포크 이후 초로 변환합니다.
seconds_since_epoch = time.mktime(local_time)
print(seconds_since_epoch)

  4) 시간 포맷

time.strftime() 함수를 사용하여 시간을 문자열로 포맷할 수 있습니다.

import time

# 현지 시간대의 현재 시간을 가져옵니다.
local_time = time.localtime()

# 시간을 문자열로 포맷
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", local_time)
print(formatted_time)

  5) 시간을 구문 분석

time.strptime() 함수를 사용하여 시간 문자열을 struct_time으로 구문 분석할 수 있습니다.

import time

# 시간 문자열을 구조체_시간으로 파싱합니다.
time_string = "2023-05-02 12:30:45"
time_format = "%Y-%m-%d %H:%M:%S"
parsed_time = time.strptime(time_string, time_format)
print(parsed_time)

urllib 모듈

Python의 urllib 모듈은 URL 작업을 위한 모듈 모음을 제공하는 패키지입니다. URL을 열고, 읽고, 구문 분석할 뿐만 아니라 HTTP 요청을 전송하고 웹 서비스와 상호 작용하는 데 도움이 됩니다. urllib 패키지에는 urllib.request, urllib.parse, urllib.error 및 urllib.robotparser를 비롯한 여러 모듈이 포함되어 있습니다.

다음은 urllib 패키지와 그 모듈에 대한 사용 방법입니다.

1. urllib.request
이 모듈은 URL을 열고 읽는 함수를 제공합니다. HTTP, HTTPS, FTP 등과 같은 다양한 프로토콜을 처리할 수 있습니다. 다음은 urllib.request를 사용하여 URL을 열고 그 내용을 읽는 예제입니다:

import urllib.request

# URL을 열고 콘텐츠를 읽습니다.
url = "https://www.example.com"
response = urllib.request.urlopen(url)
content = response.read()

print(content)

2. urllib.parse
이 모듈은 URL을 구성 요소로 분할하고, URL 매개변수를 인코딩 및 디코딩하고, URL 구성 요소를 결합하는 등 URL을 조작하고 파싱하는 함수를 제공합니다. 다음은 urllib.parse를 사용하여 URL을 구성 요소로 분할하는 예제입니다:

import urllib.parse

# URL을 구성 요소로 분할
url = " https://www.example.com/path?query=param "
parsed_url = urllib.parse.urlsplit(url)

print(parsed_url)

3. urllib.error
이 모듈은 URLError 및 HTTPError와 같이 URL 처리 중에 발생할 수 있는 에러를 처리하기 위한 예외 클래스를 제공합니다. 이러한 예외를 사용하면 urllib.request 모듈로 작업할 때 오류를 정상적으로 처리할 수 있습니다. 다음은 urllib.error를 사용하여 예외를 처리하는 예제입니다:

import urllib.request
import urllib.error

url = "https://www.nonexistentwebsite.com"

try:
    response = urllib.request.urlopen(url)
urllib.error.URLError를 e로 제외합니다:
    print(f"오류가 발생했습니다: {e}")

4. urllib.robotparser
이 모듈은 웹사이트의 robots.txt 파일을 파싱하고 분석하는 데 사용할 수 있는 RobotFileParser라는 클래스를 제공합니다. 웹 크롤러나 스크레이퍼를 작성하여 웹사이트의 특정 섹션에 액세스할 수 있는지 여부를 결정할 때 유용할 수 있습니다. 다음은 사용자 에이전트가 URL에 액세스할 수 있는지 확인하기 위해 urllib.robotparser를 사용하는 예제입니다:

import urllib.robotparser

robot_parser = urllib.robotparser.RobotFileParser()
robot_parser.set_url("https://www.example.com/robots.txt")
robot_parser.read()

user_agent = "MyWebCrawler"
url_to_check = "https://www.example.com/some-page/"

can_fetch = robot_parser.can_fetch(user_agent, url_to_check)
print(f"가져올 수 있음: {can_fetch}")

urlopen 함수

urlopen 함수는 Python의 urllib.request 모듈의 일부입니다. 이 함수는 URL을 열고 URL에서 콘텐츠를 가져오는 데 사용됩니다. urlopen 함수는 URL에서 데이터를 읽고 상호 작용할 수 있는 메서드를 제공하는 HTTPResponse 객체를 반환합니다.

다음은 urlopen 함수에 대한 간략한 설명입니다.

• 구문(Syntax)
  
  urllib.request.urlopen(url, data=None, timeout=<default timeout>, *, cafile=None, capath=None, cadefault=False, context=None)
  
  
• 매개변수(Parameters)
  
  
  • url: 열 URL입니다. 문자열 또는 요청 객체일 수 있습니다.
  • data: 선택 사항입니다. 제공된 경우, POST 메서드를 사용할 때 HTTP 요청 본문으로 전송될 바이트열 객체여야 합니다.
  • timeout: 선택 사항입니다. URL을 열 수 없는 경우 포기하기 전에 대기할 시간(초)입니다. 기본값은 글로벌 기본 시간 제한 설정입니다.
  • cafile, capath, cadefault: 선택 사항입니다. 이러한 매개 변수는 SSL/TLS 연결에 대한 사용자 지정 CA(인증 기관) 인증서를 지정하는 데 사용됩니다.
  • context: 선택 사항입니다. 연결에 대한 사용자 지정 SSL/TLS 설정을 지정하는 데 사용할 수 있는 ssl.SSLContext 객체입니다.

다음은 urlopen 함수를 사용하여 URL을 열고 콘텐츠를 읽는 예제입니다.

import urllib.request

# URL을 열고 콘텐츠를 읽습니다.
url = "https://www.example.com"
response = urllib.request.urlopen(url)
content = response.read()

print(content)

urlopen 함수를 사용할 때는 URL을 여는 데 문제가 있거나 서버가 HTTP 오류 상태 코드를 반환하는 경우 발생할 수 있는 URLError 및 HTTPError와 같은 예외를 처리하는 것이 좋습니다. 다음은 예외 처리와 함께 urlopen을 사용하는 예시입니다.

import urllib.request
import urllib.error

url = "https://www.example.com"

try:
    response = urllib.request.urlopen(url)
    content = response.read()
    print(content)
urllib.error.URLError를 e로 제외합니다:
    print(f"오류가 발생했습니다: {e}")

urlopen 함수는 Python을 사용하여 URL을 열고, 콘텐츠를 가져오고, 웹 서비스와 상호 작용하는 편리한 방법입니다.

operator.itemgetter 함수

operator.itemgetter 함수는 파이썬의 연산자 모듈의 일부입니다. 이 함수는 피연산자의 __getitem__() 메서드를 사용하여 피연산자로부터 항목을 가져오는 호출 가능한 객체를 만드는 데 사용됩니다. 이터러블에서 특정 항목을 검색하거나 복잡한 데이터 구조를 정렬하거나 처리할 때 특히 유용합니다.

다음은 operator.itemgetter 함수에 대한 간략한 설명입니다.

• 구문(Syntax): operator.itemgetter(item[, args...])
  
  
• 매개변수
  
  • item: 피연산자에서 항목을 검색하는 데 사용할 인덱스 또는 키입니다.
  • args: 선택 사항. 여러 항목을 검색하기 위한 추가 인덱스 또는 키입니다.

다음은 operator.itemgetter 함수를 사용하여 목록에서 특정 항목을 검색하는 예제입니다.

import operator

data = [1, 2, 3, 4, 5]
get_second_item = operator.itemgetter(1)
second_item = get_second_item(data)

print(second_item) # 출력: 2

operator.itemgetter는 특정 키나 인덱스를 기준으로 딕셔너리 또는 튜플 목록을 정렬할 때도 매우 유용합니다. 다음은 예제입니다.

import operator

data = [
    {'name': 'Alice', 'age: 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35},
]

# 'age' 키를 기준으로 사전 목록을 정렬합니다.
sorted_data = sorted(data, key=operator.itemgetter('age'))
print(sorted_data)
# 출력: [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

operator.itemgetter 함수는 피연산자로부터 특정 항목을 가져오는 호출 가능한 객체를 만드는 편리한 방법입니다. 특히 복잡한 데이터 구조를 정렬하고 처리하는 데 유용합니다.

목차

• PART1
  1. math 모듈
  2. math 함수에 from, as 구문 함께 사용하기
  3. random 모듈
  4. sys 모듈
  5. os 모듈
• PART2
  1. datetime 모듈
  2. time 모듈
  3. urllib 모듈
  4. urlopen 함수
  5. operator.itemgetter 함수

math 모듈

파이썬의 math 모듈은 다양한 math 함수와 상수를 제공하므로 코드에서 math 연산을 더 쉽게 수행할 수 있습니다. 다음은 math 모듈을 사용하는 몇 가지 방법과 예제입니다:

1. 모듈을 가져옵니다.
math 모듈을 사용하려면 먼저 모듈을 임포트해야 합니다.

import math

2. math 함수
math 모듈은 sqrt, sin, cos, tan, log, ceiling, floor 등과 같은 여러 math 함수를 제공합니다.

# 숫자의 제곱근을 계산합니다.
result = math.sqrt(25)
print(result) # 출력합니다: 5.0

# 각의 사인, 코사인, 탄젠트를 계산합니다(라디안 단위).
angle = math.radians(30)
sin_value = math.sin(angle)
cos_value = math.cos(angle)
tan_value = math.tan(angle)
print(f"Sin: {sin_value}, Cos: {cos_value}, Tan: {tan_value}")

3. math 상수
math 모듈은 파이와 e와 같은 유용한 math 상수를 제공합니다.

# 원의 둘레를 계산합니다.
radius = 5
circumference = 2 * math.pi * 반지름
print(circumference) # 출력: 31.41592653589793

# 숫자의 자연 로그 계산하기
number = 2
natural_log = math.log(number, math.e)
print(natural_log) # 출력: 0.6931471805599453

4. 고급 math 함수
math 모듈에는 gcd, lcm, comb, perm 등과 같은 고급 함수도 포함되어 있습니다.

# 두 숫자의 최대공약수(GCD, greatest common divisor) 계산하기
gcd_result = math.gcd(15, 20)
print(gcd_result) # 출력: 5

# 한 번에 r씩 취한 n개의 항목의 조합과 순열을 계산합니다.
n = 5
r = 3
comb_result = math.comb(n, r)
perm_result = math.perm(n, r)
print(f"조합: {comb_result}, Permutations: {perm_result}") # 출력: Combinations: 10, Permutations: 60

math 함수에 from, as 구문 함께 사용하기

Python에서 math 모듈과 함께 from 및 as 키워드를 사용하면 필요한 경우 특정 함수를 가져오고 이름을 변경하는 것이 더 편리해집니다. 이러한 키워드를 사용하는 방법은 다음과 같습니다:

1. from
from 키워드를 사용하면 전체 모듈을 가져오는 대신 모듈에서 특정 함수나 어트리뷰트를 가져올 수 있습니다. 이 키워드는 몇 가지 함수만 사용하고 모든 함수를 가져오지 않으려는 경우에 유용할 수 있습니다.

예를 들어 math 모듈에서 sqrt 함수를 가져오고 싶다고 가정해 보겠습니다:

from math import sqrt

# 이제 math 접두사 없이 sqrt 함수를 사용할 수 있습니다.
square_root = sqrt(16)
print(square_root)

2. as
as 키워드를 사용하면 가져온 함수, 속성 또는 모듈의 이름을 바꿀 수 있습니다. 이름에 충돌이 있거나 더 편리한 이름을 사용하려는 경우 유용하게 사용할 수 있습니다.

예를 들어 math 모듈에서 sqrt 함수를 가져와서 square_root_function으로 이름을 바꾸고 싶다고 가정해 보겠습니다:

from math import sqrt as square_root_function

# 이제 이름이 바뀐 함수를 사용할 수 있습니다.
square_root = square_root_function(16)
print(square_root)

전체 모듈을 임포트할 때 as 키워드를 사용할 수도 있습니다:

import math as m

# 이제 m. 접두사가 붙은 math 모듈 함수를 사용할 수 있습니다.
square_root = m.sqrt(16)
print(square_root)

math 모듈에 from 및 as 키워드를 사용하면 이름 충돌을 피하고 필요에 따라 함수 이름을 단순화하면서 코드를 더 간결하고 읽기 쉽게 만들 수 있습니다.

random 모듈

파이썬의 랜덤 모듈은 난수를 생성하고 다양한 랜덤 연산을 수행하는 데 사용됩니다. 임의의 정수, 부동 소수점 숫자를 생성하고 리스트와 같은 시퀀스에서 항목을 무작위로 선택하는 함수를 제공합니다. 다음은 random 모듈에서 일반적으로 사용되는 몇 가지 함수입니다:

1. 모듈을 가져옵니다.
random 모듈을 사용하려면 먼저 모듈을 가져와야 합니다.

import random

2. 임의의 정수를 생성
randint 함수는 지정된 범위(양쪽 끝점 포함) 내에서 임의의 정수를 생성합니다.

# 1에서 10 사이의 임의의 정수를 생성합니다.
random_int = random.randint(1, 10)
print(random_int)

3. 임의의 부동 소수점 숫자를 생성
랜덤 함수는 0에서 1 사이의 임의의 부동 소수점 숫자를 생성합니다(0을 포함하지만 1은 아님).

# 0과 1 사이의 임의의 실수를 생성합니다.
random_float = random.random()
print(random_float)

4. uniform 함수는 지정된 범위 내에서 임의의 부동 소수점 숫자를 생성

# 1에서 10 사이의 임의의 실수를 생성합니다.
random_float = random.uniform(1, 10)
print(random_float)

5. 시퀀스에서 random 항목 선택하기
choice 함수는 시퀀스(예: 리스트 또는 튜플)에서 임의의 항목을 선택합니다.

# 리스트에서 random 요소 선택
items = ['사과', '바나나', '체리', '날짜']
random_item = random.choice(items)
print(random_item)

선택 함수는 시퀀스에서 여러 개의 random 항목을 선택하며, 가중치 및 교체 옵션을 선택할 수 있습니다.

# 리스트에서 random 요소 3개 선택 후 대체하기
random_items = random.choices(items, k=3)
print(random_items)

6. 시퀀스 셔플하기
셔플 함수는 리스트와 같이 변경 가능한 시퀀스의 요소를 random로 재배열합니다.

# 리스트 셔플
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print(numbers)

sys 모듈

Python의 sys 모듈은 Python 인터프리터의 환경 및 스크립트에 전달되는 명령줄 인수와 같은 다양한 시스템별 매개변수 및 함수에 대한 액세스를 제공합니다. sys 모듈을 사용하는 방법은 다음과 같습니다:

1. sys 모듈을 가져옵니다.
sys 모듈을 사용하려면 먼저 모듈을 임포트해야 합니다:

import sys

2. sys 모듈의 일반적인 용도

  1) 명령줄 인자에 액세스

sys.argv 리스트를 사용하여 스크립트에 전달된 명령줄 인수에 액세스할 수 있습니다. 리스트의 첫 번째 요소인 sys.argv[0]은 스크립트의 이름이고, 그 이후의 요소는 인수입니다.

import sys

# 스크립트 이름과 인수를 인쇄합니다.
print("스크립트 이름:", sys.argv[0])

for i, arg in enumerate(sys.argv[1:], start=1):
    print(f"인자 {i}:", arg)

  2) 스크립트를 종료

sys.exit() 함수를 사용하여 지정된 종료 코드로 스크립트를 종료할 수 있습니다. 종료 코드가 0이면 일반적으로 성공적으로 종료되었음을 나타내며, 0이 아닌 종료 코드는 오류를 나타냅니다.

import sys

# 종료 코드 0으로 스크립트를 종료합니다.
sys.exit(0)

  3) 파이썬 버전을 확인

sys.version_info 튜플을 사용하여 파이썬 인터프리터의 버전을 확인할 수 있습니다.

import sys

# 파이썬 버전을 인쇄합니다.
print("파이썬 버전:", sys.version_info)

  4) 파이썬 모듈 검색 경로에 디렉터리를 추가

sys.path 리스트를 사용하여 파이썬 모듈 검색 경로에 디렉터리를 추가하여 사용자 정의 모듈을 가져올 수 있습니다.

import sys

# 파이썬 모듈 검색 경로에 사용자 정의 디렉터리 추가하기
sys.path.append("/path/to/your/custom/directory")

os 모듈

Python의 os 모듈은 운영 체제와 상호 작용할 수 있는 방법을 제공하여 파일 및 디렉터리 작업을 수행하고, 환경 변수에 액세스하고, 시스템 명령을 실행할 수 있도록 합니다. 다음은 os 모듈에 대한 개요입니다:

1. os 모듈 가져오기.
os 모듈을 사용하려면 먼저 모듈을 임포트해야 합니다:

import os

2. os 모듈의 일반적인 용도

  1) 디렉터리의 내용을 나열

os.listdir() 함수를 사용하여 지정된 디렉터리에 있는 파일과 디렉터리를 나열할 수 있습니다.

import os

# 현재 디렉터리의 내용을 나열합니다.
print(os.listdir("."))

  2) 새 디렉토리 생성

os.mkdir() 함수를 사용하여 새 디렉터리를 만들 수 있습니다.

import os

# 새 디렉토리 만들기
os.mkdir("new_directory")

  3) 파일 또는 디렉터리 이름 변경

os.rename() 함수를 사용하여 파일 또는 디렉터리 이름을 바꿀 수 있습니다.

import os

# 파일 또는 디렉토리 이름 바꾸기
os.rename("old_name", "new_name")

  4) 파일을 제거

os.remove() 함수를 사용하여 파일을 삭제할 수 있습니다.

import os

# 파일 제거
os.remove("file_to_delete.txt")

  5) 환경 변수를 가져오고 설정

os.environ 딕셔너리를 사용하여 환경 변수에 액세스하고 수정할 수 있습니다.

import os

# 환경 변수의 값을 가져옵니다.
print(os.environ["PATH"])

# 환경 변수 값 설정
os.environ["MY_VARIABLE"] = "my_value"

  6) 시스템 명령을 실행

os.system() 함수를 사용하여 시스템 명령을 실행할 수 있습니다.

import os

# 시스템 명령 실행
os.system("ls")