[Python]파이썬 내장 함수: 유용한 기능과 활용 방법 소개

python 인터프리터에는 항상 사용할 수 있는 많은 함수가 내장되어 있습니다.각 내장 함수들은 특정한 기능을 수행하며 별도의 라이브러리를 import 하지 않고도 사용할 수 있습니다.

≣ 목차

• 문자열 내장 함수📚
• 숫자 내장 함수☝✌
• 시퀀스 내장 함수⌚
• 컬렉션 내장 함수🌈
• 핵심 내용👀

파이썬 내장함수의 종류를 주요 작업을 기준으로 분류하면 크게 문자열과 관련된 함수, 숫자 관련 함수, 시퀀스 관련 함수, 컬렉션 관련 함수, 입출력 관련 함수가 있습니다.

입출력 관련 함수의 경우 주로 사용되는 함수가 input()과 print()가 있습니다. 해당 내용은 아래 포스팅을 확인해 주세요😁

오늘은 주로 사용 되는 내장 함수 중 문자열, 숫자, 시퀀스, 컬렉션과 관련된 함수를 알아보겠습니다.

[파이썬]input()과 형 변환

[파이썬]Print 함수

---

1. 문자열 내장 함수📚

파이썬 문자열 내장함수의 종류를 코드 예제로 정리해 보겠습니다.

▶ chr(): 유니코드를 문자로 변환

# chr(): 유니코드 -> 문자로 출력 
print(chr(48)) # [0]
print(chr(49)) # [1]
print(chr(65)) # [A]
print(chr(66)) # [B]
print(chr(97)) # [a]
print(chr(98)) # [b]

▶ ord(): 문자를 유니코드로 변환

# ord(): 문자 -> 유니코드로 변환
print(ord('0')) # [48]
print(ord('1')) # [49]
print(ord('A')) # [65]
print(ord('B')) # [66]
print(ord('a')) # [97]
print(ord('b')) # [98]

▶ eval(): 문자열로 된 값을 계산

# 문자열 -> 계산
print(eval('100 + 200')) # [300]

# print()로만 이용한 값과 비교해보기
print('100 + 200') # [100 + 200]

# eval, min함수 같이 이용해 문자열의 최솟값 구하기
print(eval('min(1, 2, 3)')) # 1

▶ len(): 문자열의 길이를 구해주는 함수

# len(): 문자 -> 글자 수(길이) 구하기 
ch = 'Hello'
print(len(ch)) # [5]

▶ capitalize(): 문자열의 첫 글자를 대문자로 변환

▶ lower(): 문자열을전부 소문자로 변환

▶ upper(): 문자열을 전부 대문자로 변환

# capitalize(): 첫 글자 -> 대문자로 변환 
print('hello world'.capitalize()) # Hello world

# lower(): 모두 소문자로 변환 
print('Hello World'.lower()) # hello world

# upper(): 모두 대문자로 변환 
print('Hello World'.upper()) # HELLO WORLD

▶ strip(): 문자열 양옆의 공백을 제거

# strip():양 옆 공백 제거
print('    Hello World    '.strip()) #  [Hello World]

# print()로만 이용한 값과 비교해보기 
print('    Hello World    ') # [    Hello World    ]

▶ replace(): 문자열의 특정한 문자, 문자열을 다른 문자나 문자열로 대체

# replace(): 특정 부분 문자열 대체 
print('Hello World'.replace('Hello', 'Hi')) #  [Hi World]

▶ split(): 문자열을 지정된 구분자를 기준으로 나누어 리스트로 반환

# split(): 특정 구분자 기준으로 나누어 리스트로 반환
print('Hello, World'.split(',')) # [['Hello', ' World']]

▶ join(): 문자열 리스트를 한 개의 문자열로 결합

# join(): 문자열 리스트 -> 하나의 문자열로 결합 
li = ['Hello', 'World']
print(''.join(li)) # [Hello World]

▶ find(): 문자열의 왼쪽부터 특정 문자열을 찾아서 위치를 반환

▶ rfind(): 문자열의 오른쪽부터 특정 문자열을 찾아서 위치를 반환

# find(): 특정 문자 위치 확인 (왼쪽부터 처음 등장하는 문자) 
str= 'best of best'
print(str.find('best')) # [0]

# rfind(): 특정 문자 위치 확인 (오쪽부터 처음 등장하는 문자) 
str= 'best of best'
print(str.rfind('best')) # [8]

문자열의 구성을 파악하는 is~로 시작하는 내장 함수는 조건 만족 여부를 bool값으로 반환합니다.

▶ isalnum(): 문자열이 알파벳 또는 숫자로만 구성되어 있는지 확인

▶ isalpha(): 문자열이 알파벳으로만 구성되어 있는지 확인

▶ isdigit(): 문자열이 숫자로 인식될 수 있는지 확인

