1. if 문
대표적인 조건문으로 조건을 판단하여 해당 조건에 맞는 상황을 수행하는 데 쓰임
1) 기본 구조
if 조건문 :
수행할_문장 1
수행할_문장 2
else :
수행할_문장 A
수행할_문장 B
- 조건문을 테스트해서 참이면 if 문 바로 다음 문장(if 블록)들을 수행
- 조건문이 거짓이면 else 문 다음 문장(else 블록)들을 수행
- else 문은 if 문 없이 독립적으로 사용할 수 없다.
- if 조건문 뒤에는 반드시 콜론(:)이 붙는다.
2) 들여쓰기
if 조건문 : 바로 다음 문장부터 if 문에 속하는 모든 문장에 들여쓰기해야 한다.
if 조건문 :
수행할_문장1
수행할_문장2
수행할_문장3
- 수행할_문장 중 하나라도 들여쓰기하지 않으면 오류가 난다.
- 들여쓰기는 언제나 같은 깊이로 해야 한다.
3) 조건문
참과 거짓을 판단하는 문장
money = True
if money :
print("택시 탄다.")
else :
print("걸어간다.")
- 출력 : 택시 탄다.
money가 True이기 때문에 조건이 참이 되어 if 문 다음 문장을 수행한다.
4) 비교 연산자
| 비교 연산자 | 설명 |
| x < y | x가 y보다 작다. |
| x > y | x가 y보다 크다. |
| x == y | x와 y가 같다. |
| x != y | x와 y가 같지 않다. |
| x >= y | x가 y보다 크거나 같다. |
| x <= y | x가 y보다 작거나 같다. |
x = 3
y = 2
print(x > y)
print(x < y)
print(x == y)
print(x != y)
- 출력 : True
- 출력 : False
- 출력 : False
- 출력 : True
money = 2000
if money >= 3000 :
print("택시 탄다.")
else :
print("걸어간다.")
- 출력 : 걸어간다
위 코드를 글로 표현하면 "만약 3000원 이상의 돈이 있다면 택시를 타고, 그렇지 않으면 걸어간다."이다.
이때, money >= 3000 조건문이 거짓이 되기 때문에 else 문이 실행된다.
(1) and, or, not
| 연산자 | 설명 |
| x or y | x와 y 둘 중 하나만 참이어도 참이다. |
| x and y | x와 y 모두 참이어야 참이다. |
| not x | x가 거짓이면 참이다. |
money = 2000
card = True
if money >= 3000 or card :
print("택시 탄다.")
else :
print("걸어간다.")
- 출력 : 택시 탄다.
위 코드를 글로 표현하면 "만약 돈이 3000원 이상 있거나 카드가 있다면 택시를 타고, 그렇지 않으면 걸어간다."이다.
money는 False지만, card가 True이기 때문에 if 문이 수행된다.
(2) in, not in
영어 단어 in의 뜻이 '~안에'라는 것을 생각하면 쉽다.
| in | not in |
| x in 리스트 | x not in 리스트 |
| x in 튜플 | x not in 튜플 |
| x in 문자열 | x not in 문자열 |
a = 1
print(a in [1, 2, 3])
b = 1
print(b not in [1, 2, 3])
- 출력 : True
- 출력 : False
a가 [1, 2, 3] 안에 있는가?라는 조건문이다. a는 리스트 안에 있으므로 True를 리턴한다.
b가 [1, 2, 3] 안에 없는가?라는 조건문이다. b는 리스트 안에 있으므로 False를 리턴한다.
pocket = ['paper', 'phone', 'money']
if 'money' in pocket :
print("택시 탄다.")
else :
print("걸어간다.")
- 출력 : 택시 탄다.
'money'가 pocket 리스트 안에 있으므로 챔이 되어 if 문을 수행한다.
위 코드를 글로 표현하면 "만약 주머니에 돈이 있다면 택시를 타고, 그렇지 않으면 걸어간다."이다.
5) elif
다중 조건 판단을 할 때 사용
(1) 기본 구조
if 조건문 :
수행할_문장
elif 조건문 :
수행할_문장
elif 조건문 :
수행할_문장
else :
수행할_문장
- elif는 이전 조건문이 거짓일 때 수행된다.
pocket = ['paper', 'phone']
card = True
if 'money' in pocket :
print("택시 탄다.")
elif card :
print("택시 탄다.")
else :
print("걸어간다.")
- 출력 : 택시 탄다.
"주머니에 돈이 있으면 택시를 타고, 주머니에 돈은 없지만 카드가 있으면 택시를 타고, 돈도 없고 카드도 먹으면 걸어간다."
6) 조건부 표현식
변수 = 조건문이_참인_경우의_값 if 조건문 else 조건문이_거짓인_경우의_값
- 조건부 표현식은 가독성에 유리하고 한 줄로 작성할 수 있어 활용성이 좋다.
2. while 문
조건문이 참인 동안 while 문에 속한 문장들이 반복해서 수행된다.
1) 기본 구조
while 조건문 :
수행할_문장1
수행할_문장2
'열 번 찍어 안 넘어가는 나무 없다'라는 속담을 코드의 수행 순서대로 도식화해 본다.
| Hit | 조건문 | 조건 판단 | 수행하는 문장 | while 문 |
| 0 | 0 < 10 | 참 | 나무를 1번 찍었습니다. | 반복 |
| 1 | 1 < 10 | 참 | 나무를 2번 찍었습니다. | 반복 |
| 2 | 2 < 10 | 참 | 나무를 3번 찍었습니다. | 반복 |
| 3 | 3 < 10 | 참 | 나무를 4번 찍었습니다. | 반복 |
| 4 | 4 < 10 | 참 | 나무를 5번 찍었습니다. | 반복 |
| 5 | 5 < 10 | 참 | 나무를 6번 찍었습니다. | 반복 |
| 6 | 6 < 10 | 참 | 나무를 7번 찍었습니다. | 반복 |
| 7 | 7 < 10 | 참 | 나무를 8번 찍었습니다. | 반복 |
| 8 | 8 < 10 | 참 | 나무를 9번 찍었습니다. | 반복 |
| 9 | 9 < 10 | 참 | 나무를 10번 찍었습니다. 넘어갑니다. | 반복 |
| 10 | 10 < 10 | 거짓 | 종료 |
도식화하면 반복문을 보면 쉽게 볼 수 있다.
Hit = 0 # 나무 찍은 횟수
while Hit < 10 : # 나무 찍은 횟수가 10보다 작을 때 반복
Hit += 1 # 나무 찍은 횟수 1씩 증가
print(f'나무를 {Hit}번 찍었습니다.')
if Hit == 10 : # 나무 열 번 찍으면
print('나무 넘어갑니다.')
나무 찍은 횟수가 10보다 작을 때 while 문에 포함된 문장들을 계속 수행한다. 이때, 나무 찍은 횟수가 10이되면 조건문이 거짓이 되고 while 문을 빠져나간다.
2) 만들기
number = 0 # 사용자 입력을 받을 변수
menu = """
1. Add
2. Del
3. List
4. Quit
"""
while number != 4 : # 입력받은 번호가 4가 아니면 while문 반복
print(menu) # menu 출력
number =int(input()) # 사용자 입력
- while 문의 조건문에서 number가 4가 아니면 menu를 출력하고 사용자로부터 입력받은 값이 4가 아니면 menu를 다시 출력하고 4가 되면 while 문을 빠져나간다.
3) 강제로 나가기
조건이 참인 동안 계속 반복 수행하는데 이때, 강제로 멈추게 하는 것이 break 문이다.
coffee = 5
money = 300
while money :
print('커피 추출')
coffee -= 1
print(f'남은 커피 {coffee}개')
if coffee == 0 :
print('커피 없음 중지')
break
- money는 0이 아니기 때문에 while 문은 항상 참으로 무한 루프
- while 문이 한 번 수행할 때마다 coffee 개수는 1개씩 줄어듦
- 만약 coffee가 0이면 if 문이 참이 되어 if 문 다음 문장이 출력되고 break 문을 만나 while 문을 강제로 빠져나감
4) 처음으로 돌아가기
while 문 안에 조건문이 있을 때 조건문이 거짓이면 while 문을 빠져나지 않고 while 문의 조건문으로 다시 돌아가게 하는 것이 continue 문이다.
a = 0
while a < 10 :
a += 1
if a % 2 == 0 :
continue
print(a)
- 1 ~ 10에서 홀수만 출력하는 코드
- a를 2로 나눈 나머지가 0이면 if 문을 수행
- if 문 수행 시 continue를 만나 while 문 조건문으로 이동
5) 무한 루프
무한히 반복한다.
(1) 기본 구조
while True :
수행할_문장1
수행할_문장2
- while 문의 조건문이 항상 True이므로 무한히 수행한다.
3. for 문
while 문과 비슷한 반복문
1) 기본 구조
for 변수 in 리스트(또는 튜플, 문자열) :
수행할_문장1
수행할_문장2
- 리스트, 튜플, 문자열의 첫 번째 요소부터 마지막 요소까지 차례로 변수에 대입
a = ['one', 'two', 'three']
for i in a :
print(i)
- a 리스트 안에 있는 one, two, three를 i에 하나씩 대입
scores= [90, 25, 67, 46, 80]
number = 0
for score in scores :
number += 1
if score >= 60 :
print(f"{number}번 합격")
else :
print(f"{number}번 불합격")
- 각각의 학생에게 번호를 주기 위해 number 변수를 사용
- scores에서 처음부터 차례대로 score 변수에 대입
- 만약 score가 60 이상이면 if 문 수행, 그게 아니면 else 문 수행
2) continue 문
while 문에서 사용한 continue 문을 for 문에서도 사용할 수 있다.
scores= [90, 25, 67, 46, 80]
number = 0
for score in scores :
number += 1
if score < 60 :
continue
print(f"{number}번 합격")
- 60점 이하인 학생인 경우 if 문 조건문이 참이 되어 continue 문이 수행
- 합격을 출력하지 않고 for 문 처음으로 돌아간다.
3) range
range(x)는 0부터 x 미만의 숫자를 포함하는 range 객체를 만들어 주는 함수
print(range(10))
print(range(1, 11))
- 출력 : range(0, 10) => 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
- 출력 : range(1, 11) => 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
- range(시작_숫자, 끝_숫자), 끝 숫자는 포함 하지 않는다.
for a in range(10):
print(a, end =" ")
print()
for b in range(1, 10):
print(b, end =" ")
print()
for c in range(1, 10, 2) :
print(c, end =" ")
print()
for d in range(9, 0, -1) :
print(c, end = " ")
print()
- 출력 : 0 1 2 3 4 5 6 7 8 9
- 출력 : 1 2 3 4 5 6 7 8 9
- 출력 : 1 3 5 7 9
- 출력 : 9 8 7 6 5 4 3 2 1
- range(1, 10, 2)는 1부터 10 미만의 숫자를 2의 간격으로 범위를 지정한다
scores = [ 10, 22, 30, 44, 50, 66 ]
# range(len(리스트변수)) 방법
for index in range(len(scores)):
print(f'{index+1}번째 학생의 점수는 {scores[index]}점입니다.')
# enumerate() 함수를 이용하는 방법 ⇒ (인덱스, 값) 형식의 튜플 리스트를 반환
scoresWithIndex = list(enumerate(scores))
for index, score in scoresWithIndex:
print(f'{index+1}번째 학생의 점수는 {score}점입니다.')
- len(scores)는 5, range(len(scores))는 range(5)가 된다.
- 따라서 index변수에 차례로 0부터 4까지 숫자가 대입된다.
- enumerate(리스트)는 리스트의 인덱스와 값을 튜플로 만들고 리스트에 넣어 반환
4) range를 이용한 구구단
for dan in range(2, 10):
print(f'{dan}단')
for no in range(1, 10):
print(f'{dan} x {no} = {dan*no:2}')
2단
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18
위와 같이 세로로 9단까지 출력된다.
for no in range(0, 10):
for dan in range(2, 10):
if no == 0:
print(f'{dan}단', end=' '*10)
else:
print(f'{dan} x {no} = {dan*no:2}', end=' '*3)
print()
2단 3단
2 x 1 = 2 3 x 1 = 3
2 x 2 = 4 3 x 2 = 6
2 x 3 = 6 3 x 3 = 9
2 x 4 = 8 3 x 4 = 12
2 x 5 = 10 3 x 5 = 15
2 x 6 = 12 3 x 6 = 18
2 x 7 = 14 3 x 7 = 21
2 x 8 = 16 3 x 8 = 24
2 x 9 = 18 3 x 9 = 27
위와 같이 가로로 9단까지 출력된다.
5) 리스트 컴프리헨션(List Comprehension)
좀 더 편리하고 직관적인 프로그램을 만들 수 있다.
[표현식 for 항목 in 반복_가능_객체 if 조건문]
- if 조건문은 생략 가능
[표현식 for 항목1 in 반복_가능_객체 if 조건문1
for 항목2 in 반복_가능_객체 if 조건문2
for 항목n in 반복_가능_객체 if 조건문n]
- for 문을 2개 이상 사용 가능
a = [1, 2, 3, 4]
result = []
for num in a:
resul.append(num*3)
print(result)
- 출력 : [3, 6, 9, 12]
- 일반적인 코드
a = [1, 2, 3, 4]
result = [num*3 for num in a]
print(result)
- 출력 : [3, 6, 9, 12]
- 위 일반적인 코드를 컴프리헨션으로 for 문 사용
a = [1, 2, 3, 4]
result = [num*3 for num in a if num%2 == 0]
print(result)
- 출력 : [6, 12]
- 컴프리헨션으로 for 문 if 문 사용
4. map, filter
1) map() 함수
map(f, iteralbe)은 함수(f)와 반복할 수 있는 데이터를 입력받아 각 요소에 함수 f를 적용한 결과를 리턴하는 함수
def two_times(numbers) :
result = []
for number in numbers :
result.append(number * 2)
return result
result = two_times([1, 2, 3, 4])
print(result)
- 출력 : [2, 4, 6, 8]
- two_times는 리스트 입력받아 리스트의 각 요소에 2를 곱해 려턴하는 함수
def two_times(x) :
return x * 2
print(list(map(two_times, [1, 2, 3, 4])))
- 출력 : [2, 4, 6, 8]
- map() 함수를 사용해 변경
리스트의 첫 번째 요소인 1이 two_times 함수의 입력값으로 들어가서 1 * 2 연산을 거쳐 2가 된다. 4개 요소가 똑같은 과정으로 수행 후 리턴한다.
2) filter() 함수
filter(함수, 반복_가능한_데이터)
반복할 수 있는 데이터의 요소 순서대로 함수를 호출했을 때 리턴값이 참인 것만 묶어서(걸러내서) 리턴한다.
def positive(l) :
result = []
for i in l:
if i > 0:
result.append(i)
return result
print(positive([1, -3, 2, 0, -5, 6]))
- 출력 : [1, 2, 6]
- positive는 리스트를 입력으로 받아 각각의 요소를 판별해서 양수 값만 리턴하는 함수
def positive(x) :
return x > 0
print(list(filter(positive, [1, -3, 2, 0, -5, 6])))
- 출력 : [1, 2, 6]
- filter(positive, [1, -3, 2, 0, -5, 6])는 리스트의 각 요솟값을 순서대로 positive 함수에 적용하여 리턴값이 참인 것만 묶어서 리턴
5. *args, **kwargs
1) *args
- 콤마로 구분한 여러 개의 인자를 튜플로 리턴
- 함수 정의 시, 알 수 없는 개수의 인자를 받을 때 사용
2) **kwargs
- 함수 정의 시, 키워드와 값 형태의 인자를 받을 때 사용
- 함수 내부에서 kwargs 변수를 사용하면, 들어온 인자들이 딕셔너리로 저장
3) 코드
def calcurator(operator, *operand):
if operator == "+":
result = 0
for i in operand:
result += i
return result
if operator == "*":
result = 1
for i in operand:
result *= i
return result
def calcurator2(**kwargs):
return calcurator(kwargs["operator"], *kwargs["operand"])
# *args
print(calcurator("*", 10, 20, 30))
print(calcurator("+", 10, 20, 30))
# **kwargs
print(calcurator2(operator="*", operand=(10, 20, 30)))
print(calcurator2(operator="+", operand=(10, 20, 30)))
- 출력 : 6000
- 출력 : 60
- 출력 : 6000
- 출력 : 60
6. 난수(random number)
random은 난수(규칙이 없는 임의의 수를 방생시키는 모듈
import random
print(random.random())
- 출력값은 0.0에서 1.0 사이의 실수 중에서 난수 값을 리턴
import random
r = int(random.random() * 100)
print(r)
- 0 < r < 100 정수
import random
print(random.randint(1, 10))
print(random.randint(1, 55))
- randint(x, y)는 x부터 y 사이의 정수 중에서 난수 각을 리턴
'SK Shieldus Rookies 19th > 인프라 활용을 위한 파이썬' 카테고리의 다른 글
| [SK shieldus Rookies 19기][Python] - 함수, 파일 (1) | 2024.03.17 |
|---|---|
| [SK shieldus Rookies 19기][Python] - 실습 1 (2) | 2024.03.17 |
| [SK shieldus Rookies 19기][Python] - 자료형 4 (0) | 2024.03.14 |
| [SK shieldus Rookies 19기][Python] - 자료형 3 (1) | 2024.03.13 |
| [SK shieldus Rookies 19기][Python] - 자료형 2 (0) | 2024.03.11 |
댓글