습관처럼

1. input() 말고 sys.stdin.readline() 를 사용하자.

입출력 속도에서 많은 차이가 발생합니다.

sys.stdin.readline() > raw_input() > input()

input() 으로 코드를 제출할 시, 시간초과가 발생하지만, sys.stdin.readline() 으로 제출할 시 정답이 된다는 점입니다.

직접 실행해보면서 테스트 해보시길 바랍니다. 

a = [int(x) for x in input().split()] 
# a = [1, 2, 3, 4 ,5]

import sys 
a = map(int, sys.stdin.readline()) # a = [1, 2, 3, 4, 5]

import sys n = input() 
a = [sys.stdin.readline() for i in range(n)] 
# a = ["1 2 3", "4 5 6"]

2. 재귀함수가 있는 경우, 최대 재귀 깊이를 설정해줘야 한다.

자주 접하는 DFS,BFS에 자주 사용된다.

파이썬의 재귀 허용 깊이의 기본치가 c 보다 약한건지, c 로 짠 DFS, BFS의 경우 문제 없이 돌아가지만,

파이썬으로 돌리면 런타임 오류가 뜨는 경우가 있다. 그래서 다음과 같이 재귀 허용 깊이를 수동으로 늘려주는 코드를, 코드 상단에 적어줘야 한다.

import sys 
sys.setrecursionlimit(10**8) # 10^8 까지 늘림.

3.pypy vs Python

PyPy 가 뭔지 찾아보니, 쉽게말해 파이썬 보다 몇 배 더 빠른 개선된 파이썬이라고 생각하면 된다.

좀 더 자세히 말하면, Python3 는 내부적으로는 C로 짜여져있는데, 이를 C가 아니라 Python으로 다시 짠 것이다.

때문에, 일반적으로 Python3 보다 PyPy로 제출해서 내는게 더 안전한 듯 하다. (빠르다는 의미에서)

한편, PyPy에서는 sys.setrecursionlimit(10**8) 이 안먹는다. 즉 임의로 재귀 호출 깊이를 설정할 수 없다는 것에 주의해야 한다.

출처: https://dailyheumsi.tistory.com/32 

python : _(언더바)의 기능

1. interpreter에서 마지막 값을 저장하고자 할때.

2. 값을 무시하고 싶을 때

3. 변수나 함수명에 특별한 의미를 부여하고자 할때.

4. 숫자 리터럴 값의 자리 수 구분을 위한 구분자로서 사용할때 

a,_,c = 1,2,3 일 경우 a 에는 1, c 에는 3 이 저장되는 것을 알 수 있습니다.

여러개의 값을 무시하고 싶은 경우에는 a,*_,c 처럼 _ 앞에 * 를 사용하면 됩니다.

또한 값을 무시하는 _ 는 index 가 필요없는 for loop 문을 작성할 경우에 사용할 수 있습니다.

a,_,c=1,2,3
print(a,c)
# 1,3 출력

for _ in range(10):
	print("print")
# 인덱스에 상관없는 경우 _(언더바 사용)

어떤 것에 특별한 의미를 부여하고 싶을 때 사용할 수 있습니다.

파이썬에서 특별한 의미를 부여할 수 있는 부분들은 폴더와 메소드 속성 으로 총 3가지가 있습니다. 

폴더안에 __init__.py 라는 파일이 있으면 그 폴더를 패키지로 만들 수 있습니다.

'_' 가 앞에 붙으면 외부 사용자는 사용하지 말라는 권유의 문법입니다. 외부에서 이 모듈, 클래스를 import 할 경우 from module import * 같이 전체를 불러오는 import 를 하면 '_' 가 앞에 붙어있는 변수나 메소드들은 호출되지 않습니다. 하자만 직접 '_' 가 붙은 변수나 메소드를 호출한다면 사용이 가능하기 때문에 권유의 문법이라고 불립니다.

'__' 언더바가 붙은 메소드는 2가지 종류로 나누어집니다. 기본적으로 제공하는 매직 메소드들이거나 맹글링을 위한 메소드 입니다.

