Python 내장 함수(Built-in Function)

Python 내장 함수(Built-in Function)

2022. 9. 28. 16:29ㆍPython

이번 포스팅에서는 코딩 테스트에 유용하게 쓰일 내장 함수에 대해 알아보도록 하겠습니다.

list

# list 
dir([1, 2, 3, 4])

Out[-]
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',  
 'clear',  
 'copy',   
 'count', 
 'extend', 
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

● append : 리스트 끝에 그 자체로 원소를 추가

x = [1,2,3,4]
x.append([3,4])
print(x)

Out[-]
[1, 2, 3, 4, [3, 4]]

● extend : 리스트 끝에 모든 원소 추가 (가장 바깥쪽 iterable의 모든 항목을 넣음)

x = [1,2,3,4]
x.extend([3,4])
print(x)

Out[-]
[1, 2, 3, 4, 3, 4]

● copy : 원본에 영향을 주지 않기 위해서 사용

x = [1, 2, 3, 4]
y = x
y.extend([3,4])
print(x)
print(y)

Out[-]
[1, 2, 3, 4, 3, 4]
[1, 2, 3, 4, 3, 4]

x = [1, 2, 3, 4]
y = x.copy()
y.extend([3,4])
print(x)
print(y)

Out[-]
[1, 2, 3, 4]
[1, 2, 3, 4, 3, 4]

● clear : 리스트 안의 원소 모두 삭제

x = [1, 2, 3, 4, 5]
print(x)
x.clear()
print(x)

Out[-]
[1, 2, 3, 4, 5]
[]

● count(a) : 리스트 안에 원소 a의 개수 반환

x = [1, 6, 3, 6, 5, 6, 7]
x.count(6)

Out[-]
3

● index(a) : 리스트 값의 위치를 반환, 리스트 안에 원소 a의 위치를 반환 (0부터 시작)

x = [5, 8, 3]
x.index(8)

Out[-]
1

● insert (a,b): 리스트의 a위치에 b 원소 삽입

x = [1, 7, 2, 8, 4]
x.insert(2,5)
x

Out[-]
[1, 7, 5, 2, 8, 4]

● pop : 리스트의 지정한 위치의 원소 삭제

x = [0, 2, 4, 6, 8]
x.pop(1)
x

Out[-]
[0, 4, 6, 8]

● remove : 리스트에 들어있는 원소 중 지정한 원소 삭제

x = [0, 2, 4, 6, 8]
x.remove(6)
x

Out[-]
[0, 2, 4, 8]

format( )

format(value, format_spec)
형식 지정자가 제어하는 주어진 값의 형식화된 표현을 출력

# 단위 : 원
format(10000000000, ',')

Out[-]
'10,000,000,000'

# 지수
format(10000000000, 'e')

Out[-]
'1.000000e+10'

filter( )

filter(function, iterable)
iterable의 각 요소가 true인지 아닌지 확인 후 출력

def lea(value):
    if value % 2 == 0:
        return True
    else:
        return False
    
list(filter(lea, range(20)))

Out[-]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

list(filter(lambda x: x % 2 == 0, range(20)))

Out[-]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

[i for i in range(20) if i % 2 == 0]

Out[-]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

len([1, 2, 3, 4])

Out[-]
4

map( )

map(function, iterable, ...)
주어진 function를 iterable의 각 항목에 적용하고 결과 목록을 출력

list(map(lea, range(20)))
list(map(lambda x: x % 2 == 0, range(20)))
list(map(lambda x: x**2, range(20)))

Out[-]
[True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False]
[True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False, True, False]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361]

zip( )

zip(*iterables)
iterables을 가져와 튜플로 집계하여 출력

x = ['a','b','c']
y = [1,3,2]

z = list(zip(x,y))
print(z)

[('a', 1), ('b', 3), ('c', 2)]

list(zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4], [10, 20, 30, 40], 'ABCD'))
set(zip(['a', 'b', 'c', 'd'], [1, 2, 3, 4], [10, 20, 30, 40], 'ABCD'))

Out[-]
[('a', 1, 10, 'A'), ('b', 2, 20, 'B'), ('c', 3, 30, 'C'), ('d', 4, 40, 'D')]
{('a', 1, 10, 'A'), ('b', 2, 20, 'B'), ('c', 3, 30, 'C'), ('d', 4, 40, 'D')}

max/min( )

max([1, 2, 3, 4])
min([1, 2, 3, 4])

Out[-]
4
1

x = {8: 1, 3: 9, -2: 1, 10:-1}