# isalnum(): 알파벳, 숫자로만 구성됬는지 확인
print('python123'.isalnum()) # True
print('python 123'.isalnum()) # False -> 띄어쓰기가 포함되어도 False(거짓)

# isalpha(): 알파벳으로만 구성됬는지 확인
print('python'.isalpha()) # True
print('python123'.isalpha()) # False

# isdigit(): 숫자로만 구성됬는지 확인
print('123'.isdigit()) # True
print('python123'.isdigit()) # False

---

2. 숫자 내장 함수☝✌

▶ abs(): 절댓값을 반환

# abs(): 절대값 반환
print(abs(-1)) # 1
print(abs(-2)) # 2
print(abs(-3)) # 3

▶ round(x, n): n소수점 자리까지 반올림한 값을 반환(n 생략 시 소수점 첫 째자리 반환)

# round(숫자, 원하는 소수점 자리 수) : 반올림
print(round(1.5)) # 2 -> 일의 자리까지
print(round(1.4)) # 1
print(round(1.55, 1)) # 1.6 -> 소수 첫 째자리 까지

▶ max(): 반복 가능한 객체 중 최댓값 반환

▶ min(): 반복 가능한 객체 중 최솟값반환

# max() : 최댓값
print(max(1, 2, 3, 4, 5)) # 5

# min() : 최솟값
print(min(1, 2, 3, 4, 5)) # 1

▶ pow(x, y): x의 값을 y 거듭제곱

# pow() : 거듭제곱
print(pow(10, 2)) # 100 -> 10을 두 번 곱함
print(pow(10, 3)) # 1000 -> 10을 세 번 곱함
print(pow(10, -2)) # 0.01 -> 10을 두 번 곱함

▶ divmod(x, y): x를 y로 나눈 몫과 나머지를 튜플로 반환

# divmod() : 몫과 나머지 -> 튜플로 반환
print(divmod(10, 3)) # (3, 1)
d, m = divmod(10, 3)
print(d) # 3
print(m) # 1

▶ bin(): 정수의 이진표현을 반환

▶ hex(): 정수의 16진수 표현을 반환

▶ oct(): 정수의 8진수 표현을 반환

num = int(3)

# bin() : 이진 표현
binary = bin(num)
print(binary) # 0b11

# hex() : 16진수 표현
hexadecimal = hex(num)
print(hexadecimal) # 0x3

# oct() : 8진수 표현
octal = oct(num)
print(octal) # 0o3

int()와 float()은 숫자를 나타는 일반 자료형으로 함수입니다.

자료형 포스팅 내용을 참고해 주세요😊

▶ int(): 문자열이나 숫자를 정수로 반환

▶ float(): 문자열이나 숫자를 실수로실수로 반환

[파이썬]자료형

---

3. 시퀀스 내장 함수⌚

▶ sorted(): 시퀀스를 정렬

# sort(): 정렬
li = [6, 3, 1, 2, 5, 4]
sorted_ascending_list = sorted(li)
sorted_descending_list = sorted(li, reverse=True)

print(li) # [6, 3, 1, 2, 5, 4]
print(sorted_ascending_list) # [1, 2, 3, 4, 5, 6] -> 정렬 후(오름차순)
print(sorted_descending_list) # [6, 5, 4, 3, 2, 1] -> 정렬 후(내림차순)

▶ reversed(): 시퀀스를 역순으로 반환

## reversed() : 시퀀스 자료형을 역순으로 반환

# 리스트를 역순으로 출력
li = [1, 2, 3, 4, 5]
reversed_list = reversed(li)
print(list(reversed_list))  # [5, 4, 3, 2, 1]

# 문자열을 역순으로 출력
str = "Hello, World!"
reversed_string = reversed(str)
print(''.join(reversed_string))  # !dlroW ,olleH

문자열을 reversed() 함수로 역순으로 변환할 때 한 가지 주의해야 합니다.

str = "Hello, Python!"
reversed_string = print(reversed(str)) # <reversed object at 0x0000018371CD1840>

위 코드처럼 reversed() 함수를 이용하면 역순으로 순회한 문자열의 리스트의 주소만 나오는 것을 볼 수가 있습니다.

그래서 역순으로 순회한 문자열 리스트를 다시 join() 함수를 이용해 결합해 주어야 합니다.

str = "Hello, World!"
reversed_string = reversed(str)
print(''.join(reversed_string))  # reversed 객체를 문자열로 변환하여 출력

▶ enumerate(iterable, start=0): 반복 가능한 객체를 입력으로 받아 요소와 인덱스를 함께 반환

[기본 형태]

for 인덱스번호, 값 in enumerate(리스트명):

수행할 코드

# enumerate() : 인덱스와 요소를 튜플로 묶어 반환
li = ['peach', 'strawberry', 'grape']
for index, value in enumerate(li):
    print(f'인덱스 {index}의 값: {value}') # 인덱스 0의 값: peach
                                           # 인덱스 1의 값: strawberry
                                           # 인덱스 2의 값: grape

