[인프라 활용을 위한 파이썬] 제어문과 컴프리헨션

제어문

1. 조건문(conditional statements)

1.1. if 문

조건을 만족했을 때 코드를 실행

 

age = input('나이를 입력하세요: ')

if int(age) < 19:
    print('애들은 가라')

 

 

1.2. elif 문

앞에 있는 if 문 또는 elif 문의 조건이 거짓일 때 새로운 조건을 검사할 때 사용

 

age = input('나이를 입력하세요: ')
age = int(age)

if age >= 18:
    print('성인입니다.')
elif age >= 13:			# 자바와 같은 언어에서는 else if로 표현
    print('청소년입니다.')

 

 

1.3. else 문

모든 if 문과 elif 문의 조건이 거짓일 때 실행

 

age = input('나이를 입력하세요: ')
age = int(age)

if age >= 18:
    print('성인입니다.')
elif age >= 13:
    print('청소년입니다.')
else:
    print('어린이입니다.')

 

 

1.4. 중첩 조건문

조건문 안에 또 다른 조건문이 들어있는 형태

 

age = input('나이를 입력하세요: ')
age = int(age)

is_employed = input('직장인입니까? (y/n): ')
if is_employed == 'y' or is_employed == 'Y':
    is_employed = True
else:    
    is_employed = False

if age >= 18:
    if is_employed:
        print('성인이면서 직장인입니다.')
    else:
        print('성인이지만 직장인이 아닙니다.')
elif age >= 13:
    print('청소년입니다.')
else:
    print('어린이입니다.')

 

 

1.5. 조건부 표현식

삼항 연산자, conditional expression, ternary operator

 

value_if_true if condition else value_if_false
~~~~~~~~~~~~~    ~~~~~~~~~      ~~~~~~~~~~~~~~
|                |              | 
|                |              +-- 조건식을 만족하지 않는 경우에 반환되는 값 
|                +-- 조건식
+-- 조건식을 만족하는 경우에 반환되는 값

age = input('나이를 입력하세요: ')
age = int(age)

# if ... else ... 구문을 이용
if age >= 18:
    print('성인입니다.')
else:
    print('미성년자입니다.')

# 삼항 연산자를 이용
message = '성년입니다' if age >= 20 else '미성년자입니다.'
print(message)

 

 

1.6. 조건식을 구성하는 연산자

비교 연산자

• == : 등호. 두 값이 같은지 비교
• != : 부등호. 두 값이 다른지 비교
• : 크다. 왼쪽 값이 오른쪽 값보다 큰지 비교
• < : 작다. 왼쪽 값이 오른쪽 값보다 작은지 비교
• = : 크거나 같다. 왼쪽 값이 오른쪽 값보다 크거나 같은지 비교
• <= : 작거나 같다. 왼쪽 값이 오른쪽 값보다 작거나 같은지 비교

논리 연산자

• and : 모든 조건이 참인 경우에만 참을 반환
• or : 하나 이상의 조건이 참이면 참을 반환
• not : 조건의 참/거짓 값을 반대로 반환

멤버십 연산자

특정 값이 시퀀스(리스트, 튜플, 문자열 등)나 컬렉션(집합, 딕셔너리 등)에 포함되어 있는지 여부를 확인하는 데 사용

• in : 특정 값이 시퀀스나 컬렉션에 포함되어 있는 경우 참을 반환
• not in : 특정 값이 시퀀스나 컬렉션에 포함되어 있지 않는 경우 참을 반환

 

# 리스트에 값이 포함되어 있는지 여부를 확인
fruits = [ 'apple', 'banana', 'cherry' ]

if 'apple' in fruits:
    print('apple이 포함되어 있습니다.')

if 'grape' not in fruits:
    print('grape이 포함되어 있지 않습니다.')

# 문자열에 값이 포함되어 있는지 여부를 확인
message = 'Hello, world!'
print("Hello" in message)   # True
print("hello" in message)   # False <= 대소문자 구분

# 튜플에 값이 포함되어 있는지 여부를 확인
members = ('James', 'Robert', 'Lisa', 'Mary')
print('Lisa' in members)        # True
print('Lisa' not in members)    # False

# 딕션너리에 키를 포함하고 있는지 여부를 확인
person = {"name": "John", "age": 36, "country": "Norway"}
print("name" in person)     # True
print("John" in person)     # False <= 딕션너리는 키를 기준으로 검색
print("gender" in person)   # False

 

2. 반복문(loop statements)

