如何获取 Python 中列表中元素的数量（列表的长度）？

Question

如何获取列表items中的元素数？

items = ["apple", "orange", "banana"]

# There are 3 items.

Answer 1

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

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

Answer 2

如何获取列表的大小？

要查找列表的大小，请使用内置函数len ：

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

现在：

len(items)

返回 3。

解释

Python 中的一切都是对象，包括列表。 所有对象在 C 实现中都有某种类型的头文件。

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

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

从文档

len(s)

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

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

object.__len__(self)

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

我们还可以看到__len__是一个列表方法：

items.__len__()

返回 3。

您可以获得的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 items或if not items都更具可读性和更高的性能。

Answer 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属性的额外好处。

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

Answer 4

除了len您还可以使用operator.length_hint （需要 Python 3.4+）。 对于普通list两者是等效的，但length_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_hint根据定义只是一个“提示”，所以大多数时候len更好。

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

Answer 5

为了完整性（主要是教育性的），可以不使用len()函数。 我不会宽恕这是一个很好的选择DO NOT PROGRAM LIKE THON IN PYTHON ，但它用于学习算法。

def count(list):
    item_count = 0
    for item in list[:]:
        item_count += 1
    return item_count

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

（ list[:]带冒号的索引操作是隐式的，因此也是可选的。）

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

跟踪长度以提高性能同时占用更多内存空间的示例。 请注意，我从不使用 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

Answer 6

回答您的问题作为之前也给出的例子：

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

print items.__len__()

Answer 7

要获取任何顺序对象中的元素数，Python 中的 goto 方法是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

Answer 8

python 中有一个名为 len() 的内置函数，可以帮助解决这些情况。

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

输出：

>>> 6

在字符串的情况下，这将略有不同（如下）：

a="Hello"
print(len(a)) #Here the len() function counts the alphabets or characters in the list.

输出：

>>> 5

这是因为变量 (a) 是一个字符串而不是一个列表，所以它会计算字符串中的字符数或字母数，然后打印输出。

Answer 9

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

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是一个C整数，被转换为 Python int （在 C 代码中仍称为“Long”，因为 Python 2 有两种用于存储整数的类型）并返回。

Answer 10

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

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__任何大小的对象）。

Answer 11

您可以通过三种方式找到列表中元素的长度。 我将在此处将 3 种方法与性能分析进行比较。

方法一：使用len()

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

print(len(items))

输出：

3

方法 2：使用 Naive Counter 方法

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

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

print(counter)

输出：

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

性能分析length_hint() vs len() vs 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

结论

可以清楚地看到，与其他两种方法相比，naive 花费的时间非常大，因此len() & length_hint()是最好的选择。

Answer 12

只需使用

len(list_name)

或者你可以创建一个函数链接 -

def count(list):
item_count = 0
for item in list[:]:
    item_count += 1
return item_count

Answer 13

如何在 Python 中查找列表的长度

Python 中的 List 用于存储各种类型的数据的序列，这些数据是有序的、可变的，它也可以有重复的值。 在这里，Python 有三种方法来查找列表的长度：

1. len()

它是一个名为 len() 的内置函数，用于获取列表中元素的总数。 len() 方法接受参数，您可以在其中提供一个列表并返回给定列表的长度。 这是在 Python 中查找列表长度的最方便的方法。

    #Finding length of list by using len() method
    list_example = [1, 2, 3, 4, 5,6,7,8,9]
    print("The length of list is: ", len(list_example))
    The output will be:
    
    Output:
    The length of list is:  9

2. 朴素的方法

使用 for 循环可以很容易地找到列表的长度，这种方法称为 Naive 方法。 可以总结如下：

首先，声明一个计数器变量并将其初始化为零。

使用for循环，遍历所有数据元素，遇到每个元素后，将计数器变量加1。

现在，数组的长度将存储在计数器变量中，它将表示列表中元素的数量。

#Finding length of list by using Naive method
#Initializing list
list_example = [1, 2, 3, 4, 5,6,7,8,9]
print("The list is: ", str(list_example))
#finding length of list using loop
counter = 0
for i in list_example:
    counter = counter + 1
print ("Length of list using Naive Method is: ", str(counter))

3. 长度提示（）

该方法在算子类中定义，也可以定义列表的长度。

#Using Length_hint() Method
from operator import length_hint
list_len_1 = [1, 2, 3, 5, 6, 'PickupBrain']
list_len_hint = length_hint(list_len_1)
print(list_len_hint)

len()、Naive Method 和 lenght_list 方法的性能测试

此时间分析将有助于了解执行所有方法所需的时间，这将帮助您选择一个而不是另一个。

#Code for Performance Analysis
from operator import length_hint
import time
#define list
list_example = [1, 2, 3, 4, 5,6,7,8,9]
print("The list is: ", list_example)
# Using Naive method & loop to find length of list
# Initializing counter
start_naive_time = time.time()
counter = 0
for i in list_example:
    counter = counter + 1
    end_naive_time = float(time.time() - start_naive_time)
# Using len() method
start_len_time = time.time()
list_len = len(list_example)
end_len_time = float(time.time()- start_len_time)
# Using length_hint() method
start_hint_time = time.time()
list_hint = length_hint(list_example)
end_hint_time = float(time.time()- start_hint_time)
#Printing time for each method
print("Time taken by Naive Method: ", end_naive_time)
print("Time taken by Length_hint() Method: ", end_len_time)
print("Time taken by len() Method: ", end_hint_time)
The output will be this:

Output:

The list is:  [1, 2, 3, 4, 5, 6, 7, 8, 9]
Time taken by Naive Method:  3.0994415283203125e-06
Time taken by Length_hint() Method:  4.76837158203125e-07
Time taken by len() Method:  1.1920928955078125e-06

结论所花费的时间是 Naive Method >> len() >length_hint()