파이썬 기본 문법 익히기

• ℹ️ 참고 강의

• 📌 정수, 실수, 문자, 불리안 자료형

• 📌 정수, 실수, 문자, 불리안 자료형 변환

• 📌 연산자 (산술, 비교, 논리, 멤버)

• 📌 주석

• 📌 변수 선언 및 사용

• 📌 인덱스와 슬라이싱

• 📌 문자열 처리

• 📌 문자열 메소드

• 📌 문자열 출력

• 📌 탈출 문자

• 📌 리스트

• 📌 튜플

• 📌 세트

• 📌 딕셔너리

• 📌 리스트 vs 튜플 vs 세트 자료형 비교

• 📌 리스트, 튜플, 세트 자료형 변환

• 📌 조건문 (if)

• 📌 반복문 (for, while)

• 📌 리스트 컴프리헨션

• 📌 함수 (전달 값, 반환 값, 기본 값, 키워드 값, 가변 인자)

• 📌 지역 변수, 전역 변수

• 📌 사용자 입력

• 📌 파일 입출력 (with)

• 📌 클래스 (멤버 변수, 메소드, self)

• 📌 상속 (super, 다중 상속, 메소드 오버라이딩)

• 📌 pass

• 📌 예외 처리

• 📌 모듈

• 📌 패키지

 

ℹ️ 참고 강의

 

📌 정수, 실수, 문자, 불리안 자료형

# 문자 자료형
print('hello world') 
print("안녕하세요")

# 숫자 자료형
print(10)
print(3.14)

# 불리안 자료형
print(True)
print(False)​

 

📌 정수, 실수, 문자, 불리안 자료형 변환

# 형 변환
int('2') # 정수로
float('1.5') # 실수로
str(2) # 문자로
bool('hello') # 값이 있으면 True, 없으면 False (bool(''), bool(0), bool(None)은 False)

# 활용 예시
num = int(float('2.5'))
print(num)​

 

📌 연산자 (산술, 비교, 논리, 멤버)

