[Python] 코딩 테스트 Cheating Sheet

>> 참조
점프 투 파이썬 : https://wikidocs.net/book/1
개인 깃허브 : https://github.com/96glory/TIL/tree/master/Python

1. Intro

# 변수에 값 넣고 출력하기
a = "Python"
print(a)

# 조건문
a = 3
if a > 1:
  print("a is grater than 1")

# 반복문
for a in [1, 2, 3]:
  print(a)

i = 0
while i < 3:
  i = i + 1
  print(i)
  
# 함수
def add(a, b):
  return a + b
add(3, 4) # 7

2. 자료형

(1) 숫자형

# 정수형
a = 123

# 실수형
b = 12.3

# 8진수
c = 0o123

# 16진수
d = 0x123

• 사칙연산 : +, -, /, *
• 나머지 : %
• 몫 : //
• 제곱 : **

(2) 문자열

1) 문자열 선언 및 초기화

# 큰따옴표로 감싸기
food1 = "Python's favorite food is perl"
say1 = "\"Python is very easy.\" he says."

# 작은따옴표로 감싸기
food2 = 'Python\'s favorite food is perl'
say2 = '"Python is very easy." he says'

# 큰따옴표/작은따옴표 3개로 감싸기
multiline1 = "Life is too short\nYou need python"
multiline2 = """
Life is too short
You need python
"""
multiline3 = '''
Life is too short
You need python
'''

2) 문자열 인덱싱 및 연산

• 문자열 인덱싱 : 파이썬의 string 배열은 0부터 숫자를 센다.

a = "Life is too short, You need Python"
a[0]    # 'L'
a[12]   # 's'
a[-1]   # 'n'

• Concatenation

head = "Python"
tail = " is fun!"
head + tail # Python is fun!

• 문자열 곱하기

a = "python"
a * 2 # pythonpython

• 문자열 길이

a = "python"
len(a) # 6

• 문자열 안에서 문자 개수 세기

a = 'hobby'
a.count('b') # 2

• 문자열 안에서 특정 문자열 위치 찾기

a = "Python is the best choice"
a.find('b') # 14 : 맨 처음 찾게 된 b
a.find('k') # -1 : 없으면 -1

b = "Life is too short"
b.index('t')    # 8
b.index('k')    # 오류 발생
# Traceback (most recent call last):
# File "<stdin>", line 1, in <module>
# ValueError: substring not found

• 문자열 삽입

",".join('abcd') # a,b,c,d

• 문자열 교체

a = "Life is too short"
a.replace("Life", "인생") # 인생 is too short

• 문자열 나누기

a = "Life is too short"
a.split()       # ['Life', 'is', 'too', 'short']

b = "a:b:c:d"
b.split(':')    # ['a', 'b', 'c', 'd']

• upper, lower : 대문자, 소문자로 바꾸기
• lstrip, rstrip, strip : 왼쪽 공백 / 오른쪽 공백 / 양쪽 공백 지우기

 

• 문자열 슬라이싱

a = "Life is too short, You need Python"
b = a[0] + a[1] + a[2] + a[3]   # 'Life'


c = "Life is too short, You need Python"
c[0:4]  # 'Life'
c[0:3]  # 'Lif'
c[19:]  # 'You need Python'
c[:17]  # 'Life is too short'
c[:]    # 'Life is too short, You need Python'

• 문자열 포매팅

# 숫자 바로 대입
"I eat %d apples." % 3  # 'I eat 3 apples.'

# 문자열 바로 대입
"I eat %s apples." % "five" # 'I eat five apples.'

# 변수 대입
number = 10
day = "three"
"I ate %d apples. so I was sick for %s days." % (number, day)
# 'I ate 10 apples. so I was sick for three days.'

# %는 %%로
"Error is %d%%." % 98
# 'Error is 98%.'

# format 함수를 사용한 포매팅
number = 10
day = "three"
"I ate {0} apples. so I was sick for {1} days.".format(number, day)
# 'I ate 10 apples. so I was sick for three days.'

