# 序列類型長(zhǎng)度計(jì)算
string = "Hello World"
print(f"字符串長(zhǎng)度: {len(string)}")  # 輸出: 11

list_data = [1, 2, 3, 4, 5]
print(f"列表長(zhǎng)度: {len(list_data)}")  # 輸出: 5

tuple_data = (10, 20, 30)
print(f"元組長(zhǎng)度: {len(tuple_data)}")  # 輸出: 3

# 集合類型長(zhǎng)度計(jì)算
set_data = {1, 2, 3, 2, 1}  # 去重后
print(f"集合長(zhǎng)度: {len(set_data)}")  # 輸出: 3

dict_data = {'a': 1, 'b': 2, 'c': 3}
print(f"字典長(zhǎng)度: {len(dict_data)}")  # 輸出: 3

# 范圍對(duì)象
range_obj = range(1, 10)
print(f"范圍對(duì)象長(zhǎng)度: {len(range_obj)}")  # 輸出: 9

class DataValidator:
    @staticmethod
    def validate_input_length(data, min_len=0, max_len=None):
        """驗(yàn)證輸入數(shù)據(jù)長(zhǎng)度"""
        data_len = len(data)
        
        if data_len < min_len:
            raise ValueError(f"數(shù)據(jù)長(zhǎng)度不能小于{min_len}")
        
        if max_len is not None and data_len > max_len:
            raise ValueError(f"數(shù)據(jù)長(zhǎng)度不能超過(guò){max_len}")
        
        return True
    
    @staticmethod
    def chunk_data(data, chunk_size):
        """將數(shù)據(jù)分塊"""
        if len(data) == 0:
            return []
        
        chunks = []
        for i in range(0, len(data), chunk_size):
            chunk = data[i:i + chunk_size]
            chunks.append(chunk)
        return chunks
    
    @staticmethod
    def compare_structures(struct1, struct2):
        """比較兩個(gè)數(shù)據(jù)結(jié)構(gòu)的長(zhǎng)度"""
        len1 = len(struct1) if hasattr(struct1, '__len__') else 'N/A'
        len2 = len(struct2) if hasattr(struct2, '__len__') else 'N/A'
        
        return {
            'structure1_length': len1,
            'structure2_length': len2,
            'equal_length': len1 == len2 if isinstance(len1, int) and isinstance(len2, int) else False
        }

# 使用示例
validator = DataValidator()

# 長(zhǎng)度驗(yàn)證
try:
    validator.validate_input_length("hello", min_len=3, max_len=10)
    print("長(zhǎng)度驗(yàn)證通過(guò)")
except ValueError as e:
    print(f"驗(yàn)證失敗: {e}")

# 數(shù)據(jù)分塊
data = list(range(20))
chunks = validator.chunk_data(data, chunk_size=5)
print(f"數(shù)據(jù)分塊: {chunks}")

# 結(jié)構(gòu)比較
list1 = [1, 2, 3]
dict1 = {'a': 1, 'b': 2}
result = validator.compare_structures(list1, dict1)
print(f"結(jié)構(gòu)比較: {result}")

# 從字符串創(chuàng)建（字符列表）
chars = list("hello")
print(f"字符串轉(zhuǎn)列表: {chars}")  # 輸出: ['h', 'e', 'l', 'l', 'o']

# 從元組創(chuàng)建
tuple_data = (1, 2, 3)
list_from_tuple = list(tuple_data)
print(f"元組轉(zhuǎn)列表: {list_from_tuple}")  # 輸出: [1, 2, 3]

# 從范圍對(duì)象創(chuàng)建
numbers = list(range(5))
print(f"范圍轉(zhuǎn)列表: {numbers}")  # 輸出: [0, 1, 2, 3, 4]

# 從集合創(chuàng)建（順序可能不同）
set_data = {3, 1, 4, 2}
list_from_set = list(set_data)
print(f"集合轉(zhuǎn)列表: {list_from_set}")  # 輸出: [1, 2, 3, 4]（順序可能變化）

# 空列表
empty_list = list()
print(f"空列表: {empty_list}")  # 輸出: []

# 從字典創(chuàng)建（只獲取鍵）
dict_data = {'a': 1, 'b': 2}
keys_list = list(dict_data)
print(f"字典鍵列表: {keys_list}")  # 輸出: ['a', 'b']

