* 코딩 테스트 전 기본 문법 정리 요약본
1. 자료형
정수형, 실수형, 문자열, 리스트, 튜플, 딕셔너리 등
- 정수형 : 양의 정수, 음의 정수, 제로(0)
num = 100 # 양의 정수
print(num) # 100
num = 0 # 제로(0)
print(num) # 0
num = -100 # 음의 정수
print(num) # -100
- 실수형 : 정수형에 소수점(.) 아래 값이 포함된 자료형
num = 123.12 # 실수
print(num) # 123.12
num = -123. # 소수점 아래 0 생략
print(num) # -123.0
num = 10e3 # 지수형(양의 정수)
print(num) # 10000.0 (10 x e(10)^3)
num = 123e-3 # 지수형(음의 정수)
print(num) # 0.123 (123 x e(10)^(-3) == 123 * 0.001)# 0.1 + 0.2 = 0.3 인가?
num = 0.1 + 0.2
print(num) # 30000000000000004
# 그럼 0.3을 정확하게 표현하는 법
num = round(0.1 + 0.2, 0) # 소수점 첫 번째(0+1) 자리 반올림
print(num) # 0.0
num = round(0.1 + 0.2, 1) # 소수점 두 번째(1+1) 자리 반올림
print(num) # 0.3
num = round(0.1 + 0.2, 3) # 소수점 네 번째(3+1) 자리 반올림
print(num) # 0.3
- 실수형의 연산 : 더하기, 빼기, 곱하기, 나누기, 나머지, 거듭제곱 등
a = 3
b = 5
print(a + b) # 8
print(a * b) # 15 (곱하기)
print(a ** b) # 243 (거듭제곱 3^5)
# 주의
print(a / b) # 0.6 (3 나누기 5의 실수형 반환)
print(a % b) # 3 (3 나누기 5의 나머지)
print(a // b) # 0 (3 나누기 5의 몫)
- 리스트
C, Java의 Array 그리고 C++의 Vector와 유사 (가장 자주 쓰이는 자료형 중 하나)
# 선언
lst = [1, 2, 3, 4, 5]
lst1 = []
print(lst) # [1, 2, 3, 4, 5]
print(lst1) # []
# 선언2
lst2 = [1] * 5 # 값이 1이고, 크기가 5인 리스트 생성
print(lst2) # [1, 1, 1, 1, 1]
# 원소 참조
print(lst[2]) # 3 (인덱스 2, 다시 말해 리스트 상 3번 째 값)- 리스트 인덱싱, 슬라이싱 : 리스트의 원소 참조 방식
- 리스트 컴프리헨션 : 대괄호(리스트) 안에 조건문과 반복문을 적용하여 리스트를 간편하게 초기화
lst = [1, 2, 3, 4, 5, 6, 7]
# 리스트 인덱싱
print(lst[2]) # 3 (앞에서 3번째 원소 출력)
print(lst[-4]) # 4 (뒤에서 4번째 원소 출력)
print(lst[3]) # 4 (앞에서 4번째 원소 출력)
# 리스트 슬라이싱 [a:b] 는 "a+1"번째부터 "b"번째까지
print(lst[2:5]) # [3, 4, 5] (3번째 원소부터 "5"번째 원소까지 출력)
# 리스트 컴프리헨션
# 0 ~ 4까지 원소를 가지는 리스트
lst2 = [i for i in range(5)] # [0, 1, 2, 3, 4]
# 1 ~ 20까지 수 중 홀수만 포함하는 리스트
lst3 = [i for i in range(1, 21) if i % 2 == 1]
print(lst3) # [1, 3, ... 19]- 리스트 관련 주요 메서드
arr = [3, 4, 5]
# append() : 리스트에 원소를 삽입
arr.append(2) # [3, 4, 5, 2]
# sort() : 리스트 원소 정렬
arr.sort() # [2, 3, 4, 5]
arr.sort(reverse=True) # [5, 4, 3, 2]
# insert() : 특정 인덱스에 원소 삽입
arr.insert(0, 5) # 인덱스 0에 5 삽입
print(arr) # [5, 5, 4, 3, 2]
# count() : 리스트 안에 특정 값의 개수
print(arr.count(1)) # 0
print(arr.count(3)) # 1
print(arr.count(5)) # 2
# remove() : 특정 원소 값을 제거
arr.remove(2)
print(arr) # [5, 5, 4, 3]
arr.remove(5) # 중복된 값은 아래처럼 1개만 제거된다
print(arr) # [5, 4, 3]
arr.remove(5)
print(arr) # [4, 3]
arr.remove(1) # 없는 원소를 지우려고 하기 때문에 에러 발생## 심화 ##
# 리스트에서 특정 값을 가지는 모든 원소 제거하기
arr = [1, 2, 3, 4, 5, 5, 6]
remove = {2, 5} # 리스트에서 2와 5는 모두 제거
arr = [i for i in arr if i not in remove]
print(arr) # [1, 3, 4, 6]
remove = {3, 4, 6} # 리스트에서 3, 4, 6 모두 제거
arr = [i for i in arr if i not in remove]
print(arr) # [1]
- 문자열 : 큰 따옴표(") 또는 작은 따옴표(')를 이용 가능
# 큰 따옴표, 작은 따옴표 모두 무관하다
str1 = "Hello World"
print(str1) # Hello World
str2 = 'Hello World'
print(str2) # Hello World
if str1 == str2:
print("Same") # Same 출력
else:
print("Diff")# 문자열 연산 (더하기)
s1 = 'Hello'
s2 = "World"
print(s1 + ' ' + s2) # Hello Wrold
# 문자열 연산 (곱하기)
s = "ABC" * 3
print(s) # ABCABCABC
# 문자열 연산 (슬라이싱)
s = "ABCDEFG"
print(s[1:4]) # BCD (인덱스 1부터 4-1까지)
##### 불가능 #####
# 문자열 연산 (인덱스 변경)
s = "ABBDEFG"
s[2] = "C" # 에러 발생
'''
Traceback (most recent call last):
File "e:\Projects\test.py", line 19, in <module>
s[2] = "C"
TypeError: 'str' object does not support item assignment
'''
- 튜플
리스트와 유사. 그러나 한번 선언된 값을 변경할 수 없다.
특징
- 서로 다른 성질의 데이터를 묶어서 관리해야 할 때
- 해싱(Hashing)의 키 값으로 사용해야 할 때
- 메모리를 효율적으로 사용해야 할 때 추천
- 딕셔너리
키(Key)와 값(Value)의 쌍을 데이터로 가지는 자료형
특징
- 해시 테이블(Hash Table)을 이용한다
- 데이터의 조회 및 수정이 아주 빠르다
- 딕셔너리의 키는 Immutable(변경 불가능한) 자료형만 사용 가능하다.
참고
- Immutable: 정수형, 실수형, 문자열, 튜플 등
- Mutable: 리스트, 딕셔너리, Numpy배열 등
# 딕셔너리 선언1
dic = dict()
dic['A'] = 80
dic['B'] = 70
dic['C'] = 90
print(dic) # {'A': 80, 'B': 70, 'C': 90}
# 딕셔너리 선언2
dic2 = {
'A' : 80,
'B' : 70,
'C' : 90,
}
print(dic2) # {'A': 80, 'B': 70, 'C': 90}
# 조회1
print(dic['A']) # 80
# 조회2
print(dic['D']) # 에러 발생
'''
KeyError: 'D'
'''
# 조회3
if 'B' in dic:
print("존재한다") # 출력
else:
print("존재하지 않음")dic = dict()
data["수지"] = 80
data["수현"] = 90
data["길동"] = 75
# 키(Key)만 추출
keys = dic.keys()
print(keys) # dict_keys(['수지', '수현', '길동'])
# 값(Data)만 추출
datas = dic.values()
print(datas) # dict_values([80, 90, 75])
# 예시
for key in keys: # 80
print(dic[key]) # 90
# 75
- 집합 : 순서가 없고, 중복을 허용하지 않는 자료형
# 집합 선언1
s1 = set([1, 1, 2, 3, 4, 5, 5, 5])
print(s1) # {1, 2, 3, 4, 5}
# 집합 선언2
s2 = {1, 1, 3, 3, 5, 5, 5, 7, 7, 9}
print(s2) # {1, 3, 5, 7, 9}
# 합집합
print(s1 | s2) # {1, 2, 3, 4, 5, 7, 9}
# 교집합
print(s1 & s2) # {1, 3, 5}
# 차집합
print(s1 - s2) # {2, 4}
print(s2 - s1) # {9, 7}- 집합 관련 주요 메서드
s = set([4, 2, 3])
print(s) # {2, 3, 4} <- 자동으로 정렬됨
# add() : 새로운 원소 추가
s.add(5)
print(s) # {2, 3, 4, 5}
s.add(2) # 중복된 값은 추가되지 않음
print(s) # {2, 3, 4, 5}
# update() : 원소 여러 개 추가
s.update([8, 5, 7])
print(s) # {2, 3, 4, 5, 7, 8}
# remove() : 원소 '값' 삭제(인덱스 아님)
s.remove(3)
print(s) # {2, 4, 5, 7, 8}- 리스트나 튜플은 순서가 있기 때문에, 인덱싱을 통해 자료형의 값을 얻을 수 있다.
- 딕셔너리와 집합은 순서가 없기 때문에, 인덱싱을 통해 값을 얻을 수 없다.
2. 입출력
- 표준 입력
# input() : 한 줄의 문자열을 입력 받음
s = input() # string
n = int(input()) # integer
# split(문자) : 인자로 주어진 문자를 기준으로 구분함
s1 = input().split() # 띄어쓰기를 기준으로
s2 = input().split(',') # 콤마(,)를 기준으로
# map() : 리스트 모든 원소에 특정한 함수를 적용
s = input().split() # ex. 1 2 3 4
print(s) # ['1', '2', '3', '4']
n = map(int, s) # s(리스트)에 모두 int 함수 적용
n = list(n)
print(n) # [1, 2, 3, 4]
### 종합 ###
# 1. 공백으로 구분된 값을 입력받아 정수로 변환 후 리스트로 저장
arr = list(map(int, input().split()))
# 2. 각 변수에 정수를 입력 받을 때(ex. 3개)
a, b, c = list(map(int, input().split()))
print(a, b, c)# 다량의 입력을 받는 경우(feat. 코딩테스트)
import sys
# 문자열 입력 받기(엔터 포함)
str = sys.stdin.readline()
# 문자열 입력 받기(엔터 제외)
str = sys.stdin.readline().rstrip()
- 표준 출력
# 개행 포함
print("Hello") # Hello
print("World") # World
# 개행 제외
print("Hello", end = " ")
print("World", end = " ") # Hello Wrold
# 변수 출력 1
num = 10
print("num : " + num) # 에러 발생
print("num : " + str(num)) # num : 10
# 변수 출력 2 (f-string) (Python 3.6 이상)
num = 20
print(f"num : {num}") # num : 20
3. 조건문
파이썬 코드의 블록은 들여쓰기(Indent)로 구분한다(조건문, 반복문, 함수 등)
# 조건문 기본
a = 10
if a > 10 :
print("a > 10")
if a == 10 : # 또는 elif a == 10 :
print("a == 10")
if a < 10 : # 또는 else :
print("a < 10")
# 조건문 안의 조건문
a = 6
if a % 2 == 0:
if a % 3 == 0:
print("2와 3의 공배수")
# 2개의 조건
a = 20
if a >= 10 and a < 30 :
print("10 이상 30 미만")num = 100
# 조건문의 간소화 1
if num > 80: print("Pass")
else: print("Fail")
# 조건문의 간소화 2
# int a = (num == 100) ? num : 0 # C언어 스타일
a = num if num == 100 else 0
print(a) # 100
# 조건문의 간소화 3
if 80 <= num <= 100:
print("80 이상 100 이하")
else:
print("그 외")
4. 반복문
소스를 반복적으로 사용하고 싶을 때(while, for문)
# 1 ~ 10까지 더하는 코드
# while문
num = 1
sum = 0
while num <= 10:
sum += num
num += 1
print(sum)
# for문 1
sum = 0
for i in range(1, 11):
sum += i
print(sum)
# for문 2 (만약 리스트가 존재한다면)
sum = 0
arr = [i for i in range(1, 11)]
for i in arr:
sum += i
print(sum)
# Break & Continue
sum = 0
for i in range(1, 9999):
if i % 2 == 0:
continue # 짝수는 스킵
if i > 10: # 10 초과일 경우 중단
break
sum += i
print(sum)
5. 함수와 람다 식
- 함수
반복적으로 사용되는 코드를 하나의 묶음으로 모아놓은 것.
# 더하기 함수
def add(a, b):
return a + b
print(add(1, 3)) # 4
# 함수의 파라메터 지정
print(add(b = 3, a = 1)) # 4
# 다중 리턴 함수
def calc(a, b):
add = a + b;
sub = a - b;
mul = a * b;
div = a / b;
return add, sub, mul, div
a, s, m, d = calc(10, 4)
print(a, s, m, d) # 14 6 40 2.5# 전역변수 사용법 1
def sub(a):
# 함수 외부에서 선언했던 g 변수
# 변수는 global 키워드가 필요하다.
global g
return g - a
g = 10
print(sub(3)) # 7
# 전역변수 사용법 2
def func():
# 외부에서 선언했던 리스트
# global 없이 접근 가능
arr.append(5)
arr = [1, 2, 3, 4]
func()
print(arr) # [1, 2, 3, 4, 5]- 람다
함수를 한 줄로 간단하게 작성하는 문법
# 람다 표현식 (더하기 함수)
add = (lambda a, b: a + b)(3, 5)
print(add) # 8
############
# 자주 쓰는 람다 형식(정렬)
arr = [("사과", 1000), ("복숭아", 2000), ("토마토", 500)]
# 튜플의 참조(예시)
tup = ("AAA", 100)
print(tup[0], tup[1]) # AAA 100
# 람다 구현 (가격 기준 정렬)
print(sorted(arr, key=lambda x: x[1]))
############
# 자주 쓰는 람다 형식(리스트 활용)
lst1 = [1, 2, 3, 4, 5]
lst2 = [6, 7, 8, 9, 10]
lst = list(map(lambda a, b: a + b, lst1, lst2))
print(lst)