7. 불리언과 조건

# boolean_basics.py
# Boolean 변수 만들기
is_sunny = True
is_raining = False
 
print(is_sunny)    # Output: True
print(is_raining)  # Output: False
 
print(type(True))   # Output: <class 'bool'>
print(type(False))  # Output: <class 'bool'>

# boolean_variables.py
# 상태를 추적하기 위해 Boolean 변수 사용하기
is_logged_in = False
has_permission = True
is_valid_email = True
 
print("User logged in:", is_logged_in)        # Output: User logged in: False
print("Has permission:", has_permission)      # Output: Has permission: True
print("Valid email:", is_valid_email)         # Output: Valid email: True
 
# Boolean 변수는 다시 할당할 수 있습니다
is_logged_in = True
print("User logged in:", is_logged_in)        # Output: User logged in: True

# comparison_operators.py
# 숫자 비교하기
x = 10
y = 20
 
print(x == y)   # Output: False
print(x != y)   # Output: True
print(x < y)    # Output: True
print(x > y)    # Output: False
print(x <= y)   # Output: True
print(x >= y)   # Output: False
 
# 같은 값을 비교할 때
a = 15
b = 15
 
print(a == b)   # Output: True
print(a <= b)   # Output: True
print(a >= b)   # Output: True

# comparing_types.py
# 부동소수점 숫자 비교하기
temperature = 23.5
print(temperature > 20.0)   # Output: True
print(temperature == 23.5)  # Output: True
 
# 문자열 비교하기 (알파벳/사전식 순서)
name1 = "Alice"
name2 = "Bob"
print(name1 < name2)   # Output: True
print(name1 == name2)  # Output: False
 
# 문자열 비교는 대소문자를 구분합니다
word1 = "Python"
word2 = "python"
print(word1 == word2)  # Output: False
 
# len()을 사용해 문자열 길이 비교하기
print(len(name1) == len(name2))  # Output: False

# storing_comparisons.py
# 나중에 사용하기 위해 비교 결과를 저장하기
age = 25
is_adult = age >= 18
is_senior = age >= 65
is_teenager = 13 <= age <= 19  # 곧 체인 비교에 대해 배웁니다
 
print("Is adult:", is_adult)        # Output: Is adult: True
print("Is senior:", is_senior)      # Output: Is senior: False
print("Is teenager:", is_teenager)  # Output: Is teenager: False
 
# 저장된 비교 결과를 계산이나 다른 표현식에 사용하기
price = 100
discount_eligible = price > 50
print("Discount eligible:", discount_eligible)  # Output: Discount eligible: True

# bool_function.py
# 숫자를 Boolean으로 변환하기
print(bool(1))       # Output: True
print(bool(42))      # Output: True
print(bool(-5))      # Output: True
print(bool(0))       # Output: False
print(bool(0.0))     # Output: False
 
# 문자열을 Boolean으로 변환하기
print(bool("Hello"))     # Output: True
print(bool("False"))     # Output: True
print(bool(""))          # Output: False
 
# None을 Boolean으로 변환하기
print(bool(None))    # Output: False

# falsy_values.py
# 이 값들은 모두 falsy입니다
print("Boolean False:", bool(False))     # Output: Boolean False: False
print("None:", bool(None))               # Output: None: False
print("Zero integer:", bool(0))          # Output: Zero integer: False
print("Zero float:", bool(0.0))          # Output: Zero float: False
print("Empty string:", bool(""))         # Output: Empty string: False
print("Empty list:", bool([]))           # Output: Empty list: False
print("Empty tuple:", bool(()))          # Output: Empty tuple: False
print("Empty dict:", bool({}))           # Output: Empty dict: False

# truthy_values.py
# 이 값들은 모두 truthy입니다
print("Boolean True:", bool(True))           # Output: Boolean True: True
print("Positive integer:", bool(42))         # Output: Positive integer: True
print("Negative integer:", bool(-1))         # Output: Negative integer: True
print("Non-zero float:", bool(3.14))         # Output: Non-zero float: True
print("Non-empty string:", bool("Hello"))    # Output: Non-empty string: True
print("String 'False':", bool("False"))      # Output: String 'False': True
print("String '0':", bool("0"))              # Output: String '0': True
print("Non-empty list:", bool([1, 2, 3]))    # Output: Non-empty list: True
print("Non-empty tuple:", bool((1,)))        # Output: Non-empty tuple: True
print("Non-empty dict:", bool({"a": 1}))     # Output: Non-empty dict: True

# truthiness_preview.py
# bool()로 진릿값을 보여 주기
# (8장에서는 이를 직접 if 문에서 사용할 것입니다)
 
# 문자열에 내용이 있는지 확인하기
user_input = ""
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: False
 
user_input = "Alice"
has_content = bool(user_input)
print("User entered something:", has_content)  # Output: User entered something: True
 
