Python #7 내장 함수

수치 연산 함수

abs()

인자로 숫자를 전달하면 그 숫자의 절대값을 반환

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

> abs(10) => 10

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

> abs(-10) => 10

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

> abs(-3.14) => 3.14

divmod()

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

val1, val2 = 9, 5
result = divmod(val1, val2)


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

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

# 2 제곱한 결과를 항목으로 가진 map 객체를 얻어, 리스트로 변환해 사용
print("list(map(lambda x: pw(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]

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

all()

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

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

> True

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

> True

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

# 0은 False
> False

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

# 공백은 False
> False

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

> False

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

# None은 False
> False

any()

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

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

> True

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

> True

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

> True

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

> True

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

> True

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

> True

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

# 모두 False 일 때 False 반환
> False

enumerate()

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

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

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

print()

# obj 는 튜플 객체
# 첫 번째 항목에 접근해 인덱스를, 두 번째 항목에 접근해 값을 출력함
for obj in enumerate(data_list) :
    print("{0}: {1}, {2}".format(type(obj), obj[0], obj[1]))

print()
# 위 코드와 같음
for obj in enumerate(data_list) :
    print("{0}: {1}, {2}".format(type(obj), *obj))

filter()

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

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

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

# iseven 함수가 True를 반환한 짝수 값을 항목으로 하는 리스트 생성후 반환
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]

list() tuple() set() dict()

반복 가능한 자료형을 인자로 전달받아
각각 리스트, 튜플, 셋, 딕셔너리로 변환하는 함수

str = "Hello"

data_list = list(str)

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

> list('Hello') => <class 'list'> ['H', 'e', 'l', 'l', 'o']


data_tuple = tuple(data_list)

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

> tuple(['H', 'e', 'l', 'l', 'o']) => <class 'tuple'> ('H', 'e', 'l', 'l', 'o')


# set 은 중복을 허용하지 않는다
data_set = set(data_tuple)

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

# 시퀀스 타입이 아니므로 순서는 의미 없다
> set(('H', 'e', 'l', 'l', 'o')) => <class 'set'> {'e', 'l', 'o', 'H'}