맹글링이란 컴파일러나 인터프리터가 변수나 함수명을 일정한 규칙에 의해 변형시키는 것을 의미합니다. 메소드의 맹글링 규칙은 메소드 앞에 _ClassName 을 붙이는 것으로 맹글링 됩니다.

class A:
    def __double_method(self):
        pass
class B(A):
    def __double_method(self):
        pass
print(dir(A()))
print(dir(B()))

숫자 또는 문자값의 자릿수 구분을 위한 구분자로써 '_' 가 사용 가능합니다.

dec_base = 1_000_000
dec_add = 11_000
print(dec_base)
print(dec_add)
print(dec_base + dec_add)

출처:https://gomguard.tistory.com/125

파이썬은 정규 표현식을 지원하기 위해 re(regular expression의 약어) 모듈을 제공한다.

re 모듈은 파이썬을 설치할 때 자동으로 설치되는 기본 라이브러리로 사용 방법은 다음과 같다.

>>> import re
>>> p = re.compile('ab*')

re.compile을 사용하여 정규 표현식(위 예에서는 ab*)을 컴파일한다.

re.compile의 결과로 돌려주는 객체 p(컴파일된 패턴 객체)를 사용하여 그 이후의 작업을 수행한다.

match, search는 정규식과 매치될 때는 match 객체를 돌려주고, 매치되지 않을 때는 None을 돌려준다.

>>> import re
>>> p = re.compile('[a-z]+')

match

#"python" 문자열은 [a-z]+ 정규식에 부합되므로 match 객체를 돌려준다.
>>> m = p.match("python")
>>> print(m)
<_sre.SRE_Match object at 0x01F3F9F8>	

#"3 python" 문자열은 처음에 나오는 문자 3이 정규식 [a-z]+에 부합되지 않으므로 None을 돌려준다.
>>> m = p.match("3 python")
>>> print(m)
None

p = re.compile(정규표현식)
m = p.match( 'string goes here' )
if m:
    print('Match found: ', m.group())
else:
    print('No match')

search

>>> m = p.search("python")
>>> print(m)
<_sre.SRE_Match object at 0x01F3FA68>

>>> m = p.search("3 python")
>>> print(m)
<_sre.SRE_Match object at 0x01F3FA30>

"3 python" 문자열의 첫 번째 문자는 "3"이지만 search는 문자열의 처음부터 검색하는 것이 아니라 문자열 전체를 검색하기 때문에 "3 " 이후의 "python" 문자열과 매치된다.

findall

>>> result = p.findall("life is too short")
>>> print(result)
['life', 'is', 'too', 'short']

"life is too short" 문자열의 'life', 'is', 'too', 'short' 단어를 각각 [a-z]+ 정규식과 매치해서 리스트로 돌려준다.

finditer

>>> result = p.finditer("life is too short")
>>> print(result)
<callable_iterator object at 0x01F5E390>


>>> for r in result: print(r)
...
<_sre.SRE_Match object at 0x01F3F9F8>
<_sre.SRE_Match object at 0x01F3FAD8>
<_sre.SRE_Match object at 0x01F3FAA0>
<_sre.SRE_Match object at 0x01F3F9F8>

finditer는 findall과 동일하지만 그 결과로 반복 가능한 객체(iterator object)를 돌려준다. 반복 가능한 객체가 포함하는 각각의 요소는 match 객체이다.

match 객체의 메서드

match 메서드와 search 메서드를 수행한 결과로 돌려준 match 객체에 대해 알아보자. 

>>> m = p.match("python")
>>> m.group()
'python'
>>> m.start()
0
>>> m.end()
6
>>> m.span()
(0, 6)

예상한 대로 결괏값이 출력되는 것을 확인할 수 있다. match 메서드를 수행한 결과로 돌려준 match 객체의 start()의 결괏값은 항상 0일 수밖에 없다. 왜냐하면 match 메서드는 항상 문자열의 시작부터 조사하기 때문이다.

search 메서드를 사용했다면 start() 값은 다음과 같이 다르게 나온다.

>>> m = p.search("3 python")
>>> m.group()
'python'
>>> m.start()
2
>>> m.end()
8
>>> m.span()
(2, 8)

