[Python 100일 챌린지] Day 15 - 자료형 변환 (타입 캐스팅)

게시 2025/03/15

Day 15 - 자료형 변환

By YonYonWare

27 분읽는 시간

[Python 100일 챌린지] Day 15 - 자료형 변환 (타입 캐스팅)

숫자를 문자열로, 문자열을 숫자로! 서로 다른 데이터 타입을 자유자재로 변환하는 방법을 배워봅시다. input()으로 받은 문자열을 계산하거나, 숫자를 문자열과 합치는 등 실전에서 가장 자주 쓰이는 필수 기술입니다! (20분 완독 ⭐⭐)

🎯 오늘의 학습 목표

타입 변환이 무엇인지 이해하기
명시적 변환 사용하기
암시적 변환 알기
변환 시 주의사항 익히기

📚 사전 지식

Day 4: 변수와 print() - 변수 선언과 출력 방법
Day 5: 숫자 다루기 (int, float) - 숫자 타입과 연산
Day 6: 문자열 다루기 - 문자열 타입과 조작

🎯 학습 목표 1: 타입 변환이 무엇인지 이해하기

타입 캐스팅이란?

타입 캐스팅 = 한 자료형을 다른 자료형으로 변환하는 것

프로그래밍에서 데이터는 각자의 타입(자료형)을 가지고 있습니다. 때로는 이 타입을 바꿔야 할 때가 있습니다.

  
# 문자열 → 숫자
age_str = "25"
age_int = int(age_str)  # 25

# 숫자 → 문자열
score = 100
score_str = str(score)  # "100"

타입 변환이 필요한 이유

사용자 입력 처리: input()은 항상 문자열을 반환하므로 숫자로 변환 필요
데이터 조합: 숫자와 문자열을 합칠 때 타입을 맞춰야 함
연산 수행: 문자열로 된 숫자는 계산 불가능

  
# ❌ 에러 발생!
num = input("숫자 입력: ")  # "10" (문자열)
result = num + 5  # TypeError!

# ✅ 타입 변환 후 계산
num = int(input("숫자 입력: "))  # 10 (정수)
result = num + 5  # 15

🎯 학습 목표 2: 명시적 변환 사용하기

명시적 변환이란?

명시적 변환 = 프로그래머가 직접 변환 함수를 사용하는 것

Python에서는 int(), float(), str() 함수를 사용해 자료형을 명시적으로 변환할 수 있습니다.

int() - 정수로 변환

다양한 타입을 정수로 변환합니다.

입력 타입	예시	결과	설명
문자열	`int("10")`	`10`	숫자 문자열 → 정수
실수	`int(3.14)`	`3`	소수점 버림 (반올림 아님!)
불린	`int(True)`	`1`	True는 1, False는 0

  
# 문자열 → 정수
print(int("10"))      # 10
print(int("100"))     # 100
print(int("-25"))     # -25 (음수도 가능)

# 실수 → 정수 (소수점 버림)
print(int(3.14))      # 3
print(int(9.99))      # 9 (10 아님! 반올림 안 함)
print(int(-2.5))      # -2

# 불린 → 정수
print(int(True))      # 1
print(int(False))     # 0

float() - 실수로 변환

다양한 타입을 실수로 변환합니다.

입력 타입	예시	결과	설명
문자열	`float("3.14")`	`3.14`	실수 문자열 → 실수
정수	`float(10)`	`10.0`	정수 → 실수
불린	`float(True)`	`1.0`	True는 1.0, False는 0.0

  
# 문자열 → 실수
print(float("3.14"))  # 3.14
print(float("10"))    # 10.0
print(float("-2.5"))  # -2.5

# 정수 → 실수
print(float(10))      # 10.0
print(float(100))     # 100.0
print(float(-5))      # -5.0

# 불린 → 실수
print(float(True))    # 1.0
print(float(False))   # 0.0

str() - 문자열로 변환

모든 타입을 문자열로 변환합니다.

입력 타입	예시	결과	설명
정수	`str(100)`	`"100"`	정수 → 문자열
실수	`str(3.14)`	`"3.14"`	실수 → 문자열
불린	`str(True)`	`"True"`	불린 → 문자열
리스트	`str([1,2,3])`	`"[1, 2, 3]"`	리스트 → 문자열

  
# 숫자 → 문자열
print(str(100))       # "100"
print(str(3.14))      # "3.14"
print(str(-25))       # "-25"