# 산술 연산자
print(5 + 2) # 더하기
print(5 - 2) # 빼기
print(5 * 2) # 곱하기
print(5 / 2) # 나누기
print(5 % 2) # 나머지
print(5 // 2) # 몫
print(5 ** 2) # 거듭 제곱

# 비교 연산자
print(5 > 2) # 크다
print(5 >= 2) # 크거나 같다
print(5 < 2) # 작다
print(5 <= 2) # 작거나 같다
print(5 == 2) # 같다
print(5 != 2) # 같지 않다

# 논리 연산자
print(3 < 5 and 7 < 5) # 둘 다 참이면 True
print(3 < 5 or 7 < 5) # 하나라도 참이면 True
print(not 3 < 5) # 반전

# 멤버 연산자
print('c' in 'cat') # 포함
print('c' not in 'cat') # 미포함

 

📌 주석

# 한 줄 주석
print('신랑 신부 입장')
# 걷기 시작하면
print('큰 박수 부탁드립니다')

# 여러 줄 주석
print('신랑 신부 입장')
'''걷기 시작하고
잠시 후에'''
print('큰 박수 부탁드립니다')

 

📌 변수 선언 및 사용

# 변수 선언
# 변수 이름 규칙 1. 문자 또는 _로 시작
# 변수 이름 규칙 2. 문자, 숫자, _로 구성
# 변수 이름 규칙 3. 공백 X, 특수문자 X
# 변수 이름 규칙 4. 대소문자 구분
# 변수 이름 규칙 5. 키워드(예약어) X
envelope1 = 10000
envelope2 = 20000
envelope3 = '파이팅'

# 변수 사용
print(envelope1)
print(envelope2)
print(envelope3)​

 

📌 인덱스와 슬라이싱

# 인덱스
lang = 'PYTHON'
print(lang[0]) # P 출력
print(lang[5]) # N 출력
print(lang[-1]) # N 출력

# 슬라이싱 
print(lang[1:6]) # YTHON 출력 ( @ 부터 @ 직전까지 )
print(lang[1:]) # YTHON 출력 ( @ 부터 끝까지 )
print(lang[:4]) # PYTH ( 처음부터 @ 직전까지 )
print(lang[:]) # PYTHON ( 처음부터 끝까지 )

 

📌 문자열 처리

# 한 줄 문자열
snack = '꿀꽈배기'
two = '2개'

# 여러 줄 문자열
snack = '''꿀꽈배기는
너무
맛있어요'''

# 문자열 관련 함수
print(len(snack)) # len() : 문자열 또는 리스트 등의 길이

# 문자열 처리
juseyo = snack + two
juseyo = juseyo + '주세요' # juseyo += '주세요' 로도 표현 가능
print(juseyo) # '꿀과배기2개주세요' 출력

 

📌 문자열 메소드

letter = 'how are YOU?'
print(letter.lower()) # 모든 내용을 소문자로 변환
print(letter.upper()) # 모든 내용을 대문자로 변환
print(letter.capitalize()) # 첫 글자만 대문자로 변환
print(letter.title()) # 각 단어들의 첫 글자만 대문자로 변환
print(letter.swapcase()) # 대소문자 상호 변환
print(letter.split()) # 문자열 분리 (띄어쓰기를 기준으로 리스트 형태로 반환)
print(letter.count('how')) # 특정 단어의 수

s = '나도고등학교'
print(s.startswith('나도')) # ~로 시작하는지
print(s.endswith('초등학교') # ~로 끝나는지
print(s.strip('.')) # 앞뒤 불필요한 부분 제거 (비워둘 경우 공백 제거)
print(s.replace('고등학교', '고교')) # 단어 바꾸기
print(s.find('학교')) # 단어 위치 찾기 (인덱스 반환)
print(s.center(10, '-')) # 다른 문자들 사이 가운데 ('--나도고등학교--' 출력)

# 이 외에도 다양한 메소드가 존재한다.
# Google에서 'python 내장형' 검색 후 공식 홈페이지에서 추가적으로 확인 가능

 

📌 문자열 출력

python = '파이썬'
java = '자바'

# 문자열 포맷을 사용하지 않는 경우
print(python + ' ' + java)  # 문자열 연결(+)을 사용하여 출력
print(python, java)  # 쉼표(,)를 사용하면 자동으로 띄어쓰기 적용
print('개발 언어에는 ' + python + ', ' + java + ' 등이 있어요')  # 문자열 연결(+) 방식
print('개발 언어에는', python, ',', java, '등이 있어요')  # 쉼표(,)를 사용한 출력

# 문자열 포맷을 사용하는 경우
print('개발 언어에는 {}, {} 등이 있어요'.format(python, java))  # 기본 순서 출력 (파이썬, 자바)
print('개발 언어에는 {1}, {0} 등이 있어요'.format(python, java))  # 인덱스를 지정하여 순서 변경 (자바, 파이썬)
print(f'개발 언어에는 {python}, {java} 등이 있어요')  # f-string을 사용한 출력 (Python 3.6+)

 

📌 탈출 문자

# 문자열 내부에 따옴표가 포함된 경우
print('친구가 "파이썬 배우기 쉬워?" 하고 물었다.')
print("나는 속으로 '엄청 어려운데...' 라고 생각했다.")

# 문자열 내부에 여러 개의 따옴표가 포함된 경우
print('하지만 \'나만 당할 순 없지\'라는 생각에 \"엄청 쉽지\" 라고 했다.')

# 역슬래시(\) 표현
print('C:\\Users\\Nadocoding')

# 줄바꿈
snack = '꿀꽈배기는\n너무\n맛있어요'

 

📌 리스트

# 중복 저장 가능, 여러 자료형 저장 가능
my_list = ['오예스', '몽쉘', '초코파이', '초코파이', '초코파이']
your_list = [1, 2, 3.14, True, False, '아무거나']
empty_list = []

# 순서가 유지됨 (인덱싱과 슬라이싱 가능)
print(my_list[0]) # '오예스' 출력
print(my_list[0:2]) # ['오예스', '몽쉘'] 출력

# 리스트 관련 연산
print('몽쉘' in my_list) # 특정 요소 포함 여부 확인 (True 출력)
print(len(my_list)) # 리스트 길이(요소 개수) 반환

# 리스트 요소 수정 및 추가
my_list[1] = '몽쉘카카오' # 리스트 값 수정
my_list.append('빅파이') # 리스트 맨 뒤에 새로운 값 추가
my_list.remove('오예스') # 리스트 값 삭제
my_list.extend(your_list) # 다른 리스트 깂들을 추가

del my_list[1] # 리스트 두 번째 요소 삭제
del my_list # 리스트 자체를 삭제

# 그 외의 리스트 메소드
insert() # 원하는 위치에 값 추가
pop() # 원하는 위치(또는 마지막)의 값 삭제
clear() # 모든 값 삭제
sort() # 값 순서대로 정렬
reverse() # 순서 뒤집기
copy() # 리스트 복사
count() # 어떤 값이 몇 개 있는지
index() # 어떤 값이 어디에 있는지

 

📌 튜플

# 수정 불가 (리스트와 비슷하지만, '읽기 전용 리스트'라고 생각하면 됨)
numbers = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
my_tuple = ('오예스', '몽쉘', '초코파이', '초코파이')
your_tuple = (1, 2, 3.14, True, False, '아무거나')

# 언패킹
(pie1, pie2, pie3) = my_tuple
(one, two, *others) = numbers # others는 리스트 형태

# 순서가 유지됨 (인덱싱과 슬라이싱 가능)
print(my_tuple[0]) # '오예스' 출력
print(my_tuple[0:2]) # ('오예스', '몽쉘') 출력

# 튜플 관련 연산
print('몽쉘' in my_tuple) # 특정 요소 포함 여부 확인 (True 출력)
print(len(my_tuple)) # 튜플 길이(요소 개수) 반환

del my_tuple # 튜플 자체를 삭제 (튜플은 불변이므로, 개별 요소 삭제 불가)

# 그 외 튜플 메소드
count() # 어떤 값이 몇 개 있는지
index() # 어떤 값이 어디에 있는지

 

📌 세트

# 순서 없음, 중복 없음 (집합의 특징)
A = {'돈가스', '보쌈', '제육덮밥'}
B = {'짬뽕', '초밥', '제육덮밥'}

# 집합 연산 (교집합, 합집합, 차집합)
print(A.intersection(B)) # 교집합 {'제육덮밥'} 출력
print(A.union(B)) # 합집합 {'돈가스', '보쌈', '짬뽕', '초밥', '제육덮밥'} 출력
print(A.difference(B)) # 차집합 {'돈가스', '보쌈'} 출력

# 집합 요소 추가 및 삭제
A.add('닭갈비') # 값 추가
A.remove('제육덮밥') # 값 삭제
A.clear() # 모든 값 삭제

del A # 세트 자체를 삭제 (세트는 인덱스 및 키가 존재하지 않으므로, 개별 요소 삭제 불가)

# 그 외 집합 메소드
copy() # 세트 복사
discard() # 값 삭제 (해당 값이 없어도 에러 발생 X)
isdisjoint() # 두 세트에 겹치는 값이 없는지 여부
issubset() # 다른 세트의 부분집합인지 여부
issuperset() # 다른 세트의 상위집합인지 여부
update() # 다른 세트의 값들을 더함

 

📌 딕셔너리

# Key는 변할 수 없는 자료형만 가능하고 중복 불가
# Value는 다양한 자료형(숫자, 문자열, 불리언, 리스트, 튜플 등) 사용 가능
person = {'이름': '나귀욤', '나이': 7, '키': 120, '몸무게': 23}

# 딕셔너리 값 조회
print(person['이름']) # '나귀욤' 출력
print(person['나이']) # 7 출력
print(person.get('별명')) # 존재하지 않는 key 조회 시 None 출력

# 딕셔너리 값 추가 및 수정
person['최종학력'] = '유치원' # 새로운 key 추가
person['키'] = 130 # 기존 key의 value 변경
person.update({'키': 135, '몸무게': 26}) # 여러 key의 value 변경

# 딕셔너리 값 삭제
person.pop('몸무게') # 특정 key 삭제
person.clear() # 모든 key-value 삭제

del person['이름'] # 특정 키에 해당하는 키-값 쌍 삭제
del person # 딕셔너리 자체를 삭제

# 딕셔너리 key, value, key-value 쌍 조회
print(person.keys()) # key 목록 반환
print(person.values()) # value 목록 반환
print(person.items()) # (key, value) 쌍 목록 반환

# 그 외 딕셔너리 메소드
fromkeys() # 제공된 keys를 통해 새로운 딕셔너리 생성 및 반환
popitem() # 마지막으로 추가된 데이터 삭제
setdefault() # key에 해당하는 value 반환 (key가 없다면 새로 만들고 default value 설정 및 반환)

 

📌 리스트 vs 튜플 vs 세트 자료형 비교

 

• 리스트 (여러 값들을 순서대로 관리해야 할 때 유용)
• 튜플 (한 번 만들고 나면 바뀔 일이 없거나, 프로그램 동작 중 실수로라도 값이 바뀔 수 있는 상황을 방지하고자 할 때 유용)
• 세트 (특정 값이 있는지 없는지가 중요하거나, 중복을 허용하지 않는 데이터일 때 유용)
• 딕셔너리 (Key를 통해 효율적으로 데이터를 관리하고 싶을 때 유용)

 

📌 리스트, 튜플, 세트 자료형 변환

# 리스트 <-> 튜플 변환
my_tuple = ('오예스', '몽쉘')
my_list = list(my_tuple)
my_list.append('초코파이')
my_tuple = tuple(my_list)

# 리스트에서 중복 값 제거
my_list = ['오예스', '몽쉘', '초코파이', '초코파이', '초코파이']
my_set = set(my_list)
my_list = list(my_set) # 단 순서가 뒤죽박죽 섞일 수 있음

# 리스트의 중복 값을 제거하면서 순서를 보장하는 방법
my_list = ['오예스', '몽쉘', '초코파이', '초코파이', '초코파이']
my_dic = dict.fromkeys(my_list)
my_list = list(my_dic)

 

📌 조건문 (if)

# 단일 조건문
today = '일요일'
if today == '일요일': # 만약 ~라면
    print('게임 한 판')
elif today == '토요일' # 아니라고? 그럼 저건 어때?
    print('폰 5분만')
else: # 그렇지 않다면
    print('물 한 잔')
print('공부 시작')

# 중첩 조건문
yellow_card = 0
foul = True

if foul:
    yellow_card += 1
    if yellow_card == 2:
        print('경고 누적 퇴장')
    else:
        print('휴.. 조심해야지')
else:
    print('주의')

 

📌 반복문 (for, while)

# for 반복문 (범위)
for x in range(10):
    print('팔 벌려 뛰기 해')

for x in range(10): # range(start, stop, step)는 start 이상 stop 미만 step 만큼 증가
    print(f'팔 벌려 뛰기 {x}회')

# for 반복문 (대상)
my_list = [1, 2, 3]
for x in my_list:
    print(x)

person = {'이름':'나귀욤', '나이':7, '키':120, '몸무게':23}
for v in person.values():
    print(v)
for k in person.keys():
    print(v)
for k, v in person.items():
    print(k, v)
    
fruit = 'apple'
for x in fruit:
    print(x)

# while 반복문
max = 25 # 최대 허용 무게
weight = 0 # 현재 캐리어 무게
item = 3 # 각 짐의 무게

while weight + item <= max: # 캐리어에 짐을 더 넣어도 되는지 확인
    weight += item
    print('짐을 추가합니다')
print(f'총 무게는 {weight} 입니다')

# break
drama = ['시즌1', '시즌2', '시즌3', '시즌4', '시즌5']
for x in drama:
    if x == '시즌3':
        print('재미 없대, 그만 보자')
        break # 즉, '시즌1', '시즌2'만 시청
    print(f'{x} 시청')
    
# continue
drama = ['시즌1', '시즌2', '시즌3', '시즌4', '시즌5']
for x in drama:
    if x == '시즌3':
        print('재미 없대, 그만 보자')
        continue # 즉, '시즌3'을 제외한 '시즌1', '시즌2', '시즌4', '시즌5' 시청
    print(f'{x} 시청')

 

📌 리스트 컴프리헨션

# 리스트 컴프리헨션 사용 전
products = ['JOA-2020', 'JOA-2021', 'SIRO-2021', 'SIRO-2022']
recall = []
for p in products:
    if p.startswith('SIRO'):
        recall.append(p)
        
# 리스트 컴프리헨션 사용 후 ( 변수 활용 for 변수 in 반복 대상 if 조건 )
products = ['JOA-2020', 'JOA-2021', 'SIRO-2021', 'SIRO-2022']
recall = [p for p in products if p.startswith('SIRO')]

 

📌 함수 (전달 값, 반환 값, 기본 값, 키워드 값, 가변 인자)

# 전달 값 (함수 내에서만 사용 가능)
def show_price(customer): # 전달 값
    print(f'{customer} 고객님')
    print('커트 가격은 10,000원 입니다.')
    
customer1 = '나장발'
show_price(customer1)

customer2 = '나수염'
show_price(customer2)

# 반환 값, 기본 값
def get_price(is_vip = False): # 전달 값과 기본 값
    if is_vip == True:
        return 10000 # 반환 값
    else:
        return 15000
    
price = get_price() # 일반 손님
price = get_price(True) # 단골 손님

# 키워드 값
def get_price(is_vip = False,
              is_birthday = False,
              is_membership = False,
              card = False,
              review = False,
              first_time = False):
          ...
          
price = get_price(review = True, is_birthday = True) # 키워드 값 (순서 무관)

# 가변 인자
def visit(today, *customers): # 전달 값이 다수인 경우 마지막에 한 번만 사용 가능
    print(today)
    for customer in customers:
        print(customer)
   
visit('2022년 6월 10일', '나장발', '나수염', '나김리')

 

📌 지역 변수, 전역 변수

# 지역 변수
def secret():
    message = '이건 나만의 비밀'  # secret 함수 내에서만 유효한 지역 변수

print(message)  # 오류 발생 (message는 secret 함수 내에서 정의된 지역 변수이므로 함수 밖에서 접근할 수 없음)

def please():
    message = '이렇게 하면 되지?'  # secret 함수 내의 message 변수와 이름만 같으며, 각각의 함수 내에서 독립적인 지역 변수

# 전역 변수
message = '나는야 전역 변수'

print(message)  # 함수 밖에서도 사용 가능한 전역 변수

def no_secret():
    # message = '이러면 또 지역 변수' # 이는 함수 내에서만 유효한 지역 변수
    global message  # 전역 변수를 수정하려면 global 키워드를 사용해야 함
    message = '오 진짜 전역 변수!!'  # 전역 변수 수정
    print(message)  # 함수 안에서도 전역 변수는 사용 가능

 

📌 사용자 입력

name = input('예약자분 성함이 어떻게 되나요?')
print(name)

num = int(input('총 몇 분이세요?')) # 사용자 입력 값은 모두 문자열 형태
if num > 4: 
    print('죄송하지만 저희 식당은 최대 4분 까지만 예약 가능합니다')

 

📌 파일 입출력 (with)

# open(파일명, 열기 모드, encoding='인코딩')
# 열기 모드
#  1. r(읽기) 
#  2. a(이어서 쓰기)
#  3. w(쓰기))

# 쓰기 모드로 파일 열기
f = open('list.txt', 'w', encoding='utf8') 
f.write('김xx\n') # 문장 입력하기
f.write('정xx\n') # 문장 입력하기
f.write('허xx\n') # 문장 입력하기
f.close() # 파일 닫기

# 읽기 모드로 파일 열기
f = open('list.txt', 'r', encoding='utf8') 
contents = f.read()
print(contents)
f.close()

# 한 줄씩 읽기
f = open('list.txt', 'r', encoding='utf8') 
for line in f:
    print(line, end='')
f.close()

# with 문 활용 (with 블록을 벗어나면 파일이 자동으로 닫힘, close() 호출 불필요)
with open('list.txt', 'w', encoding='utf8') as f: # 'r' 모드도 사용 가능
    ...

 

📌 클래스 (멤버 변수, 메소드, self)

class BlackBox:
    def __init__ (self, name, price): # 객체가 생성될 때 자동으로 실행되는 생성자 함수
        self.name = name # 클래스의 멤버 변수 (객체마다 다른 값을 가질 수 있음)
        self.price = price # self는 '객체 자기 자신'을 의미 (메소드 내에서는 'self.멤버변수' 와 같은 형태로 멤버 변수를 사용)
    def set_travel_mode(self, min):
        print(f'{self.name} {min}분 동안 여행 모드 ON')
    
b1 = BlackBox('까망이', 200000) # b1 객체 생성 완료
print(b1.name, b1.price)

b2 = BlackBox('하양이', 100000) # b2 객체 생성 완료
print(b2.name, b2.price)

b1.set_travel_mode(20) # 이는 BlackBox.set_travel_mode(b1, 20) 코드와 같은 결과

print(isinstance(b1, BlackBox)) # b1 객체가 BlackBox 클래스의 인스턴스인지 확인
print(isinstance(b2, BlackBox)) # b2 객체가 BlackBox 클래스의 인스턴스인지 확인

 

📌 상속 (super, 다중 상속, 메소드 오버라이딩)

class BlackBox: # 부모 클래스
    def __init__ (self, name, price):
        self.name = name 
        self.price = price
        
class VideoMaker:
    def make(self):
        print('추억용 여행 영상 제작')

class MailSender:
    def sen(self):
        print('메일 발송')
        
class TravelBlackBox(BlackBox, VideoMaker, MailSender): # 자식 클래스
    def __init__ (self, name, price, sd):
        super().__init__(name, price) # super()는 부모 클래스를 의미 (부모 클래스의 __init__ 호출)
        self.sd = sd
    def set_travel_mode(self, min):
        print(f'{self.name} {min}분 동안 여행 모드 ON')
        
class AdvancedTravelBlackBox(TravelBlackBox): 
    def set_travel_mode(self, min): # 메소드 오버라이딩이란 자식 클래스에서 부모 클래스의 메소드를 재정의하는 것
        print(str(min) + '분 동안 여행 모드 ON')
        self.make()
        self.send()
        
b1 = BlackBox('까망이', 200000)
b2 = TravelBlackBox('하양이', 100000, 64)
b2.make()
b2.send()

 

📌 pass

class BlackBox:
    def __init__(self):
        pass # 주로 코드 블록이 필요하지만 아직 구현을 하지 않았거나, 임시로 비워두고 싶을 때 사용
    def record(self):
        pass # 클래스 메소드 뿐만 아니라 반복문, 조건문, 함수 등에도 사용 가능
    def stop(self):
        pass
    def format(self):
        pass
    ...

 

📌 예외 처리

try:
    pass # 수행 문장 (에러가 발생할 가능성이 있는 문장)
except:
    pass # 에러 발생 시 수행 문장 (에러 상황이 발생했을 때만 수행할 문장)
else:
    pass # 정상 동작 시 수행 문장 (에러가 발생하지 않았을 때만 수행할 문장)
finally:
    pass # 마지막으로 수행할 문장 (에러 여부 상관 없이 항상 수행되는 문장)
    
try:
    result = num1 / num2
    print(f'연산 결과는 {result}입니다')
except ZeroDivisionError: # 0으로 나누는 경우 발생하는 오류 처리
    print('0으로 나눌 수 없어요')
except TypeError: # 연산 대상이 숫자가 아닐 경우 발생하는 오류 처리
    print('값의 형태가 이상해요')
except Exception as err: # Exception은 모든 오류의 기본이 되는 클래스 (이를 통해 오류 내용 확인 가능)
    print('에러가 발생했어요:', err)
else:
    print('정상 동작했어요')
finally:
    print('수행 종료')
    
# 이 외에도 다양한 내장 Exception 클래스가 존재한다
# Google에서 'python exceptions' 검색 후 공식 홈페이지에서 추가적으로 확인 가능

 

📌 모듈

# 모듈 : 하나의 .py 파일로 이루어진 코드 묶음
# 방법
#  1. import 모듈
#  2. from 모듈 import 변수, 함수 또는 클래스

# goodjob.py 파일
def say():
    print('참 잘했어요')
    
# 새로운 파일 1
import goodjob
goodjob.say()

# 새로운 파일 2
from goodjob import say
say()

import random
my_list = ['가위', '바위', '보']
print(random.choice(my_list))

# 이 외에도 다양한 내장 모듈이 존재한다
# Google에서 'list of python modules' 검색 후 공식 홈페이지에서 추가적으로 확인 가능

 

📌 패키지

# 패키지 : 여러 개의 모듈을 포함하는 디렉터리
# 방법
#  1. import 패키지.모듈
#  2. from 패키지 import 모듈

# nadocoding 폴더 내 goodjob.py 파일
def say():
    print('참 잘했어요')

# nadocoding 폴더 내 goodbye.py 파일
def bye():
    print('또 만나요')
    
# nadocoding 폴더 내 새로운 파일 1
import nadocoding.goodjob
nadocoding.goodjob.say()

# nadocoding 폴더 내 새로운 파일 2
from nadocoding import goodbye
goodbye.bye()

# nadocoding 폴더 내 새로운 파일 3
from nadocoding import goodjob, goodbye
goodjob.say()
goodbye.bye()