# 查看不同類型的信息
print(type(42))           # <class 'int'>
print(type(3.14))         # <class 'float'>
print(type(True))         # <class 'bool'>
print(type(None))         # <class 'NoneType'>
print(type("hello"))      # <class 'str'>

# 查看類型的繼承關(guān)系
print(isinstance(42, int))        # True
print(isinstance(True, int))        # True！布爾值是整數(shù)的子類
print(isinstance(3.14, (int, float)))  # True

# 整數(shù)的基本使用
positive_num = 42
negative_num = -17
zero = 0

# Python 3 中的整數(shù)除法總是返回浮點(diǎn)數(shù)
result = 7 / 2    # 3.5

# 如果需要整數(shù)除法，使用 //
floor_division = 7 // 2   # 3

# 大整數(shù)支持（Python 自動(dòng)處理大整數(shù)）
big_number = 123456789012345678901234567890
print(big_number ** 2)  # 不會(huì)溢出！

# 十進(jìn)制（默認(rèn)）
decimal = 42

# 二進(jìn)制（0b 或 0B 前綴）
binary = 0b101010    # 42
print(f"二進(jìn)制 0b101010 = {binary}")

# 八進(jìn)制（0o 或 0O 前綴）
octal = 0o52         # 42
print(f"八進(jìn)制 0o52 = {octal}")

# 十六進(jìn)制（0x 或 0X 前綴）
hexadecimal = 0x2A   # 42
print(f"十六進(jìn)制 0x2A = {hexadecimal}")

# 進(jìn)制轉(zhuǎn)換函數(shù)
print(bin(42))   # 0b101010
print(oct(42))   # 0o52
print(hex(42))   # 0x2a

# 浮點(diǎn)數(shù)的基本使用
pi = 3.14159
e = 2.71828

# 科學(xué)計(jì)數(shù)法
large_number = 1.23e9    # 1.23 × 10^9
small_number = 1.23e-5   # 1.23 × 10^-5

# ?? 浮點(diǎn)數(shù)精度問(wèn)題
print(0.1 + 0.2)         # 0.30000000000000004
print(0.1 + 0.2 == 0.3)  # False！

# 解決方案：使用 round() 或 decimal 模塊
print(round(0.1 + 0.2, 1))  # 0.3

import sys

# 查看浮點(diǎn)數(shù)的限制
print(f"最大浮點(diǎn)數(shù)：{sys.float_info.max}")
print(f"最小正浮點(diǎn)數(shù)：{sys.float_info.min}")
print(f"浮點(diǎn)數(shù)精度：{sys.float_info.dig} 位十進(jìn)制")

# 特殊浮點(diǎn)數(shù)值
positive_inf = float('inf')
negative_inf = float('-inf')
not_a_number = float('nan')

print(positive_inf)     # inf
print(negative_inf)     # -inf
print(not_a_number)     # nan

# 數(shù)學(xué)運(yùn)算
print(1 / positive_inf)  # 0.0
print(positive_inf * 2)  # inf
print(not_a_number == not_a_number)  # False！NaN 不等于自身

# 創(chuàng)建復(fù)數(shù)
z1 = 3 + 4j
z2 = complex(2, -1)  # 2 - 1j

# 復(fù)數(shù)屬性
print(z1.real)   # 實(shí)部：3.0
print(z1.imag)   # 虛部：4.0
print(z1.conjugate())  # 共軛復(fù)數(shù)：(3-4j)

# 復(fù)數(shù)運(yùn)算
print(z1 + z2)   # (5+3j)
print(z1 * z2)   # (10+5j)
print(abs(z1))   # 模：5.0

# 基本運(yùn)算
a, b = 10, 3

print(f"加法：{a} +  = {a + b}")
print(f"減法：{a} -  = {a - b}")
print(f"乘法：{a} *  = {a * b}")
print(f"除法：{a} /  = {a / b}")
print(f"整除：{a} //  = {a // b}")
print(f"取余：{a} %  = {a % b}")
print(f"冪運(yùn)算：{a} **  = {a ** b}")

# 類型轉(zhuǎn)換
print(int(3.7))     # 3，截?cái)嘈?shù)部分
print(float(42))    # 42.0
print(complex(3, 4))  # (3+4j)

# 混合運(yùn)算的自動(dòng)類型轉(zhuǎn)換
print(type(1 + 2.0))     # <class 'float'>
print(type(3.14 + 2))    # <class 'float'>
print(type(2 + 3j))      # <class 'complex'>

import math
import random

# 常用數(shù)學(xué)函數(shù)
print(math.pi)           # 3.141592653589793
print(math.e)            # 2.718281828459045
print(math.sqrt(16))     # 4.0
print(math.log(100, 10)) # 2.0
print(math.sin(math.pi/2))  # 1.0

