변수는

• 데이터를 저장하는 이름을 말하며 프로그램에서 값을 저장하고 조작하는 데 사용됩니다.
• 다양한 유형의 값을 저장할 수 있으며, 이는 데이터 타입에 따라 다릅니다.
• 선언 시 데이터 타입을 명시할 필요가 없으며, 값을 할당하면 자동으로 데이터 타입이 결정됩니다.

선언 및 초기화

선언 방법

변수이름 = 값

사용예

x = 5 # 정수형 
y = 3.14 # 실수형 
name = "Alice" # 문자열
is_active = True # 논리형
numbers = [1, 2, 3, 4, 5] # 리스트
point = (10, 20) # 튜플
student = {"name": "Alice", "age": 25} # 딕셔너리
unique_numbers = {1, 2, 3, 4, 5} # 집합형

print(x, type(x))
print(y, type(y))
print(name, type(name)) 
print(is_active, type(is_active))   
print(numbers, type(numbers))   
print(point, type(point))   
print(student, type(student))   
print(unique_numbers, type(unique_numbers)) 

여러 변수에 여러 값 할당

x, y, z = "Orange", "Banana", "Cherry"

print(x)
print(y)
print(z)

하나의 값을 여러 변수 할당

x = y = z = "Orange"

print(x)
print(y)
print(z)

컬렉션 풀기

fruits = ["apple", "banana", "cherry"]
x, y, z = fruits

print(x)
print(y)
print(z)

---

데이터 타입

• 기본 데이터 타입
  1. 숫자 : int, float, complex
  2. 문자열 : str
  3. 불리언 : bool
  4. 이진 : bytes, bytearray, memoryview
  5. 없음 : NoneType
• 컬렉션 데이터 타입
  1. 시퀀스 : list, tuple, range
  2. 매핑 : dict
  3. 셋트 : set, frozenset

Python은 데이터 타입을 알고 싶을 때 사용하는 type 함수를 제공합니다.
Python은 모든 요소가 객체로 되어 있다. 객체는 클래스를 설명하면서 자세히 다룰 것입니다.

숫자

1. 정수 (int) : 음수, 양수 및 0을 포함하는 정수 값을 저장합니다. (Python 3에서는 모든 정수가 int 타입으로 처리됩니다.)

x = 10
y = 12345678901234567890

print(type(x))  # 출력: <class 'int'>
print(type(y))  # 출력: <class 'int'>

2. 실수 (float) : 소수점 이하의 값을 포함하는 부동 소수점 숫자를 저장합니다.

a = 3.14
b = -2.0
c = 0.5

print(type(a))  # 출력: <class 'float'>
print(type(b))  # 출력: <class 'float'>
print(type(c))  # 출력: <class 'float'>

3. 복소수 (complex) : 실수부와 허수부를 가지는 복소수를 저장합니다. 허수부는 j로 표현합니다.

d = 1 + 2j
e = -3j
f = 2 + 0j

print(type(d))  # 출력: <class 'complex'>
print(type(e))  # 출력: <class 'complex'>
print(type(f))  # 출력: <class 'complex'>

문자열 (string)

문자의 시퀀스를 저장합니다. 작은 따옴표(‘)나 큰 따옴표(“)로 표현합니다.

• 슬라이스 연산자 ([ ] 및 [ : ])를 사용하여 문자열의 원하는 부분을 가져올 수 있습니다.
• 문자열 시작 위치는 0이고 끝 위치는 -1 입니다.
• 플러스 (+) 기호는 문자열 연결 연산자이고 별표 (*)는 반복 연산자입니다.

문자열 할당

변수에 문자열을 할당하려면 변수 이름 뒤에 등호와 문자열을 입력합니다.
세 개의 따옴표를 사용하여 여러 줄의 문자열을 변수에 할당할 수 있습니다.

a = "Hello"  
print(a)

multitext = '''
그런데 여러 줄 문자열을 사용하면
여기 보이는 그대로 출력된다.
줄바꿈이나 탭이나 공백도 그대로이다.

범위의 내용 그대로 출력된

큰 따옴표 세 개(""")를 사용해도
같은 결과를 얻을 수 있다.
물론 다양한 특수 문자(~!@#$%^&*()도
그대로 출력된다.
'''

print(multitext)

슬라이싱 (Slicing)

