제어문은 프로그램의 기본 흐름을 변경하기 위해 사용되는 블록(문장들의 집합)이다.

• 조건문(conditional)
• 순환문(loop)

🟩 조건문(Conditional)

if 조건문

조건을 판단하여 해당 조건에 맞는 상황을 수행하는 구조문을 if 조건문이라고 한다.

if 조건문은 아래와 같은 구성으로 이루어진다.

if 조건식1:
   조건식1 '참'일때 수행 구문 블록
elif 조건식2:
   조건식2 '참'일때 수행 구문 블록
else:
   어떤 조건식도 '거짓'일때 수행 구문 블록
   
score = 74

if score >= 90:
  print('A')
elif score >= 80:
  print('B')
elif score >= 70:
  print('C')
elif score >= 60:
  print('D')
else:
  print('F')
→ 'C'

조건문을 중첩해서 사용할 수 있다(중첩 조건문).

# 20살 이상 남자 -> MAN
#      미만 남자 -> BOY
# 20살 이상 여자 -> WOMAN
#      미만 여자 -> GIRL
age = 12
gender = 'F'   # 남자: 'M', 여자: 'F'

if age >= 20:
  if gender == 'M':
    print('MAN')
  else:
    print('WOMAN')
else:
  if gender == 'M':
    print('BOY')
  else:
    print('GIRL')
→ 'GIRL'

pass, ...(Ellipsis)
내부 구현이 없는 블럭에 명시할 때 사용한다.
※ 오류를 발생시키지 않기 때문에, 골격코드를 그대로 사용할 수 있다. ※

a = 10

if a > 0:
  pass
if a > 0:
  ...

Conditional Expression

AKA "삼항연산자"

(참일때의 값) if (조건식) else (거짓일때의 값)

n = 10

result = '5의 배수입니다.' if n % 5 == 0 else '5의 배수가 아닙니다.'
result
→ '5의 배수입니다.'

비교연산자와 논리연산자

조건식에 비교연산자와 논리연산자 등을 활용해 작성해야 한다.

• 비교연산자: >, <, >=, <=, ==, !=
• 논리연산자: and, or, not, ^(xor: exclusive or)

d = 10

result = d > 2 # T 
result = d > 10 # F
result = d == 100 # F
result = d != 2 # T
result = d >= 10 and d < 100 # T
result = d >= 10 and d > 100 # F
result = d >= 10 or d > 100 # T
result = not (d < 10) # T
result = (d >= 10) ^ (d > 100) # T
result = (d >= 10) ^ (d < 100) # F

if result:
  print('T') # 참: T(rue)/거짓: F(alse)
else:
  print('F')

파이썬에서만 가능한 비교연산자 표현이 있다.

score = -1

if score >= 0 and score <= 100:
  print(score, '은/는 유효한 점수입니다.')
else:
  print(score, '은/는 유효한 점수가 아닙니다.')
→ '-1 은/는 유효한 점수가 아닙니다.'
if 0 <= score <= 100:
print(score, '은/는 유효한 점수입니다.')
else:
  print(score, '은/는 유효한 점수가 아닙니다.')
→ '-1 은/는 유효한 점수가 아닙니다.'

파이썬에서는 bool 타입 외에도 조건식에서 참/거짓으로 판정될 수 있다.

	참	거짓
bool 타입	True	False
숫자 타입	0이 아닌 숫자	0
str 타입	"abc"	""(빈 문자열)
list 타입	[1, 2, 3]	[ ](빈 list)
tuple 타입	(1, 2, 3)	( )(빈 tuple)
dict 타입	{"key": "value"}	{ }(빈 dict)
None 타입		None

result = 0.01 # T
result = 0 # F
result = 'abc' # T
result = '' # F
result = ' ' # T
result  = [1, 2, 3] # T
result = [] # F
result = (0) # F;int형 0
result = (0,) # T
result = {'name':'John'} # T
result = {} # F
result = None # F

if result:
  print('T') # 참: T(rue)/거짓: F(alse)
else:
  print('F')

SCE: Short-Circuit Evaluation

논리연산자 "and", "or"의 첫번째 조건식 판정(참/거짓)에 따라 논리연산자의 결과가 expression값이 된다.

• or
  왼쪽 조건식이 참인 경우 '왼쪽 조건식' 수행결과값 리턴
  왼쪽 조건식이 거짓인 경우 '오른쪽 조건식' 수행결과값 리턴
• and
  왼쪽 조건식이 참인 경우 '오른쪽 조건식' 수행결과값 리턴
  왼쪽 조건식이 거짓인 경우 '왼쪽 조건식' 수행결과값 리턴

result = True or False # T
result = True and False # F
result = 0 or 100 # T;result = 100
result = 120 or '' # T; result = 120
result = 'hello' or '555' # T; result = 'hello'
result = 'hello' and '555' # T; result = '555
result = '' and '555' # F;result = ''

if result:
  print('T', result) # 참: T(rue)/거짓: F(alse)
else:
  print('F', result)

a = 9

a % 2 == 0 and print('짝수')
a % 2 == 0 or print('홀수')
→ '홀수'

🟩 순환문(Loop)

while 순환문