# 불린 → 문자열
print(str(True))      # "True"
print(str(False))     # "False"

# 리스트 → 문자열
print(str([1, 2, 3])) # "[1, 2, 3]"

변환 가능 여부 표

From → To	int()	float()	str()
문자열 “10”	✅ 10	✅ 10.0	-
문자열 “3.14”	❌ ValueError	✅ 3.14	-
문자열 “hello”	❌ ValueError	❌ ValueError	-
정수 10	-	✅ 10.0	✅ “10”
실수 3.14	✅ 3	-	✅ “3.14”
불린 True	✅ 1	✅ 1.0	✅ “True”

💻 실습 예제

예제 1: 입력받은 숫자 계산

  
# input()은 항상 문자열 반환
num1 = input("첫 번째 숫자: ")  # "10"
num2 = input("두 번째 숫자: ")  # "20"

# 문자열 → 정수 변환
num1 = int(num1)
num2 = int(num2)

print(f"합: {num1 + num2}")      # 30
print(f"차: {num1 - num2}")      # -10

예제 2: 숫자와 문자열 결합

  
age = 25
name = "홍길동"

# ❌ 에러! (정수와 문자열은 + 불가)
# message = name + "의 나이는 " + age

# ✅ 숫자를 문자열로 변환
message = name + "의 나이는 " + str(age)
print(message)  # 홍길동의 나이는 25

# 또는 f-string 사용 (자동 변환)
message = f"{name}의 나이는 {age}"
print(message)

예제 3: 소수점 반올림

  
score_str = "85.7"

# 문자열 → 실수 → 정수
score_float = float(score_str)  # 85.7
score_int = int(score_float)    # 85

print(f"원래 점수: {score_str}")
print(f"정수로 변환: {score_int}")

# 반올림
score_rounded = round(score_float)  # 86
print(f"반올림: {score_rounded}")

type() 함수로 타입 확인하기

  
age = 25
name = "홍길동"
score = 3.14
is_student = True

print(type(age))        # <class 'int'>
print(type(name))       # <class 'str'>
print(type(score))      # <class 'float'>
print(type(is_student)) # <class 'bool'>

# isinstance()로 확인
print(isinstance(age, int))     # True
print(isinstance(name, str))    # True
print(isinstance(score, float)) # True

🎯 학습 목표 3: 암시적 변환 알기

자동 타입 변환이란?

암시적 변환 = Python이 자동으로 수행하는 타입 변환

명시적으로 변환하지 않아도, Python이 자동으로 타입을 변환하는 경우가 있습니다.

숫자 연산 시 자동 변환

  
# int + float → float
result = 10 + 3.14
print(result)        # 13.14
print(type(result))  # <class 'float'>

# bool + int → int
result = True + 5    # True는 1로 계산
print(result)        # 6

자동 변환 규칙

정수 + 실수 = 실수: 더 넓은 범위(실수)로 자동 변환
불린 + 숫자 = 숫자: True는 1, False는 0으로 계산

  
# 정수 + 실수
print(5 + 2.5)     # 7.5 (float)
print(10 * 1.5)    # 15.0 (float)

# 불린 + 정수
print(True + 10)   # 11 (True는 1)
print(False + 10)  # 10 (False는 0)

🎯 학습 목표 4: 변환 시 주의사항 익히기

주의 1: 변환 불가능한 값

모든 값을 모든 타입으로 변환할 수 있는 것은 아닙니다.

변환 실패 케이스

변환 시도	에러	이유
`int("hello")`	ValueError	숫자가 아닌 문자열
`int("3.14")`	ValueError	실수 형식 문자열 (float으로 먼저 변환 필요)
`float("abc")`	ValueError	숫자가 아닌 문자열
`int("10.5abc")`	ValueError	숫자가 아닌 문자 포함

  
# ❌ 에러 발생!
# int("hello")      # ValueError: invalid literal for int()
# int("3.14")       # ValueError: invalid literal for int()
# float("abc")      # ValueError: could not convert string to float

# ✅ 올바른 방법
print(int("10"))              # OK: 숫자 문자열
print(int(float("3.14")))     # OK: 실수로 먼저 변환
print(float("3.14"))          # OK: 실수 형식 문자열