class ListProcessor:
    @staticmethod
    def flatten_nested_lists(nested_list):
        """展平嵌套列表"""
        result = []
        for item in nested_list:
            if isinstance(item, list):
                result.extend(ListProcessor.flatten_nested_lists(item))
            else:
                result.append(item)
        return result
    
    @staticmethod
    def remove_duplicates_preserve_order(sequence):
        """去重并保持順序"""
        seen = set()
        return [x for x in sequence if not (x in seen or seen.add(x))]
    
    @staticmethod
    def batch_process(iterable, batch_size):
        """批量處理數(shù)據(jù)"""
        items = list(iterable)  # 確保是可迭代的
        batches = []
        for i in range(0, len(items), batch_size):
            batch = items[i:i + batch_size]
            batches.append(batch)
        return batches
    
    @staticmethod
    def create_index_map(data):
        """創(chuàng)建值到索引的映射"""
        index_map = {}
        for idx, value in enumerate(list(data)):
            if value not in index_map:
                index_map[value] = []
            index_map[value].append(idx)
        return index_map

# 使用示例
processor = ListProcessor()

# 展平嵌套列表
nested = [[1, 2], [3, [4, 5]], 6]
flat = processor.flatten_nested_lists(nested)
print(f"展平結(jié)果: {flat}")

# 去重保持順序
data_with_duplicates = [3, 1, 2, 1, 4, 2, 5]
unique_ordered = processor.remove_duplicates_preserve_order(data_with_duplicates)
print(f"去重結(jié)果: {unique_ordered}")

# 批量處理
large_data = range(100)
batches = processor.batch_process(large_data, batch_size=10)
print(f"批次數(shù)量: {len(batches)}")
print(f"第一個(gè)批次: {batches[0]}")

# 索引映射
text = "hello"
index_map = processor.create_index_map(text)
print(f"字符索引映射: {index_map}")

def demonstrate_locals():
    """演示locals()函數(shù)的基本用法"""
    x = 10
    y = "hello"
    z = [1, 2, 3]
    
    # 獲取局部變量字典
    local_vars = locals()
    print("局部變量:")
    for var_name, var_value in local_vars.items():
        print(f"  {var_name}: {var_value}")
    
    # 修改局部變量
    local_vars['x'] = 100
    local_vars['new_var'] = "動(dòng)態(tài)添加"
    
    print(f"修改后x的值: {x}")  # 輸出: 100
    print(f"新變量: {new_var}")  # 輸出: 動(dòng)態(tài)添加
    
    return local_vars

# 函數(shù)調(diào)用
local_dict = demonstrate_locals()
print(f"返回的局部字典: {local_dict}")

# 模塊級(jí)別的locals()（與globals()相同）
module_locals = locals()
module_globals = globals()
print(f"模塊級(jí)別locals和globals相同: {module_locals is module_globals}")  # 輸出: True

class DebugHelper:
    def __init__(self):
        self.snapshots = {}
    
    def take_snapshot(self, snapshot_name):
        """拍攝當(dāng)前局部狀態(tài)快照"""
        current_locals = locals().copy()
        # 移除self參數(shù)
        current_locals.pop('self', None)
        self.snapshots[snapshot_name] = current_locals
        return current_locals
    
    def compare_snapshots(self, snap1_name, snap2_name):
        """比較兩個(gè)快照的差異"""
        snap1 = self.snapshots.get(snap1_name, {})
        snap2 = self.snapshots.get(snap2_name, {})
        
        added = {k: v for k, v in snap2.items() if k not in snap1}
        removed = {k: v for k, v in snap1.items() if k not in snap2}
        changed = {}
        
        for k in set(snap1.keys()) & set(snap2.keys()):
            if snap1[k] != snap2[k]:
                changed[k] = (snap1[k], snap2[k])
        
        return {'added': added, 'removed': removed, 'changed': changed}
    
    def dynamic_variable_management(self, **kwargs):
        """動(dòng)態(tài)變量管理"""
        current_locals = locals()
        print("初始局部變量:", current_locals)
        
        # 動(dòng)態(tài)添加變量
        for key, value in kwargs.items():
            locals()[key] = value
            print(f"已添加變量: {key} = {value}")
        
        # 注意：在函數(shù)中修改locals()可能不會(huì)影響實(shí)際變量
        # 這里主要用于演示

def test_function():
    """測(cè)試函數(shù)用于演示locals()行為"""
    debugger = DebugHelper()
    
    # 第一次快照
    a = 10
    b = 20
    debugger.take_snapshot("第一次")
    
    # 第二次快照（變量變化）
    a = 100
    c = "新變量"
    debugger.take_snapshot("第二次")
    
    # 比較差異
    differences = debugger.compare_snapshots("第一次", "第二次")
    print("變量變化:", differences)
    
    # 動(dòng)態(tài)管理
    debugger.dynamic_variable_management(x=1, y=2, z=3)

# 使用示例
test_function()

