[Python] 기본 문법 정리

자료형

문자 자료형

print('hello world')
print('안녕하세요')
print('10')

숫자 자료형

print(10.0)
print(3.1872)

불리언 자료형

print(True)
print(False)

변수

• 어떤 값을 저장하는 공간
  
  (예) 봉투 - 변수 / 세뱃돈 - 값
• 변수 선언 : 변수 이름 = 값

envelop1 = 1000
print(envelop1) #1000

변수 이름 규칙

1. 문자 또는 _로 시작
2. 문자, 숫자, _로 구성
3. 공백 X, 특수문자 X
4. 대소문자 구분
5. 키워드 (예약어) X
6. 소문자 단어, _로 구분된 단어들 (권장)

#True = '1분' 불가능
name = 'seoyeon'
my_name = 'jung'

형 변환

• int() : 정수로
• float() : 실수로
• str() : 문자로
• bool() : 불리안(boolean)으로

# 2 + '2' 불가능
int('2') # 2
float('1.5') # 1.5
str(2) #'2'
# int('two') 변환 불가 (값을 알 수 없음)
int(float('2.5'))
# 먼저 실수로 변환한 뒤 정수로 변환해야 한다

연산자

• + (더하기), - (빼기), * (곱하기), / (나누기)
• % (나머지), // (몫), ** (거듭제곱)
• 비교 연산자
  • >, >=, <, <=
  • == (같다), != (같지 않다)
• 논리 연산자
  • and (둘다 참이면 True)
  • or (하나라도 참이면 True)
  • not (반전)
• 멤버 연산자
  • in (포함)
  • not in (미포함)

print(5 + 2) #7
print(5 % 2) #2
print(5 > 2) # True
print(5 != 2) # True
print(not 4 < 5) # False
print('c' in 'cat') # True
print('c' not in 'cat') # False

boolean

bool()

• 값이 있으면 / 참이면 True
• 값이 없으면 / 거짓이면 False

a = 1 (값이 있음)
b = -2 (값이 있음)
c = 0 (값이 없음)
d = '' (값이 없음)
None (값이 없음)

print(bool(None)) # False

주석

• 복잡한 코드에 부연 설명이 필요할 때
• 다른 개발자에게 메모를 남길 때
• 테스트 목적으로 일부 코드의 실행을 막을 때

슬라이스와 인덱싱

• 몇 번째 = 인덱스
• 0부터 시작한다.

long = 'PYTHON'
# 0 1 2 3 4 5
# -6 -5 -4 -3 -2 -1 (-1부터 시작해서 1씩 감소)
print(long[0]) # P
print(long[-6]) # P
print(long[-1]) # N

• 어디서부터: 어디까지 = 슬라이싱

# lang[start: end] start부터 end 직전까지
print(long[0:3]) # PYH
print(long[1:6]) # YTHON ([1] 부터 [5]까지 출력)
print(long[:4]) # PYTH
print(long[:]) # PYTHON

문자열 처리 (숫자형도 사용 가능)

snack = '꿀꽈배기'
two = '2개'

juseyo = snack + two
juseyo += '주세요'
=> 꿀꽈배기 2개 주세요

num = 3
num = num + 2
num += 2

num -= 1

• 길이(length)

snack = '꿀과배기'
print(len(snack)) # 4

snack2 = ```꿀꽈배기
너무
맛있어요```
print(snack2)
# 꿀꽈배기는
# 너무
# 맛있어요

문자열 메소드

• 메소드(Method) : 클래스 내에 정의된 어떤 동작, 기능을 하는 코드들의 묶음
• 문자열.메소드(..)

letter = 'how are YOU?'

print(letter.lower()) # how are you
print(letter.upper()) # HOW ARE YOU
print(letter.capitalize()) # How are you
print(letter.title()) # How Are You (각 단어들의 첫 글자만 대문자로)
print(letter.swapcase()) # HOW ARE you
print(leter.split()) #['how', 'are', 'YOU]

print(letter.count('how')) # 1

s = '나도고등학교'

# '나도'로 시작하는지?
print(s.startswith('나도')) # True
# '학교''로 끝나는지?
print(s.endswith('학교')) # True

# 불필요한 부분?
s2 = '...나도고등학교...'
print(s2.strip('.')) # 나도고등학교

# 문자열 일부 변경
print(s.replace('고등학교', '고교')) # 나도고교

# '학교' 글자는 어디에?
print(s.find('학교')) # 4