안전한 변환 방법

  
# 방법 1: try-except로 에러 처리
user_input = "abc"
try:
    number = int(user_input)
    print(f"변환 성공: {number}")
except ValueError:
    print("숫자로 변환할 수 없습니다!")

# 방법 2: isdigit()로 먼저 확인
user_input = "123"
if user_input.isdigit():
    number = int(user_input)
    print(f"변환 성공: {number}")
else:
    print("숫자가 아닙니다!")

주의 2: 소수점 버림 vs 반올림

중요: int()는 반올림이 아니라 버림(truncation)입니다!

함수	동작	예시
`int(9.9)`	버림	`9` (10 아님!)
`int(9.1)`	버림	`9`
`round(9.9)`	반올림	`10`
`round(9.1)`	반올림	`9`

  
# int()는 버림 (반올림 아님!)
print(int(9.9))    # 9 (10 아님!)
print(int(9.1))    # 9
print(int(3.7))    # 3
print(int(-2.5))   # -2

# 반올림하려면 round() 사용
print(round(9.9))  # 10
print(round(9.1))  # 9
print(round(3.7))  # 4
print(round(3.5))  # 4
print(round(2.5))  # 2 (짝수로 반올림)

round()의 특별한 규칙

  
# round()는 "Banker's Rounding" 사용
# 정확히 중간값(.5)일 때는 가장 가까운 짝수로 반올림
print(round(2.5))  # 2 (짝수)
print(round(3.5))  # 4 (짝수)
print(round(4.5))  # 4 (짝수)
print(round(5.5))  # 6 (짝수)

주의 3: 진법 변환

문자열 → 정수 변환 시 진법 지정 가능

진법	사용법	예시
2진법	`int("1010", 2)`	`10`
8진법	`int("12", 8)`	`10`
16진법	`int("A", 16)`	`10`

  
# 2진법 문자열 → 정수
binary = "1010"
print(int(binary, 2))  # 10

# 16진법 문자열 → 정수
hex_str = "FF"
print(int(hex_str, 16))  # 255

# 8진법 문자열 → 정수
octal = "17"
print(int(octal, 8))  # 15

주의 4: 리스트/딕셔너리 변환

list()와 str()의 차이

  
# 문자열 → 리스트
text = "hello"
chars = list(text)
print(chars)  # ['h', 'e', 'l', 'l', 'o']

# 리스트 → 문자열 (join 사용!)
chars = ['a', 'b', 'c']
text = ''.join(chars)  # ✅ 올바른 방법
print(text)  # "abc"

# ❌ str()은 리스트를 문자열 표현으로 변환
text = str(chars)
print(text)  # "['a', 'b', 'c']" (원하는 결과 아님!)

# 딕셔너리 키만 리스트로
my_dict = {"a": 1, "b": 2}
keys = list(my_dict.keys())
print(keys)  # ['a', 'b']

# 딕셔너리 값만 리스트로
values = list(my_dict.values())
print(values)  # [1, 2]

주의 5: bool 변환

모든 값은 bool로 변환 가능합니다

값	bool() 결과	설명
`0`, `0.0`	`False`	숫자 0
`""`	`False`	빈 문자열
`[]`, `()`, `{}`	`False`	빈 컬렉션
`None`	`False`	None 값
그 외 모든 값	`True`	Truthy

  
# Falsy 값들 (False로 평가)
print(bool(0))      # False
print(bool(0.0))    # False
print(bool(""))     # False
print(bool([]))     # False
print(bool({}))     # False
print(bool(None))   # False

# Truthy 값들 (True로 평가)
print(bool(1))      # True
print(bool(-1))     # True
print(bool("0"))    # True (문자열 "0"은 True!)
print(bool([0]))    # True (요소가 있는 리스트)
print(bool(" "))    # True (공백이 있는 문자열)

💡 실전 팁 & 주의사항

Tip 1: input()은 항상 문자열

  
# ❌ 실수하기 쉬운 예
age = input("나이: ")  # "25" (문자열)
next_age = age + 1     # TypeError!

# ✅ 올바른 방법
age = int(input("나이: "))  # 25 (정수)
next_age = age + 1          # 26

Tip 2: 숫자와 문자열 합칠 때

  
# ❌ 에러!
score = 100
message = "점수: " + score  # TypeError!

