Python

블록은 중괄호 대신 들여쓰기로 구분한다. 변수 선언 키워드는 없으며 실행 중 객체에 이름을 연결한다. print(a,b)는 기본적으로 공백으로 구분하고 마지막에 줄바꿈한다.

헷갈리는 지점 input()의 결과는 문자열이다. 숫자로 계산하려면 변환이 필요하다.

range(start,stop,step)과 a[start:stop:step]은 stop을 포함하지 않는다. a[-1]은 마지막 원소다. a[::-1]은 역순 복사다. 음수 step이면 인덱스가 줄어든다.

헷갈리는 지점 역방향 슬라이스에서 생략한 stop과 명시적 -1은 다르다. 문자열[4:-1:-1]은 빈 문자열이다.

list는 순서 있고 변경 가능, tuple은 순서 있고 원소 대입 불가, set은 중복 제거 집합, dict는 key→value 매핑이다. 빈 집합은 set(), {}는 빈 dict다.

헷갈리는 지점 집합의 표시 순서를 정답으로 가정하지 않는다. 정렬 결과를 물으려면 sorted(set)을 쓴다.

b=a는 같은 리스트를 가리킨다. b=a[:] 또는 a.copy()는 바깥 리스트만 새로 만든다. 안쪽 리스트는 계속 공유할 수 있다.

헷갈리는 지점 복사한 바깥 리스트에 append하는 것과 내부 원소를 바꾸는 것을 구분한다.

[식 for 원소 in 반복가능객체 if 조건]은 조건을 통과한 원소만 식으로 바꾼다. 함수는 def로 정의하며 return이 없으면 None이다.

헷갈리는 지점 함수의 기본 인자에 []를 쓰면 함수 정의 때 만들어진 리스트가 호출 사이 공유된다.

split은 나누고 join은 구분자로 잇는다. 문자열은 불변이라 replace나 upper 결과를 사용해야 한다. Python 3.7 이상 dict는 삽입 순서를 유지한다.

헷갈리는 지점 기존 키의 값을 갱신해도 그 키의 삽입 위치는 바뀌지 않는다. 없는 키의 d[k]는 KeyError, d.get(k,기본값)은 기본값.

and/or는 항상 bool을 반환하지 않고 평가한 피연산자를 반환할 수 있다. ==는 값 동등성, is는 객체 동일성이다. sorted(a)는 새 리스트, a.sort()는 원본 정렬 후 None을 반환한다.

헷갈리는 지점 문자열이나 숫자의 값 비교에 is를 쓰지 않는다. 객체 재사용 여부에 따라 우연히 맞는 사례를 외우지 않는다.

a,b=b,a처럼 콤마로 나열한 다중 대입은 오른쪽 값을 모두 먼저 평가해 튜플로 만든 뒤 왼쪽에 순서대로 대입하므로 임시 변수 없이 값을 교환할 수 있다. a,*b,c=리스트처럼 *가 붙은 이름은 나머지 원소를 리스트로 묶어 받는다.

헷갈리는 지점 a,b=b,a는 왼쪽부터 하나씩 즉시 대입하는 것이 아니라 오른쪽을 통째로 평가한 뒤 대입한다. 중간 값이 이미 바뀐 것처럼 순서를 착각하지 않는다.

연산자는 계산 방법을 지정하는 기호다. /는 나눗셈, //는 나눈 값을 바닥값으로 내리는 나눗셈, %는 나머지, **는 거듭제곱이다. 7개를 2개씩 묶으면 완전한 묶음은 3개, 남은 것은 1개다. 따라서 7 // 2는 3이고 7 % 2는 1이다.

음수에서는 “소수점만 지운다”는 설명이 틀린다. -7 / 3은 약 -2.333이고, 이 값 이하의 가장 큰 정수는 -3이다. 그래서 -7 // 3은 -3이다. a = (a // b) * b + (a % b)로 검산하면 -7 = -3 * 3 + 2다. 나누는 수가 0이면 예외가 난다.

