Python中None空对象与空值判断的正确方法详解

# 问题一：函数该返回None还是空列表？
def find_users(name):
    # 如果没找到，应该返回什么？
    pass

# 问题二：怎么区分"用户没填年龄"和"用户年龄为0"？
user = {'name': '小明', 'age': 0}
# age=0是有意义的（婴儿），但if user['age']判断为False

# 问题三：可选参数怎么设置默认值？
def connect(host, port=None):
    # None表示"使用默认端口"
    pass

# None的基础属性
print(type(None))    # <class 'NoneType'>
print(None is None)  # True——永远是True

# 整个程序中只有一个None
a = None
b = None
c = None
print(a is b is c)   # True——都指向同一个None对象
print(id(a) == id(b) == id(c))  # True

# ⚠️ 你不能创建新的NoneType实例
# NoneType()  # TypeError: cannot create 'NoneType' instances

# None的布尔值是False
print(bool(None))  # False

# Python中的"假值"全家
falsy_values = [None, False, 0, 0.0, 0j, '', [], (), {}, set(), frozenset()]

for v in falsy_values:
    print(f'{type(v).__name__:>12} : {repr(v):>10} → bool={bool(v)}')

# 输出：
#     NoneType :       None → bool=False
#         bool :      False → bool=False
#          int :          0 → bool=False
#        float :        0.0 → bool=False
#      complex :        0j → bool=False
#          str :         '' → bool=False
#         list :         [] → bool=False
#        tuple :         () → bool=False
#         dict :         {} → bool=False
#          set :    set() → bool=False
#    frozenset : frozenset() → bool=False

# 但它们都不是None！
print(None == False)  # False
print(None == 0)      # False
print(None == '')     # False
print(None == [])     # False

# None表示"没有值"或"值未知"
# 0表示数值零
# ''表示空字符串
# []表示空列表
# 语义完全不同！

# 场景一：查找操作——未找到时返回None
def find_user(users, user_id):
    """查找用户，找不到返回None"""
    for user in users:
        if user['id'] == user_id:
            return user
    return None  # 明确表示"没找到"

# ⚠️ 但注意：也用可能返回空列表/空字典
def find_user_emails(users):
    """查找所有用户邮箱——即使没找到也返回空列表"""
    emails = [u.get('email') for u in users if u.get('email')]
    return emails  # 空列表表示"没有邮箱"，而不是"操作失败"

# 选择原则：
# 返回None → 表示"没有这个对象"（像查找单个结果）
# 返回空容器 → 表示"有容器，但里面没东西"（像查询列表）

# ✅ 经典模式——用None做可选参数的默认值
def create_user(name, age=None, email=None, role=None):
    """创建用户，age/email/role都是可选的"""
    user = {'name': name}
    if age is not None:
        user['age'] = age
    if email is not None:
        user['email'] = email
    if role is not None:
        user['role'] = role
    return user

print(create_user('小明'))                        # {'name': '小明'}
print(create_user('小红', age=25, role='admin'))  # {'name': '小红', 'age': 25, 'role': 'admin'}

# ⚠️ 为什么不用其他默认值？
# 问题：如果age=0代表婴儿，那么age=0作为默认值就不合适
def bad_create_user(name, age=0):
    """用0作为默认值——怎么知道调用者是否传了age？"""
    return {'name': name, 'age': age}

# 调用者没传age
user1 = bad_create_user('小明')
# 调用者传了age=0（婴儿）
user2 = bad_create_user('婴儿', age=0)
# 两个调用产生相同的结果——无法区分！

class User:
    def __init__(self, name):
        self.name = name
        # 尚未设置的值用None初始化
        self.email = None     # 还未绑定邮箱
        self.phone = None     # 还未绑定手机
        self.avatar_url = None  # 还未上传头像
        self.last_login = None  # 从未登录过

# None表示"还没有值"，和"空字符串"含义不同
# email = None → 用户没绑定邮箱
# email = ''   → 这不太合理，邮箱不会是空字符串

# 在后续操作中检查
def send_notification(user):
    if user.email is None:
        print(f'用户{user.name}没有绑定邮箱，无法发送通知')
        return False
    # 发送邮件...
    return True