조건식이 '참'인 동안 수행 문장을 반복 수행하고, 조건식이 '거짓'인 순간 반복 수행을 종료한다.

※ 순환식에서 중요한 것 ※
1. 순환 횟수
2. 순환 시 변수값의 변화 범위
3. 순환문 종료 후 변수값

while (조건식):
	(수행할 문장1)
    (수행할 문장2)
    (수행할 문장3)
    ⋯

num = 0

while num < 10: # 순환 시 변수값의 범위: 0 ~ 9
  print(num)
  num += 1 # 순환 종료 후 num = 10
→ 0 
  1
  2
  3
  4
  5
  6
  7
  8
  9 # 순환 횟수: 10번

순환문도 중첩해서 사용될 수 있다(순환문 중첩(nested loop)).

# 구구단 출력 : 2단 ~ 9단

i = 2
while i <= 9:
  d = 1
  while d <= 9:
    print(f'{i} x {d} = {i * d}')
    d += 1
  i += 1
→ 2 x 1 = 2
  2 x 2 = 4
  ⋯
  2 x 9 = 18
  3 x 1 = 3
  ⋯
  4 x 1 = 4
  ...
  9 x 9 = 81

break
순환문 안에서 순환문을 강제로 종료시키는 키워드이다.
※ 감싸고 있는 가장 가까운 순환문이 종료됨 ※

n = 1
while n <= 100:
  print(n)
  n += 1
  break # 순환문 종료
print('종료', n)
→ 1
  '종료', 2

continue
순환문이 처음으로 돌아간다.
※ 순환문 종료없이 특정 조건만 skip하는 경우에 사용 ※

num = 0
while num < 10:
  num += 1
  if num % 3 == 0:
    continue # 아래를 실행 안함
  print(num)
 → 1 
   2
   4
   5
   7
   8
   10

for 순환문

파이썬서 for 순환문은 매우 직관적이고 편리하다.

for (변수) in (iterable 객체):
	(수행할 문장1)
    (수행할 문장2)
    ⋯

animals = ['dog', 'cat', 'bird', 'cow', 'pig']

for animal in animals: # list 가능
  print('I love', animal)
→ 'I love dog'
  'I love cat'
  'I love bird'
  'I love cow'
  'I love pig'
  
for ch in 'Python': # str 가능
  print(ch)
→ 'P'
  'y'
  't'
  'h'
  'o'
  'n'

my_dict = {'name':'hong', 'age':24, 'grade':4}

for key in my_dict: # dict는 key값이 추출됨
  print(key)
  
→ 'name'
  'age'
  'grade'  

range()
자동으로 숫자 list를 만들어주는 함수이다.

range(시작 숫자, 끝 숫자, step값) # 끝 숫자 미포함

for i in range(3):
  print('hello', i)
→ 'hello' 0
  'hello' 1
  'hello' 2
  
for i in range(4, 15):
  print(i)
→ 4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

for i in range(4, 15, 3):
  print(i)
→ 4
  7
  10
  13

for i in range(10, 0, -1):
  print(i)
→ 10
  9
  8
  7
  6
  5
  4
  3
  2
  1

enumerate(iterable)

(index, data) 쌍의 iterable 객체 리턴된다.

for x in enumerate(animals):
  print(x)
→ (0, 'dog')
  (1, 'cat')
  (2, 'bird')
  (3, 'cow')
  (4, 'pig')
  
for idx, animal in enumerate(animals): # assignment unpacking
  print(f'{idx} - {animal}')
→ 0 - 'dog'
  1 - 'cat'
  2 - 'bird'
  3 - 'cow'
  4 - 'pig'

for idx, animal in enumerate(animals, 10): # 시작하고 싶은 값
  print(f'{idx} - {animal}')
→ 10 - 'dog'
  11 - 'cat'
  12 - 'bird'
  13 - 'cow'
  14 - 'pig'

zip()

매개변수 iterable 데이터들의 각 원소를 묶은 tuple들의 iterable 객체를 생성한다.

zip(iterable, iterable,⋯)

for x in zip([10, 20, 30], ('a', 'b', 'c')):
  print(x)
→ (10, 'a')
  (20, 'b')
  (30, 'c')

Comprehension

파이썬의 자료구조에 데이터를 좀 더 효율적이고 간결하게 표현하기 위한 문법이다.

• list comprehension

[표현식 for 항목 in iterable 객체 (if 조건 # 생략 가능)]

a = [1, 2, 3, 4]

[num * 3 for num in a]
→ [3, 6, 9, 12]

[num * 3 for num in a if num % 2 == 0]
→ [6, 12]

• set comprehesion

{표현식 for 항목 in iterable 객체 (if 조건 # 생략 가능)}

{num % 3 for num in range(10)}
→ {0, 1, 2}

• dict comprehesion

{k: v for 항목 in iterable 객체 (if 조건 # 생략 가능)}

fruits = {"peach": 10000, "apple": 4000, "banana": 6000}

{k: v for k, v in fruits.items()}
→ {'peach': 10000, 'apple': 4000, 'banana': 6000}

{k: v for k, v in fruits.items() if k != 'banana'}
→ {'peach': 10000, 'apple': 4000}