파이썬(Python)_내장함수

코드를 직접 만들 수 있으나, 대부분 검증된 함수를 활용한다!
생산성 및 품질 향상!

API (Application Programming Interface) 를 통해 활용 가능한 함수를 파악

---

1. 수치 연산 함수

• abs( ) - 인자로 숫자를 전달하면 그 숫자의 절댓값을 반환하는 함수

val = -3.14
print(abs(val))
3.14

• divmod( ) - 첫 번째 인자를 두 번째 인자로 나눴을 때의 몫과 나머지를 튜플 객체로 반환하는 함수

val1, val2 = 9, 5
result_tuple = divmod(val1, val2)
print("divmod({0}, {1} => 몫: {2}, 나머지: {3}".format(val1, val2, *result_tuple)

[결과]
divmod(9, 5) => 몫: 1, 나머지: 4

• pow( ) - 첫 번째로 전달된 인자 값에 대해 두 번째로 전달된 인자 값으로 제곱한 결과를 반환하는 함수

data_list = [1, 2, 3, 4, 5]

print("pow({0}, 2) => {1}".format(data_list[2], pow(data_list[2], 2)))

print("list(map(lambda x: pow(x, 2), {0})) => {1}".format(data_list, list(map(lambda x: pow(x, 2), data_list)))) # 2 제곱한 결과를 항목으로 가진 map 객체를 얻어, 리스트로 변환

[결과]
pow(3, 2) => 9
list(map(lambda x: pow(x, 2), [1, 2, 3, 4, 5]))) => [1, 4, 9, 16, 25]

---

2. 시퀀스형/반복 가능한 자료형을 다루는 함수

• all( ) - 반복 가능한 자료형인 list, tuple, set, dictionary, 문자열 등을 인자로 전달하여 항목 모두가 True로 평가되면 True를 반환하고, False로 평가되는 항목이 하나라도 있으면 False를 반환

val1 = [True, True, True] # True 반환
print(all(val1))

val2 = [10, 20, 0] # 0 항목으로 False 반환
print(all(val2))