# ✅ 방법 1: str()로 변환
message = "점수: " + str(score)

# ✅ 방법 2: f-string 사용 (추천)
message = f"점수: {score}"

Tip 3: 실수 문자열을 정수로 변환할 때

  
# ❌ 직접 변환 불가
num = int("3.14")  # ValueError!

# ✅ 실수로 먼저 변환 후 정수로
num = int(float("3.14"))  # 3

Tip 4: int()와 round()의 차이

  
# int()는 버림
print(int(3.7))     # 3
print(int(3.2))     # 3

# round()는 반올림
print(round(3.7))   # 4
print(round(3.2))   # 3

Tip 5: type() vs isinstance()

  
age = 25

# type()로 확인
print(type(age) == int)  # True

# isinstance()로 확인 (더 권장)
print(isinstance(age, int))  # True

# isinstance()가 더 좋은 이유: 상속 관계 고려

🧪 연습 문제

문제 1: 온도 양방향 변환기

과제: 사용자에게 변환 방향을 선택하게 하고, 온도를 양방향(섭씨↔화씨)으로 변환하는 프로그램을 작성하세요.

초기 데이터:

# 변환 공식
# 화씨 = 섭씨 × 1.8 + 32
# 섭씨 = (화씨 - 32) / 1.8

요구사항:

사용자에게 변환 방향을 선택하도록 입력받기 (“C to F” 또는 “F to C”)
변환할 온도 값을 입력받기
input()으로 받은 문자열을 float()로 타입 변환하기
선택한 방향에 따라 적절한 공식으로 변환하기
결과를 소수점 첫째 자리까지 출력하기
여러 온도를 테스트하여 결과 확인하기

💡 힌트

input() 함수로 받은 값은 항상 문자열이에요!
float() 함수를 사용해서 실수로 변환하세요
조건문(if)으로 변환 방향을 구분하세요
f-string의 :.1f 포맷으로 소수점 첫째 자리까지 출력할 수 있어요

✅ 정답

  
print("===== 온도 양방향 변환기 =====")

# 변환 방향 선택
direction = input("변환 방향을 선택하세요 (1: 섭씨→화씨, 2: 화씨→섭씨): ")

if direction == "1":
    # 섭씨 → 화씨
    celsius_str = input("섭씨 온도를 입력하세요: ")
    celsius = float(celsius_str)

    fahrenheit = celsius * 1.8 + 32

    print(f"\n결과: {celsius}°C = {fahrenheit:.1f}°F")

elif direction == "2":
    # 화씨 → 섭씨
    fahrenheit_str = input("화씨 온도를 입력하세요: ")
    fahrenheit = float(fahrenheit_str)

    celsius = (fahrenheit - 32) / 1.8

    print(f"\n결과: {fahrenheit}°F = {celsius:.1f}°C")

else:
    print("잘못된 입력입니다.")

print("\n===== 여러 온도 변환 테스트 =====")
# 섭씨 → 화씨 테스트
test_celsius = [0, 25, 100, -40]
print("\n[섭씨 → 화씨]")
for c in test_celsius:
    f = c * 1.8 + 32
    print(f"{c}°C = {f:.1f}°F")

# 화씨 → 섭씨 테스트
test_fahrenheit = [32, 77, 212, -40]
print("\n[화씨 → 섭씨]")
for f in test_fahrenheit:
    c = (f - 32) / 1.8
    print(f"{f}°F = {c:.1f}°C")

출력:

===== 온도 양방향 변환기 =====
변환 방향을 선택하세요 (1: 섭씨→화씨, 2: 화씨→섭씨): 1
섭씨 온도를 입력하세요: 25

결과: 25.0°C = 77.0°F

===== 여러 온도 변환 테스트 =====

[섭씨 → 화씨]
0°C = 32.0°F
25°C = 77.0°F
100°C = 212.0°F
-40°C = -40.0°F

[화씨 → 섭씨]
32°F = 0.0°C
77°F = 25.0°C
212°F = 100.0°C
-40°F = -40.0°C

문제 2: 점수 데이터 분석 시스템

과제: 공백으로 구분된 점수 문자열을 받아 정수 리스트로 변환하고, 다양한 통계를 계산하는 프로그램을 작성하세요.