2.1. for 문

시퀀스(리스트, 튜플, 문자열 등)나 다른 반복 가능한(iterable) 객체를 순회(iterate)하면서 특정 코드를 반복 실행

 

for item in iterable:		⇐ item : 반복 가능한 객체의 각 항목을 의미
    # 실행할 코드 			   iterable : 반복 가능한 객체(리스트, 튜플, 문자열, 범위, ... 등)

# 리스트 순회
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

# 실행 결과
# apple
# banana
# cherry

# 문자열 순회
word = "hello"
for char in word:
    print(char)

# 실행 결과
# h
# e
# l
# l
# o

# rage() 함수를 사용한 순회
# range(n) : 0부터 n-1까지의 숫자를 생성하는 함수
# range(n, m) : n부터 m-1까지의 숫자를 생성하는 함수
# range(n, m, s) : n부터 m-1까지의 숫자를 생성하는데, s만큼 증가하는 함수
for i in range(5):
    print(i)            # 0부터 4까지 출력

 

 

2.2. while 문

조건이 참(True)인 동안 코드 블록을 반복

 

while condition:
   # 실행할 코드

# count가 5보다 작은 동안 count를 출력하고 1씩 증가시키는 코드
# 실행 결과: 0부터 4까지 출력
count = 0
while count < 5:
    print(count)
    count += 1

# 동일한 기능을 for 문으로 구현
for count in range(5):
    print(count)

 

 

2.3. 중첩 반복문(nested loop)

반복문 내부에 다른 반복문을 사용하는 구조

 

3. 제어문과 함께 사용하는 키워드

3.1. break 문

반복문을 즉시 종료 시키는 데 사용됨

중첩 반복문에서 break 문을 사용하면 가장 안쪽의 반복문만 종료되며, 바깥쪽 반복문은 계속 실행

 

for i in range(5):
    print(i, end=' ')      # 0 1 2 3 4

for i in range(5):
    if i == 3:
        break
    print(i, end=' ')      # 0 1 2

print()

for i in range(3):
    for j in range(3):
        print(f'i: {i}, j: {j}')

print("*" * 10)

for i in range(3):
    if i == 1:
        break
    for j in range(3):
        print(f'i: {i}, j: {j}')

print("*" * 10)

for i in range(3):
    for j in range(3):
        if j == 1:
            break
        print(f'i: {i}, j: {j}')

 

 

3.2. continue 문

현재 반복을 중단하고 다음 반복을 진행

 

for i in range(3):
    print(i, end=' ')      # 0 1 2

print()

for i in range(3):
    if i == 1:
        break
    print(i, end=' ')      # 0

print()

for i in range(3):
    if i == 1:
        continue
    print(i, end=' ')      # 0 2

 

 

3.3. pass 문

아무런 동작도 하지 않는 문장으로, 코드 블록이 필요하지만 특별히 실행할 코드가 없을 때 사용

예) 함수나 클래스를 미리 정의하고 구현은 나중에 할 때

     조건문이나 반복문에서 아무 것도 하지 않고 넘길 때

 

def my_func():   # 함수 선언부(헤더) => def 함수이름(매개변수):
    pass         # 함수 구현부(본문) => pass는 아무것도 하지 않는다는 의미

class MyClass:   # 클래스 선언
    pass         # 클래스 구현부 => pass는 아무것도 하지 않는다는 의미

for i in range(5):
    if i == 3:
        pass     # 아무것도 하지 않는다는 의미
    else:
        print(i)

# 위에 코드는 아래와 같은 의미
for i in range(5):
    if i != 3:
        print(i)

for i in range(5):
    if i == 3:
        continue
    print(i)

 

 

3.4. else 문

조건문이나 반복문에서 조건이 충족되지 않거나 반복이 정상적으로 완료되었을 때 실행되는 코드 블록

 

# 조건문에서 else 사용하기
num = 9
if num > 20:
    print("20 보다 큰 수 입니다.")
elif num > 10:
    print("10 보다 크고 20 보다 작은 수 입니다.")
else:
    print("10 이하의 수 입니다.")

# 반복문에서 else 사용하기
for i in range(5):
    print(i, end=' ')
else:
    print("모두 출력되었습니다.")   # 출력

for i in range(5):
    if i > 2:
        break
    print(i, end=' ')
else:
    print("모두 출력되었습니다.")   # 출력 안됨

 

---

컴프리헨션

1. 리스트 컴프리헨션 (list comprehension)