class LazyDeletedDict:
    """懒删除字典——标记为None表示已删除，但不立即移除"""
    
    def __init__(self):
        self._data = {}
    
    def delete(self, key):
        """标记删除——设为None"""
        self._data[key] = None
    
    def get(self, key, default=None):
        value = self._data.get(key, default)
        if value is None:
            # 但注意：这无法区分"存了None"和"键不存在"
            return default
        return value
    
    def compact(self):
        """真正删除标记为None的键"""
        self._data = {k: v for k, v in self._data.items() if v is not None}

_DELETED = object()

class BetterLazyDict:
    def __init__(self):
        self._data = {}
    
    def delete(self, key):
        self._data[key] = _DELETED  # 用哨兵对象
    
    def get(self, key, default=None):
        value = self._data.get(key, default)
        if value is _DELETED:
            return default
        return value
    
    def set(self, key, value):
        self._data[key] = value  # None是合法值！

# ✅ 正确——永远用is
if x is None:
    print('x是None')

if x is not None:
    print('x不是None')

# ❌ 错误——用==
if x == None:    # 不推荐，__eq__可能被重载
    pass

# ❌ 错误——用布尔上下文
if not x:        # 这会把0、''、[]等也当作"空"处理！
    pass

# 为什么==不好？
class Confused:
    def __eq__(self, other):
        return True  # 等于一切！

c = Confused()
print(c == None)   # True——但它显然不是None
print(c is None)   # False——is正确

# 为什么not不好？
x = 0
if not x:          # True！
    print('x是空')  # 这会被触发，但x是0，不是None

import time

# is None 比 == None 快很多
# 因为is是直接比较id，==需要查找和调用__eq__
n = 10000000

start = time.perf_counter()
for _ in range(n):
    _ = (None is None)
print(f'is None: {time.perf_counter() - start:.3f}秒')

start = time.perf_counter()
for _ in range(n):
    _ = (None == None)
print(f'== None: {time.perf_counter() - start:.3f}秒')
# is None通常快2-5倍

# 这是最常见的混淆点

def check_value(x):
    print(f'x={repr(x)}:')
    print(f'  x is None: {x is None}')
    print(f'  not x:     {not x}')
    print(f'  x == None: {x == None}')
    print()

# 测试各种值
check_value(None)    # 都是True——但含义不同
check_value(0)       # is None→False, not→True, ==→False
check_value('')      # is None→False, not→True, ==→False
check_value([])      # is None→False, not→True, ==→False
check_value(False)   # is None→False, not→True, ==→False
check_value('hello') # 都是False

# 结论：x is None 只检查None
#      not x 检查所有"假值"
#      它们不是一回事！

# 场景一：参数校验——严格区分None和空值
def process_list(items=None):
    if items is None:
        items = []  # 没传参数，创建空列表
    elif items == []:
        print('传了空列表，不处理')
        return
    # 处理非空列表
    for item in items:
        print(item)

process_list()        # 使用默认空列表
process_list([])      # 检测到空列表，不处理
process_list([1, 2])  # 正常处理

# 场景二：检查非空字符串（排除None和空字符串）
def validate_name(name):
    if name is None:
        return '名称不能为None'
    if not name:  # name为''或只包含空白
        return '名称不能为空'
    if not name.strip():
        return '名称不能只包含空白'
    return 'OK'

print(validate_name(None))    # 名称不能为None
print(validate_name(''))      # 名称不能为空
print(validate_name('   '))   # 名称不能只包含空白
print(validate_name('小明'))   # OK

# 场景三：数值检查——区分None和0
def set_volume(level=None):
    if level is None:
        level = 50  # 默认音量50%
    elif level == 0:
        print('静音模式')
    print(f'音量设置为: {level}%')

set_volume()     # 音量设置为: 50%
set_volume(0)    # 静音模式 \n 音量设置为: 0%
set_volume(80)   # 音量设置为: 80%

# 默认为False的情况：
# 1. None
# 2. False
# 3. 任何数值类型的零：0, 0.0, 0j, Decimal(0), Fraction(0, 1)
# 4. 空序列：'', (), []
# 5. 空映射：{}
# 6. 空集合：set(), frozenset()
# 7. 定义了__bool__返回False的对象
# 8. 定义了__len__返回0的对象

