Coding Test(Grammar) - Python

Input

# map()을 이용하여 list에 저장
data = list(map(int,input().split()))
[1, 1]

#map()을 이용하여 두 변수에 저장
a,b = map(int,input().split())
1 1

#sys.stdin.readline()을 사용하면 줄 바꿈 기호가 입력 되기때문에 rstrip() 같이 사용

data = list(map(str,sys.stdin.readline())) #['w', 'a', '\n']
num = list(map(str,input())) #['w', 'a']

# 123 => [1,2,3], 각 자리수 따로따로 저장됨
data = list(map(int,str(i)))
data = list(map(int,input()))

 

Dictionary

# Key와 Value를 한 쌍으로 갖는 자료형이다. 
# Key에는 변하지 않는 값을 사용하고, Value에는 변하는 값과 변하지 않는 값 모두 사용할 수 있다.
dic = {'name':'pey', 'phone':'0119993323', 'birth': '1118'}

#키 데이터만 담은 리스트
dic.keys()

#값 데이터만 담은 리스트
dic.values()

# dic 쌍 추가/삭제
a = {1: 'a'}

#추가
a[2] = 'b'
a['name'] = 'pey'
a => {1: 'a', 2: 'b', 'name': 'pey'}

#삭제
del a[1] 
a => {2: 'b', 'name': 'pey'}


items={'커피음료':7,"펜":3}

print(items['펜'])
>> 3

contact = {'성':'이','이름':'지원','직장':'동의대학교'}
for a,b in contact.items():
    print(a,':',b)

성 : 이
이름 : 지원
직장 : 동의대학교

#dictionary 생성
data_lower = {key : value.lower() for key, value in data.items()}


#key로 value 찾기
data2.get(key)

#value로 key찾기
for key, value in data_lower.items():
    if value == sorted(data_lower.values())[0]:
        print(data.get(key))

Tuple

#한 번 선언된 값을 변경할 수 없다
#리스트에 비해 상대적으로 공간 효율적
#서로 다른 성질의 데이터를 묶어서 관리 - 최단 경로 알고리즘(비용,노드 번호)

# 데이터의 나열을 해싱(Hashing)의 키 값으로 사용해야 할 때

Iist

list.split() # split함수는 어떤 문자를 기반으로 나누는 함수
list.strip() # 특정 문자열 및 공백 제거

#리스트 만들기
data = list(range(1,n+1))

#append(x)는 리스트의 맨 마지막에 x를 추가하는 함수이다.
data = [1, 2, 3]
data.append(4)
data => [1, 2, 3, 4]

#pop()은 리스트의 맨 마지막 요소를 돌려주고 그 요소는 삭제한다.
data = [1,2,3]
data.pop() #3
data => [1, 2]

#pop(x)는 리스트의 x번째 요소를 돌려주고 그 요소는 삭제한다.
data = [1,2,3]
data.pop(1) #2
data => [1, 3]


#index(x) 함수는 리스트에 x 값이 있으면 x의 위치 값을 돌려준다.
#리스트에 존재하지 않는 값을 사용하면 값 오류(ValueError)가 발생한다.
data = [1,2,3]
data.index(3) #2
data.index(1) #0


#insert(a, b)는 리스트의 a번째 위치에 b를 삽입하는 함수이다.
data = [1,2,3]
data.insert(0, 4) #[4, 1, 2, 3]


#remove(x)는 리스트에서 첫 번째로 나오는 x를 삭제하는 함수
#a가 3이라는 값을 2개 가지고 있을 경우 첫 번째 3만 제거되는 것을 알 수 있다.
data1 = [1, 2, 3, 1, 2, 3]
data1.remove(3) #[1, 2, 1, 2, 3]

#count(x)는 리스트 안에 x가 몇 개 있는지 조사하여 그 개수를 돌려주는 함수이다.
data1.count(1) #2

#del a[x]는 x번째 요솟값을 삭제한다.
data = [1, 2, 3]
del data[1]
data => [1, 3]