슬라이스 구문을 사용하면 다양한 문자를 반환할 수 있습니다.
문자열의 일부를 반환하려면 콜론으로 구분하여 시작 인덱스와 끝 인덱스를 지정합니다.

str1 = 'Hello World!'
print(str1)          # Prints complete string
print(str1[0])       # Prints first character of the string
print(str1[-1])       # Prints last character of the string
print(str1[2:5])     # Prints characters starting from 3rd to 5th
print(str1[2:])      # Prints string starting from 3rd character

문자열 연결

두 개의 문자열을 연결하거나 결합하려면 + 연산자를 사용하면 됩니다.

print(str1 + "TEST") # Prints concatenated string
print(str1 * 2)      # Prints string two times

문자열 형식

문자열과 숫자를 다음과 같이 결합할 수 없지만 f-string 이나 메서드를 사용하면 문자열과 숫자를 결합할 수 있습니다

f-string은 Python 3.6에서 도입되었으며, 현재는 문자열을 포맷하는 데 선호되는 방법으로 f문자열 리터럴 앞에 을 넣고 변수와 다른 연산에 대한 자리 표시자로 중괄호{}를 추가하기만 하면 됩니다.

플레이스홀더에는 값을 형식화하기 위한 변수, 연산, 함수 및 수정자가 포함될 수 있습니다.
수정자는 콜론:을 추가하고 그 뒤에 서식 유형을 지정하여 포함됩니다. 즉, .2f소수점 이하 두 자리로 이루어진 고정 소수점 숫자를 의미합니다.
플레이스홀더에는 수학 연산과 같은 Python 코드가 포함될 수 있습니다.

age = 36
#This will produce an error:
txt = "My name is John, I am " + age
print(txt) 

age = 36  
txt = f"My name is John, I am {age}"  
print(txt)

price = 59
txt = f"The price is {price} dollars"
print(txt)

price = 59  
txt = f"The price is {price:.2f} dollars"  
print(txt)

txt = f"The price is {20 * 59} dollars"  
print(txt)

이스케이프(Escape) 제어문자

문자열 안에서 특별한 기능을 수행하는 문자 조합입니다. 이들은 백슬래시(\)와 특정 문자 하나를 함께 사용하여, 눈에 보이지 않거나 키보드로 직접 입력하기 어려운 문자를 표현하는 데 사용됩니다.

• 주요 이스케이프 제어문자와 사용 예시

이스케이프 문자	설명	예시
\'	작은따옴표(‘)	print('작은따옴표는 이렇게 \'씁니다\'')
\"	큰따옴표(“)	print("큰따옴표는 이렇게 \"씁니다\"")
\\	백슬래시()	print("백슬래시를 표현하려면 \\를 사용해요.")
\n	줄 바꿈 (개행)	print("안녕하세요.\n반갑습니다.")
\t	탭 (수평 탭)	print("이름:\t김철수")

# \n (줄 바꿈) 사용 예시
print("첫 번째 줄입니다.\n두 번째 줄입니다.")

# \t (탭) 사용 예시
print("이름:\t홍길동")
print("나이:\t30")

# " (큰따옴표) 사용 예시
# 문자열이 큰따옴표로 시작하고 끝날 때, 그 안에 큰따옴표를 넣으려면 \"를 사용합니다.
print("그는 \"안녕하세요.\"라고 말했습니다.")

문자열 메서드

capitalize()

문자열의 첫 글자를 대문자로 변환합니다. 나머지 글자들은 모두 소문자가 됩니다.

text = "hello world"
result = text.capitalize()
print(result) # 출력: Hello world

casefold()

문자열의 모든 문자를 소문자로 변환합니다. lower()와 비슷하지만, 유니코드 문자에 대한 변환 규칙이 더 포괄적입니다.

text = "ß" # 독일어 소문자 ß
result = text.casefold()
print(result) # 출력: ss

center()

문자열을 지정된 너비의 중앙에 정렬합니다.

text = "apple"
result = text.center(10, '*')
print(result) # 출력: **apple***

count()

문자열 내에서 특정 문자열이 몇 번 나오는지 세어서 반환합니다.

text = "apple banana apple"
result = text.count("apple")
print(result) # 출력: 2

encode()

문자열을 지정된 인코딩 방식(예: UTF-8, ASCII)으로 인코딩하여 바이트(bytes) 객체로 반환합니다.

text = "안녕"
result = text.encode("utf-8")
print(result) # 출력: b'\xec\x95\x88\xeb\85\x95'