출처:https://wikidocs.net/4308

정규 표현식에서 사용하는 메타 문자(meta characters)에는 다음과 같은 것이 있다.

메타 문자란 원래 그 문자가 가진 뜻이 아닌 특별한 용도로 사용하는 문자를 말한다.

. ^ $ * + ? { } [ ] \ | ( )

정규 표현식에 위 메타 문자를 사용하면 특별한 의미를 갖게 된다.

문자 클래스 []

문자 클래스로 만들어진 정규식은 "[ ] 사이의 문자들과 매치"라는 의미를 갖는다.

정규 표현식이 [abc]라면 이 표현식의 의미는 "a, b, c 중 한 개의 문자와 매치"를 뜻한다. 이해를 돕기 위해 문자열 "a", "before", "dude"가 정규식 [abc]와 어떻게 매치되는지 살펴보자.

"a"는 정규식과 일치하는 문자인 "a"가 있으므로 매치

"before"는 정규식과 일치하는 문자인 "b"가 있으므로 매치

"dude"는 정규식과 일치하는 문자인 a, b, c 중 어느 하나도 포함하고 있지 않으므로 매치되지 않음

[ ] 안의 두 문자 사이에 하이픈(-)을 사용하면 두 문자 사이의 범위(From - To)를 의미한다.

예를 들어 [a-c]라는 정규 표현식은 [abc]와 동일하고 [0-5]는 [012345]와 동일하다.

[a-zA-Z] : 알파벳 모두, 

[0-9] : 숫자 모두

문자 클래스([ ]) 안에는 어떤 문자나 메타 문자도 사용할수 있지만 주의해야 할 메타 문자가 1가지 있다.

문자 클래스 안에 ^ 메타 문자를 사용할 경우에는 반대(not)라는 의미를 갖는다. 예를 들어 [^0-9]라는 정규 표현식은 숫자가 아닌 문자만 매치된다.

dot

정규 표현식의 Dot(.) 메타 문자는 줄바꿈 문자인 \n을 제외한 모든 문자와 매치됨을 의미한다.

a.b
>>"a + 모든문자 + b"

a와 b라는 문자 사이에 어떤 문자가 들어가도 모두 매치된다는 의미이다.

a[.]b
>>"a + Dot(.)문자 + b"

따라서 정규식 a[.]b는 "a.b" 문자열과 매치되고, "a0b" 문자열과는 매치되지 않는다.

※만약 앞에서 살펴본 문자 클래스([]) 내에 Dot(.) 메타 문자가 사용된다면 이것은 "모든 문자"라는 의미가 아닌 문자 . 그대로를 의미한다. 혼동하지 않도록 주의하자.

반복(*)

ca*t

이 정규식에는 반복을 의미하는 * 메타 문자가 사용되었다. 여기에서 사용한 *은 * 바로 앞에 있는 문자 a가 0부터 무한대로 반복될 수 있다는 의미이다.

반복(+)

반복을 나타내는 또 다른 메타 문자로 +가 있다. +는 최소 1번 이상 반복될 때 사용한다. 즉 *가 반복 횟수 0부터라면 +는 반복 횟수 1부터인 것이다.

ca+t
>>"c + a(1번 이상 반복) + t"

반복({m,n},?)

{ } 메타 문자를 사용하면 반복 횟수를 고정할 수 있다.

{m, n} 정규식을 사용하면 반복 횟수가 m부터 n까지 매치할 수 있다. 또한 m 또는 n을 생략할 수도 있다. 만약 {3,}처럼 사용하면 반복 횟수가 3 이상인 경우이고 {,3}처럼 사용하면 반복 횟수가 3 이하를 의미한다. 생략된 m은 0과 동일하다.

※ {1,}은 +와 동일하고, {0,}은 *와 동일하다.

ca{2}t	#"c + a(반드시 2번 반복) + t"

ca{2,5}t #"c + a(2~5회 반복) + t"

ab?c	 #"a + b(있어도 되고 없어도 된다) + c"

출처:https://wikidocs.net/4308

문자열 관련 함수들

count: 개수

