1. Data Input & Output

❕ 데이터 입력 함수 : input()

input() 함수는 Python의 표준 입력 함수로, 키보드로부터 값을 입력받아 변수에 저장한다.

input() 함수에 입력 가이드 문구를 명시해서 사용할 수 있다.
입력 문구는 화면에 출력되고 키보드로 값을 입력한 후 엔터를 누르면 입력값은 선언된 변수에 저장된다.

input() 함수가 반환하는 값은 모두 문자(열) 자료형 str이다.

'''
 ✔ 입력되는 값은 항상 **문자열**로 반환된다.
'''
userInputData = input('문자형을 입력하세요. ')  ⬅ # Hello~ 입력

>>> print(userInputData, type(userInputData))
# Hello~ <class 'str'>

userInputData = input('정수형을 입력하세요. ')  ⬅ # 13 입력

>>> print(userInputData, type(userInputData))
# 13 <class 'str'>

userInputData = input('실수형을 입력하세요. ')  ⬅ # 0.17 입력

>>> print(userInputData, type(userInputData))
# 0.17 <class 'str'>

userInputData = input('논리형을 입력하세요. ')  ⬅ # True 입력

>>> print(userInputData, type(userInputData))
# True <class 'str'>

필요한 경우 자료형을 변환하여 사용한다.

userInputData = int(input('정수형을 입력하세요. '))  ⬅ # 13 입력

>>> print(userInputData, type(userInputData))
# 13 <class 'int'>

userInputData = float(input('실수형을 입력하세요. '))  ⬅ # 0.17 입력

>>> print(userInputData, type(userInputData))
# 0.17 <class 'float'>

userInputData = bool(input('논리형을 입력하세요. '))  ⬅ # True 입력

>>> print(userInputData, type(userInputData))
# True <class 'bool'>

split() 함수를 이용해 입력 받은 데이터를 두 가지 이상의 데이터로 나눌 수 있다.
split() 함수는 default 값으로 ‘공백’이 구분 문자로 사용된다.
구분 문자를 사용자가 임의로 정할 수도 있다. ➡ split(,) split(/)

# <Q> --------------------------------------------------------------------------
# 사용자로부터 달러, 엔화, 유로, 위안화 중 하나로 금액을 입력받은 후
# 해당 금액을 원화로 변환하는 프로그램을 작성한다. 사용자는 '100 달러', '1000 엔',
# '13 유로', '100 위안'과 같이 금액과 통화명 사이에 공백을 넣어 입력한다고 가정
# - 통화별 환율 : 달러-1167 / 엔-1.096 / 유로-1268 / 위안-171

currency_list = {'달러':1167, '엔':1.096, '유로':1268, '위안':171}
userCurr = input('원화로 변환할 금액 입력(단, 금액과 통화단위를 띄어쓰기) : ')
⬅ # '3500 유로' 입력

num, currency = userCurr.split()
won = round(float(num) * currency_list[currency])

>>> print('{} -> {:,}원'.format(userCurr, won))
# 3500 유로 -> 4,438,000원

❕ 데이터 출력 함수 : print()

형식
print(출력값1, 출력값2, …, sep = 분리문자, end = 종료문자)

기본적으로 데이터 값 사이에는 공백이 들어가고, 데이터 출력 후 개행이 이루어진다.
개행을 원하지 않을 경우 end=‘’ 를 사용해 임의로 정할 수 있다.

>>> print('홍길동')
>>> print(27)
# 홍길동
# 27

>>> print('홍길동', end=' ')
>>> print(27)
# 홍길동 27

콤마(,)

콤마(,)를 이용해 연속 출력이 가능하다.

콤마(,)를 사용하면 default 값으로 구분 문자가 ‘공백’(sep=‘ ’)으로 지정되어 있다.
구분 문자는 사용자가 임의로 변경 가능하다.

userName = '홍길동'
userAge = 20