endswith()

문자열이 특정 값으로 끝나는지 확인하여 True 또는 False를 반환합니다.

text = "hello.txt"
result = text.endswith(".txt")
print(result) # 출력: True

expandtabs()

문자열 내의 탭(\t) 문자를 지정된 크기의 공백으로 확장합니다.

text = "Name\tAge\tCity"
result = text.expandtabs(8)
print(result) # 출력: Name    Age     City

find()

문자열 내에서 특정 값의 위치를 찾아 인덱스를 반환합니다. 값이 없으면 -1을 반환합니다.

text = "hello world"
result = text.find("world")
print(result) # 출력: 6

format()

문자열의 중괄호({})를 변수 값으로 대체하여 새로운 문자열을 만듭니다.

name = "Alice"
age = 30
text = "My name is {} and I am {} years old.".format(name, age)
print(text) # 출력: My name is Alice and I am 30 years old.

format_map()

딕셔너리(dictionary)를 사용하여 문자열의 값을 포맷합니다.

data = {'name': 'Alice', 'age': 30}
text = "My name is {name} and I am {age} years old.".format_map(data)
print(text) # 출력: My name is Alice and I am 30 years old.

index()

find()와 유사하지만, 값이 없으면 오류(ValueError)를 발생시킵니다.

text = "hello world"
result = text.index("world")
print(result) # 출력: 6

isalnum()

문자열의 모든 문자가 알파벳 또는 숫자인지 확인하여 True 또는 False를 반환합니다.

text1 = "hello123"
text2 = "hello world"
print(text1.isalnum()) # 출력: True
print(text2.isalnum()) # 출력: False

isalpha()

문자열의 모든 문자가 알파벳인지 확인하여 True 또는 False를 반환합니다.

text1 = "Hello"
text2 = "Hello World"
print(text1.isalpha()) # 출력: True
print(text2.isalpha()) # 출력: False

isascii()

문자열의 모든 문자가 ASCII 문자인지 확인하여 True 또는 False를 반환합니다.

text1 = "Hello"
text2 = "안녕"
print(text1.isascii()) # 출력: True
print(text2.isascii()) # 출력: False

isdecimal()

문자열의 모든 문자가 10진수 문자인지 확인하여 True 또는 False를 반환합니다. isdigit(), isnumeric()보다 엄격합니다.

text1 = "12345"
print(text1.isdecimal()) # 출력: True

isdigit()

문자열의 모든 문자가 숫자인지 확인하여 True 또는 False를 반환합니다.

text1 = "123"
print(text1.isdigit()) # 출력: True

isidentifier()

문자열이 유효한 파이썬 식별자(변수명)인지 확인하여 True 또는 False를 반환합니다.

text1 = "my_variable"
text2 = "1_variable"
print(text1.isidentifier()) # 출력: True
print(text2.isidentifier()) # 출력: False

islower()

문자열의 모든 알파벳 문자가 소문자인지 확인하여 True 또는 False를 반환합니다.

text = "hello world"
print(text.islower()) # 출력: True

isnumeric()

문자열의 모든 문자가 숫자인지 확인하여 True 또는 False를 반환합니다. 한자나 아라비아 숫자 등도 포함합니다.

text = "①②③"
print(text.isnumeric()) # 출력: True

isprintable()

문자열의 모든 문자가 출력 가능한 문자인지 확인하여 True 또는 False를 반환합니다.

text1 = "hello"
text2 = "hello\nworld"
print(text1.isprintable()) # 출력: True
print(text2.isprintable()) # 출력: False

isspace()

문자열의 모든 문자가 공백 문자인지 확인하여 True 또는 False를 반환합니다.

text = "   \n  "
print(text.isspace()) # 출력: True

istitle()

문자열이 제목 규칙(각 단어의 첫 글자만 대문자)을 따르는지 확인하여 True 또는 False를 반환합니다.

text = "Hello World"
print(text.istitle()) # 출력: True

isupper()

문자열의 모든 알파벳 문자가 대문자인지 확인하여 True 또는 False를 반환합니다.

text = "HELLO WORLD"
print(text.isupper()) # 출력: True

join()

iterable(반복 가능한 객체) 의 요소들을 문자열로 결합합니다.

my_list = ["apple", "banana", "cherry"]
result = ", ".join(my_list)
print(result) # 출력: apple, banana, cherry

ljust()