val3 = ["", False, None] # 셋 모두 False로 평가
print(all(val3)_
[결과]
True
False
False

• any( ) - list, tuple, set, dictionary, 문자열 등을 인자로 전달하여 항목 모두가 False로 평가되면 False를 반환하고, True로 평가되는 항목이 하나라도 있으면 True를 반환

val1 = [10, 20, 0] # 0이 False이지만, 10과 20이 True로 평가 → True를 반환
print(any(val1))

val2 = ["", False, None] # 셋 모두 False로 평가되기 때문에 False를 반환
print(any(val2))

[결과]
True
False

• enumerate( ) - list, tuple, 문자열과 같은 시퀀스형을 입력받아 인덱스를 포함하는 튜플 객체를 항목으로 구성하는 enumerate 객체를 반환

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

for inx, val in enumerate(data_list):
    print("data_list[{0}]: {1}".format(idx, val))
    
for obj in enumerate(data_list):
    print("{0}: {1}, {2}".format(type(obj), obj[0], obj[1]))

for obj in enumerate(data_list):
    print("{0}: {1}, {2}".format(type(obj), *obj)) # *언팩 연산자 활용

[결과]
data_list[0]: 10
data_list[1]: 20
data_list[2]: 30
data_list[3]: 40
data_list[4]: 50

<class 'tuple'>: 0, 10
<class 'tuple'>: 1, 20
<class 'tuple'>: 2, 30
<class 'tuple'>: 3, 40
<class 'tuple'>: 4, 50

<class 'tuple'>: 0, 10
<class 'tuple'>: 1, 20
<class 'tuple'>: 2, 30
<class 'tuple'>: 3, 40
<class 'tuple'>: 4, 50

• filter( ) - 조건에 해당하는 항목을 걸러내는 함수

def iseven(num):
    return num % 2 == 0 # 짝수일 경우 True를 반환

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

ret_val = filter(iseven,numbers)
# ret_val = filter(lambda n: n % 2 == 0, numbers) # lambda 식을 활용해도 됨
print("{0}".format(type(ret_val)))
print("{0}".format(list(ret_val)))

[결과]
<class 'filter'>
[2, 4, 6, 8, 10]

• list( ) / tuple( ) / set( ) / dict( )
  - 반복 가능한 자료형을 인자로 전달 받아
  각각 리스트, 튜플, 셋, 딕셔너리로 변환해 반환하는 함수

data_str = "Hello"

data_list = list(data_str)
print("list('{0}') => {1} {2}".format(data_str, type(data_list), data_list))

data_tuple = tuple(data_list)
print("tuple('{0}') => {1} {2}".format(data_list, type(data_tuple), data_tuple))

data_set = set(data_tuple)
print("set('{0}') => {1} {2}".format(data_tuple, type(data_set), data_set))

data_dict = dict(enumerate(data_set))
print("dict('{0}') => {1} {2}".format(data_set, type(data_dict), data_dict))

[결과]
list('Hello') => <class 'list'> ['H', 'e', 'l', 'l', 'o']
tuple(['H', 'e', 'l', 'l', 'o']) => <class 'tuple'> ('H', 'e', 'l', 'l', 'o')
set(('H', 'e', 'l', 'l', 'o')) => <class 'set'> {'e', 'l', 'o', 'H'} # set은 중복을 허용하지 X
dict({'e', 'l', 'o', 'H'}) => <class 'dict'> {0: 'e', 1:'l', 2:'o', 3:'H'}

• map( ) - 두 번째 인자로 반복 가능한 자료형을 전달 받아 자료형의 각 항목에 대해 첫 번째 인자로 전달 받은 함수를 적용한 결과를 맵 객체로 반환하는 함수

data_list = list("abcdef")

result = list(map(lambda x: x.upper(), data_list)) # data_list의 값을 lambda 식을 통해 대문자로 변경
print("list(map(lambda x: x.upper(), {0})) => {1} {2}".format(data_list, type(result), result))

[결과]
list(map(lamba x: x.upper(), ['a', 'b', 'c', 'd', 'e', 'f']))
=> <class 'list'> ['A', 'B', 'C', 'D', E', 'F']

• max( ) - 반복 가능한 자료형을 인자로 전달받아 항목 중 가장 큰 값 반환
• min( ) - 반복 가능한 자료형을 인자로 전달받아 항목 중 가장 작은 값 반환

data_list = list("10, 25, 30, 45, 50")

print("{0} => min: {1}, max: {2}".format(data_list, min(data_list), max(data_list)))

[결과]
[10, 25, 30, 45, 50] => min: 10, max: 50

• range( )
  1) 첫 번째 인자로 전달된 시작 값
  2) 두 번째 인자로 전달된 종료 값
  3) 세 번째 인자로 전달된 증감치
  → 시퀀스형 객체를 생성하는 함수