'''
 ✔ 콤마(,)를 이용해 데이터를 연달아 나열한다.
'''
>>> print('User name', userName, 'User age', userAge)
# User name 홍길동 User age 20

'''
 ✔ 구분 문자를 임으로 정해서 출력할 수 있다.
'''
>>> print('User name', userName, 'User age', userAge, sep='/')
# User name/홍길동/User age/20

format 문자(형식 문자)

%d %f %s

형식 문자로 출력 자료형을 지정해 준다.

✅ %d 는 정수형, %f 는 실수형, %s 는 문자(열)형을 의미!

userName = '홍길동'
userAge = 20
pi = 3.141592

'''
 ✔ 형식 문자를 이용한 데이터 출력
'''
>>> print('User name : %s, User age : %d' % (userName, userAge))
# User name : 홍길동, User age : 20

>>> print('원주율 : %f' % pi)
# 원주율 : 3.141592

형식 문자와 함께 여러 출력 옵션들을 정할 수 있다.

✅ %.2f 는 소수점 이하 둘째 자리로 자리수를 지정!

pi = 3.1415926535

>>> print("Pi : %d" % pi)      # Pi : 3

>>> print("Pi : %f" % pi)      # Pi : 3.141593
>>> print("Pi : %.0f" % pi)    # Pi : 3
>>> print("Pi : %.2f" % pi)    # Pi : 3.14
>>> print("Pi : %.5f" % pi)    # Pi : 3.14159
>>> print("Pi : %.10f" % pi)   # Pi : 3.1415926535

format 문자열

f‘ ’

문자열 내에서 중괄호{ }를 사용해 변수를 출력할 수 있다.

userName = '홍길동'
userAge = 20

'''
 ✔ 포맷 문자열을 이용한 데이터 출력
'''
>>> print(f'User name : {userName}, User age : {userAge}')
# User name : 홍길동, User age : 20

format 함수

‘ ’.format()

문자열이 제공하는 format() 메소드를 이용해 출력할 수 있다.

문자열 내에 중괄호{ }를 사용해 format() 메소드의 인수를 출력할 수 있다.
인수는 인덱스(index)를 이용해 출력 위치를 지정할 수 있다.
기본적으로 인수를 차례대로 출력할 경우 인덱스는 생략 가능하다.

userName = '홍길동'
userAge = 20

'''
 ✔ format() 함수을 이용한 데이터 출력
'''
>>> print('User name : {}, User age : {}'.format(userName, userAge))
# User name : 홍길동, User age : 20

>>> print('User age {1}, User name : {0}'.format(userName, userAge))
# User age 20, User name : 홍길동

>>> print('나의 이름은 {0}이고, 나이는 {1}살 입니다. {0} 이름은 아버님께서 지어 주셨습니다.'
		      .format(userName, userAge))
# 나의 이름은 홍길동이고, 나이는 20살 입니다. 홍길동 이름은 아버님께서 지어 주셨습니다.

데이터 출력 특수 문자

\t : tab, 탭

userName = '홍길동';  userAge = 20

>>> print(f'User name\t:\t{userName}\tUser age\t:\t{userAge}')
# User name	:	홍길동	User age	:	20

\n : new line, 개행

width = 10.5;  height = 5.5
triangle = width * height / 2
square = width * height

>>> print('Triangle :', triangle, '\nSquare :', square)
# Triangle : 28.875 
# Square : 57.75

>>> print('Triangle :', triangle, end=', ')
>>> print('Square :', square)
# Triangle : 28.875, Square : 57.75

\’ \” : 문자열 내 따옴표 출력

---

2. Operator

❕ 산술 연산

산술 연산자 : + , - , * , / , % , // , **

