#9_Python_1내장함수:수치 연산 함수, 시퀀스형 / 반복 가능한 자료형을 다루는 함수

01 수치 연산 함수 abs() / divmod() / pow()
02 시퀀스형 / 반복 가능한 자료형을 다루는 함수

      all() / any() / enumerate() / filter() / list() / tuple() / set() / dict() / map() / max() / min() / range() / sorted() / zip()
03 변환함수 chr() / ord() / hex() / int() / float() / str()
04 객체 조사를 위한 함수 dir() / globals() / locals() / id() / instance() / issubclass()
05 실행 관련 함수 eval()

---

누군가 만들어 놓은 검증된 함수들을 사용하면

생산성도 높아지고 품질또한 확보가 가능하다.

 

그러므로 프로그램을 만들기 전에 나에게 필요한 기능이

미리 구현되어 있는 함수가 있는지

API문서를 들여다 보는 습관을 들이도록 하자!

 

Python에는 기본적으로 

'수치형 데이터 조작을 위한 함수'

'집합과 원소 사이의 관계를 다루는 함수'

'각종 변환 함수' 등의 다양한 목적을 위한 내장함수를 제공한다.

 

---

#01 수치 연산 함수

 

01_abs()
인자로 숫자를 전달하면 그 숫자의 절대값을 반환하는 함수

 

val에 양의 정수 10을 저장했을 때

val = 10
print("abs({0}) => {1}".format(val, abs(val)))

# [결과]
# abs(10) => 10

abs(val)를 선언하면 절대값을 반환함

 

 

val에 음의 정수 -10을 저장했을 때

val = -10
print("abs({0}) => {1}".format(val, abs(val)))

# [결과]
# abs(-10) => 10

abs(val)를 선언하면 절대값을 반환함

 

 

val에 음의 부동소수숫자 -3.14를 저장했을 때

val = -3.14
print("abs({0}) => {1}".format(val, abs(val)))

# [결과]
# abs(-3.14) => 3.14

abs(val)에 의해 양의 부동소수숫자 3.14가 출력 됨

 

# 정수인 int형 숫자를 넣으면 int형 절댓값이

# 실수인 float형 숫자를 넣으면 float형 절댓값이 반환

 

 

02_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

val1 에는 9, val2 에는 5를 저장하고

divmod()의 함수의 인자로 각각 전달하면 몫과 나머지를 튜플 객체로 반환해 변수 result_tuple에 저장

그리고 인자에 대한 언팩 연산을 통해

변수 result_tuple로 부터 첫번째 항목으로 몫을, 두번째 항목으로 나머지를 보낼 수 있다

 

 

03_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))))
        
# [결과]
# pow(3, 2) => 9
# list(map(lambda x: pow(x, 2), [1, 2, 3, 4, 5])) => [1, 4, 9, 16, 25]

변수 data_list는 [1, 2, 3, 4, 5]의 정수 항목을 가진 리스트 객체를 참조

pow 함수는 첫 번째 인자로 data_list의 [2] 순서인 3 을 전달받고, 두 번째 인자로 2를 전달 받아

3의 2 제곱 값인 9를 반환

 

pow함수를 map함수의 첫 번째 인자로 전달하면 data_list객체의 항목들에 대해 2 제곱한 결과를

항목으로 가진 map 객체를 얻어, 리스트로 변환해 사용할 수 있다

프로그램을 실행하면 다음과 같은 결과 출력

---

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

 

01_all() <-> any()

반복 가능한 자료형인 List, Set, dictionary, 문자열 등을 인자로 전달하여

항목 모두가 True로 평가되면 True를 반환하고,

False로 평가되는 항목이 하나라도 있으면 False를 반환하는 함수

val = [True, True, True]
print("all({0}) => {1}".format(val, all(val)))

val = [10, 20, 30]
print("all({0}) => {1}".format(val, all(val)))

val = [10, 20, 0]
print("all({0}) => {1}".format(val, all(val)))

# [결과]
# all([True, True, True]) => True
# all([10, 20, 30]) => True
# all([10, 20, 0]) => False

 

0 항목으로 인해 False로 반환

 

val = [10, 20, ""]
print("all({0}) => {1}".format(val, all(val)))

val = [10, 20, False]
print("all({0}) => {1}".format(val, all(val)))

val = [10, 20, None]
print("all({0}) => {1}".format(val, all(val)))

# [결과]
# all([10, 20, ""]) => False
# all([10, 20, False]) => False
# all([10, 20, None]) => False

공백문자열 "" 로 인해 False로 반환

False 항목이 존재하여 False로 반환

None 항목으로 인해 False로 반환

 

 

02_any() <-> all()

반복 가능한 자료형인 List, Tuple, Set, dictionary, 문자열 등을 인자로 전달하여

 

항목 모두가 False로 평가되면 False를 반환하고,

True로 평가되는 항목이 하나라도 있으면 True를 반환하는 함수

val = [True, True, True]
print("any({0}) => {1}".format(val, any(val)))

val = [10, 20, 30]
print("any({0}) => {1}".format(val, any(val)))