간결하고 효율적인 방식으로 새로운 리스트를 생성하는 문법

 

특징

• 반복문과 조건문을 한 줄로 표현할 수 있어서 코드의 가독성을 높여줌
• 반복 가능한 객체(iterable)에서 특정 조건을 만족하는 항목들만 골라내고, 각 항목을 변형해 새로운 리스트를 생성할 때 유용

 

형태:
[ expression for item in iterable ] 
  ~~~~~~~~~~     ~~~~    ~~~~~~~~
  |              |        |   
  |              |        +-- 리스트, 튜플, 문자열 등 반복 가능한 객체 
  |              +-- 반복문에서 사용하는 변수로, 반복 가능한 객체의 각 요소를 나타냄
  +-- 리스트에 추가할 항목을 정의

# 1부터 10까지의 숫자를 담은 리스트를 생성

# 모든 항목을 직접 정의 => 확장성이 결여
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# rage를 list로 변환
numbers = range(1, 11)
print(numbers)              # range(1, 11)
print(type(numbers))        # <class 'range'>

numbers = list(numbers)
print(numbers)              # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(type(numbers))        # <class 'list'>

# range의 값을 빈 리스트에 추가
numbers = []
for i in range(1, 11):
    numbers.append(i)  

print(numbers)              # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(type(numbers))        # <class 'list'>

# List Comprehension
numbers = [i for i in range(1, 11)]

print(numbers)              # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(type(numbers))        # <class 'list'>

numbers = [i for i in range(1, 11)]
print(numbers)              # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 각 요소를 제곱해서 새로운 리스트를 생성
squared = [i**2 for i in range(1, 11)]
print(squared)              # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 단어로 구성된 리스트를 이용해서 새로운 리스트를 생성
# 새로운 리스트는 원래 리스트의 단어들을 대문자로 변환한 것으로 구성
words = ['hello', 'world', 'python', 'is', 'fun']
uppper_words = [ word.upper() for word in words ]
print(uppper_words) # ['HELLO', 'WORLD', 'PYTHON', 'IS', 'FUN']

 

 

리스트 컴프리헨션에 조건문을 추가하여 특정 조건을 만족하는 항목만 리스트에 포함

[ expression for item in iterable if condition ] 
                                     ~~~~~~~~~
                                     iterable 각 항목에 대해 평가하는 조건식 
                                     조건식이 True 일 때만 항목(item)이 리스트에 포함

# numbers 리스트에서 짝수만 추출해서 even_numbers 이름의 리스트에 담아 출력하기
numbers = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
even_numbers = [ ]
for number in numbers:
    if number % 2 == 0:
        even_numbers.append(number)
print(even_numbers)        # [2, 4, 6, 8, 10]

# List Comprehension을 사용하면 코드를 더 간결하게 작성할 수 있다.
even_numbers = [ number for number in numbers if number % 2 == 0 ]
print(even_numbers)        # [2, 4, 6, 8, 10]

# 짝수를 거듭제곱해서 새로운 리스틀 생성
even_numbers_squared = [ number ** 2 for number in numbers if number % 2 == 0 ]
print(even_numbers_squared) # [4, 16, 36, 64, 100]

# words 리스트에서 길이가 5글자 이하인 문자열만 추출해서 새로운 리스트를 생성
words = ['apple', 'banana', 'orange', 'melon', 'grape']
result = [word for word in words if len(word) <= 5]
print(result)       # ['apple', 'melon', 'grape']

# if 문을 이용해서 구현
result = []
words = ['apple', 'banana', 'orange', 'melon', 'grape']
for word in words:
    if len(word) <= 5:
        result.append(word)
print(result)       # ['apple', 'melon', 'grape']

# words 리스트에서 길이가 5글자 이하이고 첫 글자가 a로 시작하는 문자열만 추출해서 새로운 리스트를 생성
words = ['apple', 'banana', 'orange', 'melon', 'grape', 'add']  
result = [ word for word in words if len(word) <= 5 and word[0] == 'a' ]
print(result)       # ['apple', 'add']

# words 리스트에서 길이가 5글자 이하이고 첫 글자가 a로 시작하는 문자열만 추출해서 대문자로 변환한 값을 가지는 새로운 리스트를 생성
words = ['apple', 'banana', 'orange', 'melon', 'grape', 'add']  
result = [ word.upper() for word in words if len(word) <= 5 and word[0] == 'a' ]
print(result)       # ['APPLE', 'ADD']

 

 