문자열을 지정된 너비의 왼쪽에 정렬합니다.

text = "hello"
result = text.ljust(10, '*')
print(result) # 출력: hello*****

lower()

문자열의 모든 문자를 소문자로 변환합니다.

text = "HELLO WORLD"
result = text.lower()
print(result) # 출력: hello world

lstrip()

문자열의 왼쪽 공백 또는 특정 문자를 제거합니다.

text = "   hello world   "
result = text.lstrip()
print(result) # 출력: 'hello world   '

maketrans()

translate() 메서드와 함께 사용할 변환 테이블을 만듭니다.

trans_table = str.maketrans("aeiou", "12345")
text = "hello world"
result = text.translate(trans_table)
print(result) # 출력: h2ll4 w4rld

partition()

문자열을 지정된 구분자를 기준으로 세 부분(앞, 구분자, 뒤)으로 나누어 튜플로 반환합니다.

text = "I love python"
result = text.partition("love")
print(result) # 출력: ('I ', 'love', ' python')

replace()

문자열 내의 특정 값을 다른 값으로 대체합니다.

text = "I like apples"
result = text.replace("apples", "bananas")
print(result) # 출력: I like bananas

rfind()

find()와 유사하지만, 문자열의 끝에서부터 검색하여 가장 마지막에 발견된 위치의 인덱스를 반환합니다.

text = "hello world hello"
result = text.rfind("hello")
print(result) # 출력: 12

rindex()

rfind()와 유사하지만, 값이 없으면 오류(ValueError)를 발생시킵니다.

text = "hello world hello"
result = text.rindex("hello")
print(result) # 출력: 12

rjust()

문자열을 지정된 너비의 오른쪽에 정렬합니다.

text = "hello"
result = text.rjust(10, '*')
print(result) # 출력: *****hello

rpartition()

partition()과 유사하지만, 문자열의 끝에서부터 검색하여 가장 마지막에 발견된 구분자를 기준으로 나눕니다.

text = "I love python, he loves python too"
result = text.rpartition("python")
print(result) # 출력: ('I love python, he loves ', 'python', ' too')

rsplit()

split()과 유사하지만, 문자열의 끝에서부터 분할을 시작합니다.

text = "apple,banana,cherry"
result = text.rsplit(',', 1) # 마지막 쉼표를 기준으로 한 번만 나눔
print(result) # 출력: ['apple,banana', 'cherry']

rstrip()

문자열의 오른쪽 공백 또는 특정 문자를 제거합니다.

text = "   hello world   "
result = text.rstrip()
print(result) # 출력: '   hello world'

split()

문자열을 지정된 구분자를 기준으로 나누어 리스트로 반환합니다.

Python

text = "apple,banana,cherry"
result = text.split(',')
print(result) # 출력: ['apple', 'banana', 'cherry']

splitlines()

문자열을 줄 바꿈(\n) 기준으로 나누어 리스트로 반환합니다.

text = "First line\nSecond line"
result = text.splitlines()
print(result) # 출력: ['First line', 'Second line']

startswith()

문자열이 특정 값으로 시작하는지 확인하여 True 또는 False를 반환합니다.

text = "hello.txt"
result = text.startswith("hello")
print(result) # 출력: True

strip()

문자열의 양쪽 끝 공백 또는 특정 문자를 제거합니다.

text = "   hello world   "
result = text.strip()
print(result) # 출력: 'hello world'

swapcase()

문자열의 대소문자를 서로 바꿉니다. 소문자는 대문자로, 대문자는 소문자로 변환됩니다.

text = "HeLlO wOrLd"
result = text.swapcase()
print(result) # 출력: hElLo WoRlD

title()

문자열의 각 단어의 첫 글자를 대문자로 변환합니다.

text = "hello world"
result = text.title()
print(result) # 출력: Hello World

translate()

maketrans()로 만든 변환 테이블을 사용하여 문자열을 변환합니다.

trans_table = str.maketrans("abc", "123")
text = "abcde"
result = text.translate(trans_table)
print(result) # 출력: 123de

upper()

문자열의 모든 문자를 대문자로 변환합니다.

text = "hello world"
result = text.upper()
print(result) # 출력: HELLO WORLD

zfill()

문자열의 왼쪽에 0을 채워 지정된 길이를 만듭니다.

text = "42"
result = text.zfill(5)
print(result) # 출력: 00042

부울 (bool)