result1 = max(x) # key값의 max
print(result1) 
 
result2 = max(x, key = lambda k: x[k])
print(result2)   # value가 큰 key 값  
print(x[result2])# key 값을 적용시킨 value

Out[-]
10
3
9

x = {8: 1, 3: 9, -2: 1, 10:-1}

result1 = min(x) # key값의 min
print(result1) 
 
result2 = min(x, key = lambda k: x[k])
print(result2)   # value가 가장 작은 key 값  
print(x[result2])# key 값을 적용시킨 value

Out[-]
-2
10
-1

sort( )

● sort : 리스트의 원본을 직접 정렬

x = [10, 5, 8]
y = x.sort()

print(x)
print(y)

Out[-]
[5, 8, 10]
None

● sorted : 리스트의 원본은 그대로 보존하고 정렬된 값을 반환

x = [10, 5, 8]
y = sorted(x)
print(x)
print(y)

Out[-]
[10, 5, 8]
[5, 8, 10]

testCaseOne = ['abc', 'def', 'hello world', 'hello', 'python']
testCaseTwo = 'Life is too short, You need python'.split()
testCaseThree = list(zip('anvfe', [1, 2, 5, 4, 3]))

sorted(testCaseOne, key=len, reverse=True)
sorted(testCaseTwo, key=str.lower)
sorted(testCaseThree, key=lambda x:x[1])
sorted(testCaseThree, key=lambda x:x[0])

Out[-]
['hello world', 'python', 'hello', 'abc', 'def']
['is', 'Life', 'need', 'python', 'short,', 'too', 'You']
[('a', 1), ('n', 2), ('e', 3), ('f', 4), ('v', 5)]
[('a', 1), ('e', 3), ('f', 4), ('n', 2), ('v', 5)]

5 not in [1, 2, 3, 4, 5]

Out[-]
False

reversed( )

● reverse : 리스트에 순서를 거꾸로 뒤집기

x = [10, 5, 8]
y = x.reverse()
print(x)
print(y)

Out[-]
[8, 5, 10]
None

● reversed : 리스트의 원본은 그대로 보존하고 순서를 거꾸로 뒤집기

x = [10, 5, 8]
y = reversed(x)
print(list(x))
print(list(y))

Out[-]
[10, 5, 8]
[8, 5, 10]

Quque

l = []

l.append(10)
l.append(20)
l.append(30)
l.pop(0)
l.append()

#Queue 라이브러리를 이용한 방법
import queue
q = queue.Queue()
q.put(2) # append
q.put(5) 
q.put(7) 
q.put(8) 
print(q.get()) # pop 
print(q.get())
print(q.get())
print(q.get())

Out[-]
2
5
7
8

#리스트 queue
class listq():
    def __init__(self):
        self.queue = []
    
    def push(self, n ):
        return self.queue.append(n)
        
    def pop(self):
        if len(self.queue) == 0:
            return -1
        return self.queue.pop(0) 

    def printq(self):
    	print(self.queue)
    
    def empty(self):
        if len(self.queue) == 0:
            return print('Yes')
        return print('No')

queue= listq()
queue.push(1)
queue.push(2)
queue.push(3)
queue.empty()
queue.printq()
print(queue.pop())
print(queue.pop())
print(queue.pop())
print(queue.pop())

Out[-]
No
[1, 2, 3]
1
2
3
-1

Stack

#스택
l = []

l.append(10)
l.append(20)
l.append(30)
l.pop()
l.append()

# 리스트 stack
class list_s():
    def __init__(self):
        self.stack = []
    
    def push(self, n ):  
        return self.stack.append(n)

    def pop(self): 
    	if len(self.stack) == 0:
            return -1
    	return self.stack.pop()        

    def printq(self):
        print(self.stack)
    
    def empty(self):
        if len(self.stack) == 0:
            return print('Yes')
        return print('No')

stack= list_s()
stack.push(1)
stack.push(2)
stack.push(3)
stack.empty()
stack.printq()
print(stack.pop())
print(stack.pop())
print(stack.pop())
print(stack.pop())

Out[-]
No
[1, 2, 3]
3
2
1
-1

집합

# tuple 
t = (1, 2, 3)
dir(t)

Out[-]
['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'count',
 'index']

# 딕셔너리
d = {'one':'하나', 'two':'둘'}
dir(d)
# 'clear',
# 'copy',
# 'fromkeys',
# 'get',
# 'items',
# 'keys',
# 'pop',
# 'popitem',
# 'setdefault',
# 'update',
# 'values'

