if 문
들여쓰기
if문을 하기 전에 들여쓰기부터 짚고 가자.
파이썬에서는 콜론(:) 뒤가 하위 블록이 된다. 그래서 콜론을 쓴 다음, 그 블록에 포함되는 문장들에는 모두 "같은 개수"의 들여쓰기를 해야 한다.
if hungry:print("밥")print("먹으러")print("가자")
들여쓰기는 탭과 스페이스 중 무엇을 써도 되지만 한 코드 안에서 둘을 혼용하면 안 된다.
요즘 파이썬 커뮤니티에서는 공백 문자 4개를 쓰는 걸 권장한다고 한다. 대부분의 파이썬 에디터는 탭으로 들여쓰기를 해도 공백 4개로 자동 변환해 준다.
공백을 권장하는 이유
PEP 8이 공백을 권장 방식으로 정해 두었다. 이유는 따로 적혀 있지 않은데, 흔히 드는 이유는, 탭은 에디터나 터미널마다 보이는 폭(4칸, 8칸)이 다르지만 공백은 어디서 보든 모양이 같다는 점이다.
정리하면, 파이썬에서는 블록(하위 영역)을 정의해야 하는 if, while, for, def, class 같은 것에는 콜론으로 하위 영역을 시작하고, 그 안에서는 모두 같은 깊이로 들여쓰기를 해야 한다는 점을 유의하자!
조건문
>>> money = 20000>>> if money >= 20000:... print("초밥 먹자")... else:... print("떡볶이 먹자")...초밥 먹자
이 코드는 "조건문(money >= 20000)이 참(True)이면 초밥을 먹는다"라고 해석할 수 있다. 여기서 조건문이란 참 또는 거짓을 판단할 수 있는 문장을 말한다.
if 조건문이 참이면 if 블록이 실행되고, "그게 아니면" else 블록이 실행된다. else는 if 없이 쓸 수 없다.
조건문은 결과를 반환한다. 조건이 참이면 True, 거짓이면 False를 반환한다. 이 조건문을 if 뒤에 넣으면 조건문이 반환하는 값에 따라 하위 블록이 실행되거나 무시된다.
비교 연산자
조건문에는 비교 연산자를 많이 쓴다.
| 연산자 | 의미 |
|---|---|
x < y | x가 y보다 작다 |
x > y | x가 y보다 크다 |
x == y | x와 y가 같다 |
x != y | x와 y가 같지 않다 |
x >= y | x가 y보다 크거나 같다 |
x <= y | x가 y보다 작거나 같다 |
==가 같다, !=가 같지 않다는 뜻이라는 게 중요하다. 참고로 = 하나만 쓰면 대입 연산자다.
and, or, not
조건문에 쓰는 또 다른 연산자로 and, or, not이 있다. 이런 걸 논리 연산자라고 한다. 2장 불 자료형에서도 정리했다.
논리 연산자의 피연산자로는 값이 올 수도 있고, 값을 반환하는 조건문이 올 수도 있다. 그래서 이런 구절이 가능하다.
if money >= 15000 or card:print("연어덮밥 먹자")
여러 개를 섞어 쓰면 not → and → or 순서로 계산한다. 헷갈리면 괄호로 묶어서 우선순위를 명시적으로 표시한다. (W3Schools)
>>> True or True and False # True or (True and False)True>>> (True or True) and FalseFalse
in, not in
특이한 것도 있다. in과 not in이다.
x in 리스트/튜플/문자열x not in 리스트/튜플/문자열
x in 리스트는 "리스트 안에 x가 있는가?"라고 해석할 수 있다. 비슷하게 not in은 "없는가?"라고 해석할 수 있다.
멤버십 검사 연산자
in과 not in도 연산자이고, 파이썬 공식 문서에서는 멤버십 검사 연산자(membership test operator)라고 부른다.
pass
특정 조건일 때 아무것도 실행하지 않게 하고 싶을 수 있다. 개인적으로는 이럴 때 조건에 not을 걸겠지만, 명시적으로 넘어가야 한다면 단어 그대로 pass를 넣으면 된다.
if 조건문:passelse:print("조건이 거짓일 때만 실행")
pass는 문(statement)이다
pass는 문(statement)이다. 아무 일도 하지 않는 문이라서 문법상 블록에 문장이 꼭 있어야 하는데 실행할 게 없을 때 자리를 채우는 용도로 쓴다.
블록 안에 주석만 있으면 에러가 난다. 주석은 파이썬이 아예 무시해서 블록이 빈 걸로 취급되기 때문이다. 자리를 채우려면 실제 문장인 pass가 필요하다. (W3Schools)
if money >= 20000:# 나중에 채우기print("끝")
IndentationError: expected an indented block after 'if' statement on line 1
elif
elif는 조건을 순차적으로 걸어 주는 문이다. 여러 조건을 판단할 수 있다. 해석할 때는 "아니면 ...일 때"로 읽으면 이해하기 쉽다.
elif라는 이름
이름은 else if의 줄임말이다. (파이썬 공식 튜토리얼)
elif에 걸어 둔 조건은 앞선 조건(앞선 if나 elif에 걸린 조건)이 거짓인 경우에 검토된다.
if money >= 15000:print("연어덮밥 먹자")elif money >= 10000:print("포케 먹자")else:print("떡볶이 먹자")
else는 항상 맨 마지막이어야 한다. else 뒤에 elif를 쓰면 SyntaxError: 'elif' block follows an 'else' block가 난다. (W3Schools)
elif는 여러 개 이어 쓸 수 있다. 그래서 "2만 원 이상이면 초밥, 아니고 1만 5천 원 이상이면 연어덮밥, 그것도 아니고 1만 원 이상이면 포케"처럼 조건을 계속 이어 갈 수 있다.
>>> money = 12000>>> if money >= 20000:... print("초밥 먹자")... elif money >= 15000:... print("연어덮밥 먹자")... elif money >= 10000:... print("포케 먹자")... elif money >= 7000:... print("비빔밥 먹자")... else:... print("떡볶이 먹자")...포케 먹자
money >= 20000과 money >= 15000이 거짓이라서 넘어가고, money >= 10000이 참이라서 "포케 먹자"가 출력된다. 조건이 참인 블록을 하나 만나면 그 아래 조건은 검토하지 않는다.
중첩된 if 문
if 문 안에 if 문을 또 넣을 수 있다. 바깥 조건이 참일 때만 안쪽 조건을 확인한다. (W3Schools)
>>> money = 20000>>> hungry = True>>> if money >= 15000:... if hungry:... print("연어덮밥 먹자")... else:... print("초밥 먹자")... else:... print("떡볶이 먹자")...초밥 먹자
두 조건이 단순하면 and로 합칠 수도 있다.
>>> if money >= 15000 and hungry:... print("연어덮밥 먹자")...초밥 먹자
안쪽에 else처럼 갈래가 따로 있으면 중첩 if, 두 조건을 다 만족할 때 한 가지만 하면 and를 쓴다.
한 줄로 쓰기
if나 else처럼 콜론을 쓰는 블록 하위에 문장이 한 줄뿐이면, 줄바꿈과 들여쓰기 없이 콜론 바로 옆에 붙여 쓰는 것도 문법적으로 가능하다고 한다.
if money >= 20000: print("초밥 먹자")else: print("떡볶이 먹자")
가능은 하지만 권장하지 않는다. PEP 8은 한 줄에 여러 문장을 쓰는 것을 피하라고 하고 특히 위처럼 if/else가 같이 있는 구문은 절대 한 줄로 쓰지 말라고 한다.
match-case
다른 언어에서 switch-case 문으로 많이 쓰이는 것이다. 하나의 값을 가지고 조건을 걸어야 할 때 elif로 조건을 줄줄이 걸면 중복되는 코드가 많고 직관적으로 와닿지 않는다. 이럴 때 match-case를 쓴다. 파이썬 3.10 버전부터 사용할 수 있다.
if menu == "초밥":...elif menu == "연어덮밥":...elif menu == "떡볶이":...
match-case는 "어떤 값이 ...일 때"라고 해석하면 된다.
>>> menu = "연어덮밥">>> match menu:... case "초밥" | "연어덮밥":... print("일식집으로 가자")... case "비빔밥":... print("한식집으로 가자")... case "떡볶이":... print("분식집으로 가자")... case _:... print("메뉴부터 다시 고르자")...일식집으로 가자
보통은 case에 패턴 하나를 넣는데, | 기호를 써서 여러 조건을 조합할 수도 있다. "이거거나 저거거나 그거거나" 하는 식이다.
어느 case에도 해당하지 않을 때 뭔가를 하고 싶다면 case _ 블록을 쓰면 된다. 특별히 할 일이 없으면 생략해도 괜찮다. 그러면 아무것도 하지 않는 것으로 처리된다.
다른 언어의 switch 문과 다른 점은 break를 쓰지 않아도 된다는 것이다. 어떤 case에 걸리면 나머지는 확인하지 않고 바로 블록을 빠져나온다.
구조 패턴 매칭
match는 값이 같은지만 비교하는 게 아니라, 값의 모양을 보고 매칭하면서 그 안의 값을 변수로 꺼낼 수도 있다.
def order(o):match o:case ["초밥"]:return "초밥 단품"case ["포케", topping]:return f"포케에 {topping} 토핑"case ["떡볶이", *sides]:return f"떡볶이에 사이드 {len(sides)}개"case {"menu": "연어덮밥", "size": size}:return f"연어덮밥 {size} 사이즈"case _:return "모르는 주문"
>>> order(["초밥"])'초밥 단품'>>> order(["포케", "아보카도"])'포케에 아보카도 토핑'>>> order(["떡볶이", "튀김", "순대"])'떡볶이에 사이드 2개'>>> order({"menu": "연어덮밥", "size": "곱빼기", "memo": "덜 맵게"})'연어덮밥 곱빼기 사이즈'>>> order(["비빔밥"])'모르는 주문'
["포케", topping]: 길이가 2인 리스트이고 첫 요소가"포케"면 매칭된다. 두 번째 요소는topping에 들어간다.["떡볶이", *sides]: 첫 요소가"떡볶이"면 매칭되고, 나머지 요소는 전부sides에 리스트로 들어간다.{"menu": ..., "size": size}: 딕셔너리는 적어 둔 키만 확인한다."memo"처럼 다른 키가 더 있어도 매칭된다.
클래스 패턴(case Point(x=0, y=y):)도 있는데, 클래스를 배운 뒤에 보면 된다.
가드
case 뒤에 if를 붙이면 조건을 더 걸 수 있다. 이걸로 범위 비교도 할 수 있다.
match money:case m if m >= 20000:print("초밥 먹자")case m if m >= 10000:print("포케 먹자")case _:print("떡볶이 먹자")
다만 범위를 비교할 때는 elif가 더 읽기 쉽다. 하나의 값을 정해진 경우들과 맞춰 볼 때는 match, 크기나 범위를 비교할 때는 elif를 쓰는 편이 일반적이다.
비교 연산자 연쇄 사용
수학에서처럼 비교 연산자를 연쇄적으로 사용할 수 있다.
>>> money = 12000>>> 10000 <= money < 20000 # 1만 원 이상 2만 원 미만인가?True
이는 다음과 같이 쓰는 것과 같다.
>>> (10000 <= money) and (money < 20000)True
C, Java, JavaScript 같은 언어에서는 (1 < x) && (x < 10)처럼 나눠 써야 원하는 뜻이 돼서 꽤 쉬운 문법이라고 생각한다.
다른 언어의 1 < x < 10
C와 JavaScript에서는 1 < x < 10이 에러가 나지 않는다. 왼쪽부터 (1 < x)를 먼저 계산하고 그 결과(참/거짓)를 다시 10과 비교한다. 그래서 JavaScript에서 1 < 20 < 10은 true가 된다.
> 1 < 20 < 10 // (1 < 20) < 10 → true < 10 → 1 < 10true
Java는 boolean과 숫자를 비교할 수 없어서 컴파일 에러가 난다.
조건부 표현식
다른 언어의 삼항 연산자 같은 것이다. 조건에 따라 변수에 다른 값을 넣어야 할 때, 우리가 아는 if 문 구조를 쓸 수도 있다.
if money >= 20000:lunch = "초밥"else:lunch = "떡볶이"
조건부 표현식을 이용하면 한 줄로 적을 수 있다.
lunch = "초밥" if money >= 20000 else "떡볶이"
변수 = 참일_때_값 if 조건문 else 거짓일_때_값
"변수는 참일 때 값이다, 만약 조건이 참이면. 아니면 거짓일 때 값" 이런 식으로 적는다고 생각하면 된다.
elif처럼 이어 쓸 수도 있는데 가독성이 떨어지므로 짧고 간단한 경우에만 쓴다.(W3Schools)
>>> money = 15000>>> "초밥" if money >= 20000 else "연어덮밥" if money >= 15000 else "떡볶이"'연어덮밥'
while 문
while 문은 반복문이다. 어떤 구문들을 반복해서 실행할 때 쓴다.
while 조건문:수행할_문장1수행할_문장2수행할_문장3...
"조건문이 참인 동안 아래 문장들을 수행한다"라고 해석하면 된다.
>>> plates = 0>>> while plates < 3:... plates = plates + 1 # plates += 1 이라고 적을 수도 있다.... print(f"초밥 {plates}접시째")...초밥 1접시째초밥 2접시째초밥 3접시째
while 문은 반복을 시작하기 전에 조건부터 확인한다. 그래서 조건에 쓰는 변수는 반복 전에 미리 만들어 둬야 한다. 위 예제에서 plates = 0이 없으면 NameError: name 'plates' is not defined가 난다.
break
while 문으로 반복을 돌다가 어떤 경우에는 강제로 반복을 빠져나가야 할 때가 있다. 이때 쓰는 게 break 문이다.
break와 pass
pass처럼 키워드 하나로 이루어진 문(statement)인데, pass는 아무것도 하지 않고 break는 반복문을 빠져나간다.
if 조건문과 함께 써서 반복을 돌다가 특정 조건에 걸렸을 때 반복을 중단하게 할 수 있다.
>>> plates = 0>>> while plates < 10:... plates = plates + 1... print(f"초밥 {plates}접시째")... if plates == 4:... print("배부르다. 그만 먹자")... break...초밥 1접시째초밥 2접시째초밥 3접시째초밥 4접시째배부르다. 그만 먹자
continue
반복을 돌다가 어떤 경우에는 아래 블록을 다 실행하지 않고 다시 조건을 검사하러 가야 할 때도 있다. 이럴 때는 continue 문을 쓰면 된다.
역시 if 조건문과 함께 써서 특정 조건일 때 다시 조건을 확인하러 가게 할 수 있다.
>>> plates = 0>>> while plates < 5:... plates = plates + 1... if plates == 3: # 3번째 접시는 건너뛴다... continue... print(f"초밥 {plates}접시째")...초밥 1접시째초밥 2접시째초밥 4접시째초밥 5접시째
무한 루프
무한히 반복한다는 것이다. 반복문을 돌게 하는 조건문을 항상 참이 되는 값으로 설정하면, 조건이 거짓이 되는 일이 없어서 계속 반복을 돌게 된다.
while True:print("배고프다")
상시 대기해야 하는 서버나 입력 대기, 이벤트 처리 같은 곳에서 쓰곤 한다. 이런 경우가 아니라면 무한 루프를 돌리는 경우는 거의 없다. 어쩌다가 무한 루프를 돌리게 되면 Ctrl + C를 눌러서 아예 프로세스를 중단시키면 된다.
while-else
while 문 뒤에 else가 붙는 것이다. 조건이 거짓이 되어서 정상적으로 끝나면 else가 실행되고, while 문 안에서 조건에 따라 break로 반복을 강제로 빠져나왔다면 else는 실행되지 않는다.
>>> menus = ["떡볶이", "비빔밥"]>>> i = 0>>> while i < len(menus):... if menus[i] == "초밥":... print("초밥집 찾았다")... break... i = i + 1... else:... print("초밥집이 없다")...초밥집이 없다
어떤 경우에 쓰라고 만든 걸까?
반복을 돌면서 뭔가를 찾다가 찾으면 break로 빠져나오는 코드에서, "끝까지 못 찾았을 때"를 처리하려고 만든 문법이다. else가 없으면 찾았는지를 기억하는 변수를 따로 둬야 한다.
found = Falsewhile ...:if ...:found = Truebreakif not found:print("초밥집이 없다")
반복문 안에는 "아직 안 끝났으면 본문을 계속 실행한다"는 if가 숨어 있다. 반복문의 else는 이 if에 붙는 else다. 레이먼드 헤팅어에 따르면 반복문에 else를 붙이는 아이디어는 귀도 반 로섬이 아니라 도널드 커누스에게서 왔다.
헤팅어는 PyCon 2013 발표에서 이 이름을 아쉬워했다. 예전에는 반복문 안에 if와 goto가 숨어 있다는 걸 다들 알아서 else가 자연스러운 이름이었다. 하지만 지금은 그걸 아는 사람이 거의 없으니, 차라리 no break라고 불렀다면 누구나 무슨 일을 하는지 알았을 거라고 한다.
"If I could go back in time and talk to Guido, … I would say … why don't you call it no break? If it was called no break everybody would know what it did."
참고: Transforming Code into Beautiful, Idiomatic Python (17:01), 파이썬 공식 튜토리얼 - else Clauses on Loops
중첩된 while 문
말 그대로 while 문 안에 while 문이 있는 것이다. 반복문 안에서 반복을 이어 갈 수 있다.
>>> day = 1>>> while day <= 2:... plates = 1... while plates <= 3:... print(f"{day}일차 초밥 {plates}접시째")... plates += 1... day += 1...1일차 초밥 1접시째1일차 초밥 2접시째1일차 초밥 3접시째2일차 초밥 1접시째2일차 초밥 2접시째2일차 초밥 3접시째
안쪽 반복에 쓰는 변수(plates = 1)는 바깥 while 문 안에서 초기화해야 한다. 바깥 while 문 위로 빼면 1일차가 끝난 뒤에도 plates가 4에서 1로 돌아가지 않아서, 2일차는 아예 출력되지 않는다.
>>> day = 1>>> plates = 1 # 바깥으로 빼면>>> while day <= 2:... while plates <= 3:... print(f"{day}일차 초밥 {plates}접시째")... plates += 1... day += 1...1일차 초밥 1접시째1일차 초밥 2접시째1일차 초밥 3접시째
들여쓰기 깊이가 곧 어느 반복문에 속하는지를 정한다. 같은 day += 1이라도 몇 칸 들여썼느냐에 따라 안쪽 while 문에 속하기도 하고 바깥 while 문에 속하기도 한다. 중첩되면 들여쓰기 한 칸 차이가 결과를 완전히 바꾼다.
break는 가장 안쪽 반복문만 빠져나간다
break와 continue는 자기를 감싼 가장 안쪽 반복문 하나에만 적용된다.
>>> day = 1>>> while day <= 2:... plates = 1... while plates <= 3:... if plates == 2:... break # 안쪽 while 문만 빠져나간다... print(f"{day}일차 초밥 {plates}접시째")... plates += 1... day += 1...1일차 초밥 1접시째2일차 초밥 1접시째
Java나 JavaScript는 break outer;처럼 레이블을 붙여서 바깥 반복문까지 한 번에 빠져나올 수 있지만, 파이썬에는 이 기능이 없다. break outer라고 쓰면 SyntaxError가 난다. 두 겹을 한 번에 빠져나오려면 플래그 변수를 두고 바깥 반복문에서도 확인하거나, 반복문을 함수로 만들고 return으로 빠져나온다.
플래그 변수를 쓰는 방법:
>>> full = False>>> day = 1>>> while day <= 2:... plates = 1... while plates <= 3:... if plates == 2:... full = True... break... print(f"{day}일차 초밥 {plates}접시째")... plates += 1... if full: # 바깥에서도 확인한다... break... day += 1...1일차 초밥 1접시째
함수와 return을 쓰는 방법 (함수는 4장에서 배운다):
>>> def eat():... day = 1... while day <= 2:... plates = 1... while plates <= 3:... if plates == 2:... return # 함수 전체를 빠져나간다... print(f"{day}일차 초밥 {plates}접시째")... plates += 1... day += 1...>>> eat()1일차 초밥 1접시째
파이썬에는 ++가 없다
다른 언어처럼 i++라고 쓰면 SyntaxError가 난다. 그래서 1씩 증가시킬 때는 i += 1이라고 쓴다.
++i는 에러가 안 나는데 값도 안 바뀐다. 파이썬은 이걸 +(+i), 즉 양수 부호를 두 번 붙인 걸로 읽는다.
>>> i = 1>>> ++i1>>> i1
for 문
for 문은 while 문과 비슷한 반복문이지만 구조가 직관적이라 이해하기 쉽다는 장점이 있다고 한다. 책에서는 for 문을 잘 사용하면 프로그래밍이 즐거워질 것이라고 한다. 🤨
기본 구조
for 변수 in 리스트(또는 튜플, 문자열):수행할_문장1수행할_문장2...
in 뒤에 있는 리스트, 튜플, 문자열의 원소에 "순서대로" 하나씩 접근해서(그게 변수!) 아래 블록을 수행한다.
>>> menus = ["초밥", "연어덮밥", "포케"]>>> for menu in menus:... print(f"{menu} 먹자")...초밥 먹자연어덮밥 먹자포케 먹자
다른 언어의 for (i = 0; i < n; i++)처럼 인덱스 변수를 따로 두지 않고 원소를 바로 꺼낸다. 다른 언어의 for...of나 forEach에 가깝다. 리스트, 튜플 말고 문자열, 딕셔너리, 집합도 돌 수 있다. 딕셔너리를 돌면 키가 나온다. (W3Schools)
>>> for ch in "초밥":... print(ch)...초밥>>> prices = {"초밥": 20000, "포케": 10000}>>> for menu in prices:... print(menu)...초밥포케
변수 자리에서 바로 튜플로 나눠 받을 수도 있다.
>>> prices = [("초밥", 20000), ("연어덮밥", 15000), ("포케", 10000)]>>> for (menu, price) in prices:... print(f"{menu}: {price}원")...초밥: 20000원연어덮밥: 15000원포케: 10000원
리스트로도 나눠 받을 수 있다
튜플만 되는 건 아니다. 변수 자리를 [menu, price]처럼 리스트 모양으로 써도 되고 괄호 없이 menu, price라고만 써도 된다. 나눠 받는 원소도 ["초밥", 20000] 같은 리스트여도 된다. 개수만 맞으면 된다.
>>> for menu, price in [["초밥", 20000], ["포케", 10000]]:... print(menu, price)...초밥 20000포케 10000
continue, break
continue 문을 for 문에서도 사용할 수 있다. while 문에서와 동일하게 아래를 실행하지 않는데, for 문에는 확인할 조건이 없으니 바로 다음 원소로 넘어간다.
>>> menus = ["초밥", "떡볶이", "포케"]>>> for menu in menus:... if menu == "떡볶이":... continue... print(f"{menu} 먹자")...초밥 먹자포케 먹자
역시 동일하게 break 문도 쓸 수 있다.
>>> menus = ["떡볶이", "초밥", "포케"]>>> for menu in menus:... print(f"{menu} 확인")... if menu == "초밥":... print("초밥 찾았다")... break...떡볶이 확인초밥 확인초밥 찾았다
for-else
for 뒤에 else도 사용할 수 있다. while 문에서와 동일하게, for 문으로 반복하고자 했던 것을 모두 수행한 경우에는 else 절이 실행되고, break로 빠져나가면 실행되지 않는다.
>>> menus = ["떡볶이", "비빔밥"]>>> for menu in menus:... if menu == "초밥":... print("초밥집 찾았다")... break... else:... print("초밥집이 없다")...초밥집이 없다
range 함수
range 함수는 숫자 리스트를 자동으로 만들어 주는 함수다.
공식 문서의 인자 구조는 이렇다.
range(stop)range(start, stop, step=1)
시작 숫자(start)와 끝 숫자(stop)를 지정할 수 있는데, 시작 숫자는 생략할 수 있다. 생략하면 0부터 시작한다. 시작 숫자 이상, 끝 숫자 미만(포함 안 됨!)의 숫자 배열을 만들어 준다. step은 몇씩 건너뛸지를 정하고 생략하면 1이다.
>>> list(range(5))[0, 1, 2, 3, 4]>>> list(range(1, 11))[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]>>> list(range(0, 10, 3))[0, 3, 6, 9]>>> list(range(10, 0, -2))[10, 8, 6, 4, 2]
range는 리스트가 아니다
range가 만드는 건 리스트가 아니라 range라는 별도의 자료형이다. 그대로 출력하면 숫자가 아니라 range(1, 11)이 그대로 나온다.
>>> range(1, 11)range(1, 11)>>> type(range(1, 11))<class 'range'>
숫자를 미리 다 만들어 두지 않고 필요할 때 하나씩 꺼내 쓴다. 그래서 내용을 리스트로 보고 싶으면 위 예제처럼 list()로 감싸야 한다.
리스트는 아니지만 인덱싱, 슬라이싱, in, len()은 다 된다. 하지만 값을 바꿀 수는 없다(immutable). (W3Schools)
>>> r = range(0, 10, 2) # 0, 2, 4, 6, 8>>> r[2]4>>> r[:3]range(0, 6, 2)>>> 6 in rTrue>>> len(r)5>>> r[0] = 100TypeError: 'range' object does not support item assignment
range는 클래스다
엄밀히는 함수가 아니라 클래스다. 공식 문서에도 class range로 나온다. range(1, 11)은 함수를 호출하는 게 아니라 range 자료형의 값을 하나 만드는 것이다. 다만 쓰는 방법은 함수와 같아서 함수라고 불러도 쓰는 데는 문제가 없다.
for 문이랑 같이 쓰면 1부터 10까지 더하는 것을 이렇게 쉽게 구현할 수 있다.
>>> add = 0>>> for i in range(1, 11):... add = add + i...>>> print(add)55
n회 반복용 range
실전에서는 숫자 자체는 필요 없고 횟수만 필요할 때 for _ in range(n)처럼 n회 반복용으로 많이 쓴다. 변수 이름을 _로 두는 건 "이 값은 쓰지 않는다"는 관례다.
>>> for _ in range(3):... print("초밥 한 접시 추가")...초밥 한 접시 추가초밥 한 접시 추가초밥 한 접시 추가
for 문도 while 문처럼 중첩해서 쓸 수 있다.
>>> for day in range(1, 3):... print(f"{day}일차:", end=" ")... for plates in range(1, 4):... print(plates, end=" ")... print("")...1일차: 1 2 32일차: 1 2 3
print는 출력이 끝나면 기본으로 줄을 바꾼다. end의 기본값이 줄바꿈 문자(\n)라서다. end=" "로 바꾸면 줄을 바꾸지 않고 같은 줄에 이어서 출력한다. print는 4장에서 자세히 다룬다.
리스트 컴프리헨션
리스트 컴프리헨션은 리스트를 만드는 규칙을 한 줄로 적는 문법이다. 공식 튜토리얼은 리스트를 더 간결하게 만드는 방법이라고 소개한다.
>>> [x * x for x in [1, 2, 3]][1, 4, 9]
같은 일을 for 문으로 하면 빈 리스트를 만들고, 반복하고, 하나씩 추가하는 세 단계가 필요하다.
>>> result = []>>> for x in [1, 2, 3]:... result.append(x * x)...>>> result[1, 4, 9]
그러니까 새로운 개념은 아니고 for 문으로 리스트에 원소를 하나하나 채우는 코드를 한 줄로 컴팩트하게 쓰기 위한 문법이다. 여기에 if를 붙이면 조건에 맞는 것만 골라 담는 일까지 한 줄로 할 수 있다. 결과는 항상 새 리스트이고 원래 리스트는 바뀌지 않는다. (W3Schools)
틀은 이렇다. if 조건문 부분은 생략할 수 있다.
[표현식 for 항목 in 반복_가능_객체 if 조건문]
if를 붙이면 조건에 맞는 항목만 담는다.
>>> prices = [("초밥", 20000), ("연어덮밥", 15000), ("포케", 10000), ("떡볶이", 5000)]>>> [menu for menu, price in prices if price <= 15000]['연어덮밥', '포케', '떡볶이']
if를 앞에 쓰면 하는 일이 달라진다. 뒤에 쓰는 if는 걸러 내는 필터라 원소가 빠지지만, 앞에 쓰는 if … else …는 조건부 표현식이라 원소 개수는 그대로 두고 값을 바꾼다. 뒤쪽 if에는 else를 붙일 수 없다. (W3Schools)
>>> menus = ["초밥", "떡볶이", "포케"]>>> [m for m in menus if m != "떡볶이"]['초밥', '포케']>>> [m if m != "떡볶이" else "비빔밥" for m in menus]['초밥', '비빔밥', '포케']
for를 여러 개 이어 쓸 수도 있다.
[표현식 for 항목1 in 반복_가능_객체1 if 조건문1for 항목2 in 반복_가능_객체2 if 조건문2...for 항목n in 반복_가능_객체n if 조건문n]
>>> [f"{day}일차 {menu}" for day in range(1, 3) for menu in ["초밥", "포케"]]['1일차 초밥', '1일차 포케', '2일차 초밥', '2일차 포케']
컴프리헨션이라는 이름
이름은 수학의 집합 표기법(조건제시법)에서 왔다. 원소를 하나하나 나열하지 않고 어떤 규칙으로 만들어지는 원소들이라고 정의하는 방식이다.
{ x² | x ∈ {1, 2, 3} } → {1, 4, 9}
리스트 컴프리헨션은 이 표기법의 모양을 그대로 따른다. 이런 문법을 "comprehension"이라고 처음 부른 건 1977년 로드 버스톨(Rod Burstall)과 존 달링턴(John Darlington)의 NPL 언어 설명이다. "list comprehension"이라는 이름은 필립 와들러(Phil Wadler)가 지었다. 파이썬은 이 문법을 함수형 언어 Haskell에서 가져왔다.
참고: Wikipedia - List comprehension, 파이썬 공식 문서 - Functional Programming HOWTO
enumerate 함수
enumerate는 반복하면서 몇 번째인지(인덱스)와 값을 함께 꺼내 주는 내장 함수다. (enumerate는 '낱낱이 세다', '열거하다' 라는 뜻이다.)
공식 문서의 인자 구조는 이렇게 생겼다.
enumerate(iterable, start=0)
>>> menus = ["초밥", "연어덮밥", "포케"]>>> for i, menu in enumerate(menus):... print(i, menu)...0 초밥1 연어덮밥2 포케
(인덱스, 값) 튜플을 하나씩 꺼내 주니까 튜플 나눠 받기(for i, menu in ...)로 바로 받을 수 있다.
enumerate 없이 인덱스가 필요하면 range(len())으로 인덱스를 만들어서 돌아야 한다. (W3Schools)
>>> for i in range(len(menus)):... print(i, menus[i])
enumerate를 쓰면 menus[i]처럼 인덱스로 다시 꺼낼 필요가 없다.
start로 시작 번호를 정할 수 있다. 생략하면 0부터 센다.
>>> for i, menu in enumerate(menus, start=1):... print(i, menu)...1 초밥2 연어덮밥3 포케
enumerate는 이터레이터다
꺼내는 원소는 (인덱스, 값) 튜플이 맞지만, 튜플이 담긴 리스트를 돌려주는 건 아니다. range처럼 enumerate라는 별도의 객체를 돌려준다. 튜플을 미리 다 만들어 두지 않고 for 문이 다음 원소를 달라고 할 때마다 하나씩 만들어 준다.
>>> e = enumerate(["초밥", "포케"])>>> e<enumerate object at 0x1054147c0>>>> next(e)(0, '초밥')>>> next(e)(1, '포케')>>> list(e)[]
range와 다른 점은 한 번 다 꺼내면 끝이라는 것이다. 위에서 두 번 꺼낸 뒤 list(e)를 하면 빈 리스트가 나온다. 이렇게 하나씩 꺼내 쓰는 객체를 이터레이터(iterator)라고 하고 7장에서 자세히 다룬다.
zip 함수
두 개 이상의 리스트를 동시에 순회하고 싶을 때 zip 함수를 쓴다. 우와!
말 그대로 리스트를 합쳐 주는 것이고 각 리스트에서 같은 순서의 원소를 하나씩 모아 튜플을 만들어 준다. 그래서 튜플 나눠 받기로 꺼내서 쓸 수 있다. (공식 문서)
>>> menus = ["초밥", "연어덮밥", "포케"]>>> prices = [20000, 15000, 10000]>>> for menu, price in zip(menus, prices):... print(menu, price)...초밥 20000연어덮밥 15000포케 10000
zip도 이터레이터다
enumerate처럼 zip도 튜플을 미리 다 만들어 두지 않고 하나씩 만들어 주는 이터레이터다. 공식 문서 표현으로는 "returns an iterator of tuples"다. 내용을 보려면 list()로 감싸야 한다.
>>> list(zip(menus, prices))[('초밥', 20000), ('연어덮밥', 15000), ('포케', 10000)]
합치는 배열의 길이가 다르다면?
짧은 쪽에 맞춘다. 남는 원소가 에러 없이 빠지기 때문에, 버그가 생겨도 알아채기 어렵다.
>>> list(zip(["초밥", "연어덮밥", "포케"], [20000, 15000]))[('초밥', 20000), ('연어덮밥', 15000)]
strict=True를 주면 길이가 다를 때 ValueError가 난다. 파이썬 3.10부터 쓸 수 있다.
>>> list(zip(["초밥", "연어덮밥", "포케"], [20000, 15000], strict=True))ValueError: zip() argument 2 is shorter than argument 1
반대로 긴 쪽에 맞추고 싶으면 itertools.zip_longest를 쓴다. 모자란 자리는 None으로 채운다.
>>> from itertools import zip_longest>>> list(zip_longest(["초밥", "연어덮밥", "포케"], [20000, 15000]))[('초밥', 20000), ('연어덮밥', 15000), ('포케', None)]
zip 함수 활용하기
딕셔너리 만들기:
>>> dict(zip(menus, prices)){'초밥': 20000, '연어덮밥': 15000, '포케': 10000}
다시 풀기(unzip). 묶여 있는 짝들을 메뉴끼리, 가격끼리 다시 나눈다. 공식 문서도 zip을 행과 열을 바꾸는 것(행렬 전치)과 비슷하다고 설명한다.
>>> pairs = [("초밥", 20000), ("포케", 10000)]>>> names, costs = zip(*pairs)>>> names('초밥', '포케')>>> costs(20000, 10000)
*pairs는 리스트를 풀어서 각 원소를 따로따로 인자로 넘기는 문법이다. zip(*pairs)는 zip(("초밥", 20000), ("포케", 10000))과 같다. 함수 인자는 4장에서 자세히 다룬다.
반대로 받는 쪽 변수에 *를 붙이면 남는 값을 리스트로 모은다. (W3Schools)
>>> menus = ("초밥", "연어덮밥", "포케", "비빔밥", "떡볶이")>>> first, second, *rest = menus>>> rest['포케', '비빔밥', '떡볶이']>>> first, *middle, last = menus>>> middle['연어덮밥', '포케', '비빔밥']
참고 자료
W3Schools
- if 문: If · Elif · Else · Shorthand If · Logical Operators · Nested If · Pass
- 연산자: Comparison Operators (Chaining Comparison Operators) · Membership Operators · Ternary Operator
- Match
- While Loops
- for 문: For Loops · Range · List Comprehension
- 리스트·튜플 순회: Loop Lists (Loop Through the Index Numbers) · Loop Tuples · Unpack Tuples (Using Asterisk*)
- 이터레이터: Iterators (Iterator vs Iterable)