int | 정수: 42, -17, 0 |
float | 실수: 3.14, -0.5 |
str | 문자열: "hello", 'world' |
bool | 불리언: True, False |
list | 순서가 있는 가변 시퀀스: [1, 2, 3] |
tuple | 순서가 있는 불변 시퀀스: (1, 2, 3) |
dict | 키-값 쌍: {"a": 1, "b": 2} |
set | 중복 없는 집합: {1, 2, 3} |
None | Null/빈 값 |
+ - * / | 산술 연산자 |
// | 정수 나눗셈 |
% | 나머지 |
** | 거듭제곱 |
== != < > <= >= | 비교 연산자 |
and or not | 논리 연산자 |
in / not in | 멤버십 연산자 |
is / is not | 동일성 연산자 |
s.upper() | 대문자로 변환 |
s.lower() | 소문자로 변환 |
s.strip() | 앞뒤 공백 제거 |
s.split(sep) | 문자열을 리스트로 분할 |
s.join(list) | 리스트를 문자열로 합침 |
s.replace(old, new) | 부분 문자열 교체 |
s.find(sub) | 부분 문자열 인덱스 찾기 (없으면 -1) |
s.startswith(pre) | 접두사로 시작하는지 확인 |
s.endswith(suf) | 접미사로 끝나는지 확인 |
f"Hello {name}" | F-문자열 (권장) |
f"{value:.2f}" | 소수점 2자리로 포맷 |
f"{num:05d}" | 5자리로 0 패딩 |
"{} {}".format(a, b) | format 메서드 |
"%s %d" % (s, n) | 기존 스타일 포맷팅 |
list.append(x) | 끝에 항목 추가 |
list.extend(iter) | 이터러블의 모든 항목 추가 |
list.insert(i, x) | 인덱스에 항목 삽입 |
list.remove(x) | x의 첫 번째 항목 제거 |
list.pop(i) | 인덱스의 항목 제거 후 반환 |
list.sort() | 리스트 정렬 (제자리) |
list.reverse() | 리스트 역순 (제자리) |
list.index(x) | 첫 번째 항목의 인덱스 찾기 |
list.count(x) | x의 개수 세기 |
list[start:end:step] | 리스트 슬라이싱 |
d.keys() | 모든 키 가져오기 |
d.values() | 모든 값 가져오기 |
d.items() | 모든 키-값 쌍 가져오기 |
d.get(key, default) | 기본값과 함께 값 가져오기 |
d.pop(key) | 값 제거 후 반환 |
d.update(dict2) | 다른 딕셔너리 병합 |
d.setdefault(key, val) | 키가 없으면 설정 |
key in d | 키 존재 여부 확인 |
d | d2 | 딕셔너리 병합 (3.9+) |
s.add(x) | 요소 추가 |
s.remove(x) | 요소 제거 (없으면 에러) |
s.discard(x) | 요소 제거 (에러 없음) |
s1 | s2 | 합집합 |
s1 & s2 | 교집합 |
s1 - s2 | 차집합 |
s1 ^ s2 | 대칭 차집합 |
if condition: | if 문 |
elif condition: | else if |
else: | else |
x if cond else y | 삼항 표현식 |
match value: case x: | 패턴 매칭 (3.10+) |
for x in iterable: | For 루프 |
for i, x in enumerate(iter): | 인덱스와 함께 루프 |
for k, v in dict.items(): | 딕셔너리 키-값 루프 |
while condition: | While 루프 |
break | 즉시 루프 종료 |
continue | 다음 반복으로 건너뛰기 |
else: | break 없이 끝나면 실행 |
pass | 아무것도 안 함 (플레이스홀더) |
def func(args): | 함수 정의 |
return value | 함수에서 값 반환 |
def func(a, b=1): | 기본 인자 |
*args | 가변 위치 인자 |
**kwargs | 가변 키워드 인자 |
lambda x: x * 2 | 익명 함수 |
@decorator | 함수 데코레이터 |
def func(x: int) -> str: | 타입 힌트 |
len(x) | 시퀀스 길이 가져오기 |
range(start, stop, step) | 숫자 시퀀스 생성 |
enumerate(iter) | 인덱스와 값 쌍 가져오기 |
zip(iter1, iter2) | 이터러블에서 항목 쌍 만들기 |
map(func, iter) | 모든 항목에 함수 적용 |
filter(func, iter) | 함수로 항목 필터링 |
sorted(iter, key=f) | 정렬된 리스트 반환 |
reversed(iter) | 역순 이터레이터 반환 |
sum(iter) | 모든 숫자 합계 |
min(iter) / max(iter) | 최소값/최대값 가져오기 |
any(iter) / all(iter) | 하나라도/모두 참인지 확인 |
isinstance(obj, type) | 객체 타입 확인 |
type(obj) | 객체 타입 가져오기 |
print(*args, sep, end) | 콘솔에 출력 |
input(prompt) | 사용자 입력 읽기 |
[x for x in iter] | 리스트 컴프리헨션 |
[x for x in iter if cond] | 조건부 리스트 |
[f(x) for x in iter] | 변환이 있는 리스트 |
{x for x in iter} | 집합 컴프리헨션 |
{k: v for k, v in iter} | 딕셔너리 컴프리헨션 |
(x for x in iter) | 제너레이터 표현식 |
open(f, "r") | 읽기용으로 열기 |
open(f, "w") | 쓰기용으로 열기 (덮어쓰기) |
open(f, "a") | 추가용으로 열기 |
open(f, "rb") | 바이너리 읽기용 열기 |
with open(f) as file: | 컨텍스트 매니저 (자동 닫기) |
file.read() | 파일 전체 읽기 |
file.readline() | 한 줄 읽기 |
file.readlines() | 모든 줄을 리스트로 읽기 |
file.write(s) | 파일에 문자열 쓰기 |
file.writelines(list) | 문자열 리스트 쓰기 |
try: / except: | 예외 잡기 |
except Error as e: | 특정 예외 잡기 |
except (E1, E2): | 여러 예외 잡기 |
else: | 예외 없으면 실행 |
finally: | 항상 실행 (정리) |
raise Exception(msg) | 예외 발생 |
raise from e | 예외 체인 |
assert condition | 조건이 참인지 확인 |
class MyClass: | 클래스 정의 |
class Child(Parent): | 상속 |
class C(A, B): | 다중 상속 |
def __init__(self): | 생성자 |
def __str__(self): | 문자열 표현 |
def __repr__(self): | 디버그 표현 |
def __len__(self): | 길이 프로토콜 |
def __eq__(self, other): | 동등 비교 |
def __lt__(self, other): | 미만 비교 |
def __hash__(self): | 딕셔너리 키용 해시 |
def __getitem__(self, key): | [] 인덱싱 활성화 |
def __setitem__(self, key, val): | [] 할당 활성화 |
def __iter__(self): | 이터러블 만들기 |
def __next__(self): | 이터레이터 프로토콜 |
def __call__(self): | 호출 가능하게 만들기 |
def __enter__(self): | 컨텍스트 매니저 진입 |
def __exit__(self, *args): | 컨텍스트 매니저 종료 |
@property | 게터 프로퍼티 |
@name.setter | 세터 프로퍼티 |
@classmethod | 클래스 메서드 (cls) |
@staticmethod | 정적 메서드 |
@dataclass | 메서드 자동 생성 |
@dataclass(frozen=True) | 불변 데이터클래스 |
field(default_factory=list) | 가변 기본값 |
class Proto(Protocol): | 구조적 타이핑 |
ABC / abstractmethod | 추상 기본 클래스 |
@decorator | 데코레이터 적용 |
@decorator(arg) | 인자가 있는 데코레이터 |
@dec1 @dec2 | 데코레이터 쌓기 |
@functools.wraps(func) | 함수 메타데이터 보존 |
@functools.lru_cache | 함수 메모이제이션 |
@functools.cached_property | 캐시된 프로퍼티 |
@contextlib.contextmanager | 컨텍스트 매니저 생성 |
# 간단한 데코레이터
def timer(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(f"소요 시간: {time.time() - start:.2f}초")
return result
return wrapper
# 인자가 있는 데코레이터
def repeat(times):
def decorator(func):
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(times):
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@repeat(3)
def greet(name):
print(f"안녕하세요 {name}") os.getcwd() | 현재 작업 디렉토리 |
os.listdir(path) | 디렉토리 내용 목록 |
os.makedirs(path) | 디렉토리 생성 |
os.path.join(a, b) | 경로 결합 |
os.path.exists(path) | 경로 존재 확인 |
os.environ["KEY"] | 환경 변수 |
sys.argv | 명령줄 인자 |
sys.exit(code) | 프로그램 종료 |
sys.path | 모듈 검색 경로 |
Path("file.txt") | 경로 객체 생성 |
Path.cwd() / Path.home() | 현재/홈 디렉토리 |
p.exists() / p.is_file() | 존재/타입 확인 |
p.read_text() / p.write_text() | 텍스트 읽기/쓰기 |
p.mkdir(parents=True) | 디렉토리 생성 |
p.glob("*.py") | 패턴 매칭 |
p.stem / p.suffix | 파일명 / 확장자 |
p.parent / p.name | 부모 디렉토리 / 파일명 |
json.dumps(obj) | 객체를 JSON 문자열로 |
json.loads(s) | JSON 문자열을 객체로 |
json.dump(obj, file) | 파일에 JSON 쓰기 |
json.load(file) | 파일에서 JSON 읽기 |
datetime.now() | 현재 날짜/시간 |
datetime.strptime(s, fmt) | 날짜/시간 문자열 파싱 |
dt.strftime(fmt) | 날짜/시간 포맷 |
timedelta(days=1) | 시간 간격 |
re.search(pattern, s) | 첫 번째 일치 찾기 |
re.match(pattern, s) | 시작에서 일치 |
re.findall(pattern, s) | 모든 일치 찾기 |
re.sub(pattern, repl, s) | 일치 항목 교체 |
re.split(pattern, s) | 패턴으로 분할 |
re.compile(pattern) | 패턴 컴파일 |
m.group() / m.groups() | 일치/그룹 가져오기 |
r"\d+" (raw string) | 정규식용 원시 문자열 |
async def func(): | 비동기 함수 정의 |
await coro | 코루틴 대기 |
asyncio.run(main()) | 비동기 진입점 실행 |
asyncio.sleep(secs) | 비동기 슬립 |
asyncio.create_task(coro) | 코루틴 스케줄 |
asyncio.gather(*coros) | 동시 실행 |
asyncio.wait_for(coro, timeout) | 타임아웃과 함께 대기 |
async for item in async_iter: | 비동기 반복 |
async with resource: | 비동기 컨텍스트 매니저 |
import asyncio
async def fetch_data(url):
await asyncio.sleep(1) # 네트워크 시뮬레이션
return f"{url}에서 데이터"
async def main():
# 태스크 동시 실행
tasks = [
fetch_data("url1"),
fetch_data("url2"),
fetch_data("url3"),
]
results = await asyncio.gather(*tasks)
for r in results:
print(r)
asyncio.run(main()) # 조건부 리스트 컴프리헨션
evens = [x for x in range(10) if x % 2 == 0]
# 두 리스트로 딕셔너리 만들기
d = dict(zip(keys, values))
# 파일 줄 읽기
with open("file.txt") as f:
lines = f.readlines()
# map과 람다
doubled = list(map(lambda x: x * 2, numbers))
# 삼항 표현식
result = "예" if condition else "아니오"
# 값 언패킹
a, b, *rest = [1, 2, 3, 4, 5]
# 바다코끼리 연산자 (3.8+)
if (n := len(data)) > 10:
print(f"{n}개 항목을 받았습니다")
# 여러 파일 컨텍스트 매니저
with open("in.txt") as f1, open("out.txt", "w") as f2:
f2.write(f1.read()) python -m venv env로 가상 환경 생성pip freeze > requirements.txt로 의존성 저장if __name__ == "__main__":으로 스크립트 진입점 설정