len（） 函数可以与 Python 中的几种不同类型一起使用 - 内置类型和库类型。例如：

>>> len([1, 2, 3])
3

虽然这可能没有用，因为它作为“开箱即用”功能更有意义，但一个相当简单的技巧是构建一个带有属性的类：length

class slist(list):
    @property
    def length(self):
        return len(self)

您可以这样使用它：

>>> l = slist(range(10))
>>> l.length
10
>>> print l
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

从本质上讲，它与列表对象完全相同，但具有 OOP 友好属性的额外好处。length

与往常一样，您的里程可能会有所不同。

如何获取列表的长度？

要查找列表中的元素数，请使用内置函数 len：

items = []
items.append("apple")
items.append("orange")
items.append("banana")

现在：

len(items)

返回 3。

解释

Python 中的所有内容都是一个对象，包括列表。所有对象在 C 实现中都有某种标头。

特别是 Python 中具有“大小”的列表和其他类似的内置对象，具有一个名为 的属性，其中缓存了对象中的元素数。因此，检查列表中的对象数量非常快。ob_size

但是，如果您要检查列表大小是否为零，请不要使用 - 而是将列表放在布尔上下文中 - 如果为空，则将其视为 False，如果非空，则将其视为 True。len

从文档中

len(s)

返回对象的长度（项数）。参数可以是序列（如字符串、字节、元组、列表或范围）或 集合（如字典、集合或冻结集合）。

len是用 实现的，来自数据模型文档：__len__

object.__len__(self)

调用来实现内置函数 。应返回对象的长度，即整数 >= 0。此外，一个没有的对象 定义一个 [在 Python 2 或 Python 3 中] 方法，其方法返回零 在布尔上下文中被认为是假的。len()__nonzero__()__bool__()__len__()

我们也可以看到，这是一种列表的方法：__len__

items.__len__()

返回 3。

内置类型，您可以获得 （length）len

事实上，我们看到我们可以获得所有描述类型的这些信息：

>>> all(hasattr(cls, '__len__') for cls in (str, bytes, tuple, list, 
                                            range, dict, set, frozenset))
True

不要用于测试空列表或非空列表len

当然，要测试特定长度，只需测试相等性：

if len(items) == required_length:
    ...

但是，对于零长度列表或相反列表的测试，有一种特殊情况。在这种情况下，不要测试相等性。

另外，不要做：

if len(items): 
    ...

相反，只需执行以下操作：

if items:     # Then we have some items, not empty!
    ...

或

if not items: # Then we have an empty list!
    ...

我在这里解释了原因，但简而言之，或者比其他替代方案更具可读性和性能。if itemsif not items

回答您的问题，如之前给出的示例：

items = []
items.append("apple")
items.append("orange")
items.append("banana")

print items.__len__()

除了 len，您还可以使用 operator.length_hint（需要 Python 3.4+）。对于普通值，两者是等价的，但可以获取列表迭代器的长度，这在某些情况下可能很有用：listlength_hint

>>> from operator import length_hint
>>> l = ["apple", "orange", "banana"]
>>> len(l)
3
>>> length_hint(l)
3

>>> list_iterator = iter(l)
>>> len(list_iterator)
TypeError: object of type 'list_iterator' has no len()
>>> length_hint(list_iterator)
3

但根据定义，这只是一个“提示”，所以大多数时候更好。length_hintlen

我已经看到几个建议访问的答案。在处理像 这样的内置类时，这是可以的，但它可能会导致自定义类出现问题，因为（和）实现了一些安全检查。例如，两者都不允许负长度或长度超过特定值（值）。因此，使用函数而不是方法总是更安全！__len__listlenlength_hintsys.maxsizelen__len__

为了完整性（主要是教育性的），可以在不使用该功能的情况下进行。我不会宽恕这是一个不错的选择，不要在 PYTHON 中这样编程，但它用于学习算法。len()

def count(list):   # list is an iterable object but no type checking here!
    item_count = 0
    for item in list:
        item_count += 1
    return item_count

count([1,2,3,4,5])

（列表对象必须是可迭代的，由节暗示。for..in

对于新程序员来说，这里的教训是：如果不在某个时候计算它们，你就无法获得列表中的项目数量。问题变成了：什么时候是计算它们的好时机？例如，像连接系统调用套接字（用 C 编写）这样的高性能代码不会计算元素的长度（将该责任交给调用代码）。注意到地址的长度被传递以节省先计算长度的步骤吗？另一种选择：从计算上讲，在传递的对象中添加项目时跟踪项目的数量可能是有意义的。请注意，这会占用更多内存空间。查看 Naftuli Kay 的回答。connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

跟踪长度以提高性能，同时占用更多内存空间的示例。请注意，我从不使用 len（） 函数，因为长度是跟踪的：

