Python零基础入门实战教程：从Hello World到文件处理-3

第3章：数据的容器——变量与基本数据类型

章节介绍

当你开始学习任何编程语言，首先要打交道的，就是“数据”。我们说话、计算、记录信息，本质上都是在处理数据。在程序的世界里，我们需要一个地方来存放这些数据，就像生活中用水杯装水、用书包放书一样。

在Python中，存放数据的“容器”叫做 变量。你可以把变量想象成一个贴了名字标签的盒子。比如，你有一个叫做 my_age 的盒子，里面放着数字 25。这个名字 my_age 就是变量名，数字 25 就是存放在里面的数据。创建这个容器的过程非常简单：

my_age = 25

但是，数据并非只有数字一种。一句话、一个判断对错的结果、一系列物品的清单，它们都是数据，并且形态各异。为了高效地管理和操作它们，Python 将这些数据分门别类，这就是 基本数据类型。

数字是一种类型，专门用于计算。文本（比如你的名字"Alice"）是另一种类型，我们称之为字符串，它有一系列处理文字的方法。还有用于表示“是”或“否”的布尔类型，只有 True 和 False 两个值。更复杂一些的，像可以存放多个项目的列表，以及像字典一样可以通过关键词查找信息的字典，也都是重要的数据类型。

为什么类型如此重要？因为数据类型决定了你能对这个“容器”里的内容做什么。你可以把两个数字相加，但不能把两个单词直接“相加”成有意义的句子（除非是字符串拼接）。知道容器里装的是什么，是正确使用它的第一步。

这一章，我们将一起认识这些最基本、最常用的数据容器和它们的类型。我们会看看如何创建它们，如何辨别一个变量里究竟装着什么类型的数据（这里我们可以用到一个叫 `

def get_variable_type(variable) -> str:
    """
    获取变量的数据类型名称
    
    参数:
    variable: 任意类型的变量
    
    返回:
    str: 变量的数据类型名称
    
    示例:
    >>> get_variable_type(42)
    'int'
    >>> get_variable_type("Hello")
    'str'
    """
    return type(variable).__name__

` 的工具来帮忙），以及不同类型的数据都有哪些独特的能力和限制。

为了方便探索，我们可以先用 `

def create_data_type_examples() -> dict:
    """
    创建各种基本数据类型的示例
    
    返回:
    dict: 包含各种数据类型示例的字典
    
    示例:
    >>> examples = create_data_type_examples()
    >>> examples['integer']
    42
    >>> examples['string']
    'Hello, World!'
    """
    return {
        'integer': 42,
        'float': 3.14159,
        'string': 'Hello, World!',
        'boolean': True,
        'list': [1, 2, 3, 4, 5],
        'tuple': (1, 2, 3),
        'dictionary': {'name': 'Alice', 'age': 25},
        'set': {1, 2, 3, 4},
        'none': None
    }

` 快速生成一些各种数据类型的例子，看看它们长什么样。之后，我们会像认识新朋友一样，逐一了解数字、字符串、布尔值、列表和字典这些核心成员。

准备好了吗？让我们开始打开这些数据的容器，看看里面究竟装着怎样的奇妙世界。

核心概念

想象一下，你有一个巨大的仓库，里面存放着各种物品。为了管理和找到它们，你需要给每个储物箱贴上标签，并且根据物品的种类（比如书籍、工具、食品）来分门别类。在Python的世界里编程，我们做的事情非常相似——处理各种各样的数据，而“变量”和“数据类型”就是我们用来组织和标识这些数据的核心工具。

你想过没有，当你在Python里写下 name = '小明' 时，到底发生了什么？这行简单的代码完成了两件重要的事：第一，它创建了一个叫做 name 的“标签”（也就是变量）；第二，它把“小明”这个数据放进了这个标签对应的“盒子”里。以后我们想用“小明”这个值，直接叫 name 就可以了。变量就是一个保存数据的容器，而容器里具体能放什么，由“数据类型”来决定。

Python内置了几种最基本、最常用的数据类型，它们是构建所有程序的基础。我们可以先用一个函数来快速浏览一下它们的模样：