▶ zip(): 시퀀스를 묶어서 같은 인덱스 요소를 튜플로 묶어서 반환

# zip() = 같은 인덱스 요소 튜플로 반환
fruits = ['peach', 'strawberry', 'grape']
colors = ['link', 'red', 'green']
zipped = zip(fruits, colors)
print(list(zipped)) # [('peach', 'link'), ('strawberry', 'red'), ('grape', 'green')]

▶ slice(start, stop, step): 시퀀스의 부분적인 값을 출력, '시작, 끝, 간격'의 형식으로 슬라이싱(간격 생략 시 기본값은 1)

# slice() : 부분적인 값 추출

# 리스트 슬라이싱
li = [1, 2, 3, 4, 5]
slice_result = li[1:4]  # 인덱스 1부터 3까지의 부분 리스트 추출
print(slice_result)  # [2, 3, 4]

# 문자열 슬라이싱 
str = "Hello World!"
slice_result = str[6:]  # 인덱스 6부터 끝까지의 부분 문자열 추출
print(slice_result)  # World!

▶ len(): 시퀀스 길이(항목 수)를 구해주는 함수

▶ max(): 시퀀스의 최댓값을 구해주는 함수

▶ min(): 시퀀스의 최솟값을 구해주는 함수

li = [20, 2, 8, 5, 7] 

# len(): 길이(항목) 구하기
print(len(li)) # 5

# max(): 최댓값 구하기
print(max(li)) # 20

# max(): 최솟값 구하기
print(min(li)) # 2

---

4. 컬렉션 내장 함수🌈

딕셔너리(dict), 세트(set), 리스트(list), 튜플(tuple)은 컬렉션과 관련된 내장 함수입니다.

지난 포스팅 내용을 참고해 주세요😊

▶ dict() : 딕셔너리를 생성(키-값 한쌍의 컬렉션)

▶ set() : 집합을 생성(순서가 없는 컬렉션, 중복 요소 불포함)

[파이썬]딕셔너리(dictionary)와 세트(set)

▶ list(): 리스트를 생성(순서가 있는 요소의 컬렉션)

▶ tuple(): 튜플을 생성(순서가 있는 컬렉션, 변경 불가능)

[파이썬]리스트(list)와 튜플(tuple)

▶ sum(): 숫자로 이루어진 컬렉션의 요소를 합산

# sum() : 숫자 합산
li = [1, 2, 3, 4, 5]
print(sum(li)) # 15

▶ all(): 모든 요소가 True인지 여부를 반환

▶ any(): 하나 이상의 요소가 True인지 여부를 반환

# all() : 모든 요소가 True인지
li = [1, 'python', 7, True]
result = all(li)
print(result)  # True

li = [0, 'python', 7, True]
result = all(li)
print(result)  # False # 숫자 0이 있으므로

# any() : 어떤 요소라도 True인지
li = [0, '', False, None]
result = any(li)
print(result)  # False

li = [0, '', 7, False, None]
result = any(li)
print(result)  # True

▶ len(): 컬렉션의 요소 수를 반환해 주는 함수

▶ max(): 컬렉션의 최댓값을 반환해 주는 함수

▶ min(): 컬렉션의 최솟값을 반환해 주는 함수

▶ sorted(): 컬렉션의 요소를 정렬 후 리스트로 반환해 주는 함수

▶ enumerate(): 요소와 인덱스를 함께 반환

▶ zip(): 둘 이상의 컬렉션을 튜플로 반환

li = [7, 8, 10, 2, 4, 3]

# len() : 길이(항목 수) 구하기
length = len(li)
print(length) # 6

# max() : 최댓값 구하기
max_value = max(li)
print(max_value) # 10

# min() : 최솟값 구하기
min_value = min(li)
print(min_value) # 2 

# sorted() : 정렬 후 리스트로 반환
sorted_value = sorted(li)
print(sorted_value) # [2, 3, 4, 7, 8, 10] 

# enumerate() : 인덱스와 요소 함께 반환
for index, value in enumerate(li):
    print(f'{index}번째:{value}'# 0번째:7
    				# 1번째:8
                    		# 2번째:10
                    		# 3번째:2
                            	# 4번째:4
                            	# 5번째:3
                                
# zip() : 튜플로 묶어 반환
letters = ['a', 'b', 'c', 'd', 'e']
zipped = zip(li, letters)
print(list(zipped)) # [(7, 'a'), (8, 'b'), (10, 'c'), (2, 'd'), (4, 'e')]

파이썬 내장함수는 모두 암기하기보다 이런 것이 있구나 하고 종류를 정리하고 기록해 뒀다가 필요할 때 찾아 쓰시면 됩니다. 파이썬 내장함수 정리를 핵심내용에서 확인해 보시기 바랍니다.😊

---

5. 핵심 내용👀