d.keys()
d.values()
d.items()

Out[-]
dict_keys(['one', 'two'])
dict_values(['하나', '둘'])
dict_items([('one', '하나'), ('two', '둘')])

# 세트
s = {'1', '2', '3', '4', '5', '6'}
dir(s)

# 'add',
# 'clear',
# 'copy',
# 'difference', : 차집합 집합하나.difference(집합둘)
# 'difference_update',
# 'discard',
# 'intersection',
# 'intersection_update',
# 'isdisjoint',
# 'issubset',
# 'issuperset',
# 'pop',
# 'remove',
# 'symmetric_difference',
# 'symmetric_difference_update',
# 'union', : 합집합
# 'update', : 한꺼번에 많은 데이터를 추가

s.add(7)
s.discard(7)
'1' in s

Out[-]
{'1', '2', '3', '4', '5', '6', 7}
{'1', '2', '3', '4', '5', '6'}
True

판콜에이 = {'A', 'B', 'C'}
타이레놀 = {'A', 'B', 'D'}

print(판콜에이.difference(타이레놀)) #차집합
print(판콜에이.intersection(타이레놀)) #교집합
print(len(판콜에이.intersection(타이레놀))) #교집합
print(판콜에이.union(타이레놀))

Out[-]
{'C'}
{'B', 'A'}
2
{'B', 'A', 'D', 'C']

# 단톡방에 x마리의 동물이 대화를 하고 있습니다.
# 각각의 동물들이 톡을 전송할 때마다 서버에는 아래와 같이 저장됩니다.
# 1. 단톡방에는 모두 몇 마리의 동물이 있을까요? 톡은 무조건 1회 이상 전송합니다.
# 2. 단톡방에 동물들마다 몇 번의 톡을 올렸을까요?

serverData = '개리 라이캣 개리 개리 라이캣 자바독 자바독 파이 썬'

len(set(serverData.split()))	#5

d = {}
for i in set(serverData.split()):
    print(i, serverData.split().count(i))
    d[i] = serverData.split().count(i)
print(d)

Out[-]
라이캣 2
썬 1
파이 1
자바독 2
개리 3
{'라이캣': 2, '파이': 1, '썬': 1, '자바독': 2, '개리': 3}

set( )

● set(iterable)

s = set('11122345666')
s

Out[-]
{'1', '2', '3', '4', '5', '6'}

split( )

for i in '1 2 3 4 5 6 7'.split():
    print(int(i))

list(map(int, '1 2 3 4 5 6 7'.split()))

1
2
3
4
5
6
7
[1, 2, 3, 4, 5, 6, 7]

n = list(map(int, input().split()))
print(n)

In[-] : 입력
2 1 4
Out[-]
[2, 1, 4]

enumerate( )

enumerate(iterable, start=0)
iterable에 counter 추가하고 출력한다.

인덱스(index)와 원소를 동시에 접근하면서 루프를 돌리는 방법으로 for 문의 in 뒷 부분을 enumerate() 함수로 한 번 감싸주기만 하면 됩니다. enumerate() 함수는 기본적으로 인덱스와 원소로 이루어진 튜플로 만들어줍니다.

x = ['one','two','three']
for iterable in enumerate(x):
    print(iterable)
for counter , value in enumerate(x):
    print(counter, value)

Out[-]
(0, 'one')
(1, 'two')
(2, 'three')
0 one
1 two
2 three

x = [10,20,30,40,50]

for i , j in enumerate(x,2):
    print(i , j)

abs( )

abs(num)
주어진 숫자의 절대 값을 출력

abs(-1)
abs(0)
abs(-15)

Out[-]
1
0
15

참고:

https://www.inflearn.com/course/%EC%BD%94%EB%94%A9-%ED%85%8C%EC%8A%A4%ED%8A%B8-%EC%A0%84%EB%82%A0/dashboard

눈떠보니 코딩 테스트 전날 - 인프런 | 강의

다가오는 코딩 테스트에 대비하여 기본적으로 알아야 할 개념을 복습하고 Python, Javascript를 통해 알고리즘 문제를 풀어볼 수 있습니다., - 강의 소개 | 인프런...

www.inflearn.com

저작자표시

'Python' 카테고리의 다른 글

Python 엑셀 프로그래밍 - with xlsxwriter (0)	2022.11.30
공공데이터와 Folium(폴리움)으로 제주 오름 지도 안내 서비스 만들기 (0)	2022.10.28
Python 기본 문법 정리 (0)	2022.09.28

ShootForTheMoon