def create_data_type_examples() -> dict:
    """
    创建各种基本数据类型的示例
    
    返回:
    dict: 包含各种数据类型示例的字典
    
    示例:
    >>> examples = create_data_type_examples()
    >>> examples['integer']
    42
    >>> examples['string']
    'Hello, World!'
    """
    return {
        'integer': 42,
        'float': 3.14159,
        'string': 'Hello, World!',
        'boolean': True,
        'list': [1, 2, 3, 4, 5],
        'tuple': (1, 2, 3),
        'dictionary': {'name': 'Alice', 'age': 25},
        'set': {1, 2, 3, 4},
        'none': None
    }

这个函数给我们展示了常见类型的例子。让我们来仔细看看它们各自的特点。

首先是最直观的数字。在Python中，数字主要分为整数（比如 42）和浮点数（比如 3.14）。我们经常需要判断一个数据是不是数字，或者把用户输入的文本转换成数字进行计算：

def check_numeric_type(value) -> bool:
    """
    检查值是否为数值类型（整数或浮点数）
    
    参数:
    value: 要检查的值
    
    返回:
    bool: 如果值是整数或浮点数则返回True，否则返回False
    
    示例:
    >>> check_numeric_type(42)
    True
    >>> check_numeric_type(3.14)
    True
    >>> check_numeric_type("123")
    False
    """
    return isinstance(value, (int, float))

def convert_to_number(value):
    """
    将字符串转换为数字（整数或浮点数）
    
    参数:
    value: 要转换的值，通常是字符串
    
    返回:
    int|float: 转换后的数字，如果转换失败则返回原始值
    
    示例:
    >>> convert_to_number("123")
    123
    >>> convert_to_number("3.14")
    3.14
    >>> convert_to_number("abc")
    'abc'
    """
    try:
        # 先尝试转换为整数
        return int(value)
    except ValueError:
        try:
            # 如果整数转换失败，尝试转换为浮点数
            return float(value)
        except (ValueError, TypeError):
            # 如果都无法转换，返回原始值
            return value

当你需要把计算结果清晰地展示给人看时，比如在财务报告中显示金额，格式化数字就非常重要：

def format_number(number, precision=2) -> str:
    """
    格式化数字，添加千位分隔符并控制小数精度
    
    参数:
    number: 要格式化的数字
    precision: 小数位数，默认为2
    
    返回:
    str: 格式化后的字符串
    
    示例:
    >>> format_number(1234567.89123)
    '1,234,567.89'
    >>> format_number(1234, 0)
    '1,234'
    """
    if not isinstance(number, (int, float)):
        return str(number)
    
    # 格式化整数部分
    int_part = f"{int(abs(number)):,}"
    
    # 处理小数部分
    if precision > 0:
        decimal_part = f"{abs(number) % 1:.{precision}f}"[1:]
        result = int_part + decimal_part
    else:
        result = int_part
    
    # 处理负数
    if number < 0:
        result = "-" + result
    
    return result

接着是文本，也就是字符串。它是由引号包围起来的一系列字符，是我们和程序交互、展示信息的主要方式。判断一个值是不是字符串很简单：

def check_string_type(value) -> bool:
    """
    检查值是否为字符串类型
    
    参数:
    value: 要检查的值
    
    返回:
    bool: 如果值是字符串类型则返回True，否则返回False
    
    示例:
    >>> check_string_type("Hello")
    True
    >>> check_string_type(123)
    False
    """
    return isinstance(value, str)

我们还能获取一个字符串的详细“体检报告”，比如它有多长、包含了哪些类型的字符：

def get_string_info(text) -> dict:
    """
    获取字符串的详细信息
    
    参数:
    text: 要分析的字符串
    
    返回:
    dict: 包含字符串详细信息的字典
    
    示例:
    >>> get_string_info("Hello 123!")
    {
        'length': 10,
        'is_empty': False,
        'has_letters': True,
        'has_digits': True,
        'has_spaces': True,
        'has_special': True
    }
    """
    if not isinstance(text, str):
        raise TypeError("输入必须是字符串类型")
    
    return {
        'length': len(text),
        'is_empty': len(text) == 0,
        'has_letters': any(c.isalpha() for c in text),
        'has_digits': any(c.isdigit() for c in text),
        'has_spaces': any(c.isspace() for c in text),
        'has_special': any(not c.isalnum() and not c.isspace() for c in text)
    }

有时，为了统一格式（比如把用户输入的姓名变成首字母大写），我们需要改变字符串的大小写：