>>> a = "hobby"
>>> a.count('b')
2

find: 문자를 통해 인덱스 위치

>>> a = "Python is the best choice"
>>> a.find('b')
14
>>> a.find('k')
-1

index: 인덱스 위치

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

join: 문자열 사이에 해당문자를 삽입

>>> ",".join('abcd') #abcd 문자열의 각각의 문자 사이에 ','를 삽입한다.
'a,b,c,d'

upper: 전부 대문자로

>>> a = "hi"
>>> a.upper()
'HI'

lower: 전부 소문자로

>>> a = "HI"
>>> a.lower()
'hi'

lstrip: 왼쪽 공백 제거

>>> a = " hi "
>>> a.lstrip()
'hi '

rstrip: 오른쪽 공백 제거

>>> a= " hi "
>>> a.rstrip()
' hi'

strip: 양쪽 공백 제거

>>> a = " hi "
>>> a.strip()
'hi'

replace: 문자열 대체

>>> a = "Life is too short"
>>> a.replace("Life", "Your leg")
'Your leg is too short'

split: 공백을 기준으로 문자열 나누기

>>> a = "Life is too short"
>>> a.split()
['Life', 'is', 'too', 'short']
>>> b = "a:b:c:d"
>>> b.split(':')
['a', 'b', 'c', 'd']

출처:https://wikidocs.net/13

문자열(String)이란 문자, 단어 등으로 구성된 문자들의 집합을 의미한다

.