# 其他所有值默认为True

# 自定义类的真值
class MyClass:
    pass

obj = MyClass()
print(bool(obj))  # True——默认是真

class EmptyContainer:
    def __len__(self):
        return 0

ec = EmptyContainer()
print(bool(ec))  # False——__len__返回0

class AlwaysFalse:
    def __bool__(self):
        return False

af = AlwaysFalse()
print(bool(af))  # False——__bool__返回False

# ⚠️ __bool__优先于__len__
class Conflicted:
    def __bool__(self):
        return True
    def __len__(self):
        return 0

c = Conflicted()
print(bool(c))  # True——__bool__优先

# 完整的真假值对照表
test_values = [
    None,                    # False
    True,                    # True
    False,                   # False
    0,                       # False
    1,                       # True
    -1,                      # True
    0.0,                     # False
    0.1,                     # True
    '',                      # False
    ' ',                     # True（空格是字符！）
    '0',                     # True
    [],                      # False
    [0],                     # True（包含元素）
    [None],                  # True
    (),                      # False
    (0,),                    # True
    {},                      # False
    {'a': None},            # True（有键）
    set(),                   # False
    {0},                     # True
]

print('值                          | bool() | if判断')
print('-' * 55)
for v in test_values:
    bool_val = bool(v)
    print(f'{str(v):<28} | {str(bool_val):<6} | {"通过" if bool_val else "跳过"}')

# ⚠️ 陷阱一：'0'字符串不是假值！
print(bool('0'))  # True！'0'是非空字符串

# ⚠️ 陷阱二：包含空格的字符串不是假值！
print(bool(' '))  # True！空格也是字符

# ⚠️ 陷阱三：包含None的列表不是假值！
print(bool([None]))  # True！列表非空

# ⚠️ 陷阱四：[False]也不是假值！
print(bool([False]))  # True！列表有元素

# ⚠️ 陷阱五：datetime.time(0,0,0)的真实性
import datetime
t = datetime.time(0, 0, 0)
# 在Python 3.5之前，midnight time bool值为False
# 在Python 3.5+，始终为True
print(f'午夜时间的bool: {bool(t)}')

# ⚠️ 陷阱六：numpy和pandas中的NaN
# import numpy as np
# np.nan的bool值会引发ValueError
# if np.nan:  # ValueError
#     pass

# 用or为"假值"设置替代值
# ⚠️ 注意：这会把0、''、[]等也替换掉！

def get_display_name(name):
    """获取显示名称——如果name为空则用默认值"""
    return name or '匿名用户'

print(get_display_name('小明'))    # 小明
print(get_display_name(''))        # 匿名用户
print(get_display_name(None))      # 匿名用户

# ⚠️ 但如果name=0或False呢？
# 这些场景or就不合适了

# 当只想处理None时——用更精确的写法
def get_display_name_safe(name):
    """只在name为None时用默认值"""
    return '匿名用户' if name is None else name

print(get_display_name_safe(''))   # ''（空字符串保留）
print(get_display_name_safe(0))    # 0（保留）
print(get_display_name_safe(None)) # 匿名用户

# dict.get(key, default)——只在键不存在时返回默认值
config = {
    'host': 'localhost',
    'port': 8080,
    'debug': False,    # 值为False
    'timeout': 0,       # 值为0
}

# ✅ get返回默认值——区分"键不存在"和"值为假"
print(config.get('host', '0.0.0.0'))      # localhost——键存在
print(config.get('database', 'sqlite'))   # sqlite——键不存在

# ⚠️ 但不要这样写：
# host = config.get('host') or '0.0.0.0'  # 如果host是空字符串，也会被替换！

# ✅ 用None做默认值，然后检查is None
value = config.get('debug', None)
if value is None:
    value = True  # 只在键不存在时设置默认值

