如何在 Python 中获取列表中的元素数量？

迷南。 2024-03-29 14:45 95阅读 0赞

## 问： ##

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

items = ["apple", "orange", "banana"]
    
    # There are 3 items.

## 答1: ##

> huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

len() 函数可用于 Python 中的多种不同类型 - 内置类型和库类型。例如：

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

## 答2: ##

> huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

如何获取列表的大小？

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

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

现在：

len(items)

返回 3。

解释

Python 中的一切都是对象，包括列表。所有对象在 C 实现中都有某种标题。

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

但是，如果您要检查列表大小是否为零，请不要使用 len - 而应使用 put the list in a boolean context - it treated as False if empty, True otherwise。

从文档

len(s)

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

len 通过数据模型 docs 中的 **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!
        ...

我explain why here 但简而言之，if items 或 if not items 都更具可读性和性能。

## 答3: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

虽然这可能没有用，因为它作为“开箱即用”的功能更有意义，但一个相当简单的技巧是构建一个具有 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 属性的额外好处。

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

`如您所知，您可以只执行 length = property(len) 并跳过单行包装函数，并将 len 的文档/自省与您的属性一起保存。`

## 答4: ##

> huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

除了 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** 方法总是更安全！

## 答5: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

并且为了完整性（主要是教育性的），可以不使用 len() 函数。我不会容忍这是一个很好的选择不要在 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‘s answer。

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

`为什么是for item in list[:]:？为什么不for item in list:？另外，我会使用 += 1 来增加。`

`@GrannyAching 我明确提到了可选的冒号（范围说明符）。出于教育目的，我将范围说明符留在那里 - 知道它是隐含的是有益的。正如您所建议的那样，还推断出列表类型 [] 与我的代码等效。增量运算符也相当于将 1 添加到现有变量，但在所有情况下都更短。因此，如果这是您的推理，我同意应该使用它。无论如何，这段代码不应该在任何地方投入生产（学习编程时除外）。`

`如果我们要陷入“不要这样做，但它很有趣”的兔子洞，我会提供 length = max(enumerate(list))[0] + 1。`

`@KirkStrauser 哈哈，我在 len() 上对这种巧妙的回避笑了`

## 答6: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

以前面给出的示例回答您的问题：

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

`在 Python 中，以下划线开头的名称在语义上是非公共方法，用户不应使用。`

`1. __foo__：这只是一个约定，是 Python 系统使用不会与用户名冲突的名称的一种方式。 2. _foo：这只是一个约定，是程序员指示变量是私有的（无论在 Python 中是什么意思）的一种方式。 3. __foo：这有实际意义：解释器用_classname__foo替换这个名字，以确保这个名字不会与另一个类中的相似名字重叠。 * 在 Python 世界中没有其他形式的下划线有意义。 * 在这些约定中，类、变量、全局等没有区别。`

`此问答解释了为什么您不应直接以用户身份使用特殊方法：stackoverflow.com/q/40272161/541136`

`@AaronHall 但对于 len 功能几乎相同。对于非常大的变量，它可能会更快。但是，我明白你的意思，我们应该使用 len(obj) 而不是 obj.__len__()。`

## 答7: ##

> huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

您可以使用 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** 的任何大小的对象）。

## 答8: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

在 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) 是一个字符串而不是一个列表，所以它会计算字符串中的字符或字母的数量，然后打印输出。

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

## 答9: ##

> huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

要获取任何顺序对象中的元素数量，您在 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

`"any iterable" -- 这是不正确的。我认为您的意思是“任何序列”。生成器，例如：len(x for x in range(8)) -> TypeError: object of type 'generator' has no len()。`

`迭代器和可迭代之间存在细微差别。所有迭代器都是可迭代的，但不是。更多解释请参考这篇文章geeksforgeeks.org/python-difference-iterable-iterator/amp`

## 答10: ##

> huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

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

方法一：使用 len()

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

输出：

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

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)

输出：

性能分析——Naive 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() 是使用的最佳选择。

> huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

## 答11: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

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

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 有两种用于存储整数的类型）并返回。

`为什么了解或了解 C 实现很重要？`

`由于此问题并非特定于 CPython，因此此答案可能具有误导性。 PyPy，IronPython，...可以并且确实以不同的方式实现它。`

`这不是一个有用的答案，因为它只是说“len 调用 PyObject_Size()”并没有说明它的作用，即“PyObject_Size() calls 传递的 sq_length 或 PyMapping_Size在对象中。”`

原文链接：[https://www.huntsbot.com/qa/WyVP/how-do-i-get-the-number-of-elements-in-a-list-in-python?lang=zh\_CN&from=csdn][https_www.huntsbot.com_qa_WyVP_how-do-i-get-the-number-of-elements-in-a-list-in-python_lang_zh_CN_from_csdn]

> huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。

[https_www.huntsbot.com_qa_WyVP_how-do-i-get-the-number-of-elements-in-a-list-in-python_lang_zh_CN_from_csdn]: https://www.huntsbot.com/qa/WyVP/how-do-i-get-the-number-of-elements-in-a-list-in-python?lang=zh_CN&from=csdn