📌 특징
    ▶ 숫자와 문자는 더할 수 없다. → TypeError 발생!
    ▶ 문자(열)은 뺄셈 연산 불가능!! → TypeError 발생!
    ▶ 0으로 나누는 것은 불가능!! → ZeroDivisonError 발생!
    ▶ 0을 나누면 결과는 항상 0.0!
    ▶ 나눗셈의 결과는 항상 float!
    ▶ divmode() 함수로 몫[0]과 나머지[1]를 한번에 연산할 수 있다.

+ 덧셈 연산자

✅ 숫자와 문자(열)형은 덧셈 연산 할 수 없다.

정수와 실수를 덧셈 연산하면 결과 자료형은 실수이다.

inum = 10; fnum = 3.14
result = inum + fnum

>>> print(f'({inum} + {fnum}) result : {result}')
>>> print(f'type of result : {type(result)}')
# (10 + 3.14) result : 13.14
# type of result : <class 'float'>

문자(열)형의 덧셈 연산 결과는 문자(열) 연결이다.

str1 = 'Good'
str2 = ' '
str3 = 'Morning'
result = str1 + str2 + str3

>>> print(f'result : {result}')
# Good Morning

- 뺄셈 연산자

✅ 뺄셈 연산은 숫자와 문자(열) 뿐만 아니라 문자(열) 끼리도 연산할 수 없다.

* 곱셈 연산자

숫자와 문자(열)의 곱셈 연산 결과는 문자(열)이 숫자만큼 반복되는 것이다.

'''
 ✔ 문자열 곱셈은 반복 횟수를 의미한다!
'''
str1 = 'Hello '
result = str1 * 7

>>> print(f'result : {result}')
# result : Hello Hello Hello Hello Hello Hello Hello

/ 나눗셈 연산자

✅ ‘0’으로 나누는 연산은 할 수 없다.

‘0’을 나눗셈한 결과는 항상 ‘0.0’이다.

num1 = 0;  num2 = 3
result = num / num2

>>> print(f'({num1} / {num2}) result : {result}')
# (0 / 10) result : 0.0

나눗셈 연산의 결과는 항상 float형이다.

inum1 = 20;  inum2 = 10
result = inum1 / inum2

>>> print(f'({inum1} / {inum2}) result : {result}')
>>> print('type of result : {}'.format(type(result)))
# (20 / 10) result : 2.0
# type of result : <class 'float'>

divmode() 함수로 몫과 나머지를 한번에 구할 수 있다.

💡 divmode() 함수는 나눗셈 연산 후 몫과 나머지를 tuple형으로 반환한다.

inum1 = 17;  inum2 = 4
result = divmod(inum1, inum2)

>>> print('result : {}'.format(result))
>>> print('type of result : {}'.format(type(result)))
# result : (4, 1)
# <class 'tuple'>
'''
 ✔ 몫은 [0]번 인덱스, 나머지는 [1]번 인덱스로 접근 가능
'''
>>> print('몫 : {}, 나머지 : {}'.format(result[0], result[1]))
# 몫 : 4, 나머지 : 1

% 나머지 연산자

나눗셈의 결과 나머지만 구하는 연산자로 나머지 연산의 결과는 int형이다.

inum1 = 17;  inum2 = 4
result = inum1 % inum2 # 나머지

>>> print(f'({inum1} % {inum2}) result : {result}')
>>> print('type of result : {}'.format(type(result)))
# (17 % 4) result : 1
# type of result : <class 'int'>

// 몫 연산자

나눗셈의 결과 몫만 구하는 연산자로 몫 연산의 결과도 int형이다.

inum1 = 17;  inum2 = 4
result = inum1 // inum2 # 몫

>>> print(f'({inum1} // {inum2}) result : {result}')
>>> print('type of result : {}'.format(type(result)))
# (17 // 4) result : 4
# type of result : <class 'int'>

** 거듭제곱 연산자

형식 : n ** m → n의 m제곱 (n을 m번 곱한다.)

num1 = 2;  num2 = 3
result = num1 ** num2