print(list(range(0, 10, 1)) # 0~9까지, 1씩 증가하는 값을 항목으로 함
print(list(range(0, 10)) # 생략된 세 번째 매개변수의 기본값은 1
print(list(range(10)) # 생략된 첫 번째 매개변수의 기본값은 0, 세 번째 매개변수의 기본값은 1

[결과]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• sorted( ) - 반복 가능한 자료형을 인자로 전달받아 항목들로부터 정렬된 리스트를 생성해 반환하는 함수

data_list = [3, 8, 12, 2, 5, 11]

asc_result = sorted(data_list) # 오름차순으로 정렬된 리스트 객체를 생성해 반환
desc_result = list(reversed(asc_result)) # 내림차순의 리스트 객체 생성

print("{0} {1}".format(type(data_list), data_list)) # 원본
print("{0} {1}".format(type(asc_list), asc_list)) # 오름차순
print("{0} {1}".format(type(desc_list), desc_list)) # 내림차순

[결과]
<class 'list'> [3, 8, 12, 2, 5, 11]
<class 'list'> [2, 3, 5, 8, 11, 12]
<class 'list'> [12, 11, 8, 5, 3, 2]

• zip( )
  - 둘 이상 반복 가능한 자료형을 인자로 전달받아, 동일 위치의 항목을 묶어 튜플을 항목으로 구성하는 zip객체를 생성하는 함수
  - 인자로 전달된 객체는 동일 자료형이면서, 항목의 개수가 같아야 함

data_list1 = [1, 2, 3]
data_list2 = [4, 5, 6]
data_list3 = ["a", "b", "c"]

print("list(zip({0}, {1})) => {2}".format(data_list1, data_list2, list(zip(data_list1, data_list2))))
print("list(zip({0}, {1}, {2})) => {3}".format(data_list1, data_list2, data_list3, list(zip(data_list1, data_list2, data_list3))))
print("list(zip({0}, {1})) => {2}".format(data_list3, data_list1, list(zip(data_list3, data_list1)))) # 딕셔너리 객체로 변환

[결과]
list(zip([1, 2, 3], [4, 5, 6])) => [(1, 4), (2, 5), (3, 6)]
list(zip([1, 2, 3], [4, 5, 6], ['a', 'b', 'c'])) => [(1, 4, 'a'), (2, 5, 'b'), (3, 6, 'c')]
list(zip(['a', 'b', 'c'], [1, 2, 3])) => {'a': 1, 'b': 2, 'c': 3} # 딕셔너리 객체

---

3. 변환 함수

• chr( ) - 정수형태의 유니코드 값을 인자로 전달받아 해당 코드의 문자를 반환하는 함수
• ord( ) - 문자를 인자로 전달 받아 유니코드 값(10진 정수)을 반환하는 함수
• hex( ) - 10진 정수 값을 인자로 전달 받아 16진수로 변환된 값을 반환하는 함수

val = 65
print(chr(val))
A

val = 0xac00
print(chr(val))
가

val = "A"
print(ord(val))
65

val = "가"
print(ord(val))
44032

print(hex(ord(val))
0xac00

• int( ) - 숫자 형식의 문자열, 부동소수점 숫자를 정수로 반환
• float( ) - 숫자 형식의 문자열, 정수를 부동소수점 숫자로 반환
• str( ) - 객체에 대한 문자열 변환 값을 반환

x = "10"
y = "3C"
z = 4.5

print(int(x, 2)) # 2진수 표현인 문자열 10을 10진수로 변환
2
print(int(y, 16)) # 16진수 표현인 문자열 3C를 10진수로 변환
60
print(int(z))
4
print(int(x))
10
print(str(z))
'4.5'

---

4. 객체 조사를 위한 함수

• dir( )
  - 인자로 전달된 객체가 가지고 있는 변수, 메서드와 같은 속성 정보를 리스트 객체로 반환
  - 인자를 전달하지 않고 호출하면 현재 지역 스코프에 대한 정보를 리스트 객체로 반환
  

• globals( ) - 현재의 전역 심볼 테이블을 보여주는 딕셔너리를 반환하는 함수 (전역변수와 함수, 클래스의 정보 포함)

• locals( ) - 현재의 지역 심볼 테이블을 보여주는 딕셔너리를 반환하는 함수 (매개변수를 포함한 지역변수와 중첩함수의 정보 포함)

• id( ) - 인자로 전달된 객체의 고유 주소(참조값)를 반환하는 함수

• isinstance( ) - 첫 번째 인자로 전달된 객체가 두 번째 인자로 전달된 클래스의 인스턴스인지에 대한 여부를 True/False로 반환하는 함수

• issubclass( ) - 첫 번째 인자로 전달된 클래스가 두 번째 인자로 전달된 클래스의 서브클래스인지에 대한 여부를 Trule/False로 반환하는 함수

5. 실행 관련 함수

• eval( ) - 실행 가능한 표현식의 문자열을 인자로 전달받아 해당 문자열의 표현식을 실행한 결과값을 반환하는 함수

expr = "2 + 5 * 3"
print(eval(expr))
17

expr = "'hello, python!'.upper()"
print(eval(expr))
HELLO, PYTHON!

실습. map( ) 함수와 filter( ) 함수를 활용하여 프로그램 만들기

1) map 함수, filter 함수 활용법
2) lambda expression의 활용법
3) eval 함수를 통해 사용자를 통해 입력받은 문자를 실행코드로 활용하는 법

✨ 역시나 실습에서 다루는 프로그램은 조금 어렵다. map, filter, lambda 표현식 등 자주 활용할 만한 함수의 개념을 잘 익히자! (2021.07.12)

해당 포스팅은 아래의 사이트를 참고하여 작성하였습니다.
SW Expert Academy https://swexpertacademy.com/