# 在推導(dǎo)式中的使用（Python 3.12+）
def demonstrate_comprehension_locals():
    """演示推導(dǎo)式中的locals()行為"""
    external_var = "外部變量"
    
    # 列表推導(dǎo)式
    result = [locals().get('external_var') for _ in range(3)]
    print(f"推導(dǎo)式中的locals(): {result}")
    
    # 注意：在推導(dǎo)式中，locals()的行為可能因Python版本而異

demonstrate_comprehension_locals()

class SafeVariableManager:
    def __init__(self):
        self._protected_vars = {'self', '_protected_vars'}
    
    def get_public_variables(self):
        """獲取公有變量（不包含保護(hù)變量）"""
        current_locals = locals()
        public_vars = {}
        
        for var_name, var_value in current_locals.items():
            if not var_name.startswith('_') or var_name in self._protected_vars:
                public_vars[var_name] = var_value
        
        return public_vars
    
    def cleanup_temporary_vars(self):
        """清理臨時(shí)變量"""
        current_locals = locals()
        vars_to_remove = []
        
        for var_name in current_locals:
            if var_name.startswith('_temp_'):
                vars_to_remove.append(var_name)
        
        # 注意：在實(shí)際函數(shù)中，不能直接通過(guò)locals()刪除變量
        # 這里返回需要?jiǎng)h除的變量名列表
        return vars_to_remove
    
    def create_variable_report(self):
        """創(chuàng)建變量狀態(tài)報(bào)告"""
        current_locals = locals()
        report = {
            'total_variables': len(current_locals),
            'variable_types': {},
            'variable_details': []
        }
        
        for var_name, var_value in current_locals.items():
            var_type = type(var_value).__name__
            if var_type not in report['variable_types']:
                report['variable_types'][var_type] = 0
            report['variable_types'][var_type] += 1
            
            report['variable_details'].append({
                'name': var_name,
                'type': var_type,
                'value_length': len(str(var_value)) if hasattr(var_value, '__len__') else 'N/A',
                'id': id(var_value)
            })
        
        return report

# 使用示例
def demonstrate_safe_management():
    manager = SafeVariableManager()
    
    # 添加一些測(cè)試變量
    normal_var = "正常變量"
    _temp_data = "臨時(shí)數(shù)據(jù)"
    _protected_var = "保護(hù)變量"
    
    public_vars = manager.get_public_variables()
    print("公有變量:", public_vars)
    
    report = manager.create_variable_report()
    print("變量報(bào)告:", report)
    
    temp_vars = manager.cleanup_temporary_vars()
    print("需要清理的臨時(shí)變量:", temp_vars)

demonstrate_safe_management()

def advanced_data_analysis(data_sequence):
    """高級(jí)數(shù)據(jù)分析組合使用多個(gè)函數(shù)"""
    # 使用list()確保數(shù)據(jù)是可迭代的
    data_list = list(data_sequence)
    
    # 使用len()獲取基本信息
    data_length = len(data_list)
    print(f"數(shù)據(jù)長(zhǎng)度: {data_length}")
    
    # 使用locals()記錄分析狀態(tài)
    analysis_state = locals().copy()
    
    if data_length > 0:
        # 基本統(tǒng)計(jì)
        unique_elements = list(set(data_list))
        unique_count = len(unique_elements)
        
        analysis_state.update({
            'unique_count': unique_count,
            'duplicate_count': data_length - unique_count,
            'unique_elements': unique_elements
        })
    
    # 動(dòng)態(tài)添加分析結(jié)果
    if 'unique_count' in analysis_state:
        duplication_rate = analysis_state['duplicate_count'] / data_length
        analysis_state['duplication_rate'] = round(duplication_rate, 2)
    
    return analysis_state

# 使用示例
test_data = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
result = advanced_data_analysis(test_data)

print("數(shù)據(jù)分析結(jié)果:")
for key, value in result.items():
    if not key.startswith('_') and key != 'analysis_state':
        print(f"  {key}: {value}")

def dynamic_function_builder():
    """動(dòng)態(tài)函數(shù)構(gòu)建器"""
    # 獲取當(dāng)前局部變量
    current_locals = locals()
    
    # 動(dòng)態(tài)創(chuàng)建函數(shù)
    function_definitions = [
        ('add', lambda x, y: x + y),
        ('multiply', lambda x, y: x * y),
        ('power', lambda x, y: x ** y)
    ]
    
    for func_name, func in function_definitions:
        current_locals[func_name] = func
        print(f"已創(chuàng)建函數(shù): {func_name}")
    
    # 測(cè)試動(dòng)態(tài)創(chuàng)建的函數(shù)
    if 'add' in current_locals:
        result = current_locals['add'](5, 3)
        print(f"動(dòng)態(tài)函數(shù)測(cè)試: 5 + 3 = {result}")

dynamic_function_builder()