MyVar = [0,1,0]

解决方法

>>> sum(1 for element in MyVar if element != 0)
1

>>> sum(1 for element in MyVar if element)
1

这是为了更好地理解引用计数在Python中的工作原理.

让我们创建一个类并实例化它.实例的引用计数为1(getrefcount显示2,因为它自己的内部结构引用该类实例将引用计数增加1)：

>>> from sys import getrefcount as grc
>>> class A():
    def __init__(self):
        self.x = 100000


>>> a = A()
>>> grc(a)
2

a的内部变量x有2个引用：

>>> grc(a.x)
3

我希望它由a和_的__init__方法引用.然后我决定检查一下.

所以我在__main__命名空间中创建了一个临时变量b,以便能够访问变量x.它将ref-number增加1,使其变为3(如预期的那样)：

>>> b = a.x
>>> grc(a.x)
4

然后我删除了类实例,引用计数减少了1：

>>> del a
>>> grc(b)
3

所以现在有2个引用：一个是b,一个是A(正如我所料).

通过从__main__命名空间中删除A,我希望计数再次减少1.

>>> del A
>>> grc(b)
3

但它不会发生.没有类A或其实例可以引用100000,但它仍然被__main__名称空间中的b以外的引用引用.

所以,我的问题是,除了b之外,100000引用了什么？

BrenBarn建议我应该使用object()而不是可以存储在内部某处的数字.

>>> class A():
    def __init__(self):
        self.x = object()


>>> a = A()
>>> b = a.x
>>> grc(a.x)
3
>>> del a
>>> grc(b)
2

在删除实例a之后,b只有一个引用是非常合乎逻辑的.

唯一需要理解的是为什么数字100000不是这样的.

>>> def f(): return 10000
>>> f.__code__.co_consts
(None,10000)

这条线

del A

只删除名称A并减少A的引用计数.在Python 3.x中(但不在2.x中),类通常包含一些循环引用,因此只有在显式运行垃圾收集器时才会收集垃圾.事实上,使用

import gc
gc.collect()

在del A之后确实导致b的引用计数减少.

#单一类型
users=[''yangli'',''yite'',''fixd'']
#多类型，列表嵌套
users=[''room01'',[''yangli'',20,''音乐''],[''yite'',20,''篮球'']，]

#len(list) 计算列表的长度
ls = [''a'',''b'',''c'',''d'']
length = len(ls)
print(length)
#结果：4

#append() 追加
ls = [''a'',''b'',''c'',''d'']
ls.append(''x'')
print(ls)
#结果：[''a'', ''b'', ''c'', ''d'', ''x'']
#append 将元素添加到列表的末尾

#inser(index,obj) 插入: index插入列表的起始索引(必须指定)，obj插入的元素
ls = [''a'',''b'',''c'',''d'']
ls.insert(0,''x'')        #在头部插入
print(ls)               #结果：[''x'', ''a'', ''b'', ''c'', ''d'']

ls = [''a'',''b'',''c'',''d'']
ls.insert(len(ls),''x'')  #在尾部插入
print(ls)               #结果：[''a'', ''b'', ''c'', ''d'', ''x'']

ls = [''a'',''b'',''c'',''d'']
ls.insert(2,''x'')        #在原列表索引为2的元素前 插入obj
print(ls)               #结果：[''a'', ''b'', ''x'', ''c'', ''d'']

#remove()  移除列表中某个值的第一个匹配项，无返回值
ls = [''a'',''b'',''c'',''d'']
ls.remove(''c'')          #删除c
print(ls)               #结果：[''a'', ''b'', ''d'']

#pop(index)  移除列表中某个值的第一个匹配项，无返回值
ls = [''a'',''b'',''c'',''d'']
res = ls.pop()          #默认删除最后一个元素
print(ls)               #结果：[''a'', ''b'', ''c'']
print(res)              #结果：d     pop()返回删除的元素

ls = [''a'',''b'',''c'',''d'']
res = ls.pop(2)         #默认删除最后一个元素
print(ls)               #结果：[''a'', ''b'', ''d'']
print(res)              #结果：c     pop()返回删除的元素

#reverse()              #反转列表元素
ls = [''a'',''b'',''c'',''d'']
ls.reverse()
print(ls)               #[''d'', ''c'', ''b'', ''a'']

# + *
ls1 = [''a'',2,''c'']
ls2 = [1,''y'',''z'']
ls3 = ls1 + ls2
print(ls3)            #结果：[''a'', 2, ''c'', 1, ''y'', ''z'']
print(ls1*3)          #结果：[''a'', 2, ''c'', ''a'', 2, ''c'', ''a'', 2, ''c'']

#in                   #判断元素是否存在列表中
ls = [''a'',''b'',''c'',''d'']
print(''c'' in ls)      #True
print(''x'' in ls)      #False

# 大前提：只能同类型直接比较大小，对于有索引值直接的比较是按照位置一一对应进行比较的
ls1 = [''a'',''b'',''c'']
ls2 = [''x'',''y'',''z'']
ls3 = [''A'',''Z'']
print(ls1 > ls2)        #结果：False
print(ls1 > ls3)        #结果：True

ls = [''a'',''b'',''c'',''d'']
#依赖索引
i=0
while i < len(ls):　　　　　　　　#while循环
    print(ls[i])
    i+=1

for i in range(len(ls)):　　　　#for循环
    print(i, ls[i])

# 不依赖索引
for item  in ls:　　　　　　　　#for循环
    print(item)