>>> print(f'(num1({num1}) ** num2({num2})) result : {result}')
# (num1(2) ** num2(3)) result : 8

math 모듈의 pow() 함수로 동일한 연산 결과를 얻을 수 있다.

💡 pow() 함수는 거듭제곱** 연산 결과를 float형으로 반환한다.

import math

>>> print('2의 3제곱: %.2f' % math.pow(2, 3))
# 2의 3제곱: 8.00

>>> print(f'2의 4제곱: {math.pow(2, 4):.2f}')
# 2의 4제곱: 16.00

>>> print('2의 5제곱: {:.2f}'.format(pow(2, 5)))
# 2의 5제곱: 32.00

** (1/m) m제곱근 연산자

형식 : n ** (1/m) → n의 m제곱근 (결과값을 m번 곱하면 n)

result = 2 ** (1/2)
>>> print('2의 제곱근: ', result)
# 2의 제곱근: 1.4142135623730951

result = 2 ** (1/3)
>>> print(f'2의 3제곱근: {result}')
# 2의 3제곱근: 1.2599210498948732

result = 2 ** (1/4)
>>> print('2의 4제곱근: {}'.format(result))
# 2의 4제곱근: 1.189207115002721

math 모듈의 sqrt() 함수로 동일한 연산 결과를 얻을 수 있다.

💡 sqrt() 함수는 제곱근(n ** (1/2))만 구할 수있는 함수이다.

import math

>>> print('2의 제곱근 %f' % math.sqrt(2))
# 2의 제곱근 1.414214

>>> print(f'3의 제곱근 {math.sqrt(3):f}')
# 3의 제곱근 1.732051

>>> print('4의 제곱근 {:f}'.format(math.sqrt(4)))
# 4의 제곱근 2.000000

❕ 대입 & 복합 연산

대입 연산자 : =

복합 연산자 : += , -= , *= , /= , %= , //=

📎 의미
   += ▶ 덧셈 연산 후 결과값 할당
   -= ▶ 뺄셈 연산 후 결과값 할당
   *= ▶ 곱셈 연산 후 결과값 할당
   /= ▶ 나눗셈 연산 후 결과값 할당
   %= ▶ 나머지 연산 후 결과값 할당
   //= ▶ 몫 연산 후 결과값 할당
   **= ▶ 거듭제곱 연산 후 결과값 할당

❕ 비교 연산

비교 연산자 : > , >= , < , <= , == , !=

숫자 비교

📎 의미
   >  ▶ l-value가 크면 Ture
   >= ▶ l-value가 크거나 같으면 Ture
   <  ▶ l-value가 작으면 Ture
   <= ▶ l-value가 작거나 같으면 Ture
   == ▶ l-value와 r-value가 같으면 Ture
   != ▶ l-value와 r-value가 다르면 Ture

문자(Character) 비교

문자 한 개를 비교할 때는 ASCII 코드를 이용해 비교 연산을 한다.

cha1 = 'A' # 'A'의 아스키 코드값 : 65
cha2 = 'S' # 'S'의 아스키 코드값 : 83

>>> print('\'{}\' > \'{}\' : {}'.format(cha1, cha2, (cha1 > cha2)))
>>> print('\'{}\' >= \'{}\' : {}'.format(cha1, cha2, (cha1 >= cha2)))
>>> print('\'{}\' < \'{}\' : {}'.format(cha1, cha2, (cha1 < cha2)))
>>> print('\'{}\' <= \'{}\' : {}'.format(cha1, cha2, (cha1 <= cha2)))
>>> print('\'{}\' == \'{}\' : {}'.format(cha1, cha2, (cha1 == cha2)))
>>> print('\'{}\' != \'{}\' : {}'.format(cha1, cha2, (cha1 != cha2)))
# 'A' >= 'S' : False
# 'A' < 'S' : True
# 'A' <= 'S' : True
# 'A' == 'S' : False
# 'A' != 'S' : True