def convert_string_case(text, case_type='title') -> str:
    """
    转换字符串的大小写格式
    
    参数:
    text: 要转换的字符串
    case_type: 转换类型，可选值: 'upper', 'lower', 'title', 'swapcase'
    
    返回:
    str: 转换后的字符串
    
    示例:
    >>> convert_string_case("hello world", 'title')
    'Hello World'
    >>> convert_string_case("Hello World", 'lower')
    'hello world'
    """
    if not isinstance(text, str):
        raise TypeError("输入必须是字符串类型")
    
    case_converters = {
        'upper': str.upper,
        'lower': str.lower,
        'title': str.title,
        'swapcase': str.swapcase
    }
    
    if case_type not in case_converters:
        raise ValueError(f"不支持的转换类型: {case_type}，可选值: {list(case_converters.keys())}")
    
    return case_converters[case_type](text)

然后是一种非常简单的类型——布尔值。它只有两种状态：True（真）或 False（假），通常用于逻辑判断和条件控制。检查一个值是不是布尔类型：

def check_boolean_type(value) -> bool:
    """
    检查值是否为布尔类型
    
    参数:
    value: 要检查的值
    
    返回:
    bool: 如果值是布尔类型则返回True，否则返回False
    
    示例:
    >>> check_boolean_type(True)
    True
    >>> check_boolean_type(1)
    False
    >>> check_boolean_type("True")
    False
    """
    return isinstance(value, bool)

在实际编程中，我们常常需要把其他类型的数据（比如数字、字符串、甚至列表）转换成布尔值，以便进行逻辑运算。Python有一套清晰的转换规则：

def convert_to_boolean(value) -> bool:
    """
    将各种类型的值转换为布尔值
    
    参数:
    value: 要转换的值
    
    返回:
    bool: 转换后的布尔值
    
    示例:
    >>> convert_to_boolean(1)
    True
    >>> convert_to_boolean(0)
    False
    >>> convert_to_boolean("yes")
    True
    >>> convert_to_boolean("no")
    False
    """
    # 处理字符串
    if isinstance(value, str):
        truthy_strings = ['true', 'yes', 'on', '1', 'ok']
        falsy_strings = ['false', 'no', 'off', '0', '']
        
        value_lower = value.lower().strip()
        if value_lower in truthy_strings:
            return True
        elif value_lower in falsy_strings:
            return False
        else:
            # 非空字符串视为True
            return bool(value_lower)
    
    # 处理数字
    elif isinstance(value, (int, float)):
        return bool(value)
    
    # 处理None
    elif value is None:
        return False
    
    # 处理集合类型
    elif isinstance(value, (list, tuple, dict, set)):
        return bool(value)
    
    # 其他类型
    return bool(value)

为了更友好地显示，我们也可以格式化布尔值的输出形式：

def format_boolean(value, format_type='text') -> str:
    """
    格式化布尔值的显示方式
    
    参数:
    value: 要格式化的布尔值
    format_type: 格式类型，可选值: 'text', 'yesno', 'binary', 'checkmark'
    
    返回:
    str: 格式化后的字符串
    
    示例:
    >>> format_boolean(True, 'yesno')
    'Yes'
    >>> format_boolean(False, 'checkmark')
    '✗'
    """
    # 先将输入转换为布尔值
    bool_value = convert_to_boolean(value)
    
    formats = {
        'text': {True: 'True', False: 'False'},
        'yesno': {True: 'Yes', False: 'No'},
        'binary': {True: '1', False: '0'},
        'checkmark': {True: '✓', False: '✗'}
    }
    
    if format_type not in formats:
        raise ValueError(f"不支持的格式类型: {format_type}，可选值: {list(formats.keys())}")
    
    return formats[format_type][bool_value]

当我们处理一组相关的数据时，就需要用到“容器类型”。列表是一个有序的、可以随时增删改的集合，就像一列火车，每节车厢可以装不同的东西。检查一个变量是否为列表：

def check_list_type(value) -> bool:
    """
    检查值是否为列表类型
    
    参数:
    value: 要检查的值
    
    返回:
    bool: 如果值是列表类型则返回True，否则返回False
    
    示例:
    >>> check_list_type([1, 2, 3])
    True
    >>> check_list_type((1, 2, 3))
    False
    """
    return isinstance(value, list)

