#0函数可以与Python中的几种不同类型一起使用——包括内置类型和库类型。例如：

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

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

class slist(list):@propertydef length(self):return len(self)

你可以像这样使用它：

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

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

一如既往，因人而异。

如何获取列表的长度？

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

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

现在：

len(items)

返回3。

补充说明

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

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

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

从文档

len(s)

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

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

object.__len__(self)

调用以实现内置函数len()。应该返回对象的长度，一个整数>=0。此外，一个没有定义一个__nonzero__()[在Python 2中或在Python 3中的__bool__()]方法，其__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更具可读性和性能。

回答你的问题，正如前面给出的例子：

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

除了#0之外，您还可以使用#1（需要Python 3.4+）。对于普通的list来说，两者都是等效的，但是length_hint可以获取list迭代器的长度，这在某些情况下可能很有用：

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

为了完整性（主要是教育性的），可以不使用len()函数。我不会宽恕这是一个好的选择在Python中不要这样编程，但它有助于学习算法。

def count(list):item_count = 0for item in list[:]:item_count += 1return item_count
count([1,2,3,4,5])

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

对于新程序员来说，这里的教训是：如果不在某个时候计算它们，就无法获得列表中的元素数量。问题变成了：什么时候是计算它们的好时机？例如，像连接系统调用套接字（用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 classdef __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) # 3mylist.remove(3)print(mylist.length) # 2

就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是对象可以拥有的最大长度。#1是一个返回对象大小的函数。如果它不能确定对象的大小，则返回-1。在这种情况下，将执行此代码块：

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

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

    return PyLong_FromSsize_t(res);

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

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

要获取任何顺序对象中的元素数量，您在Python中的goto方法是len() eg。

a = range(1000) # rangeb = 'abcdefghijklmnopqrstuvwxyz' # stringc = [10, 20, 30] # Listd = (30, 40, 50, 60, 70) # tuplee = {11, 21, 31, 41} # set

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

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

len()方法的粗略估计

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

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

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

方法1：使用len()

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

输出：

3

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

items = []items.append("apple")items.append("orange")items.append("banana")
counter = 0for 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_hintlist_len_hint = length_hint(items)print(list_len_hint)

输出：

3

性能分析-朴素vslen() vslength_hint()

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

items = list(range(100000000))
# Performance Analysisfrom operator import length_hintimport time
# Finding length of list# using loop# Initializing counter
start_time_naive = time.time()counter = 0for i in items:# incrementing countercounter = counter + 1end_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 eachprint("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.536813735961914Time taken using len() is : 0.0Time taken using length_hint() is : 0.0

结论

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

如何在Python中查找列表长度

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

1. len（）

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

    #Finding length of list by using len() methodlist_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循环可以很容易地找到列表的长度，这种方法称为朴素方法。它可以总结如下：

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

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

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

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

3. length_hint（）

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

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

len（）、朴素方法和lenght_list方法的性能测试

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

#Code for Performance Analysisfrom operator import length_hintimport time#define listlist_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 counterstart_naive_time = time.time()counter = 0for i in list_example:counter = counter + 1end_naive_time = float(time.time() - start_naive_time)# Using len() methodstart_len_time = time.time()list_len = len(list_example)end_len_time = float(time.time()- start_len_time)# Using length_hint() methodstart_hint_time = time.time()list_hint = length_hint(list_example)end_hint_time = float(time.time()- start_hint_time)#Printing time for each methodprint("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-06Time taken by Length_hint() Method:  4.76837158203125e-07Time taken by len() Method:  1.1920928955078125e-06

结论所花费的时间是朴素方法>>len（）>length_hint（）