class MyList(object):
    def __init__(self):
        self._data = []
        self.length = 0 # length tracker that takes up memory but makes length op O(1) time
        

        # the implicit iterator in a list class
    def __iter__(self):
        for elem in self._data:
            yield elem
            
    def add(self, elem):
        self._data.append(elem)
        self.length += 1
            
    def remove(self, elem):
        self._data.remove(elem)
        self.length -= 1
            
mylist = MyList()
mylist.add(1)
mylist.add(2)
mylist.add(3)
print(mylist.length) # 3
mylist.remove(3)
print(mylist.length) # 2

简单：使用 或len(list)list.__len__()

就实际工作原理而言，这是它的 C 实现：len()

static PyObject *
builtin_len(PyObject *module, PyObject *obj)
/*[clinic end generated code: output=fa7a270d314dfb6c input=bc55598da9e9c9b5]*/
{
    Py_ssize_t res;

    res = PyObject_Size(obj);
    if (res < 0) {
        assert(PyErr_Occurred());
        return NULL;
    }
    return PyLong_FromSsize_t(res);
}

Py_ssize_t是对象可以具有的最大长度。PyObject_Size（） 是一个返回对象大小的函数。如果它无法确定对象的大小，则返回 -1。在这种情况下，将执行以下代码块：

    if (res < 0) {
        assert(PyErr_Occurred());
        return NULL;
    }

结果引发了异常。否则，将执行此代码块：

    return PyLong_FromSsize_t(res);

res这是一个整数，被转换为 Python（在 C 代码中仍称为“Long”，因为 Python 2 有两种用于存储整数的类型）并返回。Cint

python 中有一个名为 len（） 的内置函数，可以在这些情况下提供帮助。

>>> a = [1,2,3,4,5,6]
>>> len(a)  # Here the len() function counts the number of items in the list.
6

这在字符串的情况下会略有不同：它计算字符数。

>>> a = "Hello"
>>> len(a)
5

要获取任何连续对象中的元素数，Python 中的 goto 方法是 eg。len()

a = range(1000) # range
b = 'abcdefghijklmnopqrstuvwxyz' # string
c = [10, 20, 30] # List
d = (30, 40, 50, 60, 70) # tuple
e = {11, 21, 31, 41} # set

len()方法可以处理上述所有数据类型，因为它们是可迭代的，即您可以迭代它们。

all_var = [a, b, c, d, e] # All variables are stored to a list
for var in all_var:
    print(len(var))

该方法的粗略估计len()

def len(iterable, /):
    total = 0
    for i in iterable:
        total += 1
    return total

您可以使用该函数在 python 中查找可迭代对象的长度。len()

my_list = [1, 2, 3, 4, 5]
print(len(my_list))  # OUTPUT: 5

该函数还适用于字符串：len()

my_string = "hello"
print(len(my_string))  # OUTPUT: 5

总而言之，适用于任何序列或集合（或定义 的任何大小的对象）。len()__len__

有三种方法可以在列表中找到元素的长度。我将在这里将 3 种方法与性能分析进行比较。

方法 1：使用len()

items = []
items.append("apple")
items.append("orange")
items.append("banana")

print(len(items))

输出：

3

方法 2：使用朴素计数器方法

items = []
items.append("apple")
items.append("orange")
items.append("banana")

counter = 0
for i in items:
    counter = counter + 1

print(counter)

输出：

3

方法 3：使用length_hint()

items = []
items.append("apple")
items.append("orange")
items.append("banana")

from operator import length_hint
list_len_hint = length_hint(items)
print(list_len_hint)

输出：

3

性能分析 – 朴素 vs vslen()length_hint()

注意：为了进行比较，我将输入列表更改为一个大集合，该集合可以提供大量的时间差来比较方法。

items = list(range(100000000))

# Performance Analysis
from operator import length_hint
import time

# Finding length of list
# using loop
# Initializing counter

start_time_naive = time.time()
counter = 0
for i in items:
    # incrementing counter
    counter = counter + 1
end_time_naive = str(time.time() - start_time_naive)

# Finding length of list
# using len()
start_time_len = time.time()
list_len = len(items)
end_time_len = str(time.time() - start_time_len)

# Finding length of list
# using length_hint()
start_time_hint = time.time()
list_len_hint = length_hint(items)
end_time_hint = str(time.time() - start_time_hint)

# Printing Times of each
print("Time taken using naive method is : " + end_time_naive)
print("Time taken using len() is : " + end_time_len)
print("Time taken using length_hint() is : " + end_time_hint)

输出：

Time taken using naive method is : 7.536813735961914
Time taken using len() is : 0.0
Time taken using length_hint() is : 0.0

结论

可以清楚地看到，与其他两种方法相比，朴素所需的时间非常长，因此 & 是使用的最佳选择。len()length_hint()