同样，我们可以获取一个列表的概要信息：

def get_list_info(items) -> dict:
    """
    获取列表的详细信息
    
    参数:
    items: 要分析的列表
    
    返回:
    dict: 包含列表详细信息的字典
    
    示例:
    >>> get_list_info([1, 2, 3, "hello"])
    {
        'length': 4,
        'is_empty': False,
        'element_types': ['int', 'int', 'int', 'str'],
        'unique_types': ['int', 'str']
    }
    """
    if not isinstance(items, list):
        raise TypeError("输入必须是列表类型")
    
    element_types = [get_variable_type(item) for item in items]
    
    return {
        'length': len(items),
        'is_empty': len(items) == 0,
        'element_types': element_types,
        'unique_types': list(set(element_types))
    }

字典是另一种强大的容器。它存储的是“键-值”对，通过唯一的“键”来快速查找对应的“值”，就像用名字（键）在电话簿（字典）里查找电话号码（值）。检查字典类型：

def check_dict_type(value) -> bool:
    """
    检查值是否为字典类型
    
    参数:
    value: 要检查的值
    
    返回:
    bool: 如果值是字典类型则返回True，否则返回False
    
    示例:
    >>> check_dict_type({'a': 1})
    True
    >>> check_dict_type([1, 2, 3])
    False
    """
    return isinstance(value, dict)

获取字典的结构信息也很有用：

def get_dict_info(dictionary) -> dict:
    """
    获取字典的详细信息
    
    参数:
    dictionary: 要分析的字典
    
    返回:
    dict: 包含字典详细信息的字典
    
    示例:
    >>> get_dict_info({'name': 'John', 'age': 30})
    {
        'length': 2,
        'is_empty': False,
        'key_types': ['str', 'str'],
        'value_types': ['str', 'int'],
        'keys': ['name', 'age']
    }
    """
    if not isinstance(dictionary, dict):
        raise TypeError("输入必须是字典类型")
    
    keys = list(dictionary.keys())
    values = list(dictionary.values())
    
    return {
        'length': len(dictionary),
        'is_empty': len(dictionary) == 0,
        'key_types': [get_variable_type(key) for key in keys],
        'value_types': [get_variable_type(value) for value in values],
        'keys': keys
    }

现在你认识了这些基本的数据类型。但在Python里有一个非常灵活的特性：一个变量的类型不是固定不变的。你可以在程序运行中，让同一个变量名先后容纳不同类型的数据。如何随时知道一个变量里面究竟装着什么类型的数据呢？

def get_variable_type(variable) -> str:
    """
    获取变量的数据类型名称
    
    参数:
    variable: 任意类型的变量
    
    返回:
    str: 变量的数据类型名称
    
    示例:
    >>> get_variable_type(42)
    'int'
    >>> get_variable_type("Hello")
    'str'
    """
    return type(variable).__name__

这个函数就像给你的变量盒子贴上了一个动态的“物品类型标签”，让你一目了然。

为了更直观地对比这些数据类型，我们可以将它们的主要信息整理成一张表：

def format_data_type_table(data) -> str:
    """
    格式化数据类型信息为表格字符串
    
    参数:
    data: 包含变量名和值的字典
    
    返回:
    str: 格式化的表格字符串
    
    示例:
    >>> data = {'age': 25, 'name': 'John', 'is_student': True}
    >>> print(format_data_type_table(data))
    变量名     值      类型
    --------  ------  ------
    age       25      int
    name      John    str
    is_student True   bool
    """
    if not isinstance(data, dict):
        raise TypeError("输入必须是字典类型")
    
    # 准备表头
    headers = ['变量名', '值', '类型']
    
    # 准备数据行
    rows = []
    for key, value in data.items():
        # 格式化值，对于长字符串进行截断
        value_str = str(value)
        if len(value_str) > 20:
            value_str = value_str[:17] + '...'
        
        rows.append([key, value_str, get_variable_type(value)])
    
    # 计算每列的最大宽度
    col_widths = [len(h) for h in headers]
    for row in rows:
        for i, cell in enumerate(row):
            col_widths[i] = max(col_widths[i], len(str(cell)))
    
    # 构建表格
    result_lines = []
    
    # 添加表头
    header_line = '  '.join(h.ljust(w) for h, w in zip(headers, col_widths))
    result_lines.append(header_line)
    
    # 添加分隔线
    separator = '  '.join('-' * w for w in col_widths)
    result_lines.append(separator)
    
    # 添加数据行
    for row in rows:
        row_line = '  '.join(str(cell).ljust(w) for cell, w in zip(row, col_widths))
        result_lines.append(row_line)
    
    return '\n'.join(result_lines)