부울 값은 주로 어떤 조건이 맞는지 틀린지를 판단할 때 사용됩니다. 프로그래밍에서 조건문(if), 반복문(while) 등을 제어할 때 핵심적인 역할을 합니다.

예를 들어, “5가 3보다 크다”는 조건은 참(True) 이고, “10이 20과 같다”는 조건은 거짓(False) 입니다. 이렇게 비교 연산의 결과는 항상 부울 값으로 나타납니다.

x = 10
y = 5

# 비교 연산의 결과는 부울 값입니다.
result1 = (x > y)   # 10 > 5 이므로, True
result2 = (x == y)  # 10 == 5 이므로, False

print(result1)  # 결과: True
print(result2)  # 결과: False

# 조건문에 부울 값 사용
if result1:
    print("x는 y보다 큽니다.")

if result2:
    print("x는 y와 같습니다.") # 이 코드는 실행되지 않습니다.

이진

이진 데이터 타입은 텍스트가 아닌, 0과 1로 이루어진 바이트 시퀀스를 다룰 때 사용됩니다. 주로 이미지 파일, 오디오, 네트워크 통신 등 컴퓨터가 직접 처리하는 원시 데이터에 적합합니다.

이진 데이터를 나타내는 주요 타입으로는 bytes, bytearray, memoryview가 있습니다.

bytes

bytes 는 불변(immutable) 의 바이트 시퀀스입니다. 한번 생성되면 그 내용을 변경할 수 없습니다.

x = b"Hello"
print(x)      # 결과: b'Hello'
print(type(x))# 결과: <class 'bytes'>

• b"Hello"는 문자열 앞에 b를 붙여 이 문자열이 ASCII 문자로 인코딩된 바이트임을 나타냅니다.
• bytes() 함수를 사용해 빈 바이트 객체를 생성하거나, 다른 이진 데이터를 복사하여 생성할 수 있습니다.
• x[0] = 65 와 같이 개별 바이트 값을 변경하려고 시도하면 오류가 발생합니다.

bytearray

bytearray 는 가변(mutable) 의 바이트 시퀀스입니다. 생성 후에도 내용을 자유롭게 수정할 수 있습니다.

x = bytearray(5)
print(x)      # 결과: bytearray(b'\x00\x00\x00\x00\x00')
print(type(x))# 결과: <class 'bytearray'>

x[0] = 65    # 첫 번째 바이트를 ASCII 'A'로 변경
print(x)     # 결과: bytearray(b'A\x00\x00\x00\x00')

• bytearray(5)는 크기가 5인 bytearray를 생성하며, 모든 값은 기본적으로 0으로 초기화됩니다.
• bytearray는 데이터를 효율적으로 수정해야 할 때 유용합니다. 예를 들어, 파일을 읽어 들여 특정 부분을 수정하고 다시 저장할 때 사용됩니다.

memoryview

memoryview는 다른 이진 객체의 메모리 주소를 직접 참조하여 데이터를 다룹니다. 이는 데이터를 복사하지 않고도 원본 데이터에 접근할 수 있게 해줍니다.

data = b"Python"
x = memoryview(data)

print(x[0])     # 결과: 80 (ASCII 'P')
print(x[1:3])   # 결과: <memory at 0x...>

# memoryview는 원본 객체가 가변일 경우 데이터를 수정할 수 있습니다.
mutable_data = bytearray(b"Python")
view = memoryview(mutable_data)
view[0] = 74 # ASCII 'J'
print(mutable_data) # 결과: bytearray(b'Jython')

• memoryview는 특히 대용량 이진 데이터를 다룰 때 메모리 사용량을 줄여줍니다. 데이터를 복사하는 대신 원본 데이터를 ‘바라보는’ 방식이기 때문입니다.
• memoryview를 통해 데이터를 수정하려면 원본 객체가 가변 타입(bytearray) 이어야 합니다. bytes와 같이 불변 객체를 참조할 때는 읽기만 가능합니다.

None

NoneType은 값이 없다는 상태를 나타내는 파이썬의 특별한 데이터 타입입니다. 오직 None이라는 단 하나의 값만을 가집니다.

None은 값이 0이거나, 빈 문자열(""), 빈 리스트([])와는 다릅니다. 이들은 ‘값이 있는’ 상태인 반면, None은 “아무것도 없음” 또는 “값이 할당되지 않음” 을 명시적으로 표현하는 데 사용됩니다.