# 數(shù)值處理
print(abs(-5))           # 5，絕對(duì)值
print(round(3.14159, 2)) # 3.14，四舍五入
print(math.floor(3.7))   # 3，向下取整
print(math.ceil(3.2))    # 4，向上取整

# 隨機(jī)數(shù)
print(random.random())   # 0.0 到 1.0 之間的隨機(jī)數(shù)
print(random.randint(1, 10))  # 1 到 10 之間的隨機(jī)整數(shù)
print(random.choice(['apple', 'banana', 'cherry']))  # 隨機(jī)選擇

# 布爾值的創(chuàng)建
true_value = True
false_value = False

# 布爾值實(shí)際上是整數(shù)的子類
print(isinstance(True, int))   # True
print(True == 1)             # True
print(False == 0)            # True

# 布爾值可以參與數(shù)學(xué)運(yùn)算
print(True + True)           # 2
print(False * 5)             # 0

# 被視為 False 的值（Falsy 值）
falsy_values = [
    False,           # 布爾假
    0,               # 整數(shù)零
    0.0,             # 浮點(diǎn)零
    0j,              # 復(fù)數(shù)零
    "",              # 空字符串
    [],              # 空列表
    {},              # 空字典
    set(),           # 空集合
    None             # None 對(duì)象
]

# 測(cè)試真值
for value in falsy_values:
    print(f"{repr(value)} -> {bool(value)}")

# 其他所有值都被視為 True
print(bool("Hello"))     # True
print(bool([1, 2, 3]))   # True
print(bool(42))          # True

# and 運(yùn)算符（短路運(yùn)算）
result1 = True and False   # False
result2 = True and True    # True
result3 = False and True   # False

# or 運(yùn)算符（短路運(yùn)算）
result4 = True or False    # True
result5 = False or True    # True
result6 = False or False   # False

# not 運(yùn)算符
result7 = not True         # False
result8 = not False        # True

# 短路運(yùn)算的特性
print("" or "default")     # "default"
print("hello" and "world") # "world"
print(0 or 42)             # 42
print(None and "never")    # None

# 數(shù)值比較
print(5 > 3)               # True
print(2 == 2)              # True
print(3 != 4)              # True

# 鏈?zhǔn)奖容^（Python 特有）
age = 25
print(18 <= age < 65)      # True
print(age == 25 > 20)      # True

# 對(duì)象身份比較
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)              # True，值相等
print(a is b)              # False，不是同一個(gè)對(duì)象
print(a is c)              # True，是同一個(gè)對(duì)象
print(id(a), id(b), id(c)) # 查看內(nèi)存地址

# 默認(rèn)值設(shè)置
default_name = "Guest"
user_name = "" or default_name  # 如果用戶名為空，使用默認(rèn)值
print(user_name)                # "Guest"

# 安全訪問(wèn)嵌套數(shù)據(jù)
data = {"user": {"name": "張三"}}
user_name = data and data.get("user") and data["user"].get("name")
print(user_name)                # "張三"

# 列表過(guò)濾
numbers = [1, 0, 2, 0, 3, 0, 4]
non_zero = [n for n in numbers if n]
print(non_zero)                 # [1, 2, 3, 4]

# None 是 NoneType 的唯一實(shí)例
none_value = None
print(type(none_value))        # <class 'NoneType'>
print(id(None))                # 固定內(nèi)存地址

# None 是 Falsy 值
print(bool(None))              # False
print(None is False)           # False！None 不是 False
print(None == False)           # False

# None 常用于函數(shù)默認(rèn)參數(shù)
def greet(name=None):
    if name is None:
        name = "World"
    return f"Hello, {name}!"

print(greet())                  # "Hello, World!"
print(greet("Alice"))           # "Hello, Alice!"

# 1. 函數(shù)沒(méi)有返回值時(shí)的默認(rèn)返回值
def do_something():
    pass

result = do_something()
print(result is None)          # True

# 2. 表示缺失的值或初始狀態(tài)
class User:
    def __init__(self, name, age=None):
        self.name = name
        self.age = age
        self._verified_at = None  # 初始狀態(tài)
    
    def verify(self):
        self._verified_at = "2024-01-01"
    
    def is_verified(self):
        return self._verified_at is not None

# 3. 字典中缺失的鍵
data = {"name": "張三"}
email = data.get("email")       # 返回 None，而不是拋出異常
print(email is None)           # True

