1. 내장(built-in) 함수
■ 파이썬에는 모듈처럼 import를 사용하지 않고도 언제든지 사용할 수 있는 내장 함수가 있다. 그리고 대부분의 객체에 대해서도 사용이 가능하다. print, type, del, abs 등이 바로 내장 함수이다.
■ 아래의 내용은 활용 빈도가 높은 내장 함수들에 대한 정리이다.
1.1 abs()
■ abs(x)는 어떤 숫자를 받아, 해당 숫자의 절댓값을 리턴하는 데 사용된다.
■ 정수 및 부동 소수점 수를 포함하여 모든 수에 적용 가능하다. 복소수의 경우 복소수의 크기를 반환한다.
x = 10
abs(x)
```#결과#```
10
````````````
abs(-x)
```#결과#```
10
````````````
x = 3 + 2j
type(x)
```#결과#```
complex
````````````
abs(x)
```#결과#```
3.605551275463989
````````````1.2 all()
■ all(x)는 반복 가능한 데이터(리스트, 튜플, 문자열, 딕셔너리, 집합 등) x를 입력값으로 받아서, 반복 가능한 데이터 x의 모든 요소가 참이면 True, 하나라도 거짓이 있으면 False를 리턴한다.
x = [1, 2, 3]
all(x)
```#결과#```
True
````````````■ 반복 가능한 데이터 x가 비어 있으면 True를 반환한다.
x = set()
all(x)
```#결과#```
True
````````````
■ 요소 중 0이 아닌 값은 참으로 간주되고, 0은 거짓으로 간주된다.
x = [0, 1, 2, 3]
all(x)
```#결과#```
False
````````````
x = {'0':1, 'b':2, 'c':3}
all(x)
```#결과#```
True
````````````
x = {0:1, 'b':2, 'c':3}
all(x)
```#결과#```
False
````````````1.3 any()
■ any(x)도 반복 가능한 데이터 x를 입력값으로 받는다. 단, x의 요소 중 한 개의 요소라도 참인 경우 True를 리턴한다. 모든 요소가 거짓일 때만 False를 리턴한다. 즉, all(x)와 반대로 작동한다.
x = [1, 2, 3]
any(x)
```#결과#```
True
````````````
x = [0, 1, 2, 3]
any(x)
```#결과#```
True
````````````
x = [0]
any(x)
```#결과#```
False
````````````1.4 bin()
■ bin() 함수는 정수의 이진 표현을 반환하는 데 사용된다. 반환 결과는 항상 접두사 '0b'로 시작한다.
bin(2)
```#결과#```
'0b10'
````````````
bin(3)
```#결과#```
'0b11'
````````````
bin(4)
```#결과#```
'0b100'
````````````
bin(5)
```#결과#```
'0b101'
````````````
bin(32)
```#결과#```
'0b100000'
````````````1.5 chr(), ord()
■ chr() 함수는 유니코드 숫자 값을 입력값으로 받아 그 코드에 해당하는 문자를 반환하는 함수이다.
chr(97)
```#결과#```
'a'
````````````
chr(44032)
```#결과#```
'가'
````````````■ ord() 함수는 문자를 입력값으로 받아, 입력값에 해당되는 유니코드 숫자 값을 반환하는 함수이다.
ord('a')
```#결과#```
97
````````````
ord('가')
```#결과#```
44032
````````````1.6 dir()
■ dir은 객체가 가지고 있는 속성과 메서드를 보여준다.
■ 예를 들어, 리스트 객체가 가지고 있는 속성와 메서드를 출력해보면 다음과 같다.
list1 = [0, 1, 2, 3]
print(dir(list1))
```#결과#```
['__add__', '__class__', '__class_getitem__', '__contains__', '__delattr__', '__delitem__',
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
'__getstate__', '__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(), clear(), copy(), count() 등과 같이 리스트 객체가 제공하는 함수를 볼 수 있으며, 파이썬이 내부적으로 사용하는 함수는 앞에 __가 붙어 있는 것을 볼 수 있다.
1.7 complex()
■ complex(real, img) 함수는 복소수 객체를 생성하는 함수이다.
■ "real + img * j" 형식의 복소수가 반환된다.
x = complex(3, 2)
x
```#결과#```
(3+2j)
````````````
type(x)
```#결과#```
complex
````````````1.8 divmod()
■ divmod(a, b)는 2개의 숫자 a, b를 입력으로 받아서, a를 b로 나눈 몫과 나머지를 튜플 "(몫, 나머지)"로 반환하는 함수이다.
divmod(7,3)
```#결과#```
(2, 1) # (몫, 나머지)
````````````1.9 enumerate()
■ 시퀀스 객체(리스트, 튜플, 문자열)를 입력으로 받아서 첫 번째 요소로 인덱스 값, 두 번째 요소로 인덱스에 해당되는 값을 포함하는 열거형(enumerate) 객체를 반환하는 함수이다.
fruits = ['apple', 'banana', 'grape']list(enumerate(fruits))
```#결과#```
[(0, 'apple'), (1, 'banana'), (2, 'grape')]
````````````■ enumerate의 start를 지정해서 인덱스 번호를 start에 지정한 값부터 시작하도록 할 수 있다.
list(enumerate(fruits, start = 2))
```#결과#```
[(2, 'apple'), (3, 'banana'), (4, 'grape')]
````````````■ 주로, 다음과 같이 for문과 함께 사용한다.
for index, item in enumerate('abc'):
print(index, item)
```#결과#```
0 a
1 b
2 c
````````````■ 인덱스 값과 함께 문자열 'abc'의 문자 'a', 'b', 'c'가 순서대로 출력되는 것을 볼 수 있다. 이렇게 for문처럼 반복되는 곳에서 객체의 현재 위치를 알려주는 인덱스 값이 필요할 때 enumerate 함수를 사용하면 유용하다.
1.10 input()
■ input()은 사용자 입력을 받는 함수이다. 입력으로 문자열을 전달하면, 그 문자열은 프롬프트가 된다.
a = input()
Hello
a
```#결과#```
'Hello'
````````````
a = input('color: ')
color: black
a
```#결과#```
'black'
````````````1.11 eval()
■ eval() 함수는 전달된 수식을 분석하고 수식의 값을 계산한다.
■ 특히, 사용자가 입력하는 수식을 실행할 때 많이 사용된다. 예를 들어, 다음과 같이 문자열로 구성된 식을 입력으로 받아 해당 식을 계산한 결괏값을 리턴할 수 있다.
a = input('add: ')
add: 1+3
type(a)
```#결과#```
str
````````````
eval(a)
```#결과#```
4
````````````a = eval(input('sub: '))
sub: 3-1
a
```#결과#```
2
````````````■ 쉘에 정의된 전역 변수를 사용할 수도 있다.
a, b = 2, 3
eval('a+b')
```#결과#```
5
````````````1.12 oct(), hex()
■ oct(x)는 정수를 입력받아 8진수 문자열로 변환하여 반환하는 함수이다.
oct(1)
```#결과#```
'0o1'
````````````■ hex(x)는 정수를 입력받아 16진수 문자열로 변환하여 반환하는 함수이다.
hex(1)
```#결과#```
'0x1'
````````````1.13 id()
■ id(object)는 객체를 입력받아 객체의 고유 주솟값을 반환하는 함수이다.
a = 2
print(id(a))
a = 3
print(id(a))
b = a
print(id(b))
```#결과#```
140722450318141
140722450318173
140722450318173
````````````1.14 list()
■ list()는 기본적으로 공백 리스트를 생성하며, list(iterable)는 반복 가능한 데이터를 입력으로 받아 해당 데이터를 리스트로 만들어 반환한다.
a = list()
a
```#결과#```
[]
````````````
str1 = 'abc'
a = list(str1)
a
```#결과#```
['a', 'b', 'c']
````````````
tuple1 = (0, 1, 2, 3)
a = list(tuple1)
a
```#결과#```
[0, 1, 2, 3]
````````````■ list() 함수에 리스트를 입력하면, 동일한 리스트를 복사하여 반환한다.
b = list(a)
b
```#결과#```
[0, 1, 2, 3]
````````````1.15 tuple()
■ tuple()는 기본적으로 공백 튜플을 생성하며, tuple(iterable)는 반복 가능한 데이터를 입력으로 받아 해당 데이터를 튜플로 만들어 반환한다.
a = tuple(str1)
a
```#결과#```
('a', 'b', 'c')
````````````
a = tuple(b)
a
```#결과#```
(0, 1, 2, 3)
````````````■ tuple() 함수에 튜풀을 입력하면, 동일한 튜플을 복사하여 반환한다.
b = tuple(a)
b
```#결과#```
(0, 1, 2, 3)
````````````1.16 len()
■ len() 함수는 입력값의 길이를 계산하여 반환하는 함수이다.
■ 문자열이 입력으로 들어오면, 문자열의 길이를 계산하여 반환하고,
len('abcd')
```#결과#```
4
````````````■ 리스트, 튜플, 딕셔너리가 입력으로 들어오면, 항목(요소)의 개수를 반환한다.
len([0, 1, 2, 3])
```#결과#```
4
````````````
len((0, 1, 2, 3))
```#결과#```
4
````````````
d = {'a':0, 'b':1}
len(d)
```#결과#```
2
````````````1.17 isinstance()
■ isinstance(object, class) 함수는 첫 번째 인수로 객체, 두 번째 인수로 클래스를 받는다.
■ 첫 번째 인수로 받은 객체가 두 번째 인수로 받은 클래스의 "인스턴스"인지를 판단하여 참이면 True, 거짓이면 False를 반환한다.
isinstance(d, dict)
```#결과#```
True
````````````
class Hello:
pass
H = Hello()
isinstance(H, Hello)
```#결과#```
True
````````````
isinstance(d, Hello)
```#결과#```
False
````````````1.18 map()
■ map(function, iterable) 함수는 함수(function)와 반복 가능한 데이터(iterable)를 입력으로 받아서, 반복 가능한 데이터의 각 항목에 함수를 적용한 후, 적용한 결과를 반환하는 함수이다.
def square(n):
return n*nlist1 = [1, 2, 3, 4, 5]
result = list(map(square, list1))
result
```#결과#```
[1, 4, 9, 16, 25]
````````````cf) 이 예는 lambda를 사용하여 다음과 같이 만들 수도 있다.
list(map(lambda n: n*n, list1))
```#결과#```
[1, 4, 9, 16, 25]
````````````1.19 filter()
■ filter() 함수는 특정 조건을 만족하는 요소만을 뽑는 함수이다.
■ 두 개의 인수를 취하는데, 첫 번째 인수는 조건을 나타내는 "함수", 두 번째 인수는 "반복 가능한 데이터"이다.
■ 반복 가능한 데이터의 요소 순서대로 함수를 호출했을 때, 리턴값이 True인 요소들만 반환한다.
def func(x):
return x <3
result = list(filter(func, list1))
result
```#결과#```
[1, 2]
````````````■ filter(func, list1)은 list1 = [1, 2, 3, 4, 5]의 각 요소를 순서대로 func 함수에 적용하여 리턴값이 True인 요소들만 반환한다. - 이 예에서 list1의 요소 1, 2는 func 함수의 x < 3에 의해 True가 되며 3, 4, 5는 False가 된다. 그래서 result의 요소에 1, 2가 들어 있는 것이다.
cf) 이 예는 lambda를 사용하여 다음과 같이 만들 수도 있다.
list(filter(lambda x: x < 3, list1))
```#결과#```
[1, 2]
````````````cf) map, filter, lambda를 사용하여 다음과 같은 작업도 가능하다.
list(filter(lambda x: x < 10, map(lambda n: n*n, list1))))
```#결과#```
[1, 4, 9]
````````````- filter의 첫 번째 인수는 x: x<10인 람다 함수이고, 두 번째는 map 함수이며, map 함수에서는 list1의 모든 요소에 n*n을 적용한다.
- 그러므로 list1의 모든 요소에 n*n을 적용한 결과 중에서 x<10인 요소들만 반환된다.
1.20 min(), max()
■ min(iterable), max(iterable) 함수는 반복 가능한 데이터를 입력으로 받아 해당 데이터 내의 최솟값, 최댓값을 반환하는 함수이다.
min([0, 1, 2, 3])
```#결과#```
0
````````````
max([0, 1, 2, 3])
```#결과#```
3
````````````min('world!')
```#결과#```
'!'
````````````
max('world!')
```#결과#```
'w'
````````````1.21 pow()
■ poww(x, y)는 x를 y제곱한 결괏값을 반환하는 함수이다.
pow(2, 10)
```#결과#```
1024
````````````1.22 range()
■ range(start, stop, step)은 입력받은 범위에 해당하는 값을 함수로, 주로 for문이나 list(), tuple() 등의 함수와 함께 자주 사용한다.
■ 시작 숫자(start)를 지정하지 않으면 range 함수는 0부터 시작한다.
list(range(3))
```#결과#```
[0, 1, 2]
````````````■ 시작 숫자(start)와 끝 숫자(stop)를 입력으로 넣으면, 끝 숫자를 제외한 범위 내의 값들이 반환된다.
list(range(1, 3))
```#결과#```
[1, 2]
````````````■ start, stop, step. 3개의 인수를 모두 넣으면 step 간격만큼의 값들이 반환된다. 마찬가지로 끝 숫자는 제외된다.
list(range(1, 10, 2))
```#결과#```
[1, 3, 5, 7, 9]
````````````1.23 round()
■ round(number) 함수는 숫자를 입력받아 반올림하여 반환하는 함수이다.
round(10.4)
```#결과#```
10
````````````
round(10.6)
```#결과#```
11
````````````■ round 함수의 두 번째 인자는 반올림할 소수점 자리수를 지정하는 역할을 한다.
round(10.126, 2)
```#결과#```
10.13
````````````1.24 int()
■ int(x)는 문자열 형태의 숫자나 소수점이 있는 숫자를 정수로 변환하여 반환하는 함수이다. 정수가 입력되면 그대로 해당 정수를 반환한다.
int('10')
```#결과#```
10
````````````
int(10.6)
```#결과#```
10
````````````1.25 sum()
■ sum(iterable)은 입력으로 받은 데이터의 합을 반환하는 함수이다.
sum([0, 1, 2, 3])
```#결과#```
6
````````````1.26 type()
■ type(object)는 입력값의 자료형이 무엇인지 반환하는 함수이다.
type(list())
```#결과#```
list
````````````
print(type('abc'))
```#결과#```
<class 'str'>
````````````1.27 open()
■ open(filename, mode) 함수는 파일 이름과 모드(읽기 방법)를 입력 받아 파일 객체를 반환하는 함수이다.
- mode를 생략하면 기본값인 읽기 모드 'r'로 파일 객체를 만들어 반환한다.
1.28 zip()
■ zip() 함수는 "동일한 개수로 이루어진 반복 가능한 데이터(iterable)"를 하나로 묶어주는 함수이다.
■ 이때, zip() 함수 내에 여러 개의 반복 가능한 데이터들을 입력으로 넣을 수 있다.
dict1 = {'a':1, 'b':2, 'c':3, 'd':4}
dict2 = {'e':1, 'f':2, 'g':3, 'h':4}
result = list(zip(dict1, dict2))
result
```#결과#```
[('a', 'e'), ('b', 'f'), ('c', 'g'), ('d', 'h')]
````````````list1 = [0, 1, 2, 3]
list2 = [4, 5, 6, 7]
list3 = [8, 9, 10, 11]
result = list(zip(list1, list2, list3))
result
```#결과#```
[(0, 4, 8), (1, 5, 9), (2, 6, 10), (3, 7, 11)]
````````````- 각 iterable의 요소들이 순서대로 하나의 튜플로 묶이는 것을 볼 수 있다.
■ 이러한 zip() 함수는 for 문과 가장 많이 사용된다.
for x, y, z in result:
print(x, y, z)
```#결과#```
0 4 8
1 5 9
2 6 10
3 7 11
````````````1.29 str()
■ str(object)는 문자열 형태로 객체를 변환하여 반환하는 함수이다.
str(1)
```#결과#```
'1'
````````````
str('abc')
```#결과#```
'abc'
````````````1.30 sorted()
■ sorted(iterable) 함수는 입력 데이터를 정렬한 후, 정렬 결과를 "리스트"로 반환하는 함수이다.
sorted('world!')
```#결과#```
['!', 'd', 'l', 'o', 'r', 'w']
````````````
sorted('cab ')
```#결과#```
[' ', 'a', 'b', 'c']
````````````
sorted([3, 0, 2, 1])
```#결과#```
[0, 1, 2, 3]
````````````2. 정렬과 탐색
2.1 sorted() 함수
■ 파이썬 리스트에는 sort() 라는 메서드가 있다. 이 메서드는 리스트를 정렬된 상태로 변경하며, 해당 리스트 자체를 정렬된 상태로 변경해버린다.
■ 그리고 sorted()라는 내장 함수는 반복 가능한 객체로부터 정렬된 리스트를 생성한다.
■ 즉, sorted()는 "정렬된 새로운 리스트를 반환"하는 함수이며, 기존의 리스트는 변경되지 않는다.
2.1.1 key, reverse 인자
■ 파이썬 2.4부터 선택 인자인 key에 함수도 지정할 수 있다. key는 요소를 어떤 기준으로 정렬할지를 결정하는 역할을 한다.
■ reverse 인자에는 부울형으로, True를 지정하면 내림차순, False를 지정하면 오름차순으로 정렬한다. 기본값은 오름차순이다.
dict1 = {'f':10, 'c':1, 'z':5, 'a':4}
sorted(dict1)
```#결과#```
['a', 'c', 'f', 'z']
````````````
sorted(dict1, reverse = True)
```#결과#```
['z', 'f', 'c', 'a']
````````````
sorted(dict1, key = dict1.get)
```#결과#```
['c', 'a', 'z', 'f']
````````````
sorted(dict1, key = dict1.get, reverse =True)
```#결과#```
['f', 'z', 'a', 'c']
````````````- 딕셔너리 dict1을 sorted() 함수에 넣으면, 기본적으로 딕셔너리의 키를 기준으로 정렬하는 것을 볼 수 있다.
- reverse=False이므로, sorted() 결과로 딕셔너리의 키인 'f', 'c', 'z', 'a'를 오름차순으로 정렬한 리스트 ['a', 'c', 'f', 'z']가 생성된 것을 볼 수 있다.
- sorted(dict1, reverse=True)는 딕셔너리 키를 기준으로 내림차순 정렬한 리스트 ['z', 'f', 'c', 'a']를 생성한다.
- sorted(dict1, key = dict1.get)은 딕셔너리의 get메서드를 sorted() 함수의 key에 지정했으므로, dict1의 키에 대응되는 값을 기준으로 dict1의 키를 오름차순 정렬한 리스트를 생성한다.
sorted("Hello World".split(), key = str.upper, reverse = True)
```#결과#```
['World', 'Hello']
````````````
sorted("Hello World!!!".split(), key = len, reverse = True)
```#결과#```
['World!!!', 'Hello']
````````````
sorted("Hello World", key = str.upper, reverse = True)
```#결과#```
['W', 'r', 'o', 'o', 'l', 'l', 'l', 'H', 'e', 'd', ' ']
````````````- sorted() 함수의 key에 str.upper. 즉, 대문자로 변환하는 함수나 len처럼 문자열의 길이를 반환하는 함수를 지정할 수도 있다.
def func(x):
return x <2
list1 = [0, 1, 2, 3]
sorted(list1, key = func, reverse = True)
```#결과#```
[0, 1, 2, 3]
````````````
result = [(1, 4, 8), (0, 5, 9), (3, 6, 10), (2, 7, 11)]
sorted(result, key = lambda item:item[0], reverse = True)
```#결과#```
[(3, 6, 10), (2, 7, 11), (1, 4, 8), (0, 5, 9)]
````````````- 위와 같이 def로 정의한 사용자 정의 함수를 sorted() 함수의 key에 지정할 수 있고, 람다식을 지정할 수도 있다.
- key에 람다식을 지정한 예의 경우, 리스트 내 각 튜플 항목의 첫 번째 항목을 기준으로 내림차순 정렬한다.
3. 람다식(람다 함수)
■ 람다식(또는 람다 표현, 람다 함수)은 lambda 키워드로 이름이 없는 함수를 만드는 방법이다. def로 만드는 함수와 동일한 역할을 한다. 주로 간단한 함수가 필요할 때 자주 사용한다.
3.1 람다식 정의
■ 람다식을 정의하는 방법은 다음과 같다.
■ 람다식은 여러 개의 매개변수를 가질 수 있으나 반환값은 하나만 있어야 한다.
lambda 매개변수들: 매개변수들로 표현된 수식f = lambda x, y: x+y- x, y는 매개변수, 콜론(:) 뒤에 있는 수식이 함수의 몸체(body)이다.
f(10, 20)
```#결과#```
30
````````````- 람다 함수 f의 인수로 10과 20을 넣은 다음, f를 호출하면 10과 20은 람다 함수 f의 매개변수 x와 y에 전달되며, 매개변수로 표현된 수식 x+y의 결과가 반환된다.
3.2 map(), filter()와 람다식
■ 내장 함수인 map()과 filter()는 모두 "함수"를 입력으로 받는다. 그러므로 무명 함수인 람다식 또한 입력으로 넣을 수 있다.
list1 = [0, 1, 2, 3, 4, 5]
f = lambda x: x%2==0
result = list(map(f, list1))
result
```#결과#```
[True, False, True, False, True, False]
````````````- 위의 예시는 각 요소가 짝수인지 확인하는 람다식 f와 리스트인 list1을 map() 함수에 같이 넣어, list1의 각 요소가 2의 배수인지 확인한다.
- 람다식 f의 수식이 'x%2==0'이므로, map() 함수를 통해 list1의 각 요소는 짝수이면 True, 그렇지 않으면 False가 된다.
result = list(filter(f, list1))
result
```#결과#```
[0, 2, 4]
````````````- filter() 함수를 사용할 경우, 짝수에 해당하는 0, 2, 4가 필터링되는 것을 볼 수 있다.
'파이썬' 카테고리의 다른 글
| 예외 처리 (0) | 2024.09.11 |
|---|---|
| 클로저와 데코레이터, 이터레이터와 제너레이터, 파이썬 타입 어노테이션 (0) | 2024.09.09 |
| 함수 (1) | 2024.09.06 |
| 파일 읽고 쓰기 (0) | 2024.09.03 |
| 제어문(control statement) (2) - 반복문 for, while (0) | 2024.09.02 |