记住，变量是数据的名字，数据类型定义了数据的种类和你能对它进行的操作。从简单的数字计算、文字处理，到复杂的逻辑判断和数据集合管理，都离不开对这些核心概念的掌握。尝试用上面提到的函数去探索你创建的各种变量，看看它们究竟是什么，又能做什么，这是熟悉它们的最好方式。

实践应用

掌握了变量和基本数据类型的概念后，我们来看看它们在实际编程中如何发挥作用。编程不仅仅是记忆规则，更是解决问题的工具。一个常见的场景是处理来自外部的、不确定的数据，比如用户输入、文件读取或网络请求返回的信息，然后对这些数据进行验证、转换和格式化。

让我们从一个具体的情景开始：假设我们正在处理一些从文本文件或网页表单中收集到的原始数据。这些数据最初通常都是字符串格式，我们需要将它们识别并转换成合适的类型，以便进行进一步的计算或逻辑判断。

首先，我们可以使用 [引用函数:create_data_type_examples] 函数来快速创建一组模拟的原始数据示例，这能让我们直观地看到各种数据类型的初始状态。

有了这些原始数据，我们首先要做的就是识别它们的类型。[引用函数:get_variable_type] 函数是我们的好帮手，它能告诉我们手头的数据到底是什么类型。这是处理数据的第一步，就像给物品贴上标签一样。

很多时候，我们收到的数字是以字符串形式存在的，比如 “123.45”。直接对这样的字符串做数学计算会出错。这时，[引用函数:convert_to_number] 函数就能尝试将其转换为真正的整数或浮点数。在进行转换前或对某些值进行验证时，[引用函数:check_numeric_type] 可以快速判断一个值是否为可运算的数值类型。

转换成功后，我们可能希望将数字以一种更友好的方式展示出来，比如添加千位分隔符。[引用函数:format_number] 函数正是为此设计的，它能让一串长长的数字变得易于阅读。

对于字符串数据，除了基本的类型检查（[引用函数:check_string_type]），我们常常需要了解它的详细构成。[引用函数:get_string_info] 函数可以提供长度、是否为空以及大致的字符类型分布，这在验证用户输入的密码或分析文本时非常有用。有时我们还需要统一字符串的格式，比如将用户名转换为首字母大写，[引用函数:convert_string_case] 可以轻松完成这个任务。

在处理配置项或开关逻辑时，布尔值非常关键。数据可能以字符串 “True”、数字 1 或 0 的形式出现。[引用函数:convert_to_boolean] 函数能将这些五花八门的输入统一转换为标准的 True 或 False。当然，我们也可以用 [引用函数:check_boolean_type] 来直接检查一个值是否为布尔类型。在输出结果时，[引用函数:format_boolean] 能让我们选择以 “是/否” 或 “启用/禁用” 等更直观的方式显示布尔值。

当数据是集合形式时，比如兴趣爱好列表（列表类型）或用户个人资料（字典类型），我们需要了解它们的结构。[引用函数:get_list_info] 和 [引用函数:get_dict_info] 能告诉我们列表里有多少元素、字典里有哪些键值对，帮助我们对数据结构有个快速把握。配合 [引用函数:check_list_type] 和 [引用函数:check_dict_type] 进行类型验证，能确保后续的操作不会因为类型错误而意外中断。

想象这样一个流程：我们接收到一段原始的字符串 “25,true,Python;Data;AI”。我们可以先将其按分隔符拆分成一个列表 [‘25‘, ‘true‘, ‘Python;Data;AI‘]。接着，识别并转换每个元素：将 ‘25‘ 转换为整数，将 ‘true‘ 转换为布尔值，将 ‘Python;Data;AI‘ 按分号拆分成兴趣列表。然后，对年龄数字进行格式化，对布尔值进行友好显示，并分析兴趣列表的长度。最后，我们可以利用 [引用函数:format_data_type_table] 函数，将这些处理好的、类型清晰的数据整理成一份格式规整的表格或报告输出。这个过程完美地展示了如何将变量和数据类型知识，与具体的工具函数结合，来解决一个真实的数据处理任务。