a = None
b = None
print(a is b)  # True, 같은 객체인지 비교

함수 반환 값: 함수가 명시적으로 return 값을 지정하지 않으면, 파이썬은 자동으로 None을 반환합니다

def greet(name):
    print(f"안녕하세요, {name}!")

result = greet("김철수")
print(result)  # 결과: None

초기값 설정: 변수에 어떤 값이 들어갈지 확정되지 않았을 때, 초기값으로 None을 할당하여 ‘아직 값이 정해지지 않았다’는 것을 나타낼 수 있습니다.

user_input = None
if some_condition:
    user_input = "특정 값"

None과 false의 차이점

None은 False와 혼동할 수 있지만, 둘은 완전히 다른 개념입니다. None은 ‘값이 없음’을 나타내고, False는 논리적으로 ‘거짓’을 나타냅니다.

조건문에서 if x:와 같이 None을 사용할 경우, None은 논리적으로 False로 간주되기는 하지만, 데이터 타입 자체는 다릅니다. 이 점을 이해하는 것이 중요합니다.

변수명 규칙

1. 변수 이름은 문자, 숫자, 밑줄(_)로 구성될 수 있습니다.

my_name = "Alice"
age2 = 30
_score = 95

2. 변수 이름은 숫자로 시작할 수 없습니다.

# 잘못된 변수명 예시
2nd_place = "Bob"  # 오류 발생!

# 올바른 변수명 예시
second_place = "Bob"
_2nd_place = "Bob"

3. 변수 이름은 공백을 포함할 수 없습니다.

# 잘못된 변수명 예시
first name = "John"  # 오류 발생!

# 올바른 변수명 예시
first_name = "John"  # 밑줄을 사용한 예시 (snake_case)
firstName = "John"   # 카멜 케이스를 사용한 예시 (camelCase)

4. 변수 이름은 대소문자를 구분합니다.

my_age = 25
My_age = 30

5. 예약어(키워드)는 변수 이름으로 사용할 수 없습니다.

# 잘못된 변수명 예시
class = "Math"  # 'class'는 예약어이므로 오류 발생

# 올바른 변수명 예시
class_name = "Math"
my_class = "Math"

파이썬의 예약어 목록을 확인하려면 아래 코드를 실행해 볼 수 있습니다.

import keyword
print(keyword.kwlist)

6. 문자열 변수는 작은따옴표나 큰따옴표를 사용하여 선언할 수 있습니다.

x = "John"  
# is the same as  
x = 'John'

다른 언어와의 차이

C나 Java에서는 변수를 선언할 때, 변수의 데이터 타입을 앞에 붙여 선언해야 합니다.

int x = 10;

Python에서는 단순히 변수에 값을 대입하는 것으로 변수를 생성합니다.

x = 10

변수 x 에 10이라는 값을 대입하는 순간 Python은 메모리에 10이라는 값을 가지고 있는 객체를 생성하고, x변수가 해당 객체를 가르키게 합니다.
즉, Python에서의 변수란 특정 값을 가지고 잇는 객체를 가리키는 참조자 역할을 합니다.
C에서의 포인터, Java에서의 참조 변수와 비슷한 개념인 것이죠.
함수와 클래스 개념을 설명하면서 더 자세히 알아보도록 하겠습니다.

• 장점 : 프로그래밍 제약이 다소 느슨하여 사용성이 편리하다. 프로그래밍 입문하기에 좋은 언어이다.
• 단점 : 프로그래밍 의도와 달리 오류가 발생할 가능성이 많고 변수의 사용의미에 모호한 점이 발생할 수 있다.

형 변환(Casting)

변수의 데이터 타입을 명시적으로 지정하거나, 한 데이터 타입을 다른 타입으로 바꾸는 것을 의미합니다.
파이썬은 동적 타이핑 언어라서 변수를 선언할 때 타입을 따로 지정하지 않습니다. 하지만 때로는 특정 데이터 타입이 꼭 필요한 상황이 발생합니다. 예를 들어, 사용자가 입력한 값은 기본적으로 문자열로 인식되는데, 이 값을 가지고 숫자를 더해야 할 때가 그렇죠.

하나의 데이터 유형에서 다른 데이터 유형으로 변환을 수행하는 몇 가지 내장 함수가 있습니다.
이 함수는 변환된 값을 나타내는 새 객체를 반환합니다.