# 리스트에 항목이 있는지 확인하기
shopping_list = []
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: False
 
shopping_list = ["milk", "eggs", "bread"]
has_items = bool(shopping_list)
print("Shopping list has items:", has_items)  # Output: Shopping list has items: True
 
# 값이 존재하는지(None이 아닌지) 확인하기
optional_value = None
value_exists = bool(optional_value)
print("Value exists:", value_exists)  # Output: Value exists: False

# chained_comparisons.py
# 값이 어떤 범위에 속하는지 확인하기
x = 15
 
# 수학적인 방식(체인 비교)
in_range = 10 < x < 20
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# 이는 두 개의 비교를 결합한 것과 같습니다
# ('and'에 대해서는 9장에서 배웁니다)
in_range = (10 < x) and (x < 20)
print("x is between 10 and 20:", in_range)  # Output: x is between 10 and 20: True
 
# 범위 밖의 값으로 테스트하기
y = 25
in_range = 10 < y < 20
print("y is between 10 and 20:", in_range)  # Output: y is between 10 and 20: False
 
# 경계값으로 테스트하기
z = 10
in_range = 10 < z < 20
print("z is between 10 and 20:", in_range)  # Output: z is between 10 and 20: False
 
# <= 와 >= 를 사용해 경계를 포함하기
in_range_inclusive = 10 <= z <= 20
print("z is between 10 and 20 (inclusive):", in_range_inclusive)  # Output: z is between 10 and 20 (inclusive): True

# multiple_chains.py
# 여러 비교를 체인으로 연결하기
a = 5
b = 10
c = 15
d = 20
 
# 값들이 오름차순인지 확인하기
ascending = a < b < c < d
print("Values are in ascending order:", ascending)  # Output: Values are in ascending order: True

# assignment_vs_comparison_pitfall.py
x = 10
 
# 이것은 비교가 아니라 대입입니다
# x에 20을 대입하지, x를 20과 비교하지 않습니다
# x = 20  # 이렇게 하면 x는 20으로 바뀝니다
 
# 이것이 비교입니다
result = (x == 20)  # x가 20과 같은지 확인합니다
print("x equals 20:", result)  # Output: x equals 20: False
print("x is now:", x)  # Output: x is now: 10
 
# 8장에서 배우겠지만, 조건에서 = 를 사용하면 에러가 발생합니다
# if x = 20:  # SyntaxError: invalid syntax
#     print("This won't work")
 
# 올바른 비교
# 8장에서는 이렇게 쓸 것입니다: if x == 10:
result = x == 10
print("x equals 10:", result)  # Output: x equals 10: True

# floating_point_comparison.py
# 부동소수점 연산은 정밀도 문제를 가질 수 있습니다
result = 0.1 + 0.2
print("0.1 + 0.2 =", result)  # Output: 0.1 + 0.2 = 0.30000000000000004
 
# 직접 비교는 기대와 다르게 동작할 수 있습니다
is_equal = (result == 0.3)
print("Result equals 0.3:", is_equal)  # Output: Result equals 0.3: False
 
# 실제 값은 0.3과 매우 가깝지만 정확히 0.3은 아닙니다
print("Difference:", result - 0.3)  # Output: Difference: 5.551115123125783e-17
 
# 부동소수점 비교에는 작은 허용 오차를 두는 것이 좋습니다
tolerance = 0.0001
is_close = abs(result - 0.3) < tolerance
print("Result is close to 0.3:", is_close)  # Output: Result is close to 0.3: True
 
# Python 3.5+에는 이를 위한 math.isclose()가 있습니다
# 모듈 임포트에 대해서는 23장에서 배웁니다
# import math
# is_close = math.isclose(result, 0.3)

# booleans_as_integers.py
# Boolean은 정수의 하위 타입입니다
print(isinstance(True, int))   # Output: True
print(isinstance(False, int))  # Output: True
 
# True는 1과 같고, False는 0과 같습니다
print(True == 1)    # Output: True
print(False == 0)   # Output: True
print(True == 2)    # Output: False
 
# Boolean을 산술 연산에 사용할 수 있습니다(하지만 그러지 않는 것이 좋습니다!)
result = True + True
print("True + True =", result)  # Output: True + True = 2
 
result = True + False
print("True + False =", result)  # Output: True + False = 1
 
result = False * 100
print("False * 100 =", result)  # Output: False * 100 = 0
 
# Boolean은 리스트 인덱스로도 사용할 수 있습니다
items = ["first", "second", "third"]
print(items[False])  # Output: first
print(items[True])   # Output: second

# boolean_arithmetic_problems.py
# 혼란스러운 코드의 예
count = 0
has_error = True
has_warning = False
 
# 이렇게 해도 동작은 하지만 혼란스럽습니다
total = count + has_error + has_warning
print("Total:", total)  # Output: Total: 1
 