# 4. 默認(rèn)參數(shù)值（避免可變默認(rèn)參數(shù)的問(wèn)題）
def add_item(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

list1 = add_item("apple")
list2 = add_item("banana")
print(list1)                   # ["apple"] - 獨(dú)立的列表
print(list2)                   # ["banana"] - 獨(dú)立的列表

# ?? 陷阱：使用 == 比較 None
value = None
print(value == None)         # True，但不推薦
print(value is None)         # True，推薦方式

# ?? 陷阱：在布爾上下文中混淆 None 和 False
def check_value(x):
    if x:                    # 這會(huì)過(guò)濾掉 None、0、"" 等值
        print(f"Value {x} is truthy")
    elif x is None:          # 明確檢查 None
        print("Value is None")
    else:
        print(f"Value {x} is falsy but not None")

check_value(None)            # "Value is None"
check_value(0)               # "Value 0 is falsy but not None"

# ? 最佳實(shí)踐：明確檢查 None
def process_data(data):
    if data is None:
        raise ValueError("數(shù)據(jù)不能為 None")
    # 繼續(xù)處理數(shù)據(jù)...

# 基本類型檢查
def analyze_value(value):
    print(f"值: {repr(value)}")
    print(f"類型: {type(value).__name__}")
    print(f"布爾值: {bool(value)}")
    print(f"是否為數(shù)字: {isinstance(value, (int, float, complex))}")
    print(f"是否為 None: {value is None}")
    print("-" * 30)

# 測(cè)試不同類型
test_values = [42, 3.14, 2+3j, True, "hello", [], {}, None]
for value in test_values:
    analyze_value(value)

# 轉(zhuǎn)換為整數(shù)
print(int(3.7))                # 3，截?cái)嘈?shù)
print(int("42"))               # 42
print(int(True))               # 1
print(int(False))              # 0
print(int(3.5))                # 3，不是四舍五入！

# 轉(zhuǎn)換為浮點(diǎn)數(shù)
print(float(42))               # 42.0
print(float("3.14"))           # 3.14
print(float(True))             # 1.0

# 轉(zhuǎn)換為布爾值
print(bool(1))                 # True
print(bool(0))                 # False
print(bool("hello"))           # True
print(bool(""))                # False

# 轉(zhuǎn)換為字符串
print(str(42))                 # "42"
print(str(3.14))               # "3.14"
print(str(True))               # "True"
print(str(None))               # "None"

def safe_int_convert(value, default=None):
    """安全地將值轉(zhuǎn)換為整數(shù)"""
    try:
        return int(value)
    except (ValueError, TypeError):
        return default

def safe_float_convert(value, default=None):
    """安全地將值轉(zhuǎn)換為浮點(diǎn)數(shù)"""
    try:
        return float(value)
    except (ValueError, TypeError):
        return default

# 使用示例
print(safe_int_convert("42"))      # 42
print(safe_int_convert("abc"))     # None
print(safe_int_convert("3.14"))    # 3（注意：會(huì)截?cái)嘈?shù)）
print(safe_int_convert(None, 0))   # 0（使用默認(rèn)值）

from typing import Union, Optional

# 基本類型注解
def add_numbers(a: int, b: int) -> int:
    return a + b

def divide(x: float, y: float) -> float:
    if y == 0:
        raise ValueError("除數(shù)不能為0")
    return x / y

# 可選類型（可能為 None）
def greet_user(name: Optional[str] = None) -> str:
    if name is None:
        name = "Guest"
    return f"Hello, {name}!"

# 聯(lián)合類型（多種類型）
def process_value(value: Union[int, float, str]) -> str:
    return f"處理后的值: {value}"

# 使用示例
print(add_numbers(1, 2))                    # 3
print(divide(10.0, 3.0))                    # 3.333...
print(greet_user())                         # "Hello, Guest!"
print(process_value(42))                    # "處理后的值: 42"

import time

# 比較不同數(shù)字類型的運(yùn)算性能
def benchmark_operation(operation, iterations=1000000):
    start_time = time.time()
    for _ in range(iterations):
        operation()
    end_time = time.time()
    return end_time - start_time

# 測(cè)試整數(shù)運(yùn)算
int_time = benchmark_operation(lambda: 42 + 24)
print(f"整數(shù)加法耗時(shí): {int_time:.4f}秒")

# 測(cè)試浮點(diǎn)數(shù)運(yùn)算
float_time = benchmark_operation(lambda: 3.14 + 2.71)
print(f"浮點(diǎn)數(shù)加法耗時(shí): {float_time:.4f}秒")

# 測(cè)試布爾值運(yùn)算
bool_time = benchmark_operation(lambda: True and False)
print(f"布爾運(yùn)算耗時(shí): {bool_time:.4f}秒")

import sys

# 查看不同對(duì)象的內(nèi)存占用
print(f"小整數(shù)內(nèi)存占用: {sys.getsizeof(1)} 字節(jié)")
print(f"大整數(shù)內(nèi)存占用: {sys.getsizeof(2**100)} 字節(jié)")
print(f"浮點(diǎn)數(shù)內(nèi)存占用: {sys.getsizeof(3.14)} 字節(jié)")
print(f"布爾值內(nèi)存占用: {sys.getsizeof(True)} 字節(jié)")
print(f"None 內(nèi)存占用: {sys.getsizeof(None)} 字節(jié)")

# Python 的小整數(shù)緩存（-5 到 256）
a = 256
b = 256
print(a is b)  # True，同一個(gè)對(duì)象

c = 257
d = 257
print(c is d)  # False，不同對(duì)象（但在某些實(shí)現(xiàn)中可能相同）

# ?? 問(wèn)題：浮點(diǎn)數(shù)比較
x = 0.1 + 0.2
print(x == 0.3)  # False！

# ? 解決方案：使用 math.isclose 或自定義容差
import math
print(math.isclose(x, 0.3))  # True

# 或者使用自定義容差
def float_equal(a, b, tolerance=1e-9):
    return abs(a - b) < tolerance

print(float_equal(x, 0.3))   # True

# ?? 問(wèn)題：Python 2 的除法行為
# 在 Python 2 中：3 / 2 = 1（整數(shù)除法）
# 在 Python 3 中：3 / 2 = 1.5（浮點(diǎn)除法）

# ? 解決方案：明確使用 // 進(jìn)行整除
result = 3 // 2  # 1，明確的行為
print(result)

# ?? 問(wèn)題：使用 None 作為字典值時(shí)的混淆
data = {"count": None}
if data.get("count"):  # 這會(huì)為 None，但不會(huì)區(qū)分 0 和 None
    print("有計(jì)數(shù)值")
else:
    print("無(wú)計(jì)數(shù)值或計(jì)數(shù)為0")

# ? 解決方案：明確檢查 None
count = data.get("count")
if count is None:
    print("計(jì)數(shù)未設(shè)置")
elif count == 0:
    print("計(jì)數(shù)為0")
else:
    print(f"計(jì)數(shù)為{count}")

def number_statistics(*numbers):
    """分析一組數(shù)字的統(tǒng)計(jì)信息"""
    if not numbers:
        return None
    
    stats = {
        'count': len(numbers),
        'sum': sum(numbers),
        'average': sum(numbers) / len(numbers),
        'min': min(numbers),
        'max': max(numbers),
        'range': max(numbers) - min(numbers)
    }
    
    # 計(jì)算中位數(shù)
    sorted_nums = sorted(numbers)
    n = len(sorted_nums)
    if n % 2 == 0:
        stats['median'] = (sorted_nums[n//2-1] + sorted_nums[n//2]) / 2
    else:
        stats['median'] = sorted_nums[n//2]
    
    return stats

# 測(cè)試
result = number_statistics(1, 2, 3, 4, 5, 6)
print("數(shù)字統(tǒng)計(jì):", result)

class SafeConverter:
    """安全的類型轉(zhuǎn)換工具類"""
    
    @staticmethod
    def to_int(value, default=0, min_val=None, max_val=None):
        """安全轉(zhuǎn)換為整數(shù)"""
        try:
            result = int(float(value))  # 先轉(zhuǎn) float 再轉(zhuǎn) int，避免 "3.14" 報(bào)錯(cuò)
            if min_val is not None and result < min_val:
                return min_val
            if max_val is not None and result > max_val:
                return max_val
            return result
        except (ValueError, TypeError):
            return default
    
    @staticmethod
    def to_float(value, default=0.0, min_val=None, max_val=None):
        """安全轉(zhuǎn)換為浮點(diǎn)數(shù)"""
        try:
            result = float(value)
            if min_val is not None and result < min_val:
                return min_val
            if max_val is not None and result > max_val:
                return max_val
            return result
        except (ValueError, TypeError):
            return default
    
    @staticmethod
    def to_bool(value, strict=False):
        """安全轉(zhuǎn)換為布爾值"""
        if strict:
            # 嚴(yán)格模式：只接受 True 和 False
            return value is True
        
        # 寬松模式：使用 Python 的真值測(cè)試
        return bool(value)

# 使用示例
converter = SafeConverter()
print(converter.to_int("42"))           # 42
print(converter.to_int("3.14"))         # 3
print(converter.to_int("invalid", 99)) # 99
print(converter.to_float("3.14159"))   # 3.14159
print(converter.to_bool("hello"))       # True
print(converter.to_bool("", strict=True))  # False