No	Function & Description
1	int(x [,base]) : x를 정수로 변환합니다. base는 x가 문자열 인 경우 2부터 36까지의 정수여야 합니다. 이 인자는 주로 2진수, 8진수, 16진수 등의 문자열을 다룰 때 사용됩니다.
2	long(x [,base] ) : x를 long integer로 변환합니다.
3	float(x) : x를 부동 소수점 숫자로 변환 (컴퓨터에서 실수를 표현하는 방식으로, 숫자를 유효숫자를 나타내는 가수부와 소수점 위치를 나타내는 지수부로 나누어 저장합니다.)
4	complex(real [,imag]) : 복소수 생성
5	str(x) : 객체 x를 문자열 표현으로 변환
6	repr(x) : 오브젝트 x를 표현식 문자열로 변환
7	eval(str) : 문자열을 평가하고 객체를 반환
8	tuple(s) : s를 튜플로 변환
9	list(s) : s를 리스트로 변환
10	set(s) : s를 집합으로 변환
11	dict(d) : 사전 생성. d는 반드시 (키, 값) 튜플의 시퀀스
12	frozenset(s) : s를 변경할 수 없는 집합으로 변환
13	chr(x) : 정수를 문자로 변환
14	unichr(x) : 정수를 Unicode 문자로 변환
15	ord(x) : 하나의 문자를 정수 숫자로 변환
16	hex(x) : 정수를 16진수 문자열로 변환
17	oct(x) : 정수를 8진수 문자열로 변환

문자열 -> 숫자(int)

str_to_int = int('7')
print(str_to_int, type(str_to_int))

str_to_int = int("101", 2) # 문자열 "101"을 2진수로 해석하여 10진수로 변환합니다. (1×2^2+0×2^1+1×2^0=4+0+1=5)
print(str_to_int, type(str_to_int))

str_to_int = int("77", 8) # 문자열 "77"을 8진수로 해석하여 10진수로 변환합니다. (7×81+7×80=56+7=63)
print(str_to_int, type(str_to_int))

str_to_int = int("FF", 16) # 문자열 "FF"를 16진수로 해석하여 10진수로 변환합니다. (15×161+15×160=240+15=255)
print(str_to_int, type(str_to_int))

int -> float

int_to_float = float(str_to_int)
print(int_to_float, type(int_to_float))

int -> 문자열

int_to_str = str(str_to_int)
print(int_to_str, type(int_to_str))

repr()

repr(x) 함수는 객체 x를 공식적인 문자열 표현(representation) 으로 변환할 때 사용됩니다.
이 표현식은 개발자가 객체를 검사하고 디버깅하는 데 유용하며, eval() 함수를 사용하여 원래 객체를 재구성할 수 있을 만큼 상세한 정보를 포함하는 경우가 많습니다.

1. 디버깅 및 로깅

객체의 정확한 상태를 확인하고 싶을 때 repr()은 매우 유용합니다.
print() 함수는 객체를 사용자가 읽기 쉬운 형태로 변환하지만, repr()은 객체의 내부 상태를 보여주는 개발자 친화적인 형식을 반환합니다.

import datetime

today = datetime.date(2025, 9, 25)
print(str(today))  # 출력: 2025-09-25 (사용자 친화적)
print(repr(today)) # 출력: datetime.date(2025, 9, 25) (개발자 친화적), datetime.date 객체를 다시 만들 수 있는 정확한 정보를 제공합니다.

2. __repr__ 메서드 구현 ✍️

클래스를 만들 때 __repr__ 메서드를 직접 구현하여 객체의 repr() 동작을 정의할 수 있습니다. 이는 다른 개발자가 내가 만든 객체의 상태를 쉽게 파악하도록 도와주는 좋은 관례입니다.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Point(x={self.x}, y={self.y})"

p = Point(10, 20)
print(p)         # 출력: Point(x=10, y=20)
print(repr(p))   # 출력: Point(x=10, y=20)

eval(str)

문자열에 담긴 파이썬 코드를 실행하고, 그 결과로 생성된 객체를 반환하는 함수입니다.
파이썬 코드가 들어있는 문자열을 받아서, 마치 사용자가 터미널에 직접 코드를 입력한 것처럼 처리합니다.
즉, 문자열을 파이썬 표현식(expression) 으로 해석하고 평가(evaluate)하는 역할을 합니다.

• eval()의 사용 시 주의점

