如何获取列表 items
中的元素数?
items = ["apple", "orange", "banana"]
# There are 3 items.
如何获取列表的大小?
要查找列表的大小,请使用内置函数 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
都更具可读性和性能。
虽然这可能没有用,因为它作为“开箱即用”的功能更有意义,但一个相当简单的技巧是构建一个具有 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
,您还可以使用 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__
方法总是更安全!
并且为了完整性(主要是教育性的),可以不使用 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
来增加。
length = max(enumerate(list))[0] + 1
。
len()
上对这种巧妙的回避笑了
以前面给出的示例回答您的问题:
items = []
items.append("apple")
items.append("orange")
items.append("banana")
print items.__len__()
__foo__
:这只是一个约定,是 Python 系统使用不会与用户名冲突的名称的一种方式。 2. _foo
:这只是一个约定,是程序员指示变量是私有的(无论在 Python 中是什么意思)的一种方式。 3. __foo
:这有实际意义:解释器用_classname__foo
替换这个名字,以确保这个名字不会与另一个类中的相似名字重叠。 * 在 Python 世界中没有其他形式的下划线有意义。 * 在这些约定中,类、变量、全局等没有区别。
您可以使用 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__
的任何大小的对象)。
在 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()
,例如。
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
len(x for x in range(8))
-> TypeError: object of type 'generator' has no len()
。
您可以通过三种方式找到列表中元素的长度。我将在此处将这 3 种方法与性能分析进行比较。
方法一:使用 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
性能分析——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()
是使用的最佳选择。
就 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 有两种用于存储整数的类型)并返回。
len
调用 PyObject_Size()
”并没有说明它的作用,即“PyObject_Size()
calls 传递的 sq_length
或 PyMapping_Size在对象中。”
只需使用
len(list_name)
或者你可以创建一个函数链接 -
def count(list):
item_count = 0
for item in list[:]:
item_count += 1
return item_count
如何在 Python 中查找列表的长度
Python 中的 List 用于存储各种类型的数据的序列,这些数据是有序的、可变的,它也可以有重复的值。在这里,Python 有三种方法来查找列表的长度:
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
朴素的方法
使用 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))
长度提示()
该方法在算子类中定义,也可以定义列表的长度。
#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()
不定期副业成功案例分享
length = property(len)
并跳过单行包装函数,并将len
的文档/自省与您的属性一起保存。