# f 문자열 포매팅
name = '홍길동'
age = 30
f'나의 이름은 {name}입니다. 나이는 {age}입니다.'
# '나의 이름은 홍길동입니다. 나이는 30입니다.'

(3) 리스트

• 리스트 선언

a = []
b = [1, 2, 3]
c = ['Life', 'is', 'too', 'short']
d = [1, 2, 'Life', 'is']
e = [1, 2, ['Life', 'is']]​

• 리스트 인덱싱

a = [1, 2, 3, ['a', 'b', 'c']]
a[0]        # 1
a[-1]       # ['a', 'b', 'c']
a[-1][0]    # 'a'
a[2][2]     # 'c'

a = [1, 2, ['a', 'b', ['Life', 'is']]]
a[2][2][0]  # 'Life'​

• 리스트 슬라이싱

a = [1, 2, 3, 4, 5]
a[0:2]  # [1, 2]
a[:2]   # [1, 2]
a[3:]   # [4, 5]

b = [1, 2, 3, ['a', 'b', 'c'], 4, 5]
b[2:5]      # [3, ['a', 'b', 'c'], 4]
b[3][:2]    # ['a', 'b']​

• 리스트 연산

a = [1, 2, 3]
b = [4, 5, 6]

# 리스트 더하기
a + b   # [1, 2, 3, 4, 5, 6]

# 리스트 반복
a * 3   # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 리스트 길이
len(a)  # 3

• 리스트 수정 및 삭제

# 리스트 수정
a = [1, 2, 3]
a[2] = 4
a   # [1, 2, 4]

# 리스트 요소 삭제
del a[1]
a   # [1, 3]

b = [1, 2, 3, 4, 5]
del b[2:]
b   # [1, 2]

• 리스트 함수

# 리스트에 요소 추가
a = [1, 2, 3]
a.append(4)
a # [1, 2, 3, 4]

# 리스트 정렬
a = [1, 4, 3, 2]
a.sort()
a # [1, 2, 3, 4]

# 리스트 뒤집기
a = [1, 2, 3]
a.reverse()
a # [3, 2, 1]

# 리스트 위치 반환
a = [1, 2, 3]
a.index(3) # 2
a.index(0) # 오류 발생

# 리스트 요소 삽입
a = [1, 2, 3]
a.insert(0, 4)
a # [4, 1, 2, 3]

# 리스트 요소 제거
a = [1, 2, 3, 1, 2, 3]
a.remove(3)
a # [1, 2, 1, 2, 3]

# 리스트 요소 끄집어내기
a = [1, 2, 3, 4, 5]
a.pop() # 5
a # [1, 2, 3, 4]
a.pop(0) # 1
a # [2, 3, 4]

# 리스트에 포함된 요소의 개수 세기
a = [1, 2, 3, 1]
a.count(1) # 2

(4) 튜플

• 리스트는 [ ]으로 둘러싸지만 튜플은 ( )으로 둘러싼다.
• 리스트는 그 값의 생성, 삭제, 수정이 가능하지만 튜플은 그 값을 바꿀 수 없다.

t1 = ()
t2 = (1,)
t3 = (1, 2, 3)
t4 = 1, 2, 3    # 괄호를 생략해도 된다!
t5 = ('a', 'b', ('ab', 'cd'))

(5) 딕셔너리

• 딕셔너리는 Key를 통해 Value를 얻는다.
• 딕셔너리의 Key에 리스트는 사용이 불가하지만, 튜플은 사용 가능하다.

dic = {'name': 'glory', 'phone': '01000000000', 'birth': '1226', 'a': [1, 2, 3]}

• 딕셔너리 key-value 추가하기

a = {1: 'a'}
a[2] = 'b'
a   # {1: 'a', 2: 'b'}
a['name'] = [1, 2, 3]
a   # {1: 'a', 2: 'b', 'name': [1, 2, 3]}​

• 딕셔너리 요소 삭제하기

del a[1]
a   # {2: 'b', 'name': [1, 2, 3]}

• 딕셔너리 관련 함수

# keys : Key 객체/리스트 만들기
a = {'name': 'pey', 'phone': '0119993323', 'birth': '1118'}
a.keys()        # dict_keys(['name', 'phone', 'birth'])

