파일명 : day03.txt
학습 목표 :
파이썬에서 제공하는 연산자의 종류를 파악할 수 있다.
연산자의 종류
1. 산술 연산자 (Arithmetic operators)
2. 대입 연산자 (Assignment operators)
3. 관계 연산자 (Relational operators)
4. 논리 연산자 (Logical operators)
5. 비트 연산자 (Bitwise operators)
6. 구성원 연산자 (Membership Operators)
7. 식별 연산자 (Identity Operators)
파이썬에서 수식(식)은 연산자와 피연산자로 이루어져 있다.
2 + 3 이라는 수식에서 2와 3은 피연산자(연산의 대상)에 해당되며, + 는 연산자(무엇을 연산할 것이지 나타내는 부분)에 해당한다.
연산자(operator) : 프로그램을 짤 때 변수나 값의 연산을 위해 사용되는 부호를 말한다.
피연산자(operand) : 피연산(operation)의 대상이 되는 데이터를 말한다.
a + b라는 연산에서 +는 연산자에 해당되고 a와 b는 피연산자에 해당된다.
##########################################
## 1. 산술 연산자 (Arithmetic Operators)
##########################################
수학 연산을 사용하기 위한 연산자
결과는 연산된 결과값
형식 :
a 산술연산자 b
a,b = 2,8 이라고 할 때
연산자 사용 예 의미 설명
+ a + b 더하기 (Addition)
- a - b 빼기 (Subtraction)
* a * b 곱하기 (Multiplication)
/ a / b 나누기 (몫) (Division) python 3.x 부터는 소수점으로 결과가 나온다.
% a % b 나머지 (Modulus)
// a // b 나누기 (몫, 소수점 제거) (Floor division)
** a ** b 거듭 제곱 (Exponentiation)
산술 연산자 우선 순위
1. **
2. *, /, //, %
3. +, -
우선 순위를 변경하기 위해서는 ( ) 괄호를 넣어준다.
(20 + 3) + 12 + 2 ** 3 / 4 * 3
-- exArithmetic1.py --
"""
파일명: exArithmetic1.py
프로그램 설명: 산술 연산자 예제 1
작성자: 리눅스마스터넷
"""
# a = 2, b = 8 이라고 할 때
a, b = 2, 8
# 연산의 결과를 일시적으로 사용하는 방법
# 연산 결과를 바로 적용한다.
print(a + b) # 10
print(a - b) # -6
print(a * b) # 16
print(b / a) # 4.0 몫
print(b % a) # 0 나머지
print(b // a) # 4 몫(소수점 제거)
print(a ** 3) # 거듭 제곱
# 연산의 결과를 영구적으로 저장하는 방법
# 연산 결과를 변수에 저장한다.
# 산술 연산자(+)가 대입 연산자(=)보다 우선 순위가 높다.
hap = 2 + 20
print(max(hap, 10, 3*2)) # 22
# 산술 연산자 우선 순위
# 1. **
# 2. *, /, //, %
# 3. +, -
# 우선 순위를 먼저 지정할 경우에는 ( ) 괄호를 넣어준다.
print(3 + 5 * 3) # 18
print((3 + 5) * 3) # 24
print((20 + 3) + 12 + 2 ** 3 / 4 * 3) # 41.0
-- exArithmetic1.py --
-- exArithmetic2.py --
"""
파일명 : exArithmetic2.py
프로그램 설명 : 산술 연산자 예제 2
작성자: 리눅스마스터넷
"""
# 산술 연산자 우선 순위
# 1. ()
# 2. **
# 3. *, /, //, %
# 4. +, -
# 아래 수식에서 연산의 결과의 값은 무엇인가 ?
# (10 + 5) + 12 + 4 ** 3 / 4 * 2
# ~~~~~~~~
# 15 + 12 + 4 ** 3 / 4 * 2
# ~~~~~~
# 15 + 12 + 64 / 4 * 2
# ~~~~~~
# 16.0
# 15 + 12 + 16.0 * 2
# ~~~~~~
# 32.0
# 15 + 12 + 32.0
# ~~~~~~~
# 27 + 32.0
# ~~~~~~~~
# 59.0
result = (10 + 5) + 12 + 4 ** 3 / 4 * 2
print(result) # 59.0
-- exArithmetic2.py --
#########################################
## 2. 대입 연산자 (Assignment Operator)
#########################################
변수에 값을 저장(대입)하기 위해서 사용하는 연산자
결과는 변수에 값을 저장한다.
형식 :
a는 변수가 오고 b는 변수, 수식, 함수를 사용한다.
a 대입연산자 b --> a = 1 (값 1을 변수 a에 저장)
대입 연산자의 종류
= : 순수한 대입 연산자
+=, -=, *=, /=, %=, **= , //= : 복합 대입 연산자(대입 연산자 + 산술 연산자)
a, b = 2, 8
연산자 사용 예 의미
= a = b 우변의 값을 좌변에 대입
+= a += b 좌변에 우변 값을 더한 결과를 대입 (a = a + b 동일)
-= a -= b 좌변에 우변 값을 뺀 결과를 대입 (a = a - b 동일)
*= a *= b 좌변에 우변 값을 곱한 결과를 대입 (a = a * b 동일)
/= a /= b 좌변에 우변 값을 나눈 결과를 대입 (a = a / b 동일)
%= a %= b 좌변에 우변 값을 나눈 나머지를 대입 (a = a % b 동일)
**= a **= b 좌변에 우변 값만큼 제곱하고 결과를 대입 (a = a ** b 동일)
//= a //= b 좌변에 우변 값을 나눈 결과를 대입 (a = a // b 동일)
-- exAssignment1.py --
"""
파일명 : exAssignment1.py
프로그램 설명 : 대입 연산자 예제 1
작성자: 리눅스마스터넷
"""
a = 2
b = 8
# 변수 a에 저장된 값을 1증가
# 형식 : 변수명 += 1
print(a) # 2
a += 1 # a = a + 1
print(a) # 3
# 변수 b에 저장된 값을 1감소
# 형식 : 변수명 -= 1
print(b) # 8
b -= 1 # b = b - 1
print(b) # 7
a **= b # a = a ** b
print(a, b) # 2187 7
-- exAssignment1.py --
########################################################
## 3. 관계 연산자 (비교 연산자) (Relational Operators)
########################################################
두 값을 비교하기 위한 연산자
관계 연산자는 좌변과 우변의 값을 비교해서 크기 관계를 평가하며,
그 결과를 참(True)과 거짓(False)으로 나타낸다.
형식 :
a는 변수, 값, 함수가 오고 b는 변수, 값, 함수를 사용한다.
a 관계연산자 b --> 결과는 True/False
C++, Java : true, false
Python : True, False
True : 참
False : 거짓
a,b = 2,8 이라고 할 때
연산자 사용 예 의미 설명
== a == b 같다 (동등) (Equal)
!= a != b 같지 않다 (Not equal)
> a > b 크다 (초과) (Greater than)
< a < b 작다 (미만) (Less than)
>= a >= b 크거나 같다 (이상) (Greater than or equal to)
<= a <= b 작거나 같다 (이하) (Less than or equal to)
-- exRelational1.py --
"""
파일명 : exRelational1.py
프로그램 설명 : 관계 연산자 예제 1
작성자: 리눅스마스터넷
"""
# 관계 연산자 (비교 연산자) (Relational operator)
# 두 값을 비교하기 위한 연산자
a , b = 2, 8
print(a, b) # 2 8
print(a == b) # False
print(a != b) # True
print(a > b) # False
print(a < b) # True
print(a >= b) # False
print(a <= b) # True
-- exRelational1.py --
#######################################
## 4. 논리 연산자 (Logical Operators)
#######################################
두 개 이상의 관계 연산자를 묶을 때 사용하는 연산자
형식 : 조건1 논리연산자 조건2 --> 결과는 True/False
조건1 : 관계 연산자 (1 == 1 and 2 == 2) 1 == 1
조건2 : 관계 연산자 (1 == 1 and 2 == 2) 2 == 2
*** 참고 (쇼컷) ***
논리곱은 조건1의 연산 결과가 거짓이면 조건2를 평가하지 않는다.
논리합은 조건1의 연산 결과가 참이면 조건2를 평가하지 않는다.
논리 연산자 : and, or, not
논리 연산자의 우선 순위
1. not (참고: C,Java 언어에서는 !를 사용한다.)
2. and (참고: C,Java 언어에서는 &&를 사용한다.)
3. or (참고: C,Java 언어에서는 ||를 사용한다.)
연산자 사용 예 의미
and a and b a와 b를 and 연산
or a or b a와 b를 or 연산
not not a a의 논리 부정 연산
논리곱(and) : 두 조건이 모두 참이면 참
논리곱 진리표
a b a and b
False False False
False True False
True False False
True True True
논리합(or) : 두 조건 중 하나만 참이면 참
논리합 진리표
a b a or b
False False False
False True True
True False True
True True True
논리부정(not) : 피연산자의 값이 참이면 거짓, 거짓이면 참으로 바꾼다.
논리부정(not)은 True->False, False->True 로 뒤바꾼다.
참고: 다른 언어에서는 !를 사용하지만 파이썬에서는 not을 사용한다.
논리부정 진리표
a not a
True False
False True
ex) 사용 예
a, b, c = 2, 8, 10
a == 2 and b < 8
a == b and b == c
a == b or b == c
not a
-- exLogical1.py --
"""
파일명 : exLogical1.py
프로그램 설명 : 논리 연산자 예제 1
작성자: 리눅스마스터넷
"""
# 논리합 테스트
print(False or False) # False
print(False or True) # True
print(True or False) # True
print(True or True) # True
# 논리곱 테스트
print(False and False) # False
print(False and True) # False
print(True and False) # False
print(True and True) # True
# 논리 부정 테스트
print(not False) # True
print(not True) # False
-- exLogical1.py --
-- exLogical2.py --
"""
파일명 : exLogical2.py
프로그램 설명 : 논리 연산자 예제 2
작성자: 리눅스마스터넷
"""
a = 1
b = 3
c = 5
print(a > 2 or c > b) # True
print(b == 3 and c > 3) # True
print(a != 2 and c == 3 or a == 2) # False
print(a == c or c == 3 and a > 2) # False
print(a != 2 and c == 3 or a == 1) # True
print(a == 1 or c == 3 and a > 2) # True
a = -4
b = -2
c = -9
if a > 2 or c > b and c > 2:
print("참1") # 출력 X
else:
print("거짓1") # 출력 O
if a < 2 or c > b and c > 2:
print("참2") # 출력 O
else:
print("거짓2") # 출력 X
# if a > 2 or c > b and c > 2:
# ~~~~~ ~~~~~ ~~~~~
# F and F
# ~~~~~~~~~~~~~~~~
# F or F
# ~~~~~~~~~~~~~~~~~
# F
# if a < 2 or c > b and c > 2:
# ~~~~~ ~~~~~ ~~~~~
# F and F
# ~~~~~~~~~~~~~~~~
# T or F
# ~~~~~~~~~~~~~~~~~
# T
-- exLogical2.py --
-- exLogical3.py --
"""
파일명 : exLogical3.py
프로그램 설명 : 논리 연산자 예제 3
작성자: 리눅스마스터넷
"""
# 나이 : age
# 9세 이상 ~ 12세 이하
age = 13 # 8:F , 9 ~ 12:T, 13 ~ : F
print(age >= 9 and age <= 12)
# 8세 미만, 11세 초과
age = 13 # True
age = 11 # False
age = 7 # True
age = 8 # False
print(age < 8 or age > 11)
# 아래처럼 and 로 묶으면 안된다.
# 2개의 나이를 동시에 가지는 사람은 없기 때문이다.
# print(age < 8 and age > 11) X
# 8세, 10세, 12세인 경우
# age = 7 # False
# age = 8 # True
age = 10 # True
# age = 12 # True
# age = 13 # False
print(age == 8 or age == 10 or age == 12)
# 6세 이상 ~ 8세 이하, 10세 이상 ~ 12세 이하
age = 5 # False
age = 6 # True
age = 7 # True
age = 8 # True
age = 9 # False
age = 10 # True
age = 12 # True
age = 13 # False
print(age >= 6 and age <= 8 or age >= 10 and age <= 12)
# 아래처럼 and 로 묶으면 안된다.
# print(age >= 6 and age <= 8 and age >= 10 and age <= 12)
-- exLogical3.py --
#######################################
## 5. 비트연산자 (Bitwise Operators)
#######################################
컴퓨터의 최소 단위인 비트를 다루는 연산자
결과는 연산된 결과값
참고 : https://www.binaryconvert.com/
계산기 -> 프로그래머로 확인이 가능하다.
128 64 32 16 8 4 2 1
a = 7, b = 3 일 경우 2진수 표현하면
a = 00000111
b = 00000011
연산자 사용 예 의미
& a & b 비트 AND 연산. 둘다 참일때만 만족
| a | b 비트 OR 연산. 둘 중 하나만 참이여도 만족
^ a ^ b 비트 XOR 연산. 둘 중 하나만 참일 때 만족
~ a ~ b 비트 NOT 연산, 보수 연산.
<< a << b 왼쪽 시프트 연산자. 변수의 값을 왼쪽으로 지정된 비트 수 만큼 이동
>> a >> b 오른쪽 시프트 연산자. 변수의 값을 오른쪽으로 지정된 비트 수 만큼 이동
a & b : 3
a = 00000111
b = & 00000011
----------
00000011
a | b : 7
a = 00000111
b = | 00000011
----------
00000111
a ^ b : 4
a = 00000111
b = ^ 00000011
----------
00000100
~a : -8
a = 00000111
~a :11111000
1 : 00000001
~1 : 11111110 10000001(x)
1 : 00000001
1의 보수 : 11111110
2의 보수 : 11111111
-1 : 11111111
-2 : 11111110
-3 : 11111101
-4 : 11111100
1일 경우 왼쪽 쉬프트 연산을 한 경우
128 64 32 16 8 4 2 1
1 << 1
00000001 << 1 => 00000010
00000001 << 2 => 00000100
00000001 << 3 => 00001000
128 64 32 16 8 4 2 1
64일 경우 오른쪽 쉬프트 연산을 한 경우
64 : 01000000 >> 1 => 00100000
64 : 01000000 >> 2 => 00010000
a << 1 : 14
a = 7
a = 00000111
a << 1 00001110
a << 2 : 28
a = 00000111
a << 2 00011100
a >> 1 : 3
a = 00000111
a >> 1 00000011
a >> 2 : 1
a = 00000111
a >> 2 00000001
-- exBitwise1.py --
"""
파일명 : exBitwise1.py
프로그램 설명 : 비트 연산자 예제 1
작성자: 리눅스마스터넷
"""
# 128 64 32 16 8 4 2 1
# a = 00000111
# b = 00000011
a = 7
b = 3
print(bin(a)) # 0b111
print(bin(b)) # 0b11
# 8bit로 표현
# 00000111
# 00000011
print("{0:b}".format(a).zfill(8)) # 00000111
print("{0:b}".format(b).zfill(8)) # 00000011
# 32bit로 표현
# 00000000000000000000000000000111
# 00000000000000000000000000000011
print("{0:b}".format(a).zfill(32)) # 00000111
print("{0:b}".format(b).zfill(32)) # 00000011
# 64bit로 표현
# 0000000000000000000000000000000000000000000000000000000000000111
# 0000000000000000000000000000000000000000000000000000000000000011
print("{0:b}".format(a).zfill(64)) # 00000111
print("{0:b}".format(b).zfill(64)) # 00000011
-- exBitwise1.py --
############################################
## 6. 멤버쉽 연산자 (Membership Operators)
############################################
구성원의 존재 유무를 확인하는 연산자
값이 있는지 없는지 판단할 때 사용한다.
연산의 결과 : True, False
종류 : in, not in
in : 값이 존재하면 True, 존재하지 않으면 False
not in : 값이 존재하지 않으면 True , 존재하면 False
형식 :
a in b <-- 반드시 b는 반복할 수 있는 iterable 이 와야 한다. (문자열,리스트,튜플,딕셔너리,셋)
a not in b
-- exMembership1.py --
"""
파일명: exMembership1.py
프로그램 설명: 멤버쉽 연산자 예제 1
작성자: 리눅스마스터넷
"""
# number에 1 ~ 10까지 저장한다.
number = [1,2,3,4,5,6,7,8,9,10]
# 반복 가능한지 확인한다.
# print(iter(3)) # TypeError: 'int' object is not iterable
print(iter([]), iter(()), iter({}), iter(set()))
# number 변수에 5가 존재합니까 ?
print(5 in number) # True
# number 변수에 13이 존재합니까 ?
print(13 in number) # False
# number 변수에 20이 존재하지 않습니까 ?
print(20 not in number) # True
# number 변수에 7이 존재하지 않습니까 ?
print(7 not in number) # False
# number 변수에 13이 존재하지 않습니까 ?
print(13 not in number) # True
# 실제 코드는 아래처럼 if문을 이용해서 멤버쉽 연산자를 사용한다.
if 5 in number:
print('number 변수에 5가 존재합니다.')
else:
print('number 변수에 5가 존재하지 않습니다.')
a = input('입력 : ')
a = int(a)
a == 1 or a == 2 or a == 3
a in (1,2,3) # 파이써닉한 코드 (좀 더 파이썬 다운 코드다.)
-- exMembership1.py --
########################################
## 7. 식별 연산자 (Identity Operators)
########################################
두 변수가 동일한 객체인지 확인하는 연산자
연산 결과 -> True, False
파이썬에만 존재하는 특별한 연산자다.
종류 : is, not is
is : 두 객체가 같으면 True, 다르면 False
is not : 두 객체가 같지 않으면 True, 같으면 False
형식 :
a is b
a is not b
-- exIdentity1.py --
"""
파일명 : exIdentity1.py
프로그램 설명 : 식별 연산자 예제 1
작성자: 리눅스마스터넷
"""
# 파이썬에서는 모든 변수는 객체로 만든다.
# id() 함수 : 변수의 메모리를 확인할 때 사용한다.
a1 = 7
a2 = 7
a3 = 8
print(a1, a2, a3) # 7 7 8
print("a1 :", id(a1)) # 2693008157168
print("a2 :", id(a2)) # 2693008157168
print("a3 :", id(a3)) # 2226968750608
print(a1 is a2) # True 동일한 객체이므로
print(a1 is a3) # False 동일한 객체가 아니므로
b1 = 7
b2 = 20
b3 = 20
print("b1 :", id(b1)) # 2693008157168
print("b2 :", id(b2)) # 2210206804880
print("b3 :", id(b3)) # 2210206804880
print(a1 is b1) # True 동일한 객체이므로
print(b1 is b2) # False 동일한 객체가 아니므로
print(b2 is b3) # True 동일한 객체이므로
# is not
print(a1 is not b3) # True 동일한 객체가 아니므로
print(b2 is not b3) # False 동일한 객체 이므로
-- exIdentity1.py --
파일명 : day04.txt
학습 목표 :
파이썬 프로그래밍에서 사용되는 제어문의 종류를 파악할 수 있다.
###########
## 제어문
###########
제어문이란 프로그램의 실행 흐름을 제어할 때 사용하는 문장이다.
종류 : if, while, for, break, continue
##########
## 조건문
##########
조건문이란 실행문을 조건을 판단해서 실행하는 제어문으로 if문이 여기에 해당된다.
##########
## if 문
##########
if문은 조건문으로 프로그램의 흐름을 제어할 때 사용하는 제어문이다.
예를 들어서
우산을 챙긴다.
구두를 신는다.
외출한다.
if 밖에 비가오는가 ?:
우산을 챙긴다.
구두를 신는다.
else:
운동화를 신는다.
외출한다.
if문은 4가지 종류가 있다.
단일 if문, if~else문, 다중if문, 중첩if문
단일 if문 형식 :
if 조건식 : <-- 조건식은 참(True)과 거짓(False)을 판단할 수 있어야 한다.
실행문 <-- 조건식이 참이면 실행문이 실행된다.
:
if ~ else 문 :
if 조건식 :
실행문1 <-- 조건식이 참이면 실행문1이 실행된다.
:
else:
실행문2 <-- 조건식이 거짓이면 실행문2가 실행된다.
:
다중 if문 형식 :
if 조건식1 :
실행문1 <-- 조건식1이 참이면 실행문1이 실행된다.
:
elif 조건식2: <-- 조건식1이 거짓이면 조건식2를 실행한다.
실행문2 <-- 조건식2가 참이면 실행문2가 실행된다.
:
elif 조건식3: <-- 조건식2가 거짓이면 조건식3을 실행한다.
실행문3 <-- 조건식3이 참이면 실행문3이 실행된다.
:
elif 조건식4: <-- 조건식3이 거짓이면 조건식4를 실행한다.
실행문4 <-- 조건식4가 참이면 실행문4가 실행된다.
:
else: <-- 조건식4가 거짓이면 이 부분이 실행한다. (생략 가능)
실행문5 <-- 조건식4가 기짓이면 실행문5가 실행된다.
:
중첩 if문
if 조건식 :
실행문 <-- 조건식이 참이면 실행문이 실행된다.
:
if 조건식 :
실행문
:
자료형의 참과 거짓의 판단 기준
True False
숫자 1(0이 아닌 숫자) 0
문자열 "test" "" <-- 값이 있으면 참, 없으면 거짓
리스트 [1,2,3] [] <-- 값이 있으면 참, 없으면 거짓
튜플 (1,2,3) () <-- 값이 있으면 참, 없으면 거짓
딕셔너리 {"a" : "b"} {} <-- 값이 있으면 참, 없으면 거짓
불리언 True False
if dictData :
:
if listData :
:
관계 연산자(비교 연산자)의 판단 기준
x = 3
y = 2
x > y x가 y보다 크다
x < y x가 y보다 작다
x >= y x가 y보다 크거나 같다
x <= y x가 y보다 작거나 같다
x == y x와 y가 같다
x != y x와 y가 같지 않다
if x > y :
:
if x == y :
:
논리 연산자의 판단 기준
x = 3
y = 2
a : x == 3
b : y != 2
a or b a와 b 둘 중에 하나만 참이면 참
a and b a와 b둘 다 참이어야 참
not a a가 거짓이면 참
if x != y and x >= 3:
:
if not x:
:
멤버쉽 연산자
a = [1,2,3,4,5]
if 1 in a :
:
식별연산자
if a is b :
:
X
if a = 1:
:
-- exIf1.py --
"""
파일명: exIf1.py
프로그램 설명: 단일 if문
"""
# 단일 if문
# 참일 때만 실행하는 구조이다.
# 거짓일 때는 실행하는 부분이 없다.
a = 2
b = 8
# 관계 연산자
if a == 2:
print("이 부분이 실행됩니다.")
if not a > 10:
print("a는 10보다 큽니다.")
if a :
print('참이므로 실행합니다.')
# 논리 연산자
# 참고사항
# 논리곱은 앞의 연산 결과가 거짓이면 뒤를 안본다.
# 논리합은 앞의 연산 결과가 참이면 뒤를 안본다.
if a == 2 and b == 8 :
print('a는 2이고 b는 8입니다.')
-- exIf1.py --
-- exIf2.py --
"""
파일명: exIf2.py
프로그램 설명: 단일 if문
"""
listData = [] # 빈리스트
print(listData)
if listData: # listData 변수에 값이 있는가?
print('참') # 값이 없으므로 실행되지 않는다.
# 객체에 저장된 메소드(함수)를 실행하는 형식:
# 객체.메소드(), 객체.메서드(), 객체.메쏘드() object.method()
listData.append(1) # listData 변수에 1을 추가한다.
print(listData)
if listData: # listData 변수에 값이 있는가?
print('참') # 값이 있으므로 실행된다.
-- exIf2.py --
-- exIfElse1.py --
"""
파일명: exIfElse1.py
프로그램 설명: if~else문
"""
a = 2
b = 8
if a == 2: # True
# if a != 2: # False
print('a는 2와 같습니다.')
else:
print('a는 2와 같지 않습니다.')
print('프로그램 종료')
# 사용자에게 자연수 1개를 입력 받아서 홀수/짝수인지 판별하는 프로그램
# 입력한 값은 변수 number에 저장한다.
# 사용자가 입력한 변수를 체크한다.
# 숫자를 입력하면 # if ~ else 문이나 조건 표현식(삼항연산자)으로
# 숫자 형태로 되어 있는 문자열을 정수로 변경한다.
# 만약 숫자가 아니면 1을 저장한다.
# 입력한 값을 판단해서
# 짝수면 "짝수"를 화면에 출력하고 홀수면 "홀수"를 화면에 출력한다.
number = input('자연수 입력 : ')
if number.isdigit(): # 숫자 형태로 들어왔는가?
number = int(number) # 문자열을 정수로 변환해서 number에 저장한다.
else:
number = 1
if number%2 == 0: # 짝수
print('짝수')
else: # 홀수
print('홀수')
# if ~ else문을 삼항 연산자(조건 표현식)으로 줄이는 방법
# 1. if ~ else문을 한줄로 이어쓴다.
# 2. 콜론 : 을 제거한다.
# 3. 참일 때 실행할 실행문을 if문 왼쪽으로 이동시킨다.
print('짝수') if number%2 == 0 else print('홀수')
print('짝수' if number%2 == 0 else '홀수')
-- exIfElse1.py --
-- exIfElse2.py --
"""
파일명: exIfElse2.py
프로그램 설명: if~else문을 로그인 프로그램
사용자명을 userid 변수에 저장한다.
비밀번호를 userpw 변수에 저장한다.
사용자에게 사용자명을 입력 받아서 inputUserid 변수에 저장한다.
사용자에게 비밀번호를 입력 받아서 inputUserpw 변수에 저장한다.
입력 받은 사용자 아이디와 userid 를 비교한다.
입력 받은 사용자 비밀번호와 userpw 를 비교한다.
두 값이 맞으면 로그인 환영 메세지를 출력 시키고 프로그램 실행으로 이동한다.
두 값이 틀리면 로그인 실패 메세지를 출력 시키고 프로그램을 종료한다.
"""
userid = 'pythonuser'
userpw = '123456'
print('>>> 로그인 <<<')
inputUserid = input('사용자: ')
inputUserpw = input('비밀번호: ')
if userid == inputUserid and userpw == inputUserpw:
print('로그인 성공!')
print(f'{userid}님 환영합니다.')
else:
print('로그인 실패!')
exit()
print('로그인 후 실행되는 코드가 온다.')
-- exIfElse2.py --
-- exIfElif1.py --
"""
파일명: exIfElif1.py
프로그램 설명: 다중 if문
"""
number = 5
if number == 1:
print('number는 1입니다.')
elif number == 2:
print('number는 2입니다.')
elif number == 3:
print('number는 3입니다.')
elif number == 4:
print('number는 4입니다.')
elif number == 5:
print('number는 5입니다.')
else:
print('number는 1 ~ 5가 아닙니다.')
-- exIfElif1.py --
실습> 다중 if문을 이용하여 성적처리 프로그램을 작성하시오.
파일명: exIfElif2.py
국어, 영어, 수학 점수를 입력받아서 총점, 평균, 학점을 구해서 출력한다.
다중if문을 이용하여 구현한다.
# A학점 : 90 ~ 100 , grade = 'A'
# B학점 : 80 ~ 89.9 , grade = 'B'
# C학점 : 70 ~ 79.9 , grade = 'C'
# D학점 : 60 ~ 69.9 , grade = 'D'
# F학점 : 0 ~ 59.9 , grade = 'F'
# 모범답안은 day04실습문제.txt 파일을 참고한다.
###########
## 반복문
###########
반복문이란 실행문을 여러 번 반복해서 실행하는 제어문으로 while문과 for문이 여기에 해당된다.
###########
## while문
###########
while문은 실행문을 반복할 때 사용하는 제어문이다.
형식:
while 조건식:
실행문 <-- 조건식이 참일 때 실행할 실행문
:
else: <-- else는 생략 가능
실행문 <-- 조건식 거짓일 때 실행할 실행문
:
-- exWhile1.py --
"""
파일명: exWhile1.py
프로그램 설명: while문
"""
# 반복문을 사용하지 않고 1 ~ 5까지 출력
# i = 1
# print(i) # 1
# i += 1 # 1증가
# print(i) # 2
# i += 1 # 1증가
# print(i) # 3
# i += 1 # 1증가
# print(i) # 4
# i += 1 # 1증가
# print(i) # 5
# i를 증가하면서 반복하는 형태
# 1 ~ 5까지 출력하는 코드
# 1 ~ 5까지 관계연산자로 표현하면 ?
# i = 1
# i <= 5, i < 6, 5 >= i, 6 > i
# 반복문을 사용하고 1 ~ 5까지 출력
# 초기값 -> 조건식 -> 실행문 -> 증감식
i = 1 # 초기값
while i <= 5: # 조건식
print(i) # 실행문 1 2 3 4 5
i += 1 # 증감식 1증가
else:
print('while문 종료')
-- exWhile1.py --
-- exWhile2.py --
"""
파일명: exWhile2.py
프로그램 설명: while문을 이용한 로그인 프로그램
"""
userid = 'pythonuser'
userpw = '123456'
print('>>> 로그인 <<<')
# 초기값 -> 조건식 -> 실행문 -> 증감식
i, count = 1, 3 # 초기값
while i <= count: # 조건식
# 실행문
inputUserid = input('사용자: ')
inputUserpw = input('비밀번호: ')
print()
if userid == inputUserid and userpw == inputUserpw:
print('로그인 성공!')
print(f'{userid}님 환영합니다.')
break
else:
print('로그인 실패!')
i += 1 # 증감식
else:
print('프로그램 종료')
exit()
print('로그인 후 실행되는 코드가 온다.')
-- exWhile2.py --
break문
반복문 안에서 실행문을 실행하는 도중에 break문을 만나면 반복문을 탈출(종료)한다.
break문은 반복문 밖에서는 단독으로 사용할 수 없다.
break문을 만나면 while문의 else와 for문의 else는 실행되지 않는다.
이유는 while문 안쪽으로 들어왔다는 얘기는 else쪽과 무관하기 때문이다.
반복문 안에서 단독으로 사용할 수 있지만 주로 if문과 함께 사용한다.
-- exBreak.py --
"""
파일명: exBreak.py
프로그램 설명: break문
"""
# break SyntaxError: 'break' outside loop
i = 1 # 초기값
while i <= 5: # 조건식
print(i) # 실행문
i += 1 # 증감식
if i == 3:
break
print('프로그램 종료')
-- exBreak.py --
continue문
반복문 안에서 실행문을 실행하는 도중에 continue 문을 만나면 반복문의 조건식으로 이동한다.
continue문은 반복문 밖에서는 단독으로 사용할 수 없다.
반복문 안에서 단독으로 사용할 수 있지만 주로 if문과 함께 사용한다.
-- exContinue1.py --
"""
파일명: exContinue1.py
프로그램 설명: continue문
"""
# continue # SyntaxError: 'continue' not properly in loop
i = 1
while i <= 10:
if i % 2 == 0:
i += 1
continue
print(i) # 1 3 5 7 9
i += 1
print('프로그램 종료')
-- exContinue1.py --
실습> 구구단 2단을 while문으로 구현하기
파일명: exGugudan1.py
while문을 이용해서 구구단 2단 출력을 구현한다.
실행 결과:
2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18
-- exGugudan1.py --
"""
파일명: exGugudan1.py
프로그램 설명: while문을 이용한 구구단 출력하기
"""
# 모범답안은 day04실습문제.txt 파일을 참고한다.
-- exGugudan1.py --
이중 while문(중첩 while문)
while문 안쪽에 또다른 while문이 들어있는 형태이다.
형식 :
while 조건식 :
실행문1
:
while 조건식 :
실행문2
:
else:
실행문3
:
실행문4
:
else:
실행문
-- exWhileWhile.py --
"""
파일명: exWhileWhile.py
프로그램 설명: 중첩 while문(이중 while문)
"""
# 첫 번째 while문 : 1 ~ 5까지 출력하는 코드
i = 1 # 초기값
while i <= 5: # 조건식 i < 6, 5 >= i, 6 > i
print(i) # 실행문
i += 1 # 증감식
# 두 번째 while문 : 6 ~ 10까지 출력하는 코드
j = 6 # 초기값
while j <= 10: # 조건식 j < 11, 10 >= j, 11 > j
print(j) # 실행문
j += 1 # 증감식
# 중첩 while문은 바깥쪽을 반복하고 안쪽을 반복한다.
# 첫 번째 while문 : 1 ~ 5까지 출력하는 코드
i = 1 # 초기값
while i <= 5: # 조건식 i < 6, 5 >= i, 6 > i
# 두 번째 while문 : 6 ~ 10까지 출력하는 코드
j = 6 # 초기값
while j <= 10: # 조건식 j < 11, 10 >= j, 11 > j
print(i, j) # 실행문
j += 1 # 증감식
i += 1 # 증감식
-- exWhileWhile.py --
실습> 구구단 2단 ~ 9단까지 중첩 while문으로 구현하기
파일명: exGugudan2.py
중첩 while문을 이용해서 구구단 2단 ~ 9단까지 출력을 구현한다.
실행 결과:
# 2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18
# 3x1=3 3x2=6 3x3=9 3x4=12 3x5=15 3x6=18 3x7=21 3x8=24 3x9=27
# 4x1=4 4x2=8 4x3=12 4x4=16 4x5=20 4x6=24 4x7=28 4x8=32 4x9=36
# 5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 5x6=30 5x7=35 5x8=40 5x9=45
# 6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 6x7=42 6x8=48 6x9=54
# 7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 7x8=56 7x9=63
# 8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 8x9=72
# 9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
-- exGugudan2.py --
"""
파일명: exGugudan2.py
프로그램 설명: while문을 이용한 구구단 출력하기
"""
# 모범답안은 day04실습문제.txt 파일을 참고한다.
-- exGugudan2.py --
-- exWordGame.py --
"""
파일명 : exWordGame.py
프로그램 설명 : while문을 이용한 단어 맞추기 게임
"""
wordList = ('school', 'python', 'programming')
wordCount = len(wordList) # 3
i = 0 # while 반복 변수
j = 0 # 맞춘 단어 변수
print(">>> 단어 맞추기 게임 <<<")
while i < wordCount:
print(wordList[i]) # 단어 출력
inputWord = input() # 단어 입력
if inputWord == wordList[i]:
print('단어를 맞췄습니다!!!')
j += 1
else:
print('실패!!!')
i += 1
print(f'전체 단어수 : {wordCount}, 맞춘 단어수 : {j}')
-- exWordGame.py --
##########
## for문
##########
for문
while문과 동일하게 프로그램의 실행문을 반복할 때 사용하는 제어문이다.
형식 :
for 변수 in 리스트( or 튜플, 딕셔너리, 셋, 문자열, 함수):
실행문1
실행문2
:
for 변수 in 리스트( or 튜플, 딕셔너리, 셋, 문자열, 함수):
실행문1
실행문2
:
else: <-- 생략 가능하다.
실행문3
:
range()
https://docs.python.org/ko/3/tutorial/index.html
https://docs.python.org/ko/3/tutorial/controlflow.html#the-range-function
range() 함수(클래스)를 이용한 숫자 증가하기
형식 :
range(숫자) : 숫자가 1개가 인수로 올 경우
range(시작숫자,끝숫자) : 숫자가 2개가 인수로 올 경우
range(시작숫자,끝숫자,증가할개수) : 숫자가 3개가 인수로 올 경우
range(시작숫자,끝숫자,감소할개수) : 숫자가 3개가 인수로 올 경우
range() 함수는 0부터 시작한다. 끝숫자는 포함이 안된다.
range(3) : 0,1,2
range(5) : 0,1,2,3,4
range(1,11) : 1,2,3,4,5,6,7,8,9,10
range(5,11) : 5,6,7,8,9,10
range(1,6) : 1,2,3,4,5
range(1,6,1) : 1,2,3,4,5
range(1,11,2) : 1,3,5,7,9
range(5,0,-1) : 5,4,3,2,1
range(10,0,-2) : 10, 8, 6, 4, 2
list(range(1,3001)) : [1, ... 3000]
-- exFor1.py --
"""
파일명 : exFor1.py
프로그램 설명 : for문
"""
# 1 ~ 5까지 출력하기
# for i in [1,2,3,4,5]: # 리스트를 이용한 for문
# for i in (1,2,3,4,5): # 튜플을 이용한 for문
# for i in "12345": # 문자열을 이용한 for문
# for i in range(1,6): # range()함수를 이용한 for문
# for i in myFunction(): # 함수를 이용한 for문
# for i in {1,2,3,4,5}: # set을 이용한 for문
# print(i)
dictData = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
for i in dictData: # 딕셔너리를 이용한 for문
print(dictData[i])
# for문 옆에 올 수 있는 iterator object 살펴보기
def myFunction():
return (1,2,3,4,5)
# 1 ~ 5까지 출력하기
# for i in [1,2,3,4,5]: # 리스트를 이용한 for문
# for i in (1,2,3,4,5): # 튜플을 이용한 for문
# for i in "12345": # 문자열을 이용한 for문
# for i in range(1,6): # range()함수를 이용한 for문
# for i in myFunction(): # 함수를 이용한 for문
# for i in {1,2,3,4,5}: # set을 이용한 for문
# print(i)
# dictData = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
# for i in dictData:
# print(dictData[i])
# for문 옆에 올 수 있는 iterator object 살펴보기
print(iter([1,2,3,4,5])) # <list_iterator object at 0x0000028E6004B688>
print(iter((1,2,3,4,5))) # <tuple_iterator object at 0x0000028E6004B688>
print(iter("12345")) # <str_iterator object at 0x0000028E6004B688>
print(iter(range(1,6))) # <range_iterator object at 0x0000028E5FB9E770>
print(iter(myFunction())) # <tuple_iterator object at 0x0000028E6004BA88>
print(iter({1,2,3,4,5})) # <set_iterator object at 0x0000028E60045A98>
print(iter({'a':1, 'b':2, 'c':3, 'd':4, 'e':5})) # <dict_keyiterator object at 0x0000028E60045A98>
# print(iter(2)) # for문에서 사용 불가능
# print(iter('ture')) # for문에서 사용 불가능
-- exFor1.py --
-- exFor2.py --
"""
파일명 : exFor2.py
프로그램 설명 : for문
"""
# 반복문을 사용하고 1 ~ 5까지 출력
# 2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18
# dan = 2
# i = 1
#
# while i <= 9:
# print(f'{dan}x{i}={dan*i}', end=' ')
# i += 1
# else:
# print()
dan = 2
for i in range(1,10):
print(f'{dan}x{i}={dan*i}', end=' ')
else:
print()
-- exFor2.py --
중첩 (이중) for문
for문 안에 for문이 들어간 형태
형식 :
for i in 이터러블객체 :
실행문
:
for j in 이터러블객체 :
실행문
:
else:
실행문
실행문
:
else:
실행문
-- exForFor.py ---
"""
파일명 : exForFor.py
프로그램 설명 : 중첩 for문
"""
# i = 1 ~ 5
for i in range(1,6):
print(i)
else:
print('i for문 종료')
# j = 6 ~ 10
for j in range(6,11):
print(j)
else:
print('j for문 종료')
# i = 1 ~ 5
for i in range(1,6):
# j = 6 ~ 10
for j in range(6,11):
print(i, j)
else:
print('j for문 종료')
else:
print('i for문 종료')
-- exForFor.py ---
-- exGugudan3.py --
"""
파일명 : exGugudan3.py
프로그램 설명 : 중첩 for문을 이용한 구구단 출력하기
"""
# 2x1=2 3x1=3 4x1=4 5x1=5 6x1=6 7x1=7 8x1=8 9x1=9
# 2x2=4 3x2=6 4x2=8 5x2=10 6x2=12 7x2=14 8x2=16 9x2=18
# 2x3=6 3x3=9 4x3=12 5x3=15 6x3=18 7x3=21 8x3=24 9x3=27
# 2x4=8 3x4=12 4x4=16 5x4=20 6x4=24 7x4=28 8x4=32 9x4=36
# 2x5=10 3x5=15 4x5=20 5x5=25 6x5=30 7x5=35 8x5=40 9x5=45
# 2x6=12 3x6=18 4x6=24 5x6=30 6x6=36 7x6=42 8x6=48 9x6=54
# 2x7=14 3x7=21 4x7=28 5x7=35 6x7=42 7x7=49 8x7=56 9x7=63
# 2x8=16 3x8=24 4x8=32 5x8=40 6x8=48 7x8=56 8x8=64 9x8=72
# 2x9=18 3x9=27 4x9=36 5x9=45 6x9=54 7x9=63 8x9=72 9x9=81
# 2단만 출력
# dan = 2
# for i in range(1,10):
# print(f'{dan}x{i}={dan*i}', end=' ')
# else:
# print()
# 2단 ~ 9단까지 출력
for dan in range(2, 10):
for i in range(1,10):
print(f'{dan}x{i}={dan*i:<2d}', end=' ')
else:
print()
-- exGugudan3.py --
리스트 컴프리헨션 (list comprehension)
리스트 컴프리헨션이란 리스트를 간략하게 표현한 것으로 리스트 안에 for문을 사용할 수 있도록 한 것이다.
형식 : 변수명 = [실행문 for문]
형식 : 변수명 = [실행문 for문 if문]
형식 : 변수명 = [실행문 if 조건식 else 실행문 for문 ]
-- exListComprehansion.py --
"""
파일명 : exListComprehansion.py
프로그램 설명 : 리스트 컴프리헨션
"""
# for문을 한 줄로 줄인다.
# 콜론(:)을 삭제한다.
# 실행문을 왼쪽으로 이동시킨다.
# 대괄호([])를 추가한다.
# a변수에 저장한다.
# for i in range(1,6):
# print(a)
# a = []
# for i in range(1,6):
# a.append(i)
# 리스트컴프리헨션을 사용해서 값을 추가한 경우
# 변수명 = [실행문 for문]
a = [i for i in range(1,6)]
print(a)
# 리스트컴프리헨션을 사용하지 않고 값을 추가한 경우
# for문을 한 줄로 줄인다.
# 콜론(:)을 삭제한다.
# 실행문을 왼쪽으로 이동시킨다.
# b.append()를 삭제한다.
# 대괄호([]) 안으로 이동시킨다.
# b = [i for i in range(1,6) ]
# b = []
# for i in range(1,6):
# b.append(i)
print(b)
# 형식 : 변수명 = [실행문 for문]
listData1 = [i for i in range(1,6)]
print(listData1) # [1, 2, 3, 4, 5]
listData1 = [i*2 for i in range(1,6)]
print(listData1) # [2, 4, 6, 8, 10]
# 형식 : 변수명 = [실행문 for문 if문]
# listData2 = []
# for i in range(1,11):
# if i%2 == 0: # 짝수만 저장
# listData2.append(i)
listData2 = [i for i in range(1,11) if i%2 == 0]
print(listData2)
# 형식 : 변수명 = [실행문 if 조건식 else 실행문 for문 ]
# listData3 = [i if i%2 == 0 else i+100 for i in range(1,11)]
listData3 = []
for i in range(1,11):
if i%2 == 0:
listData3.append(i)
else:
listData3.append(i+100)
print(listData3)
-- exListComprehansion.py --실습> 다중 if문을 이용하여 성적처리 프로그램을 작성하시오.
파일명: exIfElif2.py
국어, 영어, 수학 점수를 입력받아서 총점, 평균, 학점을 구해서 출력한다.
다중if문을 이용하여 구현한다.
# A학점 : 90 ~ 100 , grade = 'A'
# B학점 : 80 ~ 89.9 , grade = 'B'
# C학점 : 70 ~ 79.9 , grade = 'C'
# D학점 : 60 ~ 69.9 , grade = 'D'
# F학점 : 0 ~ 59.9 , grade = 'F'
>>> 모범 답안 <<<
-- exIfElif2.py --
"""
파일명: exIfElif2.py
프로그램 설명: 다중 if문을 이용한 성적처리 프로그램
"""
# 1. 점수 입력
print('>>> 성적 처리 프로그램 <<<')
kor = input('국어 점수: ')
eng = input('영어 점수: ')
math = input('수학 점수: ')
# 2. 점수 체크
kor = 0 if not kor.isdigit() else int(kor)
eng = 0 if not eng.isdigit() else int(eng)
math = 0 if not math.isdigit() else int(math)
# 3. 점수 계산
total = kor + eng + math # 총점
average = total / 3 # 평균
# 4. 학점 구하기
# A학점 : 90 ~ 100 , grade = 'A'
# B학점 : 80 ~ 89.9 , grade = 'B'
# C학점 : 70 ~ 79.9 , grade = 'C'
# D학점 : 60 ~ 69.9 , grade = 'D'
# F학점 : 0 ~ 59.9 , grade = 'F'
if average >= 90 and average <= 100: # A학점 : 90 ~ 100
grade = 'A'
elif average >= 80 and average < 90: # B학점 : 80 ~ 89.9
grade = 'B'
elif average >= 70 and average < 90: # C학점 : 70 ~ 79.9
grade = 'C'
elif average >= 60 and average < 70: # D학점 : 60 ~ 69.9
grade = 'D'
else: # F학점 : 0 ~ 59.9
grade = 'F'
# 5. 점수 출력
print('>>> 점수의 결과 <<<\n'
f'국어 점수: {kor}\n'
f'영어 점수: {eng}\n'
f'수학 점수: {math}\n'
f'총점: {total}\n'
f'평균: {average:.2f}\n'
f'학점: {grade}')
-- exIfElif2.py --
실습> while문을 이용해서 아래 문자열을 출력하시오.
Hint: message 변수를 while문으로 반복해서 출력한다.
message = "Hello Python!"
H
e
l
l
o
P
y
t
h
o
n
!
>>> 모범 답안 <<<
message = "Hello Python!"
# 초기값 -> 조건식 -> 실행문 -> 증감식
i = 0
while i < len(message):
print(message[i])
i += 1
실습> 구구단 2단을 while문으로 구현하기
파일명: exGugudan1.py
while문을 이용해서 구구단 2단 출력을 구현한다.
실행 결과:
2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18
>>> 모범 답안 <<<
-- exGugudan1.py --
"""
파일명: exGugudan1.py
프로그램 설명: while문을 이용한 구구단 출력하기
"""
dan = 2
i = 1
while i <= 9:
print(f'{dan}x{i}={dan*i}', end=' ')
i += 1
else:
print()
-- exGugudan1.py --
실습> 구구단 2단 ~ 9단까지 중첩 while문으로 구현하기
파일명: exGugudan2.py
중첩 while문을 이용해서 구구단 2단 ~ 9단까지 출력을 구현한다.
실행 결과:
# 2x1=2 2x2=4 2x3=6 2x4=8 2x5=10 2x6=12 2x7=14 2x8=16 2x9=18
# 3x1=3 3x2=6 3x3=9 3x4=12 3x5=15 3x6=18 3x7=21 3x8=24 3x9=27
# 4x1=4 4x2=8 4x3=12 4x4=16 4x5=20 4x6=24 4x7=28 4x8=32 4x9=36
# 5x1=5 5x2=10 5x3=15 5x4=20 5x5=25 5x6=30 5x7=35 5x8=40 5x9=45
# 6x1=6 6x2=12 6x3=18 6x4=24 6x5=30 6x6=36 6x7=42 6x8=48 6x9=54
# 7x1=7 7x2=14 7x3=21 7x4=28 7x5=35 7x6=42 7x7=49 7x8=56 7x9=63
# 8x1=8 8x2=16 8x3=24 8x4=32 8x5=40 8x6=48 8x7=56 8x8=64 8x9=72
# 9x1=9 9x2=18 9x3=27 9x4=36 9x5=45 9x6=54 9x7=63 9x8=72 9x9=81
모범답안은 day04실습문제.txt 파일을 참고한다.
-- exGugudan2.py --
"""
파일명: exGugudan2.py
프로그램 설명: while문을 이용한 구구단 출력하기
"""
# 초기값, 조건식, 실행문, 증감식 순으로 분석하기
# 2단 ~ 9단까지 출력
# 1. 바깥쪽 while문, 2. 안쪽 while문
dan = 2 # 1.초기값
while dan <= 9: # 1.조건식 2 ~ 9
# 1.실행문
i = 1 # 2.초기값
while i <= 9: # 2.조건식 1 ~ 9
print(f'{dan}x{i}={dan*i:<3d} ', end='') # 2.실행문
i += 1 # 2.증감식
else:
print()
dan += 1 # 1.증감식
-- exGugudan2.py --
정보보안 전문가