print(7 / 2, 7 // 2, 7 % 2, 2 ** 3)
print(-7 // 3, -7 % 3)
print(7.0 // 2)

헷갈리는 지점 Python의 //는 주석이 아니다. 주석은 #이다. 실수가 포함된 7.0 // 2는 정수 객체 3이 아니라 float 3.0이다.

x = 3은 x라는 이름을 값 3에 연결하는 대입이다. x == 3은 같은 값인지 비교해서 True 또는 False를 만드는 식이다. int는 정수, float는 실수, str은 문자열, bool은 논릿값, None은 값이 없음을 나타내는 특별한 객체다.

input()의 결과는 항상 문자열이다. 숫자 계산을 하려면 int(input())처럼 변환한다. "2" + "3"은 "23", int("2") + int("3")은 5다. int(3.9)는 3이고 int(-3.9)는 -3으로 0 방향으로 잘린다.

a, b = "2", "3"
print(a + b, int(a) + int(b))
x, y = 1, 2
x, y = y, x
print(x, y)

헷갈리는 지점 문자열 "3"과 정수 3을 +로 바로 더하면 TypeError. int("3.5")는 ValueError이며 int(float("3.5"))와 구별한다.

if 뒤 조건이 참이면 콜론 다음의 들여쓴 블록을 실행한다. elif는 앞 조건이 거짓일 때 다음 조건을 검사하며 else는 모두 거짓일 때 실행한다. 같은 if-elif-else 묶음에서는 선택된 한 블록만 실행한다.

0, 0.0, 빈 문자열, 빈 리스트·튜플·집합·딕셔너리, None은 거짓으로 취급된다. "0"은 비어 있지 않은 문자열이므로 참이다. a < x < b는 범위 비교이고 값1 if 조건 else 값2는 결과값을 고르는 조건식이다.

x = 0
if x:
    print("A")
elif "0":
    print("B")
else:
    print("C")
print("짝" if x % 2 == 0 else "홀")

헷갈리는 지점 if를 두 번 독립해서 쓰면 둘 다 실행될 수 있다. elif 두 개와 동작이 다르다.

not은 참·거짓을 뒤집는다. and는 왼쪽이 거짓이면 그 값을 반환하고, 참이면 오른쪽을 평가해 반환한다. or는 왼쪽이 참이면 그 값을 반환하고, 거짓이면 오른쪽을 평가해 반환한다. 따라서 and와 or의 결과가 반드시 bool인 것은 아니다.

우선순위는 비교가 not보다 먼저, 그 다음 and, 마지막 or다. a and b or c는 (a and b) or c로 읽는다. 결과가 이미 정해지면 뒤 함수가 호출되지 않을 수 있다.

print(0 or 7, 3 and 8, not [])
print(False and (1 / 0))

헷갈리는 지점 &와 |는 정수에서 비트 연산이다. and와 or로 읽지 않는다.

for x in 대상은 대상에서 원소를 하나씩 꺼내 x에 넣는다. while 조건은 조건이 참인 동안 반복한다. break는 가장 가까운 반복문 전체를 끝내며 continue는 현재 회차의 남은 부분을 건너뛴다.

반복문에 붙은 else는 break 없이 정상 종료했을 때 실행된다. 반복을 한 번도 하지 않아도 정상 종료라면 실행된다. 중첩 반복문의 break는 안쪽 반복문 하나만 끝낸다.

for i in range(1, 5):
    if i == 2:
        continue
    if i == 4:
        break
    print(i, end=" ")
else:
    print("완료")

헷갈리는 지점 for의 else는 if의 else와 다르다. break로 종료하면 실행되지 않는다.

인덱스는 한 원소의 위치다. 길이 5인 문자열 ABCDE의 인덱스는 0~4, 뒤에서 세는 인덱스는 -5~-1이다. a[-1]은 마지막 원소다. a[start:stop:step]은 여러 원소를 새 시퀀스로 가져오며 stop 위치는 제외한다.

양의 step은 오른쪽, 음의 step은 왼쪽으로 이동한다. 생략한 경계는 이동 방향에 맞는 시작·끝을 사용한다. [::-1]은 마지막부터 처음까지 역순이다. 명시적 -1은 실제 마지막 원소 위치로 해석하므로 [:-1:-1]과 [::-1]은 같지 않다.

s = "ABCDE"
print(s[-1], s[1:4], s[::2], s[::-1])

헷갈리는 지점 범위를 벗어난 단일 인덱스는 IndexError, 슬라이스 경계는 조정된다. step=0은 ValueError.

append(x)는 x 하나를 끝에 넣고 extend(대상)는 대상의 원소들을 각각 넣는다. insert(i,x)는 i 위치에 삽입한다. remove(x)는 처음 만나는 값 x를 삭제하고 pop(i)는 i 위치 값을 꺼내 반환하며 삭제한다. pop()은 마지막 값을 꺼낸다.

리스트의 sort(), reverse(), append() 등은 원본을 바꾸고 None을 반환한다. sorted(a)는 새 정렬 리스트를 반환하며 원본을 유지한다. del a[i]는 반환값 없이 삭제하는 문장이다.

a = [1]
a.append([2, 3])
a.extend([4, 5])
x = a.pop()
print(a, x)

헷갈리는 지점 remove는 인덱스가 아니라 값을 받는다. 없는 값을 remove하면 ValueError.

딕셔너리는 키를 값에 대응시키며 같은 키에 다시 대입하면 값을 덮어쓴다. d[k]는 키가 없으면 KeyError, d.get(k,기본값)는 기본값을 반환한다. for k in d는 키, d.items()는 키·값 쌍을 순회한다. 집합은 중복을 없애고 수학적 집합 연산을 지원한다.

튜플은 원소를 다른 값으로 재대입할 수 없는 시퀀스다. 원소 하나짜리 튜플은 (1,)처럼 쉼표가 필요하다. 튜플 안에 리스트가 있으면 그 리스트 자체는 변경할 수 있다. 빈 {}는 딕셔너리, 빈 집합은 set()이다.

d = {"a": 1, "b": 2}
d["a"] = 9
print(d.get("c", 0), "a" in d)
print(sorted({1, 2} ^ {2, 3}))

헷갈리는 지점 집합 출력·순회 순서를 고정 답으로 암기하지 않는다. 순서가 필요하면 sorted를 쓴다.

def는 함수를 정의한다. 매개변수는 호출할 때 인자를 받아 사용하는 이름이다. return은 함수 실행을 끝내고 값을 호출 위치로 돌려준다. print는 화면 출력이며 반환과 다르다. return이 없거나 return만 쓰면 반환값은 None이다.

함수 안에서 대입한 이름은 일반적으로 지역 이름이다. global은 모듈 수준 이름에 대입하겠다는 선언이다. lambda x: x*2는 짧은 함수를 만드는 식이며 별도 return을 쓰지 않는다. sorted(a,key=...)는 key 결과로 정렬하지만 원래 원소를 돌려준다.

def f(x):
    print(x + 1)

r = f(2)
print(r)
print(sorted(["bbb", "a", "cc"], key=lambda s: len(s)))

헷갈리는 지점 함수에서 리스트를 수정하는 것과 매개변수 이름을 새 리스트로 재연결하는 것은 다르다.

split()은 공백 구간을 기준으로 문자열을 나눠 리스트로 만든다. split(",")는 쉼표를 구분자로 사용한다. "-".join(문자열목록)은 사이에 -를 넣어 합친다. replace(이전,새값)는 교체한 새 문자열을 반환한다.

print(a,b)는 기본 sep=" "로 값 사이에 공백을 넣고 end="\n"으로 줄을 끝낸다. sep와 end를 지정하면 답의 공백·줄바꿈도 달라진다. f"{x:.2f}"는 소수 둘째 자리까지 표시한다.

s = "a,b,c"
print("-".join(s.split(",")))
print(1, 2, sep=":", end="!")
print(3)

헷갈리는 지점 join의 원소는 문자열이어야 한다. 정수 목록은 str 변환 후 합친다.

[식 for x in 대상 if 조건]은 원소를 꺼내 조건을 검사하고 통과한 원소에 식을 계산해 새 리스트를 만든다. enumerate는 (번호,원소), zip은 여러 대상의 같은 위치 원소들을 묶는다. 기본 zip은 가장 짧은 대상이 끝나면 종료한다.

map(함수,대상)은 각 원소에 함수를 적용하는 이터레이터다. list(map(int,["2","3"]))은 [2,3]이다. 이터레이터를 이미 소진하면 다시 순회할 때 값이 남아 있지 않을 수 있다.

print([i * j for i in [1, 2] for j in [3, 4]])
print(list(enumerate(["A", "B"], start=1)))
print(list(zip([1, 2, 3], ["a", "b"])))

헷갈리는 지점 [x if 조건 else y for ...]의 조건식과 [x for ... if 조건]의 필터는 다르다.

==는 값이 같은지, is는 같은 객체인지 검사한다. b=a는 새 리스트를 만들지 않고 같은 객체에 다른 이름을 연결한다. a.copy() 또는 a[:]는 새 바깥 리스트를 만들지만 내부 리스트는 여전히 공유하는 얕은 복사다.

copy.deepcopy(a)는 중첩된 변경 가능한 객체까지 복사할 때 쓴다. 종이에 바깥 리스트와 내부 리스트를 별도의 상자로 그리면 어느 변경이 공유되는지 보인다.

a = [[1], [2]]
b = a.copy()
b[0].append(9)
b.append([3])
print(a)
print(a is b, a[0] is b[0])

헷갈리는 지점 작은 정수·문자열의 객체 재사용에 기대 is로 값 비교를 하지 않는다.

함수의 기본 인자 식은 함수 정의 시 평가된다. 기본 인자로 만든 가변 리스트는 호출 사이에 재사용될 수 있다. [[0]*2]*2는 내부 리스트 하나를 두 번 참조한다. 행마다 독립된 리스트가 필요하면 컴프리헨션으로 만든다.

def f(a=[]):
    a.append(1)
    return len(a)
print(f(), f())
a = [[0]*2]*2
a[0][1] = 7
print(a)

2026.10.14 재확인: Python 3.14 제어 흐름

헷갈리는 지점 리스트의 바깥쪽만 복사해도 내부 객체 참조는 공유될 수 있다.