#슬라이싱 기법을 사용하여 리스트의 요소 여러 개를 한꺼번에 삭제할 수도 있다.
data = [1, 2, 3, 4, 5]
del data[2:]
data => [1, 2]


#sort, reverse
data.sort()
data.sort(reverse=True)

#key값을 이용해서 특정한 조건으로 정렬을 수행할 수 있다
data.sort(key=str.lower)



#key값 응용버전 : lambda를 이용한 2차원 정렬
#1열, 0열 순서로 오름차순 정렬을 한다
data.sort(key=lambda x: (x[1], x[0]))

#압축해제
print(*data)
data => 1,2,3,4,5

string

#문자열에서만 사용 가능한 함수
#찾는 문자가 문자열 안에서 첫 번째에 위치한 순서를 숫자로 출력한다.
#만일 찾는 문자가 문자열 안에 없는 경우에는 -1을 출력하는 함수
str.find()

string.upper #문자열 대문자로 변경하는 함수

string.lower #문자열 소문자로 변경하는 함수

string.isupper #문자가 대문자인지 확인하는 함수

string.islower #문자가 소문자인지 확인하는 함수

#문자열이 알파벳([a-zA-Z])과 숫자([0-9])로만 구성되었는지 확인
str.isalnum()

iteration

for x in reversed(range(num)): #for x in range(n,0,-1) -> 5~1
    print(x+1)			#range(5) -> 0~4
				#reversed(range(5)) -> 4~0

for x in data: 		#list안에 원소들을 각각 인자로 받을 때 사용
    if not x in data2: 	#list안에 원소를 찾고 싶을 때 사용
        data2.append(x)

for x in arr[1:]: #list의 특정 부분부터 반복문 수행

#enumerate()
#인덱스(index)와 원소를 동시에 접근하면서 루프 돌리기 
for i, letter in enumerate(['A', 'B', 'C']):
	print(i, letter)


0 A
1 B
2 C

 

print

for i in range(1,num+1): #print()안에서 문자열을 여러번 쓸 때 *를 이용해서 여러번 가능
    print(" " * (num-i) + "*" * i)