val = [10, 20, 0]
print("any({0}) => {1}".format(val, any(val)))

# [결과]
# any([True, True, True]) => True
# any([10, 20, 30]) => True
# any([10, 20, 0]) => True

0 항목이 False로 평가되도 True로 반환

 

val = [True, True, ""]
print("any({0}) => {1}".format(val, any(val)))

val = [10, 20, False]
print("any({0}) => {1}".format(val, any(val)))

val = [10, 20, None]
print("any({0}) => {1}".format(val, any(val)))

# [결과]
# any([True, True, ""]) => True
# any([10, 20, False]) => True
# any([10, 20, None]) => True

공백문자열 ""이 False지만 True로 반환

False 항목이 존재해도 True로 반환

None 항목이 False여도 True로 반환

 

val = [False, False, False]
print("any({0}) => {1}".format(val, any(val)))

# [결과]
# any([False, False, False]) => False

변수의 모든 항목이 False인 리스트 객체를 반환 했을 때 모든 항목이 False이므로 False반환

 

 

03_enumerate()

List, Tuple, 문자열과 같은 시퀀스형을 입력받아 인덱스를 포함하는 튜플 객체를 항목으로 구성하는

enumerate 객체를 반환하는 함수

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

for idx, val in enumerate(data_list):
	print("data_list[{0}]: {1}".format(idx, val))
    
print("-" * 25)

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

print("-" * 25)

for obj in enumerate(data_list):
	print("{0}: {1}, {2}".format(type(obj), *obj))

변수 data_list 안에 [10, 20, 30, 40, 50] 항목을 가진 리스트를 저장

 

for문에서 data_list를 enumerate 객체로 변환

이를 통해 매 반복마다 해당 idx와 항목을 변수 idx와 val에 저장하여 이 값을 출력함

 

for문에서 data_list를 enumerate 객체로 변환

이를 통해 매 반복마다 해당 항목을 변수 obj에 저장

변수 obj는 튜플 객체로 첫 번째 항목에 접근해 인덱스를, 두 번째 항목에 접근해 값을 출력함

 

for문에서 data_list를 enumerate 객체로 변환

이를 통해 매 반복마다 해당 항목을 변수 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

 

 

04_filter()

조건에 해당하는 항목을 걸러내는 함수

 

첫 번째 매개변수는 전달 받은 인자에 대해 True 또는 False 의 부울형을 반환하는 함수를 취함

 

첫 번째 매개변수에는 반복 가능한 자료형을 인자로 전달해야 함

이떼 전달된 반복 가능한 자료형 인자가 첫 번째 매개변인 함수의 인자로 전달

 

 

def iseven(num):
	return num % 2 == 0

첫 행에서는 매개변수num을 가진 iseven함수를 선언

다음 행에 iseven함수는 매개변수num의 인자로 전달된 값이 2로 나누어질 경우 (짝수일 경우) True 반환

 

def iseven(num):
	return num % 2 == 0
    
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)
print("{0}".format(type(ret_val)))
print("{0}".format(list(ret_val)))

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

변수 numbers에 1부터 10까지의 정수를 가지는 리스트를 저장하고

filter() 함수에 iseven함수를 첫 번째 인자로 전달하여 두 번째 인자에서 짝수 여부를 확인 한 후

filter() 함수의 두 번째 인자로 numbers 리스트 객체를 전달

 

filter()함수는 iseven함수가 True를 반환한 짝수 값을 항목으로 하는 리스트 생성 후 변환

이 반환 값이 변수ret_val에 저장

 

# filter() 함수의 첫 번째 인자로 iseven함수 대신 lambda식을 사용할 수도 있음

# 람다식을 사용하면 실행 가능한 코드를 인자로 전달할 수 있음

 

반환된 객체 타입은 필터 객체 타입이며

필터 객체를 리스트로 변환

 

 