# 다른 문자들 사이 가운데로?
# center(총길이, 감싸고 싶은 것들)
print(s.center(10, '-')) # --나도고등학교--

• python 내장형 검색 후 검색하면 더 많이 나온다

문자열 포맷

• 콤마로 구분해서 자동으로 띄어쓰기 후 출력 가능

python = '파이썬'
java = '자바'
print(python, java) # 파이썬 자바

# 문장 중간에 넣고 싶은 경우
print('개발 언어에는 ' + python + ', ' + java + ' 등이 있어요')

문자열 포맷 방법

1. { } + format

print('개발 언어에는 {}, {} 등이 있어요'.format(python, java))

2. {N} + format (N: 0, 1, 2)

print('개발 언어에는 {0}, {1} 등이 있어요'.format(python, java))

• 중괄호 안의 숫자를 통해 순서를 정할 수 있다

3. f-string (파이썬 3.6 이상)

print(f'개발 언어에는 {python}, {java} 등이 있어요)

탈출 문자

• 큰 따옴표는 \''
• 작은 따옴표는 \'
• 역슬래시는 \\
• 줄바꿈은 \n

리스트

• 일반적으로 서로 관련 있는 연속적인 데이터들을 관리하는 데 사용
• 리스트 = [값1, 값2, ...]
• 중복된 값을 넣을 수 있다
• 리스트의 값들은 순서가 보장된다

my_list = ['오예스', '몽쉘', '초코파이']
my_list_2 = ['오예스', '몽쉘', '초코파이', '초코파이']
empty_list = [] # 빈 리스트

print(my_list[0]) # 오예스
print(my_list[0:2]) # ['오예스', '몽쉘']
print('몽쉘' in my_list) # True
print(len(my_list)) # 3

# 리스트 수정
my_list[1] = '몽쉘카카오' # 값 수정
print(my_list) # ['오예스', '몽쉘카카오', '초코파이']

# 리스트 추가
my_list.append('빅파이')
print(my_list) # ['오예스', '몽쉘카카오', '초코파이', '빅파이']

# 리스트 값 삭제
my_list.remove('오예스')
print(my_list) # ['몽쉘카카오', '초코파이', '빅파이']

# 다른 리스트를 더하려면
your_list = ['빅파이', '오뜨']
my_list.extend(your_list) # 리스트 확장

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

튜플

• 소괄호 속에 값을 넣고 구분
• 한 번 만들면 수정 불가능
• 삭제 불가능
• 읽기 전용 리스트

my_tuple = ('오예스', '몽쉘', '초코파이') # 패킹
(pie1, pie2, pie3) = my_tuple # 언패킹
# pie1, pie2, pie3 변수에 각각 풀어서 저장하는 것
your_tuple = (1, 2, 3.21, True, False, '아무거나')

print(my_tuple[0]) # 오예스
# 슬라이싱 가능
print(my_tuple[0:2]) # ('오예스', '몽쉘')
print(len(my_tuple)) # 3
print('몽쉘' in my_tuple) # True

# count() 어떤 값이 몇 개 있는지
# index() 어떤 값이 어디에 있는지

• 언패킹

numbers = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
(one, two, *others) = numbers
# *을 사용해서 나머지는 모두 others에 집어넣으라는 의미
# others는 리스트 형태
# 별의 위치를 바꿀 수 있다

세트

• 순서 X, 중복 X
• 세트 = {값1, 값2, ...}

A = {'돈까스', '보쌈', '제육덮밥'}
B = {'짬뽕','초밥', '제육덮밥'}

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

• 순서 보장 X = 인덱스를 통해 값을 얻을 수 없다
• 읽기 전용은 아님

my_set = {'돈까스', '보쌈', '제육덮밥'}
my_set.add('닭갈비') # 추가 가능
my_set.remove('제육덮밥') # 제거 가능
my_set.clear() # 모든 값 제거
del my_set  # set 자체를 완전 삭제

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

딕셔너리

• key - value (key 중복 불가)
• 딕셔너리 = {key1: value1, key2: value2, ... }
• 숫자 문자, 불리안, 리스트, 튜플 등 value로 사용 가능

person = {
    '이름': 'seoyoen',
    '나이': 7,
    '키': 120,
    '몸무게': 23
}

print(person['이름']) # seoyeon
print(person['나이']) # 7
print(person.get('별명')) # 없는 key에 접근하면 None 출력

person['최종학력'] = '유치원' # 새로운 데이터 추가
person['키'] = 130 # 특정 key의 value 변경
person.update({'키': 140, '몸무게': 26}) # 여러 key들의 value 변경
person.pop('몸무게') # 특정 key:value 삭제
person.clear() # 모든 데이터 삭제
print(person.keys()) # 어떤 key들이 있는지 확인
# dict_keys(['이름', '나이', '키', '몸무게'])
print(person.values()) # value 확인
print(person.items()) # key-value 모두 확인 가능

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

자료형 비교

• 여러 값들을 순서대로 관리 => 리스트
• 값이 바뀔 일이 없거나 안되는 경우 => 튜플
• 값의 존재 여부가 중요하다, 중복 X => 세트
• key를 통해 효율적으로 데이터 관리 => 딕셔너리
• 튜플을 수정하는 방법

my_tuple = ('오예스', '몽쉘' )
my_list = list(my_tuple)
my_list.append('초코파이')
my_tuple = tuple(my_list)

• 리스트 중복값 제거

# set로 변경 후 중복값 제거, 다시 리스트로
my_list = ['오예스', '몽쉘', '초코파이', '초코파이']
my_set = set(my_list)
my_list = list(my_set)

# 순서가 중요하다면 set로 변환하지 않고 딕셔너리 이용
my_dic = dict.fromkeys(my_list)
print(my_dic)
# {'오예스': None, '몽쉘': None, '초코파이': None}
my_list = list(my_dic)

조건문

1. if만 있는 경우

if 조건:
    이 문장
다음 문장

today = '화요일'
if today == '일요일':
    print('게임 한 판')
print('공부 시작')

2. if, else

if 조건:
    이 문장
else:
    저 문장
다음 문장

today = '화요일'
if today == '일요일':
    print('게임 한 판')
else:
    print('폰 5분만')
print('공부 시작')

3. elif

• 앞의 조건이 참이 아닌 경우 다른 조건을 다시 한번 확인하기 위한 용도
• if와 else 사이에 넣을 수 있다
• else 는 생략 가능

if 조건1:
    이 문장
elif 조건2:
    저 문장
else:
    그 문장
다음 문장

if today == '일요일':
    print('게임 한판')
elif today == '토요일':
    print('폰 5분만')
else:
    print('물 한잔')
print('공부 시작')

4. if 중첩

if 조건1:
    이 문장
    if 조건2:
        저 문장
다음 문장

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

for 반복문

for 변수 in 반복 범위 또는 대상:
    반복 수행 문장

for x in range(10):
    print('팔 벌려뛰기')

for x in range(10): # range(0~9)
    print(f'팔 벌려뛰기 {x}회')
    # 팔 벌려뛰기 0회, 1회, 2회 ...

range

• 수를 셀 때 0부터 시작한다
• range(start, stop) : start 이상 stop 미만
• range(start, stop, step) : start 이상 stop 미만 step만큼 증가

for 활용

• 반복대상 : 리스트, 튜플, 딕셔너리

my_list = [1, 2, 3]
for x in my_list:
    print(x) # 1 2 3

my_tuple = (1, 2, 3)
for x in my_tuple:
    print(x) # 1 2 3

my_dict = {'이름': '나귀욤', '나이': 7, '키': 120, '몸무게': 23}
for v in my_dict.values():
    print(v) # value(나귀욤, 7, 120, 23)이 출력
for k in my_dict.keys():
    print(k) # key 출력
for k, v in my_dict.items();
    print(k, v) # key value 모두 출력

fruit = 'apple'
for x in fruit:
    print(x) # 문자열의 문자가 하나씩 출력

while

• ~하는 동안 이라는 의미
• 조건이 참인 동안 계속해서 반복

while 조건:
    반복 수행 문장

max_weight = 25 # 최대 허용 무게
weight = 0 # 현재 캐리어 무게
item = 3 # 각 짐의 무게

while weight + item <= max: # 캐리어에 짐을 더 넣어도 되는지 확인
    weight += item
    print('짐 추가')
print(f'총 무게는 {weight}입니다.')
# 최대 8개의 짐, 총 무게 24 임을 확인 가능

break

• 반복문 내에서 반복 수행 중인 동작을 즉시 멈추고 반복문을 탈출하는 역할
• 주로 if 조건문과 함께 쓰인다

drama = ['시즌 1', '시즌2', '시즌3', '시즌4', '시즌5']
for x in drama:
    if x === '시즌3':
        print('그만')
        break
    print(f'{x} 시청')

continue

• 어떤 동작을 건너뛰고 싶을 때 사용할 수 있음

drama = ['시즌1', '시즌2', '시즌3', '시즌4', '시즌5']
for x in drama:
    if x === '시즌3':
        print('건너뛰기')
        break
    print(f'{x} 시청')
# 시즌 1, 2 ... 건너뛰기 시즌4 시즌5 순으로 출력

들여쓰기 (indent)

• 파이썬에서는 굉장히 큰 역할을 한다
• 동일한 들여쓰기 = 같은 문단 (함께 실행)
• 콜론(:) 다음은 들여쓰기 후 작성해야 한다
• 일반적으로 스페이스 4칸 적용

리스트 컴프리헨션 (List Comprehension)

• 리스트 내에서 어떤 조건에 해당하는 데이터만 뽑아내거나 값을 바꿔서 새로운 리스트를 만들 때 사용
• new_list = [변수 활용 for 변수 in 반복대상 if 조건]

my_list = [1, 2, 3, 4, 5]
new_list = [x for x in my_list if x > 3]
# my_list에서 3보다 큰 값들만 사용해서 새로운 리스트
print(new_list) # [4, 5]

products = ['JOA-2020', 'JOA-2021', 'SIRO-2021', 'SIRO-2022']
recall = [] # 리콜 대상 제품 리스트
for p in products:
    if p.starwith('SIRO'): #SIRO로 시작하는가?
        recall.append(p)
print(recall) #['SIRO-2021', 'SIRO-2022']

# list comprehension 사용
recall = [p for p in products if p.startwith('SIRO')]
prod_se = [p + 'SE' for p in products]
# ['JOA-2020SE', 'JOA-2021SE' ...]
prod_lower = [p.lower() for p in products]
# ['joa-2021' ...]
prod_new = [p+'(최신형)' for p in products if p.endswith('2022')]
# 'SIRO-2022(최신형)'

함수

• 어떤 동작을 수행하는 코드들의 묶음
• 여러 곳에서 사용되는 코드는 하나의 함수로
• 함수 내의 문장들을 실행시키기 위해서 호출이 필요

def 함수명():
    수행할 문장

def show_price(): # 함수 정의
    print('가격은 10000원 입니다.')

show_price(); # 함수 호출

전달값

• 여러 개 사용 가능 (콤마로 구분)
• 함수 내에서만 사용

def 함수명(전달값):
    수행할 문장

def show_price(customer):
    print(f'{customer} 고객님')
    print('커트 가격은 15000원입니다')

customer1 = '나장발'
show_price(custoemr1) # 함수 호출

반환값

• 함수 내에서 처리된 결과를 반환
• 여러 개 반환 가능 (콤마로 구분, 튜플)
• 반환되는 즉시 함수 탈출

def 함수명(전달값):
    수행할 문장
    return 반환값

def get_price(is_vip): # True: 단골, False: 일반
    if is_vip == True:
        return 10000
    else:
        return 15000

price = get_price(True)
print(f'커트 가격은 {price}원입니다') # 10000원

기본값

• 전달값 에 기본으로 사용되는 값

def 함수명(전달값 = 기본값):
    수행할 문장

def get_price(is_vip = False):
    if is_vip = True:
        return 10000
    return 15000

# 일반 손님인 경우가 default

키워드값

• 여러 개의 전달값이 필요한 경우에 사용
• 전달값의 대상을 딱 정해주는 것

def get_price(is_vip=False, is_birthday=False, is_membership=False, card=False, review=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일', 'customer1') # 1명 가능
visit('2022년 6월 11일', 'customer1', 'customer2') # 여러 명 가능

지역변수

• 함수 내에서 정의된 변수
• 함수 내에서만 사용 가능
• 이름이 같아도 다른 함수에 존재하면 다른 변수

전역변수

• 어디서든 사용할 수 있는 변수
• 함수 밖에서나, 안에서나 사용 가능
• 동일한 이름이어도 지역변수와 전역변수는 다름

message = '전역 변수'
print(message) #전역 변수

def no_secret():
    global message # 전역변수 사용한다는 의미
    message = '지역 변수'
    print(message) # 지역 변수

no_secret()
print(message) # 지역 변수

파일 입출력

input()

• 사용자 입력을 받을 수 있다
• 입력값은 모두 문자열 형태

# 버거를 주문하는 코드
name = input('예약자분 성함이 어떻게 되나요?')
print(name) # name에 저장된 사용자 이름이 출력

num = int(input('총 몇 분이세요?'))
if num > '4:
    print:('최대 4분만 예약 가능합니다')

open(파일명, 열기 모드, encoding='인코딩')

• 열기 모드
  • r : read (읽기)
  • a : append (이어서 쓰기)
  • w : write (쓰기)

f = open('list.txt', 'w', encoding='utf8') #쓰기 모드로 파일 열기

f.write('김xx\n') # 문장 입력하기
f.write('정xx\n')
f.close() # 파일 닫기

f = open('list.txt', 'r', encoding='utf8') # 읽기 모드
contents = f.read()
print(contents) # 김xx 정xx 출력
f.close()

for line in f: #한줄씩 읽기
    print(line, end='')
f.close()

with

• 블럭 벗어나면 자동으로 파일 닫음
• close() 함수를 호출할 필요가 없다

with open('list.txt', 'w', encoding='utf8') as f:
    # 문장 입력
    f.write('김xx\n')
# 구문을 빠져나가면 바로 close()

클래스

• 여러 변수들을 묶어서 한 번에 관리할 수 있다
• 어떤 기능을 하는 함수와 같은 걸 만들어서 동작하게 할 수 있다
• 설계도 + 설명서
• 한 번만 정의하면 여러 객체를 생성할 수 있다
• 각 객체는 클래스의 인스턴스라고 표현한다
• 대문자로 시작하는 것이 일반적이다

class 클래스명:
    정의

class BlackBox:
    pass # 구현하기 위한 부분을 잠시 미뤄두기 위해 사용

# 클래스 객체를 만들어야 클래스 호출 가능
b1 = BlackBox() # b1 객체 생성 완료
b1.name = '까망이' # 변수 선언
print(b1.name) # 까망이
print(isinstance(b1, BlackBox))
# 정말 인스턴스가 맞는지 확인 -> 실행 결과 True

__init__

• 비어있는 class를 채우기 위해 __init__ 함수를 사용할 수 있다
• 초기화 역할을 해주는 함수
• 객체가 생성될 때 자동으로 생성된다

class BlackBox:
    def __init__(self, name, price):
        self.name = name
        self.price = price

b1 = BlackBox('까망이', 200000)
print(b1.name) # 까망이
print(b1.price) # 200000

멤버변수

• 클래스 객체마다 서로 다른 값을 가질 수 있다
• __init__ 함수의 변수
• 똑같은 클래스의 객체로 만들어져도 그들이 가지는 맴버변수의 값은 다를 수 있다

class BlackBox:
    def __init__(self, name, price):
        self.name = name
        self.price = price

b1 = BlackBox('까망이', 200000)
b2 = BlackBox('하양이', 100000)

b1.nickname = '1호'
# b2는 모르는 b1만의 새로운 멤버변수 추가
# 클래스에는 정의되지 않은 새로운 변수이다

메소드

• 클래스 내에 선언되는 함수
• 메소드를 정의할 때 처음 전달값은 반드시 self
• 메소드 내에서는 self.name과 같은 형태로 멤버변수 사용

class BlackBox:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def set_travel_mode(self, min): #여행 모드 시간(분)
        print(str(min) + '분 동안 여행모드 ON')

b1 = BlackBox('까망이', 20000)
b1.set_travel_mode(20) # '20분 동안 여행모드 on' 출력

self

• 객체 자기 자신을 의미
• 함께 호출되지 않는다
• 객체가 만들어질 때 self에 각 객체가 들어가게 된다

class BlackBox:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def set_travel_mode(self, min): #여행 모드 시간(분)
        print(str(min) + '분 동안 여행모드 ON')

b1.set_travel_mode(20)
BlackBox.set_travel_mode(b1, 20)
# 모두 같은 내용을 출력
# b1 = self, 20 = min
# BlackBox 클래스의 함수를 호출하는 것

상속

• 중복되는 내용을 그대로 사용하고 추가로 내용을 확장할 수도 있다

class BlackBox: # 부모 클래스
    def __init__(self, name, price):
        self.name = name
        self.price = price

# BlaockBox 클래스 상속
class TravelBlackBox(BlackBox): # 자식 클래스
    def set_travel_mode(self, min):
        print(str(min) + '분 동안 여행모드 ON')

b1 = BlackBox('까망이', 200000)
b2 = TravelBalckBox('하양이', 2000000)
b2.set_travel_mode(20)

super

• 부모 클래스의 중복된 내용을 그대로 상속받고 추가로 사용할 수 있다.
• super().메소드() 형식으로 부모 클래스 호출 가능
• super() = 부모 메소드

class TravelBlackBox(BlackBox):
    def __init__(self, name, price, sd):
        BlackBox.__init__(self, name, price):
        self.sd = sd

    def set_travel_mode(self, min):
        print(str(min) + '분 동안 여행모드 ON')

다중상속

• 여러 클래스로부터 상속
• 콤마로 구분해서 상속받을 수 있다
• class Child(Parent1, Parent2, ...) 형식으로 다중 상속 가능

class TravelBlackBox(BlackBox, VideoMaker, MailSender):
    ...
    def set_travel_mode(self, min):
        print(str(min) + '분 동안 여행모드 ON');

b1 = TravelBlackBox('햐양이', 100000, 64)
b1.make() # 영상 제작 관련
b1.sed() # 메일 발송 관련

메소드 오버라이딩

• 메소드를 새로 정의하는 것
• 자식 클래스 내에서 부모 클래스의 메소드를 다시 정의해서 사용할 수 있다
• 새롭게 정의되지 않으면 부모 클래스의 메소드를 사용하는 것이다

class AdvancedTravelBlackBox(TravelBlackBox):
    def set_travel_mode(self, min):
        print(str(min) + '분 동안 여행모드 ON')
        self.make() # 추억용 영상 제작
        self.send() # 메일 발송

# 부모 클래스의 메소드를 새롭게 정의

pass

• 우선은 내버려두라는 의미
• 다른 작업을 먼저 하느라 코드 작성을 못했을 때 사용할 수 있다
• error가 발생하지 않음
• for, while 같은 반복문, 함수 등에도 사용 가능
• if문의 조건으로는 사용핧 수 없다

예외 처리

• 오류(error)를 제대로 처리해줘야 한다

try:
    수행 문장
except:
    에러 처리

try:
    수행 문장
finally:
    마지막 수행

try:
    수행 문장
except:
    에러 처리
else:
    정상 동작

try:
    수행 문장
except:
    에러 발생 시 수행 문장
else:
    정상 동작 시 수행 문장
finally:
    마지막으로 수행할 문장 (에러 여부와 관계없음)

• 예외처리 예시
• try: result = num1 / num2 print(f'연산 결과는 {result}입니다') except: print('error 발생') else: print('정상 동작') finally: print('수행 종료') # num1 = 3, num2 = 0 인 경우 -> error 발생 출력

에러

• 무슨 에러인지 알아야 대처가 가능하다
• 에러가 무엇인지 왜 발생했는지 알기 위해서는 Exception as [에러명]를 추가하면 알 수 있다
• 에러의 종류에 따라 여러 에러를 추가하고 싶은 경우에는 except 구문을 여러 개 적어서 에외 처리를 해줄 수 있다

try:
    result = num1 / num2
    print(f'연산 결과는 {result}입니다')
except ZeroDivisionError:
    pirnt('0으로 나눌 수 없어요')
except Exception as err:
    print('error:: ', err) # 에러 원인 알 수 있음

모듈

• 코드들이 작성되어 있는 하나의 파이썬 파일을 의미(.py)
• 새로운 환경에서 이전 파일을 사용하고 싶을 때 가져와서 쓸 수 있다

1. import 모듈
- 모듈 전체를 가져와서 사용
2. from 모듈 import 변수, 함수 또는 클래스
- 필요한 것들만 가져다 쓰겠다는 의미

import goodjob
goodjob.say() # 모듈의 say라는 함수 사용

from goodjob import say
say()

파이썬의 기본 모듈

• random : 랜덤으로 어떤 값을 뽑는다

import random

my_list = ['가위', '바위', '보']
print(random.choice(my_list)) # random으로 출력

• 다양한 내장 모듈이 존재한다.

패키지

• 모듈이 여러개 모인 것을 의미
• 하나의 폴더이고 여러 모듈이 존재한다

# nadocoding > goodjob.py
def say():
    print('참 잘했어요')

# nadocoding > goodbye.py
def bye():
    print('또 만나요')

# practice.py
import nadocoding.goodjob
nadocoding.goodjob.say() # say 함수 호출

from nadocoding import goodbye
goodbye.bye() # bye 함수 호출

from nadocoding import goodjob, goodbye
# 전부 사용 가능

 

 

 

 

---

https://www.youtube.com/watch?v=T6z-0dpXPvU

 

이 영상을 보고 파이썬 기초 문법을 정리한 것이다. 마크다운으로 정리하고 블로그에 똑같이 옮겨적었다.

급하게 복습해서 그런가 많이 헷갈렸지만...여튼 나중에는 다시 이 블로그 글 보고 복습하기 위해 업로드했다 ㅎ