print(min(data),end=" ")
print(max(data))
------------------------------------------
print(‘{} {}’.format(min(data),max(data)) #이렇게 사용 가능

print(f'{result:.3f}%') #소수 세 번째 자리까지 표시

print('{0:02d}'.format(room)) #정수를 2자리로 표현(3을 03, 4를 04로 표현)

# f-string(python>=3.6)
s = 'coffee'
n = 5
result1 = f'저는 {s}를 좋아합니다. 하루 {n}잔 마셔요.'
print(result1)

print(':'.join(time_list))

10:20:30

sep(separation) 

영단어 그대로, 분리하여 출력한다. 다만 분리할 (갈라놓을 문자를 지정할 수 있다.) 이것을 구분자라고 한다.

예를 들어서 아래처럼 사용 할 수 있다.

print('S','E','P', sep='@')

출력 >>>>> S@E@P

S , E , P라는 문자열 사이에 @가 끼워넣어져 출력된다. 즉, 구분자는 @가 된다.

순열, 조합

from itertools import permutations #순열

for i in permutations([1,2,3,4], 2):
    print(i, end=" ")

(1, 2) (1, 3) (1, 4) (2, 1) (2, 3) (2, 4) (3, 1) (3, 2) (3, 4) (4, 1) (4, 2) (4, 3)

from itertools import combinations #조합

for i in combinations([1,2,3,4], 2):
    print(i, end=" ")
    
(1, 2) (1, 3) (1, 4) (2, 3) (2, 4) (3, 4)

for i in product([1,2,3], repeat=2): #중복순열
    print(i, end=" ")
    
(1, 1) (1, 2) (1, 3) (2, 1) (2, 2) (2, 3) (3, 1) (3, 2) (3, 3)

from itertools import combinations_with_replacement #중복조합

for cwr in combinations_with_replacement([1,2,3,4], 2):
    print(cwr, end=" ")
    
(1, 1) (1, 2) (1, 3) (1, 4) (2, 2) (2, 3) (2, 4) (3, 3) (3, 4) (4, 4)

진법 변환

#n진수 → 10진수
print(int('101',2))
print(int('202',3))
print(int('303',4))
print(int('404',5))
print(int('505',6))
print(int('ACF',16))

#10진수 → 2, 8, 16진수
#0b1011,0o13,0xb 같이 출력되는데 앞에 진법표시를 제외하기 위해 slice이용
print(bin(11)[2:])
print(oct(11)[2:])
print(hex(11)[2:])

#10진수 → n진수
def solution(n, q):
    rev_base = ''

    while n > 0:
    	#divmod : 몫과 나머지를 tuple 형식으로 반환
        n, mod = divmod(n, q)
        rev_base += str(mod)

    return rev_base[::-1] 
    # 역순인 진수를 뒤집어 줘야 원래 변환 하고자하는 base가 출력
    
print(solution(45, 3))

etc

ord(x) #문자 -> 숫자(아스키코드)
chr(x) #숫자(아스키코드) -> 문자

Collections 모듈의 Counter 클래스를 활용하여 쉽게 홀/짝수 알파벳을 구할 수 있다.

from collections import Counter
check = Counter(word)

Counter({'B': 4, 'A': 3, 'S': 2, 'D': 1})


import collections 
c2 = collections.Counter('apple, orange, grape') 
print(c2.most_common()) #가장 빈도가 많은 것 출력
print(c2.most_common(3)) #특정 문자에 대해 빈도수를 계산

''' 
결과 
[('a', 3), ('p', 3), ('e', 3), ('g', 2), (',', 2), ('r', 2), (' ', 2), ('n', 1), ('l', 1), ('o', 1)] 
[('a', 3), ('p', 3), ('e', 3)]
'''

#python 2차원 리스트의 대해서 원소 하나하나의 대한 min, max를 하는법

#단순히 2차원 리스트에 min, max를 쓰게 되면 1차원 리스트로 return
#따라서, map함수를 이용해 간단히 해결 
start = min(map(min,ground))
end =  max(map(max,ground))

s = {1, 5, 1, 1, 1, 3, 7} #class 'set’
s = set()		  #중복 제거
s => {1, 3, 5, 7}

#삼항 연산자(python 미지원)
[condition] ? [true_value] : [false_value] 

#삼항 연산자(python)
[true_value] if [condition] else [false_value]

#python slice
#연속적인 객체들의 자료구조(예: 리스트, 튜플, 문자열)
str[start : end : step]

#Index References
|  a  |  b  |  c  |  d  |  e  |
|  0  |  1  |  2  |  3  |  4  |          # 양수의 경우
| -5  | -4  | -3  | -2  | -1  |          # 음수의 경우


#문자열, 리스트를 거꾸로 가져온다
str[::-1]

 

파이썬의 zip과 unpacking 을 이용하면 코드 한 줄로 리스트를 뒤집을 수 있습니다.

mylist = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
new_list = list(map(list, zip(*mylist)))

 

# for i in range(0)을 하면 에러가 날 것 같지만 반복할 횟수가 0인 의미 이므로 아무실행도 일어나지않음

 

# 여러조건의 swhich문을 써야할꺼같을땐 조건들을 list에 저장한 후 index로 접근해보자

# 최대공약수(GCD) : 두 자연수의 공통된 약수 중 가장 큰수

    최소공배수(LCM) : 두 자연수의 곱 / 최대공약수

 

#python의 재귀 깊이의 default 값은 1000으로 설정되어 있다는 것.

(문제에서 요구하는 n은 10000까지였기 때문에 100000까지 제한을 늘려주었다.)
(이렇게 제한을 늘려도 너무 깊은 재귀는 실행되지 않는다고 했다.(정확하지 않음))

import sys
sys.setrecursionlimit(10 ** 6)