💡 ord() , chr() 함수는 문자와 아스키 코드를 서로 변환하는 함수이다.

ord() 함수는 문자 한 개를 입력받아 아스키 코드 값을 반환한다.

chr() 함수는 정수를 입력 받고 아스키 코드에 있는 해당 문자 한 개를 반환한다.

>>> print('\'A\' -> {}'.format(ord('A')))  # 'A' -> 65
>>> print('\'S\' -> {}'.format(ord('S')))  # 'S' -> 83
>>> print('65 -> {}'.format(chr(65)))  # 65 -> A
>>> print('83 -> {}'.format(chr(83)))  # 83 -> S

문자열(String) 비교

문자열 자체를 비교하므로 == , != 연산만 가능하다.

str1 = 'Hello'; str2 = 'hello'

>>> print(f'{str1} == {str2} : {str1 == str2}')  # Hello == hello : False
>>> print(f'{str1} != {str2} : {str1 != str2}')  # Hello != hello : True

❕ 논리 연산

논리 연산자 : and , or , not

and 연산

[A and B] : A와 B 모두 True인 경우만 결과값이 True이다.

>>> print('{} and {} : {}'.format(True, True, (True and True)))
>>> print('{} and {} : {}'.format(False, True, (False and True)))
>>> print('{} and {} : {}'.format(True, False, (True and False)))
>>> print('{} and {} : {}'.format(False, False, (False and False)))
# True and True : 
# False and True : False
# True and False : False
# False and False : False

or 연산

[A or B] : A와 B 중 어느 하나만 True이면 결과값은 True이다.

>>> print('{} or {} : {}'.format(True, True, (True or True)))
>>> print('{} or {} : {}'.format(False, True, (False or True)))
>>> print('{} or {} : {}'.format(True, False, (True or False)))
>>> print('{} or {} : {}'.format(False, False, (False or False)))
# True or True : True
# False or True : True
# True or False : True
# False or False : False

not 연산

[not A] : A의 상태를 부정한다.

A가 True이면 결과값은 False 이고, A가 False이면 결과값은 True이다.

>>> print('not {} : {}'.format(True, (not True)))
>>> print('not {} : {}'.format(False, (not False)))
# not True : False
# not False : True

❕ operator 모듈

operator 모듈은 산술 연산자와 관련된 함수들을 모아 놓은 파일이다.
import 키워드로 모듈을 불러 사용할 수 있다.

import operator

num1 = 8; num2 = 3
print('{} + {} = {}'.format(num1, num2, operator.add(num1, num2)))
print('{} - {} = {}'.format(num1, num2, operator.sub(num1, num2)))
print('{} * {} = {}'.format(num1, num2, operator.mul(num1, num2)))
print('{} / {} = {}'.format(num1, num2, operator.truediv(num1, num2)))
print('{} % {} = {}'.format(num1, num2, operator.mod(num1, num2)))
print('{} // {} = {}'.format(num1, num2, operator.floordiv(num1, num2)))
print('{} ** {} = {}'.format(num1, num2, operator.pow(num1, num2)))

print('{} == {} : {}'.format(num1, num2, operator.eq(num1, num2)))
print('{} != {} : {}'.format(num1, num2, operator.ne(num1, num2)))
print('{} > {} : {}'.format(num1, num2, operator.gt(num1, num2)))
print('{} >= {} : {}'.format(num1, num2, operator.ge(num1, num2))) 
print('{} < {} : {}'.format(num1, num2, operator.lt(num1, num2)))
print('{} <= {} : {}'.format(num1, num2, operator.le(num1, num2)))

flag1 = True; flag2 = False
print('{} and {} : {}'.format(flag1, flag2, operator.and_(flag1, flag2)))
print('{} or {} : {}'.format(flag1, flag2, operator.or_(flag1, flag2)))
print('not {} : {}'.format(flag1, operator.not_(flag1)))