리스트 컴프리헨션을 중첩해서 다차원 리스트를 생성하거나 변환

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 중첩된 for 문
flattened = []
for row in matrix:
    for num in row:
        flattened.append(num)
print(flattened)    # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 1부터 3까지의 숫자와 1부터 2까지의 숫자를 조합한 결과 중 두 숫자가 다른 경우만 모아서 리스트로 반환
# (1, 1) 제외
# (1, 2) 포함
# (2, 1) 포함
# (2, 2) 제외
# (3, 1) 포함
# (3, 2) 포함
combine = [(x, y) for x in range(1, 4) for y in range(1, 3) if x != y]
print(combine)  # [(1, 2), (2, 1), (3, 1), (3, 2)]

combine = []
for x in range(1, 4):
    for y in range(1, 3):
        if x != y:
            combine.append((x, y))
print(combine)   # [(1, 2), (2, 1), (3, 1), (3, 2)]

 

2. 셋 컴프리헨션

# list comprehension
new_list = [ x % 3 for x in range(10) ]    
print(new_list)         # [0, 1, 2, 0, 1, 2, 0, 1, 2, 0]

new_list = [ x + y for x in range(5) for y in range(5) ]
print(new_list)         # [0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8]

# set comprehension => 중복을 제거하고 싶을 때 사용
new_set = { x % 3 for x in range(10) }
print(new_set)          # {0, 1, 2}

new_set = { x + y for x in range(5) for y in range(5) }
print(new_set)          # {0, 1, 2, 3, 4, 5, 6, 7, 8}

 

3. 딕셔너리 컴프리헨션

students = [ 'Alice', 'Bob', 'Charlie', 'David' ]
students_0_score = { student: 0 for student in students }
print(students_0_score)     # {'Alice': 0, 'Bob': 0, 'Charlie': 0, 'David': 0}

scores = { 'Alice': 100, 'Bob': 90, 'Charlie': 80, 'David': 70 }
# 딕셔너리 데이터를 필터링해서 새로운 디셔너리를 생성
over_90 = { name: score for name, score in scores.items() if score > 90 }
print(over_90)    # {'Alice': 100}

# 딕셔너리 데이터를 변환해서 새로운 디셔너리를 생성
grades = { name: 'PASS' if score > 80 else 'No PASS' for name, score in scores.items() }
print(grades)     # {'Alice': 'PASS', 'Bob': 'PASS', 'Charlie': 'No PASS', 'David': 'No PASS'}

 

4. map, filter

numbers = [ 1, 2, 3, 4, 5 ]

# 빈 리스트를 정의하고, 루프를 돌며 각 요소를 가공해서 리스트에 추가
new_numbers = []
for number in numbers:
    new_numbers.append(number ** 2)
print(new_numbers)      # [1, 4, 9, 16, 25]

# 리스트 컴프리헨션을 사용하여 한 줄로 작성
new_numbers = [ number ** 2 for number in numbers ]
print(new_numbers)      # [1, 4, 9, 16, 25]

# map() 함수를 사용하여 한 줄로 작성
def square(number):
    return number ** 2
new_numbers = map(square, numbers)  
print(list(new_numbers))    # [1, 4, 9, 16, 25]

# map() 함수와 람다 표현식을 사용하여 한 줄로 작성
new_numbers = map(lambda number: number ** 2, numbers)
print(list(new_numbers))    # [1, 4, 9, 16, 25]

numbers = [ 1, 2, 3, 4, 5 ]

evens = []
for number in numbers:
    if number % 2 == 0:
        evens.append(number)
print(evens)        # [2, 4]

evens = [ number for number in numbers if number % 2 == 0 ]
print(evens)        # [2, 4]

def is_even(number):
    return number % 2 == 0
evens = filter(is_even, numbers)
print(list(evens))  # [2, 4]

evens = filter(lambda number: number % 2 == 0, numbers)
print(list(evens))  # [2, 4]

numbers = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

new_numbers = []
for number in numbers:
    if number % 2 == 0:
        new_numbers.append(number ** 2)
print(new_numbers)          # [4, 16, 36, 64, 100]

new_numbers = [ number ** 2 for number in numbers if number % 2 == 0 ]
print(new_numbers)          # [4, 16, 36, 64, 100]

new_numbers = filter(lambda number: number % 2 == 0, numbers)
new_numbers = map(lambda number: number ** 2, new_numbers)
print(list(new_numbers))    # [4, 16, 36, 64, 100]