소개
Python 내장 함수 (built-in functions) 에 대한 실습에 오신 것을 환영합니다. Python 인터프리터는 별도의 import 없이 항상 사용할 수 있는 풍부한 함수와 타입을 제공합니다. 이러한 함수들은 데이터 조작부터 입출력 작업에 이르기까지 일반적인 작업을 수행하는 데 필수적인 구성 요소입니다.
본 실습에서는 논리적인 그룹으로 분류된 가장 필수적인 내장 함수들을 직접 사용해 보는 경험을 하게 될 것입니다. 실습을 마칠 때쯤이면 이러한 함수들을 능숙하게 사용하여 보다 효율적이고 가독성 높은 Python 코드를 작성할 수 있게 될 것입니다.
데이터 타입 변환 및 검사
이 단계에서는 int(), str(), list(), dict(), type(), isinstance()와 같은 함수를 사용하여 다양한 데이터 타입 간에 변환하고 객체를 검사하는 방법을 배웁니다. 이는 Python 에서 데이터를 처리하는 데 필수적인 요소입니다.
참고: WebIDE(VS Code 와 유사) 사용에 익숙하지 않다면, 이 랩에서 먼저 학습하십시오.
먼저, 왼쪽 파일 탐색기에서 step1_conversion.py 파일을 엽니다. 이 파일에 코드를 작성할 것입니다.
step1_conversion.py에 다음 코드를 추가합니다. 이 코드는 문자열을 정수로, 튜플을 리스트로, 쌍의 리스트를 딕셔너리로 변환하는 방법을 보여줍니다. 또한 객체의 타입을 확인하는 방법도 보여줍니다.
## step1_conversion.py
## int(): 숫자 또는 문자열에서 정수 객체를 반환합니다.
num_str = "123"
num_int = int(num_str)
print(f"String '{num_str}' as integer: {num_int}")
## str(): 객체의 문자열 버전을 반환합니다.
int_val = 456
str_val = str(int_val)
print(f"Integer {int_val} as string: '{str_val}'")
## list(): 반복 가능한 (iterable) 객체로부터 새로운 리스트를 생성합니다.
my_tuple = ('a', 'b', 'c')
my_list = list(my_tuple)
print(f"Tuple {my_tuple} as list: {my_list}")
## dict(): 새로운 딕셔너리를 생성합니다.
my_pairs = [('x', 1), ('y', 2)]
my_dict = dict(my_pairs)
print(f"List of pairs {my_pairs} as dict: {my_dict}")
## type(): 객체의 타입을 반환합니다.
print(f"Type of num_int: {type(num_int)}")
## isinstance(): 객체가 특정 클래스의 인스턴스이면 True 를 반환합니다.
is_list = isinstance(my_list, list)
print(f"Is my_list an instance of list? {is_list}")
이제 파일을 저장하고 터미널에서 실행합니다.
python3 step1_conversion.py
데이터 타입 변환 및 검사가 성공적으로 이루어졌음을 확인하는 다음 출력을 보게 될 것입니다.
String '123' as integer: 123
Integer 456 as string: '456'
Tuple ('a', 'b', 'c') as list: ['a', 'b', 'c']
List of pairs [('x', 1), ('y', 2)] as dict: {'x': 1, 'y': 2}
Type of num_int: <class 'int'>
Is my_list an instance of list? True
수학 및 숫자 연산
이 단계에서는 내장 함수를 사용하여 일반적인 수학 계산을 수행합니다. abs(), sum(), min(), max(), round(), pow()를 다룰 것입니다.
파일 탐색기에서 step2_math.py 파일을 엽니다.
step2_math.py에 다음 코드를 추가하십시오. 이 스크립트는 다양한 수학 함수를 숫자 및 숫자 리스트에 적용하는 방법을 보여줍니다.
## step2_math.py
numbers = [5, -10, 15, -2, 8]
## abs(): 숫자의 절댓값을 반환합니다.
print(f"Absolute value of -10: {abs(-10)}")
## sum(): 반복 가능한 (iterable) 항목들의 합계를 구합니다.
print(f"Sum of numbers {numbers}: {sum(numbers)}")
## min(): 반복 가능한 항목 중 가장 작은 항목을 반환합니다.
print(f"Minimum of numbers: {min(numbers)}")
## max(): 반복 가능한 항목 중 가장 큰 항목을 반환합니다.
print(f"Maximum of numbers: {max(numbers)}")
## round(): 주어진 정밀도로 숫자를 반올림하여 반환합니다.
pi_approx = 3.14159
print(f"Rounding {pi_approx} to 2 decimal places: {round(pi_approx, 2)}")
## pow(): base 를 exp 만큼 거듭제곱한 값을 반환합니다.
print(f"2 to the power of 3: {pow(2, 3)}")
파일을 저장하고 터미널에서 실행하십시오.
python3 step2_math.py
출력에는 각 수학 연산의 결과가 표시되어야 합니다.
Absolute value of -10: 10
Sum of numbers [5, -10, 15, -2, 8]: 16
Minimum of numbers: -10
Maximum of numbers: 15
Rounding 3.14159 to 2 decimal places: 3.14
2 to the power of 3: 8
시퀀스 및 이터러블 작업
이 단계에서는 리스트 (list) 와 튜플 (tuple) 과 같은 시퀀스를 조작하고 처리하는 방법을 배웁니다. len(), sorted(), reversed(), enumerate(), map(), filter(), zip()을 다룰 것입니다. 이러한 함수들 중 다수는 효율적이고 메모리를 절약하는 객체인 이터레이터 (iterator) 를 반환합니다.
step3_sequences.py 파일을 엽니다.
step3_sequences.py에 다음 코드를 추가하십시오. 이 스크립트는 리스트의 길이를 얻고, 정렬하고, 뒤집고, map, filter, zip을 사용하여 더 복잡한 변환을 수행하는 방법을 시연합니다.
## step3_sequences.py
my_list = [3, 1, 4, 1, 5, 9]
print(f"Original list: {my_list}")
## len(): 객체의 길이 (항목의 개수) 를 반환합니다.
print(f"Length of the list: {len(my_list)}")
## sorted(): 반복 가능한 객체의 항목들로부터 새로운 정렬된 리스트를 반환합니다.
print(f"Sorted list: {sorted(my_list)}")
## reversed(): 역순 이터레이터를 반환합니다. 내용을 출력하기 위해 리스트로 변환합니다.
print(f"Reversed list: {list(reversed(my_list))}")
## enumerate(): 열거 객체 (인덱스, 값 쌍의 이터레이터) 를 반환합니다.
print(f"Enumerated list: {list(enumerate(my_list))}")
## map(): 반복 가능한 객체의 모든 항목에 함수를 적용하는 이터레이터를 반환합니다.
squared_numbers = map(lambda x: x*x, my_list)
print(f"Squared numbers (map): {list(squared_numbers)}")
## filter(): 함수가 참 (True) 을 반환하는 반복 가능한 객체의 요소들로 구성된 이터레이터를 구성합니다.
even_numbers = filter(lambda x: x % 2 == 0, my_list)
print(f"Even numbers (filter): {list(even_numbers)}")
## zip(): 여러 반복 가능한 객체들을 병렬로 순회합니다.
list_a = ['a', 'b', 'c']
list_b = [1, 2, 3]
zipped = zip(list_a, list_b)
print(f"Zipped lists: {list(zipped)}")
파일을 저장하고 실행하십시오.
python3 step3_sequences.py
다양한 시퀀스 연산의 출력을 보게 될 것입니다. reversed, map, filter, zip과 같은 함수들이 이터레이터를 반환하며, 이터레이터의 내용을 표시하기 위해 list()를 사용하여 리스트로 변환하는 방식에 주목하십시오.
Original list: [3, 1, 4, 1, 5, 9]
Length of the list: 6
Sorted list: [1, 1, 3, 4, 5, 9]
Reversed list: [9, 5, 1, 4, 1, 3]
Enumerated list: [(0, 3), (1, 1), (2, 4), (3, 1), (4, 5), (5, 9)]
Squared numbers (map): [9, 1, 16, 1, 25, 81]
Even numbers (filter): [4]
Zipped lists: [('a', 1), ('b', 2), ('c', 3)]
입력 출력 및 객체 표현
이 단계에서는 기본적인 입출력 (I/O) 작업을 처리하고 객체가 문자열로 어떻게 표현되는지 제어하는 방법을 배웁니다. print(), open(), repr(), format()에 중점을 둘 것입니다. 또한 input()에 대해서도 간략하게 언급하겠습니다.
step4_io.py 파일을 엽니다.
input() 함수는 콘솔에서 한 줄을 읽어 문자열로 변환한 후 반환합니다. 예를 들어: name = input("Enter your name: ")와 같습니다. 실행이 일시 중지되는 것을 방지하기 위해 스크립트에서는 사용하지 않겠지만, 알아두어야 할 매우 중요한 함수입니다.
이제 step4_io.py에 다음 코드를 추가하십시오. 이 스크립트는 파일에 쓰기, 파일 읽기, 그리고 객체를 문자열로 표현하고 포맷하는 다양한 방법을 시연합니다.
## step4_io.py
import datetime
## open(): 파일을 열고 해당 파일 객체를 반환합니다.
## 파일이 자동으로 닫히도록 보장하기 위해 'with' 구문을 사용합니다.
file_path = "/home/labex/project/my_file.txt"
with open(file_path, "w") as f:
f.write("Hello, LabEx!\n")
f.write("This is a test file.")
print(f"Successfully wrote to {file_path}")
## 파일에서 읽기
with open(file_path, "r") as f:
content = f.read()
print("--- File Content ---")
print(content)
print("--------------------")
## repr(): 객체의 인쇄 가능하고 모호하지 않은 표현을 포함하는 문자열을 반환합니다.
now = datetime.datetime(2023, 10, 27, 10, 30, 0)
print(f"str(now): {str(now)}")
print(f"repr(now): {repr(now)}")
## format(): 값을 "포맷된" 표현으로 변환합니다.
formatted_string = format(123.4567, ".2f")
print(f"Formatted number (123.4567 to .2f): {formatted_string}")
파일을 저장하고 터미널에서 실행하십시오.
python3 step4_io.py
스크립트는 my_file.txt를 생성하고 내용을 작성한 다음, 다시 읽어 내용을 출력합니다. 또한 datetime 객체에 대한 str()과 repr()의 차이점을 보여주고 숫자 포맷팅을 시연합니다.
Successfully wrote to /home/labex/project/my_file.txt
--- File Content ---
Hello, LabEx!
This is a test file.
--------------------
str(now): 2023-10-27 10:30:00
repr(now): datetime.datetime(2023, 10, 27, 10, 30)
Formatted number (123.4567 to .2f): 123.46
객체 인트로스펙션 및 메타프로그래밍
마지막 단계에서는 객체 속성 및 네임스페이스와 상호 작용하기 위한 고급 함수들을 탐구합니다. 이는 종종 인트로스펙션 (Introspection) 또는 리플렉션 (Reflection) 이라고 불립니다. getattr(), hasattr(), setattr(), dir(), globals(), locals()를 사용할 것입니다.
step5_introspection.py 파일을 엽니다.
간단한 클래스를 정의한 다음, 인트로스펙션 함수들을 사용하여 해당 클래스의 인스턴스를 동적으로 검사하고 수정할 것입니다. step5_introspection.py에 다음 코드를 추가하십시오.
## step5_introspection.py
class Person:
species = "Homo sapiens"
def __init__(self, name, age):
self.name = name
self.age = age
p = Person("Alice", 30)
## hasattr(): 객체에 명명된 속성이 있으면 True 를 반환합니다.
print(f"Does person have 'name' attribute? {hasattr(p, 'name')}")
print(f"Does person have 'height' attribute? {hasattr(p, 'height')}")
## setattr(): 이는 getattr() 의 대응 함수입니다. 객체의 속성을 설정합니다.
print("Setting attribute 'height' to 175...")
setattr(p, 'height', 175)
print(f"Does person have 'height' attribute now? {hasattr(p, 'height')}")
## getattr(): 객체의 명명된 속성 값을 반환합니다.
print(f"Person's name: {getattr(p, 'name')}")
print(f"Person's height: {getattr(p, 'height')}")
## dir(): 현재 로컬 범위 또는 객체의 속성 목록을 반환합니다.
## 'height'가 이제 속성 목록에 있는지 확인합니다.
print(f"Is 'height' in dir(p)? {'height' in dir(p)}")
## globals(): 현재 전역 심볼 테이블 (symbol table) 의 딕셔너리를 반환합니다.
## 우리의 'Person' 클래스가 globals 에 있는지 확인할 것입니다.
print(f"Is 'Person' in globals? {'Person' in globals().keys()}")
## locals(): 현재 로컬 심볼 테이블의 딕셔너리를 반환합니다.
def a_func():
x = 10
print(f"Is 'x' in locals()? {'x' in locals().keys()}")
a_func()
파일을 저장하고 실행하십시오.
python3 step5_introspection.py
출력 결과는 객체의 속성을 문자열 이름으로 동적으로 확인, 설정 및 가져오는 방법을 보여줍니다. 또한 객체의 속성과 전역 및 로컬 범위에서 사용 가능한 변수들을 검사하는 방법도 보여줍니다.
Does person have 'name' attribute? True
Does person have 'height' attribute? False
Setting attribute 'height' to 175...
Does person have 'height' attribute now? True
Person's name: Alice
Person's height: 175
Is 'height' in dir(p)? True
Is 'Person' in globals? True
Is 'x' in locals()? True
요약
실습을 완료하신 것을 축하드립니다! 여러분은 Python 의 필수 내장 함수 (built-in functions) 전반에 걸쳐 실질적인 경험을 쌓았습니다.
본 실습에서 여러분은 다음 사항들을 배웠습니다.
- 데이터 타입 간 변환 및 객체 검사 (
int,str,type,isinstance). - 일반적인 수학 연산 수행 (
abs,sum,min,max,round). - 시퀀스 및 이터러블 (iterable) 조작 및 처리 (
len,sorted,map,filter,zip). - 기본적인 파일 입출력 (I/O) 및 객체 문자열 표현 처리 (
open,repr,format). - 객체 및 네임스페이스 검사 및 동적 수정 (
hasattr,getattr,setattr,dir).
이러한 함수들은 일상적인 Python 프로그래밍의 근간이 됩니다. 이 함수들을 숙달하면 코딩 효율성과 가독성이 크게 향상될 것입니다. 계속해서 다른 내장 함수들을 탐색하고 자신의 프로젝트에서 이를 사용하는 연습을 하시기 바랍니다.