# 인덱스와 값으로 구성된 tuple을 항목으로 하는 enumerate 객체 생성
data_dict = dict(enumerate((data_set))

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

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

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

max() min()

반복 가능한 자료형을 인자로 전달받아 항목중 가장 큰 값, 작은 값을 반환

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

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. 세 번째 인자 : 증감치

list1 = list(range(0, 10, 1))

# 생략된 세 번째 매개변수의 기본값은 1
list2 = list(range(0, 10))

# 생략된 첫 번째 매개변수의 기본값은 0,
# 생략된 세 번째 매개변수의 기본값은 1
list3 = list(range(10))

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

sorted() reversed()

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

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

# 오름차순으로 정렬된 리스트 객체를 생성해 반환
result = sorted(data)

> [2, 3, 5, 8, 11, 12]

# 내림차순으로 정렬
desc_result = list(reversed(result))

> [12, 11, 8, 5, 3, 2]

zip()

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

주의 사항

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

list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = ["a", "b", "c"]

print(list(zip(list1, list2)))

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


print(list(zip(list1, list2, list3)))

> [(1, 4, 'a'), (2, 5, 'b'), (3, 6, 'c')]

print(dict(zip(list3, list1)))

> {'a': 1, 'b': 2, 'c':3}

변환 함수

chr()

정수 형태의 유니코드 값을 인자로 전달받아 해당 코드의 문자를 반환

val = 65

print(chr(val))

> 'A'

val = 97

print(chr(val))

> 'a'

val = 0xac00

print(chr(val))

> '가'

ord()

문자를 인자로 전달 받아 유니코드 값(10진 정수)을 반환

hex()

10진 정수 값을 인자로 전달 받아 16진수로 변환된 값을 반환

# ord()
val = 'A'

print(ord(val))

> 65

val = 'a'

print(ord(val))

> 97

val = '가'

print(ord(val))

> 44032

# hex()
hex(ord(val))

> 0xac00

int()

인자로 전달된 숫자 형식의 문자열, 부동소수점 숫자를 정수로 변환

float()

인자로 전달된 숫자 형식의 문자열, 정수를 부동소수점 숫자로 변환

str()

인자로 전달된 객체에 대한 문자열 변환 값을 반환

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

# 2진수 -> 10진수
print(int(x, 2))

> 2

# 16진수 -> 10진수
print(int(y, 16))

> 60

print(int(z))

> 4

# 정수형으로 변환
print(int(x))

> 10

# 부동소수점 -> 문자열
print(str(z))

> '4.5'

객체 조사를 위한 함수

dir()

인자로 전달된 객체가 가지고 있는 변수, 메서드와 같은 속성 정보를 리스트 객체로 변환

인자를 전달하지 않고 호출하면 현재 지역 스코프에 대한 정보를 리스트 객체로 반환

# 현재 지역 스코프에 대한 정보를 리스트 객체로 반환
print(dir())

# 문자열이 가지고 있는 많은 메소드 정보를 리스트 객체에 담아 반환
str = "hello python"
print(dir(str))

# 정수형 리스트 객체가 가지고 있는 메소드 정보들을 리스트 객체에 담아 반환
data_list = [10, 20, 30, 40, 50]
print(dir(data_list))

# 딕셔너리 객체가 가지고 있는 메소드 정보들을 리스트 객체에 담아 반환
data_dict = {"key1": 10, "key2": 20, "key3": 30}
print(dir(data_dict))

globals()

현재의 전역 심볼 테이블을 보여주는 딕셔너리를 반환하는 함수

전역변수와 함수, 클래스의 정보 포함

locals()

현재의 지역 심볼 테이블을 보여주는 딕셔너리를 반환하는 함수

매개변수를 포함한 지역변수와 중첩함수의 정보 포함

class MyClass :
    pass

def test(param) :
    # 중첩 함수
    def inner() :
        pass

    val1 = 5
    val2 = 8

    # locals 함수가 반환한 딕셔너리 객체에 대해 items 함수로 리스트 객체를 얻음
    for item in locals().items() :
        # 첫 번째 항목인 키를, 두 번째 항목인 값을 접근해 지역 정보 출력
        print("\t{0} : {1}".format(item[0], item[1]))


value1 = 10
value2 = 20

obj1 = MyClass()

# globals 함수가 반환한 dict 객체의 현재 상태를 복사해 g 에 저장
g = dict(globals())

# g의 items 함수로 반환된 리스트 객체를 얻음
print("globals()")

for item in g.items() :
    print("\t{0} : {1}".format(item[0], item[1]))

# test 함수를 호출하면서 인자 값 10을 전달해서 4~10행까지 차례대로 실행
print("\n\nlocals()")
test(10)

id()

인자로 전달된 객체의 고유 주소(참조값)를 반환

x = 10
# 고유 주소는 보통 16진수로 표현
print(hex(id(x)))

> 0x751e6f00

isinstance()

첫 번째 인자로 전달된 객체가 두 번째 인자로 전달된 클래스의 인스턴스인지에 대한 여부를 True / False 로 반환

issubclass()

첫 번째 인자로 전달된 클래스가 두 번째 인자로 전달된 클래스의 서브클래스인지에 대한 여부를 True / False 로 반환

class Parent :
    pass

class Child(Parent) :
    pass

p = Parent()
c = Child()

print("p 객체는 Parent 클래스의 인스턴스입니까? {0}".format(isinstance(p, Parent)))

> p 객체는 Parent 클래스의 인스턴스입니까? True

print("c 객체는 Parent 클래스의 인스턴스입니까? {0}".format(isinstance(c, Child)))

> c 객체는 Parent 클래스의 인스턴스입니까? True

print("p 객체는 Parent 클래스의 인스턴스입니까? {0}".format(isinstance(c, Parent)))

> p 객체는 Parent 클래스의 인스턴스입니까? True

print("p 객체는 Parent 클래스의 인스턴스입니까? {0}".format(isinstance(p, Child)))

> p 객체는 Parent 클래스의 인스턴스입니까? False

print("p 객체는 Parent 클래스의 인스턴스입니까? {0}".format(isinstance(Child, Parent)))

> p 객체는 Parent 클래스의 인스턴스입니까? 

실행 관련 함수

eval()

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

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

> 17

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

> HELLO, PYTHON

예제

# 1부터 20까지 리스트 
data_list = list(range(1, 21))



# map()
# map 은 람다식으로 사용하는 경우가 많다
# 각 리스트의 숫자에 5를 더한다
map_list =  list(map(lambda x: x + 5, data_list))


# filter()
# 특정 조건을 만족하는 항목만 찾아서 필터링
# True / False 반환
# map_list 에서 3의 배수만 가져오기
filter_list = list(filter(lambda x: x % 3 == 0, map_list))



# eval 함수를 이용하기
map_str = input("항목 x에 대해 적용할 표현식을 입력하세요 : ")

map_list =  list(map(lambda x: eval(map_str), data_list))

filter_str = input("항목 x에 대해 필터링할 조건의 표현식을 입력하세요 : ")

filter_list = list(filter(lambda x: eval(filter_str), map_list))