# 检查多个值是否都不为None
def create_connection(host, port, username, password):
    # 方案一：逐个检查（明确）
    if host is None:
        raise ValueError('host不能为None')
    if port is None:
        raise ValueError('port不能为None')
    # ...
    
    # 方案二：用any/all组合
    params = [host, port, username, password]
    if any(p is None for p in params):
        missing = [name for name, val in 
                   zip(['host', 'port', 'username', 'password'], params)
                   if val is None]
        raise ValueError(f'以下参数不能为None: {missing}')
    
    # 方案三：用None哨兵
    # (已经在之前的文章讲过了)

# 或者批量检查
def require_non_none(**kwargs):
    """检查所有关键字参数都不为None"""
    missing = [k for k, v in kwargs.items() if v is None]
    if missing:
        raise ValueError(f'参数 {missing} 不能为None')
    return True

require_non_none(host='localhost', port=8080)  # OK
# require_non_none(host='localhost', port=None)  # ValueError

from typing import Optional

# Optional[X] 等价于 Union[X, None]
# 明确告诉类型检查器：这个参数可以是X类型也可以是None

def find_user(user_id: int) -> Optional[dict]:
    """
    查找用户。
    返回：用户字典，或None（未找到时）。
    """
    users = {1: {'name': '小明'}, 2: {'name': '小红'}}
    return users.get(user_id)  # 可能返回None

def greet(user_id: int) -> str:
    user = find_user(user_id)
    if user is None:
        return f'用户{user_id}不存在'
    return f'你好，{user["name"]}！'

print(greet(1))  # 你好，小明！
print(greet(99)) # 用户99不存在

# Optional在函数签名中的含义
def set_timeout(seconds: Optional[int] = None):
    """设置超时时间。None表示不限制超时。"""
    if seconds is None:
        print('超时无限制')
    else:
        print(f'超时时间: {seconds}秒')

from typing import Any, Optional, Dict


class Config:
    """
    健壮的配置系统——正确区分"未设置"、"设为None"、"设为假值"。
    """
    
    def __init__(self, defaults: Optional[Dict] = None):
        # 用哨兵对象标记"未设置"
        self._UNSET = object()
        # 存储：{key: value}，value可以是任何值（包括None）
        self._config = {}
        # 加载默认值
        if defaults:
            for k, v in defaults.items():
                self._config[k] = v
    
    def set(self, key: str, value: Any):
        """设置配置值——任何值都是合法的（包括None、0、False）"""
        self._config[key] = value
    
    def get(self, key: str, default: Any = None):
        """
        获取配置值。
        用_key_internal方法判断键是否真的存在，
        而不是依赖值的真假性。
        """
        if key in self._config:
            return self._config[key]
        return default
    
    def is_set(self, key: str) -> bool:
        """检查配置键是否被设置过（即使值可能是None）"""
        return key in self._config
    
    def require(self, *keys: str):
        """确保某些配置项已设置且不为None"""
        missing = []
        for key in keys:
            if key not in self._config or self._config[key] is None:
                missing.append(key)
        if missing:
            raise ValueError(f'以下配置项必须设置且不为None: {missing}')
    
    def get_int(self, key: str, default: int = 0) -> int:
        """安全获取整数配置"""
        value = self._config.get(key)
        if value is None:
            return default
        try:
            return int(value)
        except (ValueError, TypeError):
            return default
    
    def get_bool(self, key: str, default: bool = False) -> bool:
        """安全获取布尔配置——区分False和未设置"""
        if key not in self._config:
            return default
        value = self._config[key]
        if isinstance(value, bool):
            return value
        if isinstance(value, str):
            return value.lower() in ('true', '1', 'yes', 'on')
        return bool(value)
    
    def show(self):
        """显示所有配置"""
        print('当前配置:')
        for k, v in self._config.items():
            print(f'  {k} = {v!r}')


# 使用示例
config = Config({'host': 'localhost', 'port': 8080, 'debug': False})

config.set('timeout', 0)      # 0是合法值（表示无限超时）
config.set('retry', None)     # 显式设为None（表示不重试）
config.set('verbose', False)  # False是合法值

config.show()

# 测试各种获取方式
print(f'\nhost: {config.get("host")}')          # localhost
print(f'timeout: {config.get_int("timeout")}')  # 0——正确获取
print(f'retry: {config.get("retry", 3)}')       # None——显式设为None
print(f'max: {config.get_int("max", 100)}')     # 100——键不存在，用默认值

print(f'\ndebug是否设置: {config.is_set("debug")}')  # True
print(f'debug值: {config.get_bool("debug")}')        # False

# 检查必需配置
config.require('host', 'port')           # OK
# config.require('host', 'retry')         # ValueError——retry是None

def clean_user_data(raw_data):
    """
    清洗用户数据——正确处理各种空值情况
    
    原则：
    - None → 保持None（表示未知/未提供）
    - 空字符串 → 转为None（统一表示"未填写"）
    - 空白字符串 → 转为None
    - 0 → 保留（是有意义的数值）
    - '0' → 保留或转成0（根据字段语义）
    """
    cleaned = {}
    
    # 姓名字段——不能为空
    name = raw_data.get('name')
    if name is None or not str(name).strip():
        raise ValueError('姓名不能为空')
    cleaned['name'] = str(name).strip()
    
    # 年龄字段——None表示未知，0表示婴儿
    age = raw_data.get('age')
    if age is None:
        cleaned['age'] = None  # 未知
    elif age == '' or str(age).strip() == '':
        cleaned['age'] = None  # 空字符串当作未知
    else:
        try:
            cleaned['age'] = int(age)
        except (ValueError, TypeError):
            cleaned['age'] = None  # 无效的年龄当作未知
    
    # 邮箱字段——可选
    email = raw_data.get('email')
    if email is None or str(email).strip() == '':
        cleaned['email'] = None
    else:
        cleaned['email'] = str(email).strip().lower()
    
    # 订阅状态——False是合法值
    subscribed = raw_data.get('subscribed')
    if subscribed is None:
        cleaned['subscribed'] = False  # 默认不订阅
    elif isinstance(subscribed, bool):
        cleaned['subscribed'] = subscribed
    elif isinstance(subscribed, str):
        cleaned['subscribed'] = subscribed.lower() in ('true', '1', 'yes', 'y')
    else:
        cleaned['subscribed'] = bool(subscribed)
    
    return cleaned


# 测试
print('清洗结果:')
print(clean_user_data({'name': '小明', 'age': '25', 'email': 'XiaoMing@TEST.com', 'subscribed': True}))
print(clean_user_data({'name': '小红', 'age': '', 'email': '  ', 'subscribed': None}))
print(clean_user_data({'name': '婴儿', 'age': '0', 'subscribed': 'false'}))
# print(clean_user_data({'name': '', 'age': '30'}))  # ValueError

# ❌ 常见错误
def process(value):
    if not value:          # 把0、''、[]、False都当成None了
        value = '默认值'
    return value

print(process(None))   # 默认值 ✓
print(process(0))      # 默认值 ✗——0是有意义的值！
print(process(''))     # 默认值 ✗——空字符串也可能有意义
print(process(False))  # 默认值 ✗——False是合法布尔值

# ✅ 正确
def process(value):
    if value is None:     # 只检查None
        value = '默认值'
    return value

config = {'timeout': 0, 'retries': 0, 'debug': False}

# ❌ 错误
timeout = config.get('timeout') or 30   # 30！——0被当作假值替换了！
debug = config.get('debug') or True     # True！——False被替换了！

# ✅ 正确
timeout = config.get('timeout') if config.get('timeout') is not None else 30
# 或者用更简洁的方式（但需要理解in的语义）
timeout = config['timeout'] if 'timeout' in config else 30

# ❌ 常见Bug——函数可能返回None但调用者没有检查
def find_user(user_id):
    users = {1: {'name': '小明'}}
    return users.get(user_id)  # 可能返回None

# 危险的调用
user = find_user(99)
print(f'用户名长度: {len(user["name"])}')  # TypeError: object of type 'NoneType' has no len()

# ✅ 安全调用
user = find_user(99)
if user is not None:
    print(f'用户名长度: {len(user["name"])}')
else:
    print('用户不存在')

# 两者等价，但PEP 8推荐前者
x = None

print(x is not None)    # True——推荐
print(not (x is None))  # True——等价，但多了括号

# ⚠️ 永远不要写：
# x is (not None)  # 这等价于 x is True，完全是错误的！