# 이게 무슨 의미일까요? 명확하지 않습니다!
# 더 나은 접근법: 의도를 명시적으로 드러내기
# if-else 표현식에 대해서는 10장에서 배웁니다.
error_count = 1 if has_error else 0
warning_count = 1 if has_warning else 0
total = count + error_count + warning_count
print("Total:", total)  # Output: Total: 1

# counting_trues.py
# 몇 개의 조건이 True인지 세기
conditions = [True, False, True, True, False]
 
# 이 코드는 의도가 분명하기 때문에 허용할 만합니다
true_count = sum(conditions)
print("Number of true conditions:", true_count)  # Output: Number of true conditions: 3
 
# sum() 이 값들을 모두 더하기 때문입니다
# True는 1로, False는 0으로 처리됩니다
# 따라서 sum([True, False, True, True, False]) = 1 + 0 + 1 + 1 + 0 = 3

# boolean_conversion.py
# Boolean을 정수로 변환하기(불필요한 작업)
value = True
int_value = int(value)
print("Integer value:", int_value)  # Output: Integer value: 1
print("Are they equal?", value == int_value)  # Output: Are they equal? True
 
# 하지만 정수를 Boolean으로 변환하는 것은 유용합니다
number = 0
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: False
 
number = 42
bool_value = bool(number)
print("Boolean value:", bool_value)  # Output: Boolean value: True

# string_membership.py
# 문자열에 특정 부분 문자열이 존재하는지 확인하기
text = "Python programming is fun"
 
# 'in' 을 사용해 부분 문자열 확인하기
has_python = "Python" in text
print("Contains 'Python':", has_python)  # Output: Contains 'Python': True
 
has_java = "Java" in text
print("Contains 'Java':", has_java)  # Output: Contains 'Java': False
 
# 대소문자를 구분하는 매칭
has_python_lower = "python" in text
print("Contains 'python':", has_python_lower)  # Output: Contains 'python': False
 
# 'not in' 을 사용해 포함되지 않았는지 확인하기
has_no_java = "Java" not in text
print("Does not contain 'Java':", has_no_java)  # Output: Does not contain 'Java': True

# case_insensitive_search.py
text = "Python Programming"
 
# 대소문자를 구분하는 검색(매치되지 않음)
result = "python" in text
print("Contains 'python':", result)  # Output: Contains 'python': False
 
# 대소문자를 구분하지 않는 검색(둘 다 소문자로 변환)
result = "python" in text.lower()
print("Contains 'python' (case-insensitive):", result)  # Output: Contains 'python' (case-insensitive): True
 
# 원본 문자열은 바뀌지 않습니다
print("Original text:", text)  # Output: Original text: Python Programming

# list_membership.py
# 리스트에 특정 값이 존재하는지 확인하기
numbers = [1, 2, 3, 4, 5]
 
has_three = 3 in numbers
print("List contains 3:", has_three)  # Output: List contains 3: True
 
has_ten = 10 in numbers
print("List contains 10:", has_ten)  # Output: List contains 10: False
 
# 'not in' 사용하기
missing_ten = 10 not in numbers
print("List does not contain 10:", missing_ten)  # Output: List does not contain 10: True
 
# 리스트 안의 문자열에도 동작합니다
fruits = ["apple", "banana", "cherry"]
has_banana = "banana" in fruits
print("List contains 'banana':", has_banana)  # Output: List contains 'banana': True
 
has_grape = "grape" in fruits
print("List contains 'grape':", has_grape)  # Output: List contains 'grape': False

# range_membership.py
# 숫자가 range 안에 있는지 확인하기
age = 25
 
# range와 함께 'in' 사용하기
is_adult = age in range(18, 100)
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 하지만 숫자 범위에는 비교 연산자가 더 효율적입니다
is_adult = 18 <= age < 100
print("Is adult:", is_adult)  # Output: Is adult: True
 
# 'in' 과 range는 특정한 수열에 대해 유용합니다
valid_ages = range(18, 66)  # 근로 가능 연령대
is_working_age = age in valid_ages
print("Is working age:", is_working_age)  # Output: Is working age: True

# not_in_operator.py
# 더 읽기 좋은 논리를 위해 'not in' 사용하기
allowed_users = ["alice", "bob", "charlie"]
current_user = "eve"
 
# 'not in' 을 사용하면 더 읽기 쉽습니다
is_unauthorized = current_user not in allowed_users
print("User is unauthorized:", is_unauthorized)  # Output: User is unauthorized: True
 
# 필요한 필드가 빠졌는지 확인하기
provided_fields = ["name", "email"]
 
# 빠진 필드 찾기
missing_name = "name" not in provided_fields
missing_email = "email" not in provided_fields
missing_password = "password" not in provided_fields
 
print("Missing name:", missing_name)      # Output: Missing name: False
print("Missing email:", missing_email)    # Output: Missing email: False
print("Missing password:", missing_password)  # Output: Missing password: True