05_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 = tuple(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'}
# dict({'e', 'l', 'o', 'H'}) => <class 'dict'>{0: 'e', 1: 'l', 2: 'o',3: 'H'}

변수 data_str에 문자열 Hello를 저장

list함수에 인자로 data_str을 저장하면 리스트 객체가 생성되고

이 객체를 변수 data_list가 참조

변수 data_list에는 data_str에 문자열을 구사했던 "Hello"의 문자 하나하나가 리스트 항목으로 구성

 

tuple함수에 인자로 변수 data_list를 전달하면

튜플 객체가 생성되고 이 객체를 변수 data_tuple이 참조

변수 data_tuple은 data_list의 항목과 동일하게 구성

 

변수 데이터 tuple을 set 함수에 인자로 전달하면

셋 객체가 생성되고 이 객체를 변수 data_set이 참조

변수 data_set은 set타입의 특성상 중복을 허용하지 않아 유일 값으로만 항목을 구성

이 때 시퀀스 타입이 아니므로 순서는 의미 없음

 

변수 데이터 set을 enumerate함수에 인자로 전달하면

인덱스와 값으로 구성된 tuple을 항목으로 하는 enumerate객체 생성

이 enumerate객체를 dict함수의 인자로 전달하면

각 튜플 항목에 저장 되어 있는 첫 번째 값인 인덱스를 딕셔너리의 키로 하고

두번째 값을 딕셔너리의 키에 대응하는 값으로 하는 딕셔너리 객체를 반환되고 이 객체를 변수data_dict가 참조

 

 

06_map()

두 번째 인자로 반복 가능한 자료형을 전달 받아 자료형의 각 항목에 대해

첫 번째 인자로 전달 받은 함수를 적용한 결과를 맵 객체로 반환하는 함수

data_list = list("abcdef")

result = list(map(lambda x: x.upper(), data_list))

print("list(map(lambda x: x.upper(), {0})) => {1}{2}".format(data_list, type(result), result))

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

data_list 변수는 문자열 abcdef를 변환한 리스트 객체를 저장

 

맵 함수를 통해 data_list객체의 항목에 대해

대문자로 변환하는 항목을 가진 맵 객체를 반환 (반환 함수로 람다식을 사용)

변수 result에서 참조

 

result객체는 모든 값이 대문자로 변환된 항목을 가진 list객체임

 

07_max() / min()

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

data_list는 리스트'10, 25, 30, 45, 50'을 참조

min() 과 max()함수에 data_list함수를 인자로 전달하여 가장 작은 값과 큰 값을 반환

 

08_range()

첫 번째 인자로 전달된 시작 값

두 번째 인자로 전달된 종료 값             => 이 세가지 함수를 이용해 시퀸스 형 객체를 생성하는 함수

세 번째 인자로 전달된 증감치

# 종료 값으로 사용된 두 번째 인자의 값은 포함되지 않음

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

print("list(range(0, 10, 1)) => {0}".format(data_list1))
print("list(range(0, 10)) => {0}".format(data_list2))
print("list(range(10)) => {0}".format(data_list3))

# [결과]
# list(range(0, 10, 1)) => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# list(range(0, 10)) => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# list(range(10)) => [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

 

 

09_sorted()

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

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

asc_result = sorted(data_list)	# 오름차순으로 정렬 (낮은 수 ~> 높은 수)

print("{0} {1}".format(type(data_list), data_list))
print("{0} {1}".format(type(asc_result), asc_result))

print("-" * 35)

desc_result = list(reversed(asc_result))		# 내림차순으로 정렬 (높은 수 ~> 낮은 수)
print("{0} {1}".format(type(data_list), data_list))	# 원본
print("{0} {1}".format(type(asc_result), acc_result))	# 오름차순
print("{0} {1}".format(type(desc_result), desc_result)) # 내림차순

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

# -----------------------------------

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

변수 data_list는 3, 8, 12, 2, 5, 11 의 정수 항목을 가진 리스트 객체를 참조

 

sorted함수는 data_list의 함수를 인자로 전달받아 오름차순으로 정렬된 list 객체를 생성해 반환

이 정렬된 리스트객체는 변수 asc_result에서 참조

 

reversed함수는 오름차순으로 정렬된 asc_result를 내림차순으로 정렬해 desc_result변수에 참조

 

data_list객체와 asc_result객를 확인해보면 원본이였던 데이터리스트 객체는 정렬 이전의 상태임을 확일 할 수 있음

 

10_zip()

둘 이상의 반복 가능한 자료형을 일자로 전달 받아,

동일 위치의 항목을 묶어 튜플을 항목으로 구성하는 zip객체를 생성하는 함수

# 인자로 전달된 객체는 동일 자료형이면서, 항목의 개수가 같아야 함

data_list1 = [1, 2, 3]
data_list2 = [4, 5, 6]		# => data_list1, 2, 3은 각각 세 개의 정수 항목을 가진 리스트 객체를 참조
data_list3 = ["a", "b", "c"]

print("list(zip({0}, {1})) => {2}"
	.format(data_list1, data_list2, list(zip(data_list1, data_list2))))
    # data_list1의 첫 번째 항목 1, data_list2의 첫 번째 항복 4을 튜플로 묶음
    # data_list2의 두 번째 항목 2, data_list2의 두 번째 항복 5을 튜플로 묶음
    # data_list3의 세 번째 항목 3, data_list2의 세 번째 항복 6을 튜플로 묶음
    
# [결과]
# list(zip([1, 2, 3], [4, 5, 6])) => [(1, 4), (2, 5), (3, 6)]

print("list(zip({0}, {1}, {2})) => {3}"
	.format(data_list1, data_list2, data_list3, list(zip(data_list1, data_list2, data_list3))))
    # 각 리스트들의 첫 번째, 두 번째, 세 번째 항목끼리 묶임
    
# [결과]
# list(zip([1, 2, 3], [4, 5, 6], ["a", "b", "c"])) => [(1, 4, "a"), (2, 5, "b"), (3, 6, "c")]

print("list(zip({0}, {1})) => {2}"
	.format(data_list3, data_list1, dict(zip(data_list3, data_list1))))
    # data_list3과 data_list1을 튜플로 묶고 dict함수로 딕셔너리 객체로 변환
    
# [결과]
# dict(zip(["a", "b", "c"], [1, 2, 3])) => {"a": 1, "b": 2, "c": 3}