백슬래시(\)를 사용해서 작은따옴표(')와 큰따옴표(")를 문자열에 포함시키기

>>> food = 'Python\'s favorite food is perl'
>>> say = "\"Python is very easy.\" he says."

문자열 곱하기

>>> a = "python"
>>> a * 2
'pythonpython'

문자열 인덱싱 활용

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

>>> a[-0]
'L'

>>> a[-2]
'o'
>>> a[-5]
'y'

문자열 슬라이싱

>>> a = "Life is too short, You need Python"
>>> a[0:4]
'Life'
>>> a[19:]
'You need Python'

format함수를 활용한 formating

>>> 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.'

>>> "I ate {number} apples. so I was sick for {day} days.".format(number=10, day=3)
'I ate 10 apples. so I was sick for 3 days.'

>>> "I ate {0} apples. so I was sick for {day} days.".format(10, day=3)
'I ate 10 apples. so I was sick for 3 days.'

>>> "{0:<10}".format("hi")	#왼쪽 정렬
'hi        '

>>> "{0:>10}".format("hi")	#오른쪽 정렬
'        hi'

>>> "{0:^10}".format("hi")	#가운데 정렬
'    hi    '

>>> "{0:=^10}".format("hi")	#공백 채우기
'====hi===='
>>> "{0:!<10}".format("hi")
'hi!!!!!!!!'

>>> y = 3.42134234	#소수점 표현하기
>>> "{0:0.4f}".format(y)
'3.4213'

>>> "{0:10.4f}".format(y)	
'    3.4213'

출처:https://wikidocs.net/13

람다 형식은 인공지능 분야나 AutoCAD라는 설계 프로그램에서 쓰이는 Lisp 언어에서 물려받았다고 하는데요, 함수를 딱 한 줄만으로 만들게 해주는 훌륭한 녀석입니다. 사용할 때는 아래와 같이 써주면 됩니다.

다음은 두 수를 더하는 함수입니다.

def hap(x, y):
   return x + y
   
>>> hap(10, 20)
30

이것을 람다 형식으로는 어떻게 표현할까요?

lambda 인자 : 표현식

>>> (lambda x,y: x + y)(10, 20)
30

정말 유용한 함수입니다. 

lambda of map

map(함수, 리스트)

>>> list(map(lambda x: x ** 2, range(5)))     # python 2 및 python 3
[0, 1, 4, 9, 16]

lambda of filter

filter(함수, 리스트)
 
>>> list(filter(lambda x: x < 5, range(10))) # python 2 및 python 3
[0, 1, 2, 3, 4]

lambda of reduce

reduce(함수, 순서형 자료)

>>> from functools import reduce   # need to python3 version
>>> reduce(lambda x, y: x + y, [0, 1, 2, 3, 4])
10

>>> reduce(lambda x, y: y + x, 'abcde')
'edcba'

출처:https://wikidocs.net/64

abs:

abs(x)는 어떤 숫자를 입력받았을 때, 그 숫자의 절댓값을 돌려주는 함수이다.

>>> abs(3)
3
>>> abs(-3)
3
>>> abs(-1.2)
1.2

chr:

chr(i)는 아스키(ASCII) 코드 값을 입력받아 그 코드에 해당하는 문자를 출력하는 함수이다.

>>> chr(97)
'a'
>>> chr(48)
'0'

divmod:

divmod(a, b)는 2개의 숫자를 입력으로 받는다. 그리고 a를 b로 나눈 몫과 나머지를 튜플 형태로 돌려주는 함수이다.

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

>>> 7 // 3
2
>>> 7 % 3
1

enumerate:

순서가 있는 자료형(리스트, 튜플, 문자열)을 입력으로 받아 인덱스 값을 포함하는 enumerate 객체를 돌려준다.

>>> for i, name in enumerate(['body', 'foo', 'bar']):
...     print(i, name)
...
0 body
1 foo
2 bar

filter:

filter 함수는 첫 번째 인수로 함수 이름을, 두 번째 인수로 그 함수에 차례로 들어갈 반복 가능한 자료형을 받는다. 그리고 두 번째 인수인 반복 가능한 자료형 요소가 첫 번째 인수인 함수에 입력되었을 때 반환 값이 참인 것만 묶어서(걸러 내서) 돌려준다.

def positive(x):
    return x > 0

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

>>> list(filter(lambda x: x > 0, [1, -3, 2, 0, -5, 6]))
[1, 2, 6]

input: 

input([prompt])은 사용자 입력을 받는 함수이다.

>>> a = input()
hi
>>> a
'hi'
>>> b = input("Enter: ")
Enter: hi

map:

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

>>> 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:

max(iterable)는 인수로 반복 가능한 자료형을 입력받아 그 최댓값을 돌려주는 함수이다.

min(iterable)은 max 함수와 반대로, 인수로 반복 가능한 자료형을 입력받아 그 최솟값을 돌려주는 함수이다.

>>> max([1, 2, 3])
3
>>> max("python")
'y'
>>> min([1, 2, 3])
1
>>> min("python")
'h'

ord:

ord(c)는 문자의 아스키 코드 값을 돌려주는 함수이다.

>>> ord('a')
97
>>> ord('0')
48

pow:

pow(x, y)는 x의 y 제곱한 결괏값을 돌려주는 함수이다.

>>> pow(2, 4)
16
>>> pow(3, 3)
27

range:

range([start,] stop [,step] )는 for문과 함께 자주 사용하는 함수이다. 이 함수는 입력받은 숫자에 해당하는 범위 값을 반복 가능한 객체로 만들어 돌려준다.

>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(5, 10))
[5, 6, 7, 8, 9]
>>> 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(number[, ndigits]) 함수는 숫자를 입력받아 반올림해 주는 함수이다.

※ [, ndigits]는 ndigits가 있을 수도 있고 없을 수도 있다는 의미이다.

>>> round(4.6)
5
>>> round(4.2)
4
>>> round(5.678, 2)
5.68

sum:

sum(iterable) 은 입력받은 리스트나 튜플의 모든 요소의 합을 돌려주는 함수이다.

>>> sum([1,2,3])
6
>>> sum((4,5,6))
15

tuple:

tuple(iterable)은 반복 가능한 자료형을 입력받아 튜플 형태로 바꾸어 돌려주는 함수이다. 만약 튜플이 입력으로 들어오면 그대로 돌려준다.

>>> tuple("abc")
('a', 'b', 'c')
>>> tuple([1, 2, 3])
(1, 2, 3)
>>> tuple((1, 2, 3))
(1, 2, 3)

zip:

zip(*iterable)은 동일한 개수로 이루어진 자료형을 묶어 주는 역할을 하는 함수이다.

>>> 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')]

출처: https://wikidocs.net/32