포스트

[이제와서 시작하는 Python 마스터하기 #2] 변수, 자료형, 연산자 완벽 정리

게시
By YonYonWare
30 분읽는 시간
[이제와서 시작하는 Python 마스터하기 #2] 변수, 자료형, 연산자 완벽 정리

image: path: /assets/img/posts/python/python-mastery-02-variables-types.png alt: Python 변수와 자료형

🎯 5분 만에 변수 마스터하기

실제 프로그램을 만들어보며 변수를 배워봅시다!

🏪 편의점 계산 프로그램

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 실제로 사용하는 변수 예제 - 편의점 계산기
customer_name = "김파이썬"
ramen_price = 1500
coffee_price = 2000
sandwich_price = 3500

# 구매 수량
ramen_qty = 2
coffee_qty = 1
sandwich_qty = 1

# 총액 계산
total = (ramen_price * ramen_qty +
         coffee_price * coffee_qty +
         sandwich_price * sandwich_qty)

# 할인 적용 (10% 할인)
discount_rate = 0.1
discount_amount = total * discount_rate
final_price = total - discount_amount

print(f"{customer_name}님의 영수증")
print(f"라면: {ramen_price}원 x {ramen_qty}개 = {ramen_price * ramen_qty}원")
print(f"커피: {coffee_price}원 x {coffee_qty}개 = {coffee_price * coffee_qty}원")
print(f"샌드위치: {sandwich_price}원 x {sandwich_qty}개 = {sandwich_price * sandwich_qty}원")
print(f"총액: {total}원")
print(f"할인: {discount_amount}원")
print(f"결제금액: {final_price}원")

📦 Python 변수(Variables)

변수는 데이터를 저장하는 이름표가 있는 상자와 같습니다. Python에서 변수를 사용하면 프로그램에서 값을 저장하고 재사용할 수 있습니다.

Python Variable Labels Python의 변수는 값을 담는 상자라기보다는, 값에 붙이는 ‘이름표’에 가깝습니다.

변수 선언과 할당

Python은 동적 타입 언어로, 변수의 타입을 명시적으로 선언할 필요가 없습니다.

1
2
3
4
5
6
7
8
9
10
11
12

# 변수 선언과 할당
name = "김파이썬"  # 문자열
age = 25          # 정수
height = 175.5    # 실수
is_student = True # 불리언

# 여러 변수 동시 할당
x, y, z = 10, 20, 30
a = b = c = 100  # 같은 값을 여러 변수에 할당

# 변수 값 교환 (Python의 독특한 기능)
x, y = y, x  # x와 y의 값이 서로 바뀜

[!TIP] 초보자를 위한 팁: 동적 타이핑

C나 Java 같은 언어는 int age = 25; 처럼 변수의 타입을 미리 정해야 하지만, Python은 age = 25 처럼 값에 따라 자동으로 타입이 정해집니다. 이를 동적 타이핑(Dynamic Typing)이라고 합니다. 편하지만, 나중에 어떤 타입인지 헷갈릴 수 있으니 변수명을 명확하게 짓는 것이 중요합니다!

변수 명명 규칙

✅ 올바른 변수명

1
2
3
4
5

user_name = "홍길동"      # 스네이크 케이스 (권장)
userName = "홍길동"        # 캐멀 케이스
_private_var = 100        # 언더스코어로 시작 (내부용)
MAX_SIZE = 1000          # 대문자 (상수)
한글변수 = "가능하지만 권장하지 않음"

❌ 잘못된 변수명

1
2
3
4

# 2name = "에러"        # 숫자로 시작 불가
# my-name = "에러"      # 하이픈 사용 불가
# class = "에러"        # 예약어 사용 불가
# my name = "에러"      # 공백 포함 불가

Python 예약어 (Keywords)

사용할 수 없는 예약어들:

1
2
3
4

import keyword
print(keyword.kwlist)
# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 
#  'break', 'class', 'continue', 'def', 'del', 'elif', 'else', ...]

🎨 Python 자료형(Data Types)

🎲 자료형 체험하기 - 주사위 게임

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

# 다양한 자료형을 활용한 주사위 게임
import random

player_name = "김파이썬"  # 문자열 (str)
player_money = 10000     # 정수 (int)
win_rate = 0.0           # 실수 (float)
is_playing = True        # 불리언 (bool)
game_history = []        # 리스트 (list)

print(f"🎲 {player_name}님, 주사위 게임에 오신 것을 환영합니다!")
print(f"💰 보유 금액: {player_money}원")

while is_playing and player_money > 0:
    bet = 1000
    dice = random.randint(1, 6)

    print(f"\n주사위를 굴립니다... 🎲 {dice}")

    if dice >= 4:  # 4, 5, 6이 나오면 승리
        player_money += bet
        game_history.append("승")
        print(f"✅ 승리! +{bet}원")
    else:
        player_money -= bet
        game_history.append("패")
        print(f"❌ 패배! -{bet}원")

    print(f"💰 현재 금액: {player_money}원")

    # 승률 계산
    wins = game_history.count("승")
    total_games = len(game_history)
    if total_games > 0:
        win_rate = (wins / total_games) * 100
        print(f"📊 승률: {win_rate:.1f}% ({wins}승 {total_games - wins}패)")

    # 게임 계속 여부
    if player_money <= 0:
        print("\n💸 파산하셨습니다!")
        is_playing = False
    elif len(game_history) >= 5:
        print(f"\n🏁 게임 종료! 최종 금액: {player_money}원")
        is_playing = False

Python의 주요 자료형을 체계적으로 알아보겠습니다.

graph TD
    A[Python 자료형] --> B[숫자형]
    A --> C[문자열]
    A --> D[불리언]
    A --> E[컬렉션]
    A --> F[None]
    
    B --> B1[int 정수]
    B --> B2[float 실수]
    B --> B3[complex 복소수]
    
    E --> E1[list 리스트]
    E --> E2[tuple 튜플]
    E --> E3[dict 딕셔너리]
    E --> E4[set 집합]

1. 숫자형 (Numeric Types)

정수 (int)

1
2
3
4
5
6
7
8
9
10

# 정수형
age = 25
population = 51_780_579  # 언더스코어로 가독성 향상
binary = 0b1010         # 2진수 (10)
octal = 0o12           # 8진수 (10)
hexadecimal = 0xA      # 16진수 (10)

# 큰 숫자도 제한 없이 사용 가능
big_number = 123456789012345678901234567890
print(type(age))  # <class 'int'>

실수 (float)

1
2
3
4
5
6
7
8
9
10
11
12

# 실수형
height = 175.5
pi = 3.14159
scientific = 1.23e-4  # 과학적 표기법 (0.000123)

# 부동소수점 주의사항
print(0.1 + 0.2)  # 0.30000000000000004 (정밀도 문제)
print(0.1 + 0.2 == 0.3)  # False

# 정확한 비교를 위한 방법
import math
print(math.isclose(0.1 + 0.2, 0.3))  # True

[!WARNING] 실수 계산 주의사항

컴퓨터는 0과 1로 숫자를 표현하기 때문에, 0.1 같은 소수를 완벽하게 표현하지 못하고 미세한 오차가 발생합니다. 돈 계산처럼 정확성이 중요한 경우에는 decimal 모듈을 사용해야 합니다.

복소수 (complex)

1
2
3
4
5

# 복소수
z = 3 + 4j
print(z.real)  # 3.0 (실수부)
print(z.imag)  # 4.0 (허수부)
print(abs(z))  # 5.0 (절댓값)

2. 문자열 (String)

문자열은 텍스트 데이터를 저장합니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# 문자열 생성
single_quote = '작은따옴표'
double_quote = "큰따옴표"
triple_quote = """여러 줄
문자열도
가능합니다"""

# 이스케이프 시퀀스
escaped = "줄바꿈\n탭\t백슬래시\\"
raw_string = r"C:\Users\name"  # raw string (이스케이프 무시)

# 문자열 포맷팅
name = "파이썬"
version = 3.12
formatted1 = f"{name} {version}"  # f-string (권장)
formatted2 = "{} {}".format(name, version)
formatted3 = "%s %.1f" % (name, version)  # 구식 방법

# 문자열 메서드
text = "  Hello, Python!  "
print(text.strip())      # 양쪽 공백 제거
print(text.upper())      # 대문자로
print(text.lower())      # 소문자로
print(text.replace("Python", "World"))
print(text.split(","))   # 분할하여 리스트로

3. 불리언 (Boolean)

참(True) 또는 거짓(False)을 나타냅니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 불리언
is_valid = True
is_empty = False

# Truthy와 Falsy 값
# Falsy: False, None, 0, 0.0, "", [], {}, set(), ()
# Truthy: 위 외의 모든 값

# 예시
if []:  # 빈 리스트는 False
    print("실행 안됨")
    
if [1, 2, 3]:  # 값이 있는 리스트는 True
    print("실행됨")

# bool() 함수로 확인
print(bool(0))      # False
print(bool(42))     # True
print(bool(""))     # False
print(bool("abc"))  # True

4. None 타입

값이 없음을 나타내는 특별한 타입입니다.

1
2
3
4
5
6
7
8
9
10
11
12

# None
result = None
print(type(result))  # <class 'NoneType'>

# None 체크
if result is None:  # is 연산자 사용 권장
    print("결과가 없습니다")

# 함수에서 None 반환
def find_user(user_id):
    # 사용자를 찾지 못한 경우
    return None

5. 타입 확인과 변환

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 타입 확인
x = 42
print(type(x))           # <class 'int'>
print(isinstance(x, int))  # True
print(isinstance(x, (int, float)))  # 여러 타입 중 하나인지

# 타입 변환 (Type Casting)
# 문자열 → 숫자
num_str = "123"
num = int(num_str)       # 123
float_num = float("3.14")  # 3.14

# 숫자 → 문자열
age = 25
age_str = str(age)       # "25"

# 주의: 변환 불가능한 경우
# int("abc")  # ValueError 발생

# 안전한 변환
def safe_int_convert(value):
    try:
        return int(value)
    except ValueError:
        return None

print(safe_int_convert("123"))  # 123
print(safe_int_convert("abc"))  # None

🔧 Python 연산자(Operators)

1. 산술 연산자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# 기본 산술 연산자
a, b = 10, 3

print(a + b)   # 13 (덧셈)
print(a - b)   # 7  (뺄셈)
print(a * b)   # 30 (곱셈)
print(a / b)   # 3.333... (나눗셈 - 항상 float 반환)
print(a // b)  # 3  (정수 나눗셈)
print(a % b)   # 1  (나머지)
print(a ** b)  # 1000 (거듭제곱)

# 복합 할당 연산자
x = 5
x += 3   # x = x + 3
x -= 2   # x = x - 2
x *= 4   # x = x * 4
x /= 2   # x = x / 2
x //= 3  # x = x // 3
x %= 2   # x = x % 2
x **= 2  # x = x ** 2

2. 비교 연산자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

# 비교 연산자
x, y = 5, 10

print(x == y)  # False (같음)
print(x != y)  # True  (다름)
print(x < y)   # True  (작음)
print(x > y)   # False (큼)
print(x <= y)  # True  (작거나 같음)
print(x >= y)  # False (크거나 같음)

# 연쇄 비교 (Python의 특징)
age = 25
print(18 <= age < 65)  # True (성인이면서 65세 미만)

# 문자열 비교 (사전순)
print("apple" < "banana")  # True
print("가" < "나")        # True

3. 논리 연산자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 논리 연산자
a, b = True, False

print(a and b)  # False (둘 다 True일 때만 True)
print(a or b)   # True  (하나라도 True면 True)
print(not a)    # False (반대)

# 단락 평가 (Short-circuit evaluation)
def expensive_check():
    print("비용이 많이 드는 검사 실행")
    return True

# and는 첫 번째가 False면 두 번째를 실행하지 않음
False and expensive_check()  # 함수 실행 안됨

# or는 첫 번째가 True면 두 번째를 실행하지 않음
True or expensive_check()    # 함수 실행 안됨

# 논리 연산자의 반환값
print(5 and 10)    # 10 (마지막 평가된 값)
print(0 or 42)     # 42 (첫 번째 Truthy 값)
print(None or "기본값")  # "기본값"

4. 비트 연산자

1
2
3
4
5
6
7
8
9

# 비트 연산자
a, b = 0b1010, 0b1100  # 10, 12

print(bin(a & b))   # 0b1000 (AND)
print(bin(a | b))   # 0b1110 (OR)
print(bin(a ^ b))   # 0b110  (XOR)
print(bin(~a))      # -0b1011 (NOT)
print(bin(a << 2))  # 0b101000 (왼쪽 시프트)
print(bin(a >> 1))  # 0b101 (오른쪽 시프트)

5. 멤버십 연산자

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# in, not in 연산자
fruits = ["apple", "banana", "orange"]
print("apple" in fruits)      # True
print("grape" not in fruits)  # True

# 문자열에서도 사용 가능
text = "Hello, Python!"
print("Python" in text)       # True
print("java" in text.lower()) # False

# 딕셔너리에서는 키를 검사
user = {"name": "김파이썬", "age": 25}
print("name" in user)         # True (키 검사)
print(25 in user.values())    # True (값 검사)

6. 식별 연산자

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# is, is not 연산자
# 객체의 동일성(identity) 검사

# == vs is
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)  # True (값이 같음)
print(a is b)  # False (다른 객체)
print(a is c)  # True (같은 객체)

# None 검사는 is 사용
value = None
if value is None:  # 권장
    print("값이 없습니다")

# 작은 정수는 캐싱되어 있음
x = 256
y = 256
print(x is y)  # True (캐싱된 객체)

x = 257
y = 257
print(x is y)  # False (새로운 객체)

7. 연산자 우선순위

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 연산자 우선순위 (높은 것부터)
# 1. () 괄호
# 2. ** 거듭제곱
# 3. +x, -x, ~x 단항 연산자
# 4. *, /, //, % 곱셈, 나눗셈
# 5. +, - 덧셈, 뺄셈
# 6. <<, >> 비트 시프트
# 7. & 비트 AND
# 8. ^ 비트 XOR
# 9. | 비트 OR
# 10. ==, !=, <, >, <=, >= 비교
# 11. is, is not, in, not in
# 12. not 논리 NOT
# 13. and 논리 AND
# 14. or 논리 OR

# 예시
result = 2 + 3 * 4 ** 2  # 2 + 3 * 16 = 2 + 48 = 50
result = (2 + 3) * 4 ** 2  # 5 * 16 = 80

# 복잡한 표현식은 괄호로 명확히
if (age >= 18 and age < 65) or (is_student and has_discount):
    print("할인 적용")

💡 실전 예제

🏢 실무 예제: 직원 급여 계산 시스템

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

def calculate_salary():
    """실제 회사에서 사용하는 급여 계산 프로그램"""

    # 직원 정보 (변수와 자료형 활용)
    employee_name = "이파이썬"
    position = "주니어 개발자"
    base_salary = 3500000      # 기본급 (정수)
    overtime_hours = 15.5       # 초과근무 시간 (실수)
    has_family = True          # 가족수당 여부 (불리언)

    # 급여 계산
    hourly_rate = base_salary / 209  # 월 근무시간 209시간 기준
    overtime_pay = hourly_rate * 1.5 * overtime_hours

    # 수당 계산
    meal_allowance = 100000    # 식대
    transport_allowance = 150000  # 교통비
    family_allowance = 200000 if has_family else 0  # 가족수당

    # 총 급여
    gross_salary = base_salary + overtime_pay + meal_allowance + transport_allowance + family_allowance

    # 공제 계산 (간소화된 버전)
    national_pension = gross_salary * 0.045  # 국민연금 4.5%
    health_insurance = gross_salary * 0.0343  # 건강보험 3.43%
    employment_insurance = gross_salary * 0.009  # 고용보험 0.9%
    income_tax = gross_salary * 0.05  # 소득세 (간소화)

    total_deduction = national_pension + health_insurance + employment_insurance + income_tax
    net_salary = gross_salary - total_deduction

    # 급여 명세서 출력
    print(f"{'='*50}")
    print(f"{'급여명세서':^50}")
    print(f"{'='*50}")
    print(f"성명: {employee_name} ({position})")
    print(f"\n[지급내역]")
    print(f"기본급: {base_salary:,}원")
    print(f"초과근무수당: {overtime_pay:,.0f}원 ({overtime_hours}시간)")
    print(f"식대: {meal_allowance:,}원")
    print(f"교통비: {transport_allowance:,}원")
    print(f"가족수당: {family_allowance:,}원")
    print(f"{'─'*50}")
    print(f"총 지급액: {gross_salary:,.0f}원")
    print(f"\n[공제내역]")
    print(f"국민연금: {national_pension:,.0f}원")
    print(f"건강보험: {health_insurance:,.0f}원")
    print(f"고용보험: {employment_insurance:,.0f}원")
    print(f"소득세: {income_tax:,.0f}원")
    print(f"{'─'*50}")
    print(f"총 공제액: {total_deduction:,.0f}원")
    print(f"{'='*50}")
    print(f"실수령액: {net_salary:,.0f}원")

    return net_salary

# 실행
# calculate_salary()

🌡️ IoT 센서 데이터 처리

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

def process_sensor_data():
    """스마트홈 IoT 센서 데이터 처리"""

    # 센서 데이터 (다양한 자료형 활용)
    room_temperature = 23.5     # 실수: 온도
    humidity = 65              # 정수: 습도 %
    is_motion_detected = True  # 불리언: 움직임 감지
    light_level = 350          # 정수: 조도 (lux)
    air_quality = "좋음"       # 문자열: 공기질

    # 스마트홈 자동 제어 로직
    actions = []  # 수행할 동작 리스트

    # 온도 제어
    if room_temperature > 28:
        actions.append("에어컨 켜기")
        target_temp = 24
    elif room_temperature < 18:
        actions.append("난방 켜기")
        target_temp = 22
    else:
        target_temp = room_temperature

    # 습도 제어
    if humidity < 40:
        actions.append("가습기 켜기")
    elif humidity > 70:
        actions.append("제습기 켜기")

    # 조명 제어
    if is_motion_detected:
        if light_level < 500:
            actions.append("조명 켜기 (밝기: 80%)")
    else:
        actions.append("조명 끄기")

    # 공기질 관리
    air_quality_levels = {"매우나쁨": 0, "나쁨": 1, "보통": 2, "좋음": 3, "매우좋음": 4}
    if air_quality_levels.get(air_quality, 3) < 2:
        actions.append("공기청정기 강모드 작동")

    # 결과 출력
    print("🏠 스마트홈 센서 상태")
    print(f"온도: {room_temperature}°C")
    print(f"습도: {humidity}%")
    print(f"움직임: {'감지됨' if is_motion_detected else '없음'}")
    print(f"조도: {light_level} lux")
    print(f"공기질: {air_quality}")

    if actions:
        print("\n📋 수행할 동작:")
        for i, action in enumerate(actions, 1):
            print(f"{i}. {action}")
    else:
        print("\n✅ 모든 환경이 최적 상태입니다")

    return actions

# 실행
# process_sensor_data()

간단한 계산기 만들기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

def calculator():
    """간단한 계산기 프로그램"""
    print("=== 파이썬 계산기 ===")
    
    # 숫자 입력받기
    num1 = float(input("첫 번째 숫자: "))
    num2 = float(input("두 번째 숫자: "))
    
    # 연산 선택
    print("\n연산을 선택하세요:")
    print("1. 덧셈 (+)")
    print("2. 뺄셈 (-)")
    print("3. 곱셈 (*)")
    print("4. 나눗셈 (/)")
    
    choice = input("\n선택 (1-4): ")
    
    # 연산 수행
    if choice == '1':
        result = num1 + num2
        operator = "+"
    elif choice == '2':
        result = num1 - num2
        operator = "-"
    elif choice == '3':
        result = num1 * num2
        operator = "*"
    elif choice == '4':
        if num2 != 0:
            result = num1 / num2
            operator = "/"
        else:
            print("에러: 0으로 나눌 수 없습니다!")
            return
    else:
        print("잘못된 선택입니다!")
        return
    
    # 결과 출력
    print(f"\n결과: {num1} {operator} {num2} = {result}")

# 함수 실행
# calculator()

데이터 타입 검사기

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

def type_checker(value):
    """값의 타입과 특성을 분석하는 함수"""
    print(f"값: {value}")
    print(f"타입: {type(value).__name__}")
    
    # 숫자형 체크
    if isinstance(value, (int, float)):
        print(f"  - 숫자형입니다")
        print(f"  - 짝수입니다" if value % 2 == 0 else f"  - 홀수입니다")
        print(f"  - 양수입니다" if value > 0 else f"  - 음수 또는 0입니다")
    
    # 문자열 체크
    elif isinstance(value, str):
        print(f"  - 문자열입니다")
        print(f"  - 길이: {len(value)}")
        print(f"  - 숫자로만 구성: {value.isdigit()}")
        print(f"  - 알파벳으로만 구성: {value.isalpha()}")
    
    # 불리언 체크
    elif isinstance(value, bool):
        print(f"  - 불리언입니다")
        print(f"  - 값: {'참' if value else '거짓'}")
    
    # None 체크
    elif value is None:
        print(f"  - None 타입입니다")
    
    print()

# 테스트
type_checker(42)
type_checker(3.14)
type_checker("Hello")
type_checker(True)
type_checker(None)

⚠️ 초보자가 자주 하는 실수

1. 부동소수점 비교 실수

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# ❌ 잘못된 방법
price = 0.1 + 0.2
if price == 0.3:  # False! (0.30000000000000004)
    print("같음")

# ✅ 올바른 방법
import math
if math.isclose(price, 0.3):
    print("같음")

# 또는 decimal 모듈 사용
from decimal import Decimal
price = Decimal('0.1') + Decimal('0.2')
if price == Decimal('0.3'):
    print("같음")

2. 변수명 실수

1
2
3
4
5
6
7
8
9

# ❌ 잘못된 변수명
# 1st_name = "김파이썬"  # 숫자로 시작
# my-name = "이파이썬"   # 하이픈 사용
# class = "3학년"        # 예약어 사용

# ✅ 올바른 변수명
first_name = "김파이썬"
my_name = "이파이썬"
class_name = "3학년"

3. 타입 변환 실수

1
2
3
4
5
6
7

# ❌ 문자열과 숫자 연산
age = input("나이: ")  # "25" (문자열)
# next_year = age + 1  # TypeError!

# ✅ 타입 변환 필요
age = int(input("나이: "))
next_year = age + 1

4. None 비교 실수

1
2
3
4
5
6
7

# ❌ == 사용
if value == None:
    print("None")

# ✅ is 사용 권장
if value is None:
    print("None")

🎯 핵심 정리

변수 Best Practices

  1. 의미 있는 이름 사용: n 보다는 student_count
  2. 일관된 명명 규칙: 스네이크_케이스 사용
  3. 상수는 대문자로: MAX_RETRY = 3
  4. 타입 힌트 활용 (Python 3.5+): 
    1
2
3

    name: str = "김파이썬"
age: int = 25
scores: list[int] = [90, 85, 88]

자료형 선택 가이드

  • 정수 계산: int 사용
  • 소수점 필요: float 사용 (정밀도 주의)
  • 텍스트 처리: str 사용
  • 참/거짓 판단: bool 사용
  • 값 없음 표현: None 사용

연산자 활용 팁

  1. 연쇄 비교 활용: 18 <= age < 65
  2. 삼항 연산자: result = "성인" if age >= 18 else "미성년"
  3. None 체크는 is 사용: if value is None:
  4. 기본값 설정: name = input_name or "기본이름"

🎓 파이썬 마스터하기 시리즈

📚 기초편 (1-7)

  1. Python 소개와 개발 환경 설정 완벽 가이드
  2. 변수, 자료형, 연산자 완벽 정리
  3. 조건문과 반복문 마스터하기
  4. 함수와 람다 완벽 가이드
  5. 리스트, 튜플, 딕셔너리 정복하기
  6. 문자열 처리와 정규표현식
  7. 파일 입출력과 예외 처리

🚀 중급편 (8-12)

  1. 클래스와 객체지향 프로그래밍
  2. 모듈과 패키지 관리
  3. 데코레이터와 제너레이터
  4. 비동기 프로그래밍 (async/await)
  5. 데이터베이스 연동하기

💼 고급편 (13-16)

  1. 웹 스크래핑과 API 활용
  2. 테스트와 디버깅 전략
  3. 성능 최적화 기법
  4. 멀티프로세싱과 병렬 처리

이전글: Python 소개와 개발 환경 설정 완벽 가이드 ⬅️ 현재글: 변수, 자료형, 연산자 완벽 정리 다음글: 조건문과 반복문 마스터하기 ➡️

이번 포스트에서는 Python의 기초가 되는 변수, 자료형, 연산자에 대해 알아보았습니다. 다음 포스트에서는 프로그램의 흐름을 제어하는 조건문과 반복문에 대해 자세히 다루겠습니다. Happy Coding! 🐍✨

Programming, Python
python programming tutorial beginner series variables data-types operators
이 기사는 저작권자의 CC BY 4.0 라이센스를 따릅니다.