# 객체를 리스트로 변환
list(a.keys())  # ['name', 'phone', 'birth']

for k in a.keys():
  print(k)
# name
# phone
# birth

# items : Key-Value 쌍으로 얻기
a.items()   # dict_items([('name', 'pey'), ('phone', '0119993323'), ('birth', '1118')])

# clear : Key-Value 쌍 모두 지우기

(6) 집합

• 집합은 중복을 허용하지 않고, 순서가 없다.

s0 = set()
s0  # {}

s1 = set([1,2,3])
s1  # {1, 2, 3}

s2 = set("Hello")
s2  # {'e', 'H', 'l', 'o'}

# 집합을 리스트로 변환
l1 = list(s1)
l1  # [1, 2, 3]

# 집합을 튜플로 변환
t1 = tuple(s1)
t1  # (1, 2, 3)

• 교집합 / 차집합 / 합집합 구하기
  • & : 교집합
  • | : 합집합
  • - : 차집합
• 값 추가/제거

# 값 1개 추가하기
s1 = set([1, 2, 3])
s1.add(4)
s1  # {1, 2, 3, 4}

# 값 여러개 추가하기
s1 = set([1, 2, 3])
s1.update([4, 5, 6])
s1  # {1, 2, 3, 4, 5, 6}

# 특정 값 제거하기
s1 = set([1, 2, 3])
s1.remove(2)
s1  # {1, 3}

(7) 불

a = True
b = False

• 숫자 0, None, 문자열, 리스트, 튜플, 딕셔너리, 집합이 비어있는 경우는 False다.

(8) 변수

• 파이썬에서의 =는 주소값을 공유한다.

# a와 b는 같은 [1, 2, 3]을 가리킨다.
a = [1, 2, 3]
b = a

# 얕은 복사하기

a = [1, 2, 3]
b = a[:]

from copy import copy
c = copy(a)

3. 제어문/반복문

(1) if

money = 2000
if money >= 3000:
    print("택시를 타고 가라")
else:
    print("걸어가라")

# 걸어가라​

• and, or, not

money = 2000
card = True
if money >= 3000 or card:
    print("택시를 타고 가라")
else:
    print("걸어가라")

# 택시를 타고 가라

• x in s, x not in s (x는 요소, s는 리스트/튜플/문자열)

1 in [1, 2, 3]
# True

1 not in (1, 2, 3)
# False​

• pass : 해당 조건문에서 아무 일을 수행하지 않는다.

pocket = ['paper', 'money', 'cellphone']
if 'money' in pocket:
    pass 
else:
    print("카드를 꺼내라")

• elif

pocket = ['paper', 'cellphone']
card = True
if 'money' in pocket:
     print("택시를 타고가라 (현금)")
elif card: 
     print("택시를 타고가라 (카드)")
else:
     print("걸어가라")

# 택시를 타고가라 (카드)

• 조건부 표현식

# 조건문이 참인 경우 if 조건문 else 조건문이 거짓인 경우

score = 70
message = "success" if score >= 60 else "failure"
# success

(2) while

treeHit = 0
while treeHit < 10:
    treeHit = treeHit +1
    print("나무를 %d번 찍었습니다." % treeHit)
    if treeHit == 10:
        print("나무 넘어갑니다.")​

• break, continue

(3) for

test_list = ['one', 'two', 'three'] 
for i in test_list: 
    print(i)

# one 
# two 
# three

a = [(1, 2), (3, 4), (5, 6)]
for (first, last) in a:
    print(first + last)

# 3
# 7
# 11

• range(시작 숫자, 끝 숫자) : 숫자 리스트를 자동으로 만들어주는 함수. 끝 숫자는 포함되지 않는다.

add = 0 
for i in range(1, 11): 
    add = add + i 

print(add)  # 55

###

marks = [90, 25, 67, 45, 80]

# 배열의 인덱스가 필요할 때
for number in range(len(marks)):
    if marks[number] < 60: 
        continue
    print("%d번 학생 축하합니다. 합격입니다." % (number + 1))

• 리스트 내포