章节总结

想象一下，你有一个工具箱，里面放着锤子、螺丝刀、尺子。写代码时，变量就是你的工具箱，而不同的数据类型，就是里面功能各异的工具。你绝不会用锤子去拧螺丝，对吧？在Python里，理解你“盒子”里装的是什么“工具”，是让代码正确工作的第一步。

变量是那个贴了标签的盒子，你可以随时把东西放进去或换掉。而盒子里东西的“种类”——是数字、文字、真假判断，还是一个集合——就是数据类型。它决定了你能对这个数据做什么。想知道盒子里到底是什么吗？用 `

def get_variable_type(variable) -> str:
    """
    获取变量的数据类型名称
    
    参数:
    variable: 任意类型的变量
    
    返回:
    str: 变量的数据类型名称
    
    示例:
    >>> get_variable_type(42)
    'int'
    >>> get_variable_type("Hello")
    'str'
    """
    return type(variable).__name__

` 看一眼标签就清楚了。

我们认识了几个最常用的“工具”：能计算的整数和浮点数（用 `

def check_numeric_type(value) -> bool:
    """
    检查值是否为数值类型（整数或浮点数）
    
    参数:
    value: 要检查的值
    
    返回:
    bool: 如果值是整数或浮点数则返回True，否则返回False
    
    示例:
    >>> check_numeric_type(42)
    True
    >>> check_numeric_type(3.14)
    True
    >>> check_numeric_type("123")
    False
    """
    return isinstance(value, (int, float))

可以确认）、能表达信息的字符串、代表“是”或“否”的布尔值，以及能收纳多个项目的列表和字典。想快速看看它们都长什么样？

def create_data_type_examples() -> dict:
    """
    创建各种基本数据类型的示例
    
    返回:
    dict: 包含各种数据类型示例的字典
    
    示例:
    >>> examples = create_data_type_examples()
    >>> examples['integer']
    42
    >>> examples['string']
    'Hello, World!'
    """
    return {
        'integer': 42,
        'float': 3.14159,
        'string': 'Hello, World!',
        'boolean': True,
        'list': [1, 2, 3, 4, 5],
        'tuple': (1, 2, 3),
        'dictionary': {'name': 'Alice', 'age': 25},
        'set': {1, 2, 3, 4},
        'none': None
    }

` 能给你一组生动的例子。

Python的魅力在于，这些“工具”的界限并非铁板一块。当你从网络或用户那里拿到一个数字，但它是以文本形式"123"存在的，你该怎么用它计算？`

def convert_to_number(value):
    """
    将字符串转换为数字（整数或浮点数）
    
    参数:
    value: 要转换的值，通常是字符串
    
    返回:
    int|float: 转换后的数字，如果转换失败则返回原始值
    
    示例:
    >>> convert_to_number("123")
    123
    >>> convert_to_number("3.14")
    3.14
    >>> convert_to_number("abc")
    'abc'
    """
    try:
        # 先尝试转换为整数
        return int(value)
    except ValueError:
        try:
            # 如果整数转换失败，尝试转换为浮点数
            return float(value)
        except (ValueError, TypeError):
            # 如果都无法转换，返回原始值
            return value

可以帮你安全地把它变成真正的数字工具。同样，

def convert_to_boolean(value) -> bool:
    """
    将各种类型的值转换为布尔值
    
    参数:
    value: 要转换的值
    
    返回:
    bool: 转换后的布尔值
    
    示例:
    >>> convert_to_boolean(1)
    True
    >>> convert_to_boolean(0)
    False
    >>> convert_to_boolean("yes")
    True
    >>> convert_to_boolean("no")
    False
    """
    # 处理字符串
    if isinstance(value, str):
        truthy_strings = ['true', 'yes', 'on', '1', 'ok']
        falsy_strings = ['false', 'no', 'off', '0', '']
        
        value_lower = value.lower().strip()
        if value_lower in truthy_strings:
            return True
        elif value_lower in falsy_strings:
            return False
        else:
            # 非空字符串视为True
            return bool(value_lower)
    
    # 处理数字
    elif isinstance(value, (int, float)):
        return bool(value)
    
    # 处理None
    elif value is None:
        return False
    
    # 处理集合类型
    elif isinstance(value, (list, tuple, dict, set)):
        return bool(value)
    
    # 其他类型
    return bool(value)

` 能帮你理解各种值背后的“是非”逻辑。这种灵活转换的能力，是处理真实世界数据的关键。