eval()은 강력한 기능이지만, 보안상의 이유로 신중하게 사용해야 합니다. 특히, 신뢰할 수 없는 소스(예: 사용자 입력, 네트워크 데이터)로부터 받은 문자열을 eval()로 실행하면 매우 위험할 수 있습니다.

악의적인 사용자가 eval()에 os.system('rm -rf /')와 같은 명령어를 주입할 경우, 시스템에 치명적인 손상을 입힐 수 있기 때문입니다. 따라서 eval()은 안전성이 보장된 환경에서만 사용하는 것이 좋습니다.

대부분의 경우, json 모듈의 json.loads()와 같은 더 안전한 대안들이 있으므로, eval()을 사용하기 전에 다른 방법이 없는지 먼저 고려하는 것이 중요합니다.

x = 10
y = 20

# 문자열 "x + y"를 파이썬 코드로 실행
result = eval("x + y")

print(result)  # 결과: 30

변수 스코프(Variable Scope)

변수가 정의되고 접근할 수 있는 영역을 의미합니다.
스코프는 프로그램이 변수의 이름을 어디서 찾아야 할지 결정하는 규칙입니다.
파이썬은 변수의 스코프를 결정하는 유명한 규칙인 LEGB 규칙을 따릅니다.

LEGB 규칙 (Scope Resolution)

파이썬이 변수를 찾을 때 다음 네 가지 영역을 순서대로 확인합니다.

약어	스코프 명칭	설명
L	Local (지역)	현재 작업 중인 함수 내에서 정의된 변수. 가장 먼저 검색합니다.
E	Enclosing (둘러싼)	현재 함수를 둘러싸고 있는 상위 함수의 스코프에 정의된 변수 (중첩 함수에서 발생).
G	Global (전역)	모듈 파일의 가장 바깥쪽에 정의된 변수. global 키워드를 사용하여 참조/수정할 수 있습니다.
B	Built-in (내장)	파이썬이 기본으로 제공하는 함수나 상수 (예: print, len, True 등).

x = "Global"  # G (전역)

def outer():
    x = "Enclosing"  # E (둘러싼)

    def inner():
        x = "Local"  # L (지역)
        print(x)     # L 스코프의 "Local" 출력

    inner()
    print(x)         # E 스코프의 "Enclosing" 출력

outer()
print(x)             # G 스코프의 "Global" 출력

각 스코프의 특징과 키워드

A. Local (지역 스코프)

함수나 메서드 내부에서 정의된 변수입니다. 이 변수는 해당 함수가 실행되는 동안에만 존재하며, 함수가 종료되면 메모리에서 사라집니다.

def my_function():
    local_var = 10  # 지역 변수
    print(local_var)

my_function()
# print(local_var) # 여기서 실행하면 NameError 발생

B. Enclosing (둘러싼 스코프)

중첩 함수(nested function) 에서만 발생하는 스코프입니다. 내부 함수가 외부 함수(둘러싼 함수)의 변수에 접근할 때 사용됩니다.

• nonlocal 키워드 사용: 내부 함수에서 외부 함수의 변수 값을 수정하고 싶을 때 사용합니다. nonlocal을 사용하면 L 스코프를 건너뛰고 E 스코프의 변수를 찾아 수정합니다.

def outer():
    count = 0 
    def inner():
        nonlocal count  # E 스코프의 count를 수정하겠다고 선언
        count += 1
        print(count)
    inner()
    inner()
    print(count) # 결과: 2 (수정됨)

outer()

C. Global (전역 스코프)

모듈 파일의 최상단(가장 바깥쪽)에 정의된 변수입니다. 파일 내의 모든 함수와 클래스에서 접근할 수 있습니다.

• global 키워드 사용: 함수 내부에서 전역 변수를 수정하고 싶을 때 사용합니다. 선언하지 않고 읽기만 할 때는 키워드가 필요 없습니다.

주의: 함수 내에서 global이나 nonlocal 키워드 없이 변수에 값을 할당하면, 파이썬은 새로운 지역 변수를 생성하여 기존의 전역 또는 둘러싼 변수와 다른 것으로 간주합니다. 이것이 변수 스코프에서 가장 흔하게 발생하는 실수입니다.

total = 100  # 전역 변수

def add_value(value):
    global total  # G 스코프의 total을 수정하겠다고 선언
    total += value

add_value(50)
print(total) # 결과: 150 (수정됨)