a = [1, 2, 3, 4]
result = []

for num in a:
    result.append(num * 3)

print(result)   # [3, 6, 9, 12]

## 리스트 내포 방식

a = [1, 2, 3, 4]
result = [num * 3 for num in a]

print(result)   # [3, 6, 9, 12]

4. 함수

def add(a, b): 
    return a + b

print(add(3, 4))            # 7
print(add(a = 3, b = 7))    # 10
print(add(b = 7, a = 3))    # 10

• 함수 파라미터 갯수가 따로 정해지지 않았을 때 args, kwargs를 활용한다

 

• *args : 입력값을 전부 모아서 튜플 형태로 만들어냄.

def add_many(*args): 
    result = 0 
    for i in args: 
        result = result + i 
    return result

print(add_many(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))    # 55

def add_mul(choice, *args): 
    if choice == "add": 
        result = 0 
        for i in args: 
            result = result + i 
    elif choice == "mul": 
        result = 1 
        for i in args: 
            result = result * i 
    return result

print(add_mul("mul", 1, 2, 3, 4))   # 24
print(add_mul("add", 1, 2, 3, 4))   # 10

• kwargs : 키워드 파라미터, 입력값을 전부 모아서 딕셔너리 형태로 만들어냄.

def print_kwargs(**kwargs):
    print(kwargs)

print_kwargs(a = 1)                 # {'a': 1}
print_kwargs(name = 'foo', age = 3) # {'age': 3, 'name': 'foo'}

• 여러 요소를 반환할 때 튜플로 반환된다.

def add_and_mul(a,b): 
    return a+b, a*b

result = add_and_mul(3, 4)              # result = (7, 12)
add_res, mul_res = add_and_mul(4, 5)    # add_res = 9, mul_res = 20

• 파라미터의 기본 값 설정하기 (단, 기본값이 설정된 파라미터는 맨 뒤에 배치해야 한다.)

#   say_myself(name, man = True, old): 오류 발생
def say_myself(name, old, man = True): 
    print("나의 이름은 %s 입니다." % name) 
    print("나이는 %d살입니다." % old) 
    if man: 
        print("남자입니다.")
    else: 
        print("여자입니다.")

• 함수 안에서 함수 밖의 변수를 변경하는 방법

a = 1 
def vartest(a): 
    a = a + 1 
    return a

a = vartest(a)

a = 1 
def vartest(): 
    global a 
    a = a + 1

vartest()​

• lambda

add = lambda a, b: a + b
result = add(3, 4)
print(result)   # 7

5. 사용자 입출력 / 파일 입출력

GitHub - 96glory/TIL: Today I Learned : 배운 것을 기록합니다.

 

6. 클래스

GitHub - 96glory/TIL: Today I Learned : 배운 것을 기록합니다.

 

7. 모듈

GitHub - 96glory/TIL: Today I Learned : 배운 것을 기록합니다.

 

8. 예외 처리

GitHub - 96glory/TIL: Today I Learned : 배운 것을 기록합니다.

 

9. 내장 함수

• abs : 절댓값 반환
• all : 반복 가능한 자료형 x를 입력 인수로 받으며, 이 x의 요소가 모두 참이면 True, 하나라도 거짓이 있으면 False를 반환

all([1, 2, 3, 0])   # False
all([])             # True

• any : 반복 가능한 자료형 x를 입력 인수로 받으며, 이 x의 요소가 하나라도 참이 있이면 True, 모두 거짓이면 False를 반환

any([0, ""])        # False
any([])             # False

• chr : 아스키 코드 값을 받아 그에 해당하는 문자를 반환

chr(48)     # '0'

• rod : 문자의 아스키 코드 값을 반환

ord('0')    # 48

• dir : 인수가 가지고 있는 변수나 함수를 보여줌.

dir([1, 2, 3])  # ['append', 'count', 'extend', 'index', 'insert', 'pop',...]
dir({'1':'a'})  # ['clear', 'copy', 'get', 'has_key', 'items', 'keys',...]

• divmod : 2개의 숫자를 입력 받고, a를 b로 나눈 몫과 나머지를 튜플 형태로 반환