知道了工具是什么，更要会用。给一个大数字加上千位分隔符让它易读，`

def format_number(number, precision=2) -> str:
    """
    格式化数字，添加千位分隔符并控制小数精度
    
    参数:
    number: 要格式化的数字
    precision: 小数位数，默认为2
    
    返回:
    str: 格式化后的字符串
    
    示例:
    >>> format_number(1234567.89123)
    '1,234,567.89'
    >>> format_number(1234, 0)
    '1,234'
    """
    if not isinstance(number, (int, float)):
        return str(number)
    
    # 格式化整数部分
    int_part = f"{int(abs(number)):,}"
    
    # 处理小数部分
    if precision > 0:
        decimal_part = f"{abs(number) % 1:.{precision}f}"[1:]
        result = int_part + decimal_part
    else:
        result = int_part
    
    # 处理负数
    if number < 0:
        result = "-" + result
    
    return result

可以做到。想分析一段用户输入的文本长度和构成？

def get_string_info(text) -> dict:
    """
    获取字符串的详细信息
    
    参数:
    text: 要分析的字符串
    
    返回:
    dict: 包含字符串详细信息的字典
    
    示例:
    >>> get_string_info("Hello 123!")
    {
        'length': 10,
        'is_empty': False,
        'has_letters': True,
        'has_digits': True,
        'has_spaces': True,
        'has_special': True
    }
    """
    if not isinstance(text, str):
        raise TypeError("输入必须是字符串类型")
    
    return {
        'length': len(text),
        'is_empty': len(text) == 0,
        'has_letters': any(c.isalpha() for c in text),
        'has_digits': any(c.isdigit() for c in text),
        'has_spaces': any(c.isspace() for c in text),
        'has_special': any(not c.isalnum() and not c.isspace() for c in text)
    }

能提供详细的报告。管理一个购物清单（列表）或一份同学通讯录（字典）？

def get_list_info(items) -> dict:
    """
    获取列表的详细信息
    
    参数:
    items: 要分析的列表
    
    返回:
    dict: 包含列表详细信息的字典
    
    示例:
    >>> get_list_info([1, 2, 3, "hello"])
    {
        'length': 4,
        'is_empty': False,
        'element_types': ['int', 'int', 'int', 'str'],
        'unique_types': ['int', 'str']
    }
    """
    if not isinstance(items, list):
        raise TypeError("输入必须是列表类型")
    
    element_types = [get_variable_type(item) for item in items]
    
    return {
        'length': len(items),
        'is_empty': len(items) == 0,
        'element_types': element_types,
        'unique_types': list(set(element_types))
    }

和

def get_dict_info(dictionary) -> dict:
    """
    获取字典的详细信息
    
    参数:
    dictionary: 要分析的字典
    
    返回:
    dict: 包含字典详细信息的字典
    
    示例:
    >>> get_dict_info({'name': 'John', 'age': 30})
    {
        'length': 2,
        'is_empty': False,
        'key_types': ['str', 'str'],
        'value_types': ['str', 'int'],
        'keys': ['name', 'age']
    }
    """
    if not isinstance(dictionary, dict):
        raise TypeError("输入必须是字典类型")
    
    keys = list(dictionary.keys())
    values = list(dictionary.values())
    
    return {
        'length': len(dictionary),
        'is_empty': len(dictionary) == 0,
        'key_types': [get_variable_type(key) for key in keys],
        'value_types': [get_variable_type(value) for value in values],
        'keys': keys
    }

` 能让你对它们的结构一目了然。

所以，这个章节不只是记住了 int、str、list 这些名词。它是在培养一种本能：每当你要处理数据时，首先问自己“它是什么类型？”。这个简单的习惯，能帮你避免大多数低级错误，并让你清晰地思考下一步该做什么。把变量看作容器，用数据类型来理解容器的内容，你的代码思路会立刻变得清晰起来。