Python파이썬

word = 'Python'
word[0]     # 'P'   — 인덱싱
word[-1]    # 'n'   — 음수 인덱싱 (뒤에서)
word[0:2]   # 'Py'  — 슬라이싱 [start:end) 끝 미포함
word[:2]    # 'Py'  — 처음부터
word[4:]    # 'on'  — 끝까지
len(word)   # 6

# f-문자열 포매팅 (Python 3.6+, 권장)
name = 'World'
f'Hello, {name}!'     # 'Hello, World!'
f'{2 ** 10}'          # '1024'

# [표현식 for 변수 in 이터러블 if 조건]
squares = [x ** 2 for x in range(10)]           # [0, 1, 4, 9, ...]
evens   = [x for x in range(20) if x % 2 == 0]  # [0, 2, 4, ...]

# 딕셔너리·집합 컴프리헨션
sq_dict = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, ...}
sq_set  = {x**2 for x in range(5)}     # {0, 1, 4, 9, 16}

x = int(input('정수 입력: '))
if x < 0:
    print('음수')
elif x == 0:
    print('0')
else:
    print('양수')

# for: 시퀀스 순회
for word in ['cat', 'window', 'defenestrate']:
    print(word, len(word))

# range(): 숫자 시퀀스 생성 (끝값 미포함)
for i in range(0, 10, 2):   # 0, 2, 4, 6, 8
    print(i)

# enumerate(): 인덱스와 값 동시
for i, val in enumerate(['a', 'b', 'c']):
    print(i, val)

# while
n = 10
while n > 0:
    n -= 1

def http_status(status):
    match status:
        case 200:
            return 'OK'
        case 404:
            return 'Not Found'
        case 400 | 401 | 403:
            return 'Client Error'
        case _:            # 와일드카드 (default)
            return 'Unknown'

# 구조 분해 패턴
match point:
    case (0, 0): print('원점')
    case (x, 0): print(f'X축: {x}')
    case (0, y): print(f'Y축: {y}')
    case (x, y): print(f'({x}, {y})')

def greet(name: str, greeting: str = 'Hello') -> str:
    """이름과 인사말을 받아 문자열을 반환합니다."""
    return f'{greeting}, {name}!'

greet('Alice')                # 'Hello, Alice!'
greet('Bob', greeting='Hi')  # 'Hi, Bob!'

def func(pos_only, /, normal, *, kwd_only):
    # pos_only: 위치 인자 전용 (/ 앞)
    # normal:   위치 또는 키워드
    # kwd_only: 키워드 인자 전용 (* 뒤)
    pass

def variadic(*args, **kwargs):
    # *args:   가변 위치 인자 → 튜플
    # **kwargs: 가변 키워드 인자 → 딕셔너리
    for arg in args:
        print(arg)
    for key, val in kwargs.items():
        print(f'{key}={val}')

# 언팩 호출
params = [3, 6]
list(range(*params))            # range(3, 6) 동일

d = {'voltage': 4000, 'state': 'dead'}
parrot(**d)                     # parrot(voltage=4000, state='dead') 동일

double = lambda x: x * 2
double(5)       # 10

# 정렬 키로 활용
pairs = [(1, 'one'), (2, 'two'), (3, 'three')]
pairs.sort(key=lambda pair: pair[1])
# [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

class Animal:
    def __init__(self, name: str, sound: str):
        self.name = name      # 인스턴스 속성
        self._sound = sound   # 관례적 비공개

    def speak(self) -> str:
        return f'{self.name} says {self._sound}'

    def __repr__(self) -> str:
        return f'Animal({self.name!r})'

class Dog(Animal):            # 상속
    def __init__(self, name: str):
        super().__init__(name, 'Woof')

    def fetch(self, item: str) -> str:
        return f'{self.name} fetches {item}!'

dog = Dog('Rex')
dog.speak()   # 'Rex says Woof'
dog.fetch('ball')  # 'Rex fetches ball!'

try:
    result = 10 / int(input('나누는 수: '))
except ZeroDivisionError:
    print('0으로 나눌 수 없습니다')
except ValueError as e:
    print(f'잘못된 입력: {e}')
else:
    print(f'결과: {result}')   # 예외 없을 때만 실행
finally:
    print('항상 실행')         # 예외 여부 무관

# 사용자 정의 예외
class InsufficientFundsError(Exception):
    def __init__(self, amount: float):
        super().__init__(f'잔액 부족: {amount}원 필요')
        self.amount = amount

# 가상 환경 생성 및 활성화
python -m venv .venv
source .venv/bin/activate      # macOS/Linux
.venv\Scripts\activate         # Windows

# pip: 패키지 설치
pip install requests            # 단일 패키지
pip install -r requirements.txt # requirements 파일
pip list                        # 설치된 패키지 목록
pip freeze > requirements.txt   # 현재 환경 저장

# 들여쓰기: 스페이스 4칸 (탭 금지)
# 줄 길이: 79자 이내
# 함수·변수: snake_case
# 클래스: UpperCamelCase
# 상수: UPPER_CASE

def calculate_area(width: float, height: float) -> float:
    """직사각형 넓이를 계산합니다."""
    return width * height


class Rectangle:
    MAX_SIZE = 10000  # 상수

    def __init__(self, width: float, height: float) -> None:
        self.width = width
        self.height = height

# Vyper 예시
balances: HashMap[address, uint256]

@external
def transfer(_to: address, _amount: uint256):
    assert self.balances[msg.sender] >= _amount
    self.balances[msg.sender] -= _amount
    self.balances[_to] += _amount

from web3 import Web3

w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/KEY'))
balance = w3.eth.get_balance('0x...')
block   = w3.eth.get_block('latest')
tx      = w3.eth.get_transaction('0xTX_HASH')