divmod(7, 3)    # (2, 1)

• enumerate : 순서가 있는 자료형을 입력받아 인덱스 값을 포함하는 enumerate 객체를 반환

for i, name in enumerate(['body', 'foo', 'bar']):
    print(i, name)

# 0 body
# 1 foo
# 2 bar

• eval : 실행 가능한 문자열을 입력받아 문자열을 실행한 결과값으로 반환

eval('1+2')             # 3
eval("'hi' + 'a'")      # 'hia'
eval('divmod(4, 3)')    # (1, 1)

• filter : 첫번째 인수로 함수를, 두번째 인수로 반복 가능한 자료형을 받는다. 두번째 인수 내 요소들 중 첫번째 인수 함수가 True인 것들을 반환해준다.

def positive(x):
    return x > 0

print(list(filter(positive, [1, -3, 2, 0, -5, 6]))) # [1, 2, 6]

• hex : 정수를 16진수 문자열로 변환해줌
• oct : 정수를 8진수 문자열로 변환해줌
• id : 객체를 입력받아 객체 고유 주소값을 반환
• input : 사용자의 입력을 받는 함수
• int : 문자열 형태의 숫자나 소수점이 있는 숫자를 정수 형태로 변환

int('11', 2)    # 3
int('1A', 16)   # 26

• isinstance : 첫번째 인수로 인스턴스, 두번째 인수로 클래스 이름을 받는다. 입력받은 인스턴스가 그 클래스의 인스턴스인지를 판단해 참/거짓을 반환한다.

class Person: pass
...
a = Person()
isinstance(a, Person)   # True

• list : 반복 가능한 자료형을 입력받아 리스트로 만들어 반환

list("python")  # ['p', 'y', 't', 'h', 'o', 'n']
list((1,2,3))   # [1, 2, 3]

• map : map(f, iterable)은 함수(f)와 반복 가능한자료형을 입력으로 받는다. map은 입력받은 자료형의 각 요소를 함수 f가 수행한 결과를 묶어서 돌려주는 함수이다.

def two_times(numberList):
    result = [ ]
    for number in numberList:
        result.append(number * 2)
    return result

result = two_times([1, 2, 3, 4])
print(result)   # [2, 4, 6, 8]

def two_times(x): 
    return x * 2

list(map(two_times, [1, 2, 3, 4]))  # [2, 4, 6, 8]

list(map(lambda a: a * 2, [1, 2, 3, 4]))  # [2, 4, 6, 8]

• max : 반복 가능한 자료형을 입력받아 그 최댓값을 돌려주는 함수
• min : 반복 가능한 자료형을 입력받아 그 최솟값을 돌려주는 함수
• pow(x, y) : x의 y 제곱한 결과를 반환
• range

# 인수가 하나일 경우
list(range(5))          # [0, 1, 2, 3, 4]

# 인수가 2개일 경우
list(range(5, 10))      # [5, 6, 7, 8, 9]

# 인수가 3개일 경우
list(range(1, 10, 2))   # [1, 3, 5, 7, 9]
list(range(0, -10, -1)) # [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

• round : 숫자를 입력받아 반올림해 주는 함수

round(4.2)      # 4
round(5.678, 2) # 5.68

• sorted : 입력값을 정렬한 후 그 결과를 리스트로 돌려주는 함수

sorted("zero")      # ['e', 'o', 'r', 'z']
sorted((3, 2, 1))   # [1, 2, 3]

• str : 문자열 형태로 객체를 변환
• sum : 입력받은 리스트의 모든 요소 합을 반환
• tuple : 반복 가능한 자료형을 입력받아 튜플 형태로 반환
• type : 입력값의 자료형이 무엇인지 반환
• zip : 동일한 개수로 이루어진 자료형을 묶어주는 역할을 하는 함수

list(zip([1, 2, 3], [4, 5, 6]))             # [(1, 4), (2, 5), (3, 6)]
list(zip([1, 2, 3], [4, 5, 6], [7, 8, 9]))  # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
list(zip("abc", "def"))                     # [('a', 'd'), ('b', 'e'), ('c', 'f')]