Python里len怎么用|完整指南

深入解析Python内置函数len:从基础用法到高级技巧,覆盖所有常见数据类型与实战场景

🌐 www.xservx.com|备案号:蜀ICP备2026035467号-3

一、len函数:Python内置的长度统计核心工具

len是Python中使用频率最高的内置函数之一,它返回对象的长度或元素个数。从字符串、列表到字典、集合,len提供了一种统一、高效的统计方式,无需遍历整个对象即可获取其“大小”。

在Python设计哲学中,len函数体现了“鸭子类型”原则:只要对象实现了__len__方法,就能被len调用。这种设计极大增强了语言的扩展性与一致性。

为什么len是函数而非方法?

早期Python曾考虑将len作为方法(如obj.length()),但最终选择作为内置函数,原因有三:

  • 保持与C语言传统一致(如strlen())
  • 统一接口:所有序列/容器均支持len,不依赖具体类型
  • 性能优化:CPython对常见类型(list、str、tuple等)做了O(1)优化

因此,len本质是调用对象的__len__方法的语法糖,但其封装使代码更简洁、语义更清晰。

二、len函数语法与基本用法

len(obj)

参数:obj为任意可计算长度的对象(需实现__len__或__length_hint__)

返回值:非负整数(若对象未实现长度协议,则抛出TypeError)

基础示例

# 字符串
s = "Hello, Python!"
print(len(s))  # 输出:14
# 列表
lst = [1, 2, 3, [4, 5]]
print(len(lst))  # 输出:4(仅统计最外层元素)
# 元组
t = (1, 2, 3)
print(len(t))  # 输出:3
# 字典
d = {"a": 1, "b": 2}
print(len(d))  # 输出:2(统计键数量)
# 集合
st = {1, 2, 3, 3}
print(len(st))  # 输出:3(去重后元素数)
# range对象
r = range(5, 15, 3)
print(len(r))  # 输出:4(5,8,11,14)
# 空容器
print(len([]))  # 输出:0
print(len(""))  # 输出:0
print(len({}))  # 输出:0

⚠️ 注意:嵌套结构的长度仅统计**直接子元素**数量。如列表[1, [2,3], 4]长度为3,而非4。

三、常见数据类型中len的行为详解

1. 字符串(str)

len返回字符串的**字符数**(Unicode码点数量),而非字节数。

s1 = "你好"
s2 = "hello"
s3 = "café"  # é是单个字符
s4 = "🚀"    # 旗帜emoji
print(len(s1))  # 2
print(len(s2))  # 5
print(len(s3))  # 4
print(len(s4))  # 1

对比字节长度(需编码):

print(len(s1.encode('utf-8')))  # 6(UTF-8中“你”占3字节,“好”占3字节)
print(len(s4.encode('utf-8')))  # 4(emoji通常占4字节)

💡 实用场景:校验输入长度(如密码至少8字符)、文本分块处理。

2. 列表(list)

len返回列表中**顶层元素个数**,不递归统计嵌套内容。

lst = [1, [2,3], "abc", None]
print(len(lst))  # 4
# 验证嵌套不影响
nested = [[1,2], [3,4,5], [6]]
print(len(nested))  # 3
print(len(nested[1]))  # 3(访问子列表)

⚠️ 常见误区:误以为len([[1,2], [3]])返回3,实际为2。

3. 字典(dict)

len返回字典中**键值对数量**,等价于键的数量。

d = {"name":"Alice","age":30,"city":"Beijing"}
print(len(d))  # 3
# 动态变化示例
d["job"] = "Engineer"
print(len(d))  # 4
del d["age"]
print(len(d))  # 3

💡 提示:字典长度反映当前状态,是动态值。

4. 集合(set)

len返回集合中**唯一元素数量**(自动去重)。

st = {1, 2, 2, 3, 3, 3}
print(len(st))  # 3
# 空集
empty_st = set()
print(len(empty_st))  # 0
# 集合推导式
st2 = {x%3 for x in range(10)}
print(len(st2))  # 3({0,1,2})

5. 元组(tuple)

行为与列表完全一致,统计顶层元素数量。

t = (1, 2, (3,4), 5)
print(len(t))  # 4
# 空元组
print(len(()))  # 0

6. range对象

len返回range生成的**整数序列长度**,计算公式为max(0, (stop-start)//step)。

print(len(range(5)))      # 5(0,1,2,3,4)
print(len(range(2,8,2)))  # 3(2,4,6)
print(len(range(10,5,-1)))# 5(10,9,8,7,6)
print(len(range(5,5,1)))  # 0(空序列)

💡 注意:负步长且start < stop时返回空序列,长度为0。

四、自定义类支持len:实现__len__协议

要让自定义类支持len,只需在类中定义__len__方法,返回非负整数。

示例:自定义容器类

class BookCollection:
    def __init__(self):
        self.books = []
    def add_book(self, title):
        self.books.append(title)
    def remove_book(self, title):
        if title in self.books:
            self.books.remove(title)
    def __len__(self):
        return len(self.books)
# 使用
collection = BookCollection()
collection.add_book("Python Core")
collection.add_book("Data Science")
print(len(collection))  # 2
collection.remove_book("Python Core")
print(len(collection))  # 1

💡 实现__len__时需确保:

  • 返回值为整数(int或bool,但bool会被视为0或1)
  • 返回值 ≥ 0,否则抛出ValueError
  • 避免在__len__中执行耗时操作(应缓存长度)

进阶:实现可变长度对象

class DynamicBag:
    def __init__(self):
        self._items = []
        self._length = 0
    def add(self, item):
        self._items.append(item)
        self._length += 1
    def remove(self, item):
        if item in self._items:
            self._items.remove(item)
            self._length -= 1
    def __len__(self):
        return self._length
    def __repr__(self):
        return f"DynamicBag({self._items})"
bag = DynamicBag()
bag.add(10); bag.add(20)
print(len(bag))  # 2
bag.remove(10)
print(len(bag))  # 1

五、性能优化:len的O(1)魔法

为什么len通常是O(1)?

CPython对内置类型做了特殊优化:

  • 列表/元组:长度存储在PyVarObject.ob_size字段中,直接读取
  • 字符串:长度缓存在PyASCIIObject.length中
  • 字典/集合:长度存储在PyDictObject.ma_used中

因此:len([1]*1000000)与len([1,2,3])耗时几乎相同!

import timeit
# 测试不同长度列表的len()耗时
for size in [10, 1000, 1000000]:
    lst = list(range(size))
    t = timeit.timeit(lambda: len(lst), number=100000)
    print(f"列表长度 {size:>7}:{t:.6f} 秒/10万次调用")
列表大小len()耗时(秒/10万次)
100.0041
1,0000.0043
1,000,0000.0045

对比:手动计数(O(n))

def manual_count(lst):
    count = 0
    for _ in lst:
        count += 1
    return count
# len(lst) vs manual_count(lst)
lst = list(range(10000))
print(timeit.timeit(lambda: len(lst), number=1000))    # 约0.0003秒
print(timeit.timeit(lambda: manual_count(lst), number=1000))  # 约0.15秒

💡 最佳实践:

六、常见误区与陷阱

误区1:误认为len对生成器可用

生成器是惰性求值,无法直接获取长度:

gen = (x**2 for x in range(5))
print(len(gen))  # TypeError: object of type 'generator' has no len()

解决方案:

# 方案1:转为列表(内存消耗大)
print(len(list(gen)))  # 5
# 方案2:用itertools.count(推荐)
from itertools import count, islice
gen = (x**2 for x in range(5))
length = sum(1 for _ in gen)
print(length)  # 5
误区2:字符串字节长度与字符长度混淆

中文/emoji在UTF-8中占多字节,但len统计字符数:

s = "你好🚀"
print(len(s))                # 3(字符数)
print(len(s.encode('utf-8'))) # 9(字节数:你3+好3+🚀3)

适用场景:

  • 前端显示限制:用len(用户看到的是字符数)
  • 网络传输:用字节长度(实际带宽消耗)
误区3:字典中None值被计入长度

len只统计键数量,值内容无关:

d = {"a": None, "b": 0, "c": False}
print(len(d))  # 3(三个键)
误区4:空字符串与None混淆
print(len(""))  # 0(空字符串)
print(len(None))  # TypeError

判断空容器应直接用len或布尔上下文:

s = ""
if not s:  # 更Pythonic
    print("空字符串")
# 避免
if len(s) == 0:
    print("空字符串")

陷阱:可变对象修改后长度变化

lst = [1, 2, 3]
n = len(lst)  # n=3
lst.append(4)
print(len(lst))  # 4
print(n)         # 3(n未更新!)

解决方案:始终在需要时直接调用len,而非缓存值。

七、网友最关心的问题集锦

💡 真实案例:某电商网站统计购物车商品数,错误使用len(cart.items)(items是生成器),导致长度始终为0。修复后改用len(list(cart.items)),但更优方案是直接在数据库层COUNT(*)。

附:Python版本兼容性

常用数据类型len速查表

类型len含义空值长度
str字符数0
list/tuple顶层元素数0
dict键数量0
set/frozenset唯一元素数0
range序列长度0
bytes字节数0
bytearray字节数0