先看列表是如何创建的:  

a = ['scolia', 123]
b = list('scolia',123)

  同样有两种创建方式,但一般用第一种。

  列表和元祖最大的不同就是列表是可以修改的。

  老规矩,使用 help(list) ,真的是 help() 大法好呀。

  好,来人,上代码。

Help on class list in module __builtin__:

class list(object)
| list() -> new empty list
| list(iterable) -> new list initialized from iterable's items
|
| Methods defined here:
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __contains__(...)
| x.__contains__(y) <==> y in x
|
| __delitem__(...)
| x.__delitem__(y) <==> del x[y]
|
| __delslice__(...)
| x.__delslice__(i, j) <==> del x[i:j]
|
| Use of negative indices is not supported.
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getattribute__(...)
| x.__getattribute__('name') <==> x.name
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __gt__(...)
| x.__gt__(y) <==> x>y
|
| __iadd__(...)
| x.__iadd__(y) <==> x+=y
|
| __imul__(...)
| x.__imul__(y) <==> x*=y
|
| __init__(...)
| x.__init__(...) initializes x; see help(type(x)) for signature
|
| __iter__(...)
| x.__iter__() <==> iter(x)
|
| __le__(...)
| x.__le__(y) <==> x<=y
|
| __len__(...)
| x.__len__() <==> len(x)
|
| __lt__(...)
| x.__lt__(y) <==> x<y
|
| __mul__(...)
| x.__mul__(n) <==> x*n
|
| __ne__(...)
| x.__ne__(y) <==> x!=y
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __reversed__(...)
| L.__reversed__() -- return a reverse iterator over the list
|
| __rmul__(...)
| x.__rmul__(n) <==> n*x
|
| __setitem__(...)
| x.__setitem__(i, y) <==> x[i]=y
|
| __setslice__(...)
| x.__setslice__(i, j, y) <==> x[i:j]=y
|
| Use of negative indices is not supported.
|
| __sizeof__(...)
| L.__sizeof__() -- size of L in memory, in bytes
|
| append(...)
| L.append(object) -- append object to end
|
| count(...)
| L.count(value) -> integer -- return number of occurrences of value
|
| extend(...)
| L.extend(iterable) -- extend list by appending elements from the iterable
|
| index(...)
| L.index(value, [start, [stop]]) -> integer -- return first index of value.
| Raises ValueError if the value is not present.
|
| insert(...)
| L.insert(index, object) -- insert object before index
|
| pop(...)
| L.pop([index]) -> item -- remove and return item at index (default last).
| Raises IndexError if list is empty or index is out of range.
|
| remove(...)
| L.remove(value) -- remove first occurrence of value.
| Raises ValueError if the value is not present.
|
| reverse(...)
| L.reverse() -- reverse *IN PLACE*
|
| sort(...)
| L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;
| cmp(x, y) -> -1, 0, 1
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __hash__ = None
|
| __new__ = <built-in method __new__ of type object>
| T.__new__(S, ...) -> a new object with type S, a subtype of T

list

  按照其功能可以将内置方法分为以下几类:

  1.序列相关方法,如索引,切片,加法,乘法,成员判断(这些都在python的序列中讲过,不再重复)

  2.内置函数相关(参考这里

  3.普通的内置方法。

  我在上篇python的元祖中分享了自己关于元祖的理解,并把其比喻成是一个菜单,而列表其实和元祖是类似的。

  只不过元祖就像是守旧派,菜式坚持传统,所以其菜单也不会改变。但列表则像是革新派,要靠层出不穷的菜式来吸引顾客,所以其菜单会经常修改。

  那为什么要分开两种呢,直接都用列表不就好了,我不改就是,这样不更方便吗?

  虽然说列表支持更多的操作,但是元祖相较于列表还是有以下优点的:

  1.数据更安全

    正是因为元祖是不可修改的,所以可以防止一些误操作。例如我有些参数非常重要,我将其放在列表里面,我在取的时候可能会出现误操作修改掉里面的参数,从而导致各种错误。而将这些重要的,确认不用修改的数据放在元祖里,我的数据就会更加安全。

  2.性能更高

    列表既然可以修改,肯定要对内存进行更多的操作,而这些操作肯定会消耗更多的资源。而元祖是不可变的,一旦在内存中创建以后,就不会有多余的内存操作了。所以进行查询的时候,元祖的效率会比列表更高

  两种各有特色,可以根据需求选用。


  列表相较元祖的最大不同就是其是可修改的,而修改的核心操作为:增删改查。

一.增

1.1 L.append(object) -- append object to end

    往列表的最后插入一个元素。   

a = ['scolia','中文']
a.append(123)
print a
a.append(['新列表',])
print a
print a[1]
print   

aaarticlea/png;base64,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" alt="" />

注意:

  1.['新列表',] 的写法

   当元祖只有一个元素的时候一定要加逗号。而列表可以不用。

  aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAHUAAAAlCAIAAADz6DEcAAABRElEQVRoge2YyxaDMAhE89f9/HRR6ytASIToGO5x0UNxtCMmlJRz/qSUC/TBwSTqHspg+lMNcpomLLpAFnNWcjnrZzLIaVqx6aJYrKlfwcpqvi0HXVuLuZeRzNEkr6cog/r8Qf5mO4urFdRNk7+axUQ4/TqO9ZsVJexav/qihlx/yY3lOvr+QS+C1z/cuz48q39w6hxaX3y9LHeh6qW5mxm3vz0f2wdm/vjP+k66wY/w15fw1xfH/S3IiPMdLPDmO1jcPN95PXjzHSxunu+8Hrz5DhZ48x0s8OY7WEz6s4cR/voS/vqy34WWw0bXVA2Xg7/E10WQNI5zM/yV/CV9LD+TQU5zNtrqV7Cymj8nzetDU3742+mvZjERTp+HHn/1RR3+9vQPklz4e8Rgf4v+QaDen53s2x9CJqc5G/H/zZfpDXDmCwt1EMYz7hp4AAAAAElFTkSuQmCC" alt="" />

   列表不写也没有关系,但是元祖在只有一个元素的时候一定要用逗号分隔!!

    2.a[3][0] 写法的含义

    这个写法其实充分地体现出一个元素就是一个独立的对象。首先 a 是一个列表,我们可以用索引的方法取到一个对象 a[3] ,但a[3]取到的还是一个列表,那我是不是可以继续对这个取到的列表进行索引取元素。

    所谓的连缀其原理也是这样的,到时候会继续分析。

2. L.insert(index, object) -- insert object before index

  在特定的索引位置插入一个新元素,原来的元素都向后移一个位置。

a = ['scolia', 123]
a.insert(1, 'good')
print a
a.insert(10, 456)
print a

aaarticlea/png;base64,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" alt="" />

  对于超出的索引值python会优雅地将其放在最后,此时相当于 append 。

  但如果是负值的超出索引:

a = ['scolia', 123]
a.insert(-10, 456)
print a

aaarticlea/png;base64,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" alt="" />

  会放在最头,这也是python优雅的地方

3. L.extend(iterable) -- extend list by appending elements from the iterable

  将一个可迭代的对象的所有元素逐一添加到列表的最后,关于迭代器我们以后会说明。

  这里先记着比较常用的:

a = ['scolia']
b = ['good',123,456]
a.extend(b)
print a
print b

aaarticlea/png;base64,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" alt="" />

  可以将两个列表合并成一个,当然 b 这里是元祖也可以,只要是可迭代的对象。另外还有注意并没有影响到b对象本身。


二、删

1.  L.pop([index]) -> item -- remove and return item at index (default last)

    删除给定索引对应的元素,并将其返回,不给索引时默认删除并返回列表的最后一个。当列表为空或给定的索引超出范围时抛出IndexError错误。

    注意,这里的返回意味着我可以用变量去承接返回的这个元素(对象)。

a = ['scolia', 'good', 123, 456]
b = a.pop()
c = a.pop(0)
print a
print b
print c

aaarticlea/png;base64,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" alt="" />

2. L.remove(value) -- remove first occurrence of value.

    给定一个元素,将找到的第一个删除,注意和上面的不同,这里不会返回被删除的对象,只会返回一个空对象 None。

a = ['scolia', 123, 123, 123, 456]
print id(a[1]), id(a[2]), id(a[3])
b = 123
print id(b)
a.remove(b)
print a

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAcgAAABRCAIAAADZ3aGCAAAI50lEQVR4nO2dy5WruhKGFRYh3ESsMNwRHM08ujcDpq25o/DgkIGT4A5AoEdJYCww3vv7Vq9ebbcolV4/JfGQ6gEAoCpqy0HdvWnu3btZP7S6KtXad+1InN/DY7CtqlAPVfJ6mqZcmQ+9XNVr0nyCtfVcvUdVrZD9esuR/fAcpMI6DIAfpX6UfmSOeprmZrx6stodon70C+28qVt090Zdw7w8n8f2iz3cytlG8prWCRJrO7aOtn1nbusO3OiYa45cpZUr82kui2NvTZrj8cu+SN0e9TRNLWsvleIkls9LLKyduTXm2fd93z90/iTjJevHxEN36e5Nsd905u79d0Mn84aWbd3J/2Gcz9aZSzxcy9se7sjK1hmZw4SpFLsVxw9JunujxIF0UGWGLbjvUX3/ajj2+R4llzQsRc063M/yiYmF1Q/0vMIkvSGea68U1sjOhk7mHxIfHtT+xtWA9z3cj+fa1hkTpyHkTsUJQxLbKt1qIS4+pjK35bLZt1fDsY/3qMXekktzNsunJhbW9QWwOqovf3o+ftR2iCt/lGp/xz+Gn3mcG3NT6meOLseZ/qAg45pUnGZImETNJkzge2j1ValW66uzc4SHAcJRN9OFi25BmpRXulcQJgjCOq/ehJHmmLurEzt+mT8qzmuo9nCKOlhrbo1q/2tuSt2a5qqa9tJcxxqbspsdTmo1TiP5E7bgb6YU45LItJQktPuq2gjL/tDqqnWr1I/Wbb5NHzroh0nPzOWV9o20QtI007rZcJ4TSxq14GJtiL33eMtxN1gY3Qfr8nZh7W3rrdalY36eq1qTjvDp49VVxPC9C8rmeDNN0/fiTN/eYz2KPbxqG1re08OQKdicMh2kx180TNNErBfWXJhQCF3T3B9aXZU4LynlNdqx2ommX2Oq/e0fehw5w+/c/EOs1TXzCcFOphQFy3IrJ1P+oOxWDwVvbfewXalW434ofRPmlfqTui32sasLdLLzPCnoztRGqfcebDli5eg+jtJSQN89iw6VW8tpn23zE4HCgC9pgTdoZ6wujzHBzn4eSnV1Tc66g7iU0/g817ZOvOqXk5Iokopyz8lWEjfFeUVRbZD77/jR/x05WfY5OX/HMf4K8Z2DoPW5Z+yEkXtj7uF1/0KtvtSRcv9KG3RNC4ZfCmvE0slpofceazlbqPLoPo7ixauly8feXDsbyyixH9hHpieJkUKQpjO3qaaW1hkjD9Nz/i4eSniaOAqiOzPPU+Y0Tcy61hHDhDlmHFydLvfF5ZpzF4a3dFSYV3e/uHPeEMHNlm2rKgtr6k+fb8HEcnA9IDqq0Mrler5qE3WwtFZTy2vyWh+x+n1s9FAYKXNJ0zXiTG30hd57pOWUlaP7OAq3Wy3Ouaa5tjskncDaNgwtXUr9mE9W+hGsgwhrLn6a//1nPsX9SMuIoodDglvTuJWXHT2ctCMkWO2a5noPaY21fKPbUutIF6njVUXxti0/d29hy6uf5Cg5XA1Wn23vIkTdanVVzT9uFXL87S0sxmv0Qa3GaTKl8FtQLsW05ttemqt3f95Vqg1/jTW0I9Wz1a3tn9Z6ecVt+jDmYYJ+GPbMnM/y+nvY9Gn/cdaERpRbUEoTW8703sMsyyfLNaP7ODY9IDCTBu0B0vT8YCYPcyHtxz2sy5H3DP6N9yc6KpZ9cZ6bZ+nuxiX+mHtXTze63xTWHI/5qtw5GC8fBxHuuTyEv5OkZ65hWpqs8hTM13PC0b2TsAIA/L0grAAAlUFYAQAqg7ACAFQGYQUAqAzCCgBQGYQVAKAyCCsAQGUQVgCAyuSE1WrlveqkUUop1binPNwXSk2JkjSCnfm48ImIYl5Z8PB9DwFgF2RhtXoeuZ1p3PuAdWO6vu/MxY1Yq4dkSRrBTm+1G+qBUhTzyoKH73sIADshCavVSms3bjvTNLMGNObfYEhbrfRvkqZbsLM2r/z7RvHwbQ8BYDdSYR1G4zTyYwkI3r05DmIxjWDHxNPYF/LCw6oeAsCOxMJqdTQ+swPVC42ENJIdN4udtWRtXnhY10MA2JV0z6uAy688tZzX+vo+M9VN7USTXzHN4jR27VF4yFIAwKdYvisgvRjij+/OmMKFF9/OrCPxUmEprzx4+L6HALALkrDOdwJNIuB9iqKkeaD7H4t2okCtlFcGPHzfQwDYDR4QAACoDMIKAFAZhBUAoDIIKwBAZRBWAIDKIKwAAJVBWAEAKoOwAgBUBmEFAKgMwgoAUBmEFQCgMt+7NQsAwEn51q1ZAABOy3duzQIAcGK+cWsWAIBT831bswAAnJyv25oFAODsfO/WLAAAJ+U7t2YBADgxPCAAAFAZhBUAoDIIKwBAZRBWAIDKIKwAAJVBWAEAKoOwAgBUBmEFAKgMwgoAUJnC+1in558++z4U3sZSJPPycAD4IBlhNeGz/DUeMHUKEAnAom7y1oA1DO9sAIBTsCismRdUbySVUW8/AoG3cnevJXSWou1kvHcevBrt7WfZqyLPrvfyhEyEirACnIg1EWtFjprXj9LmvYQr3E7m1w+EO9Os92o/y7P5UVitTRohs70NwgpwKv5QYY3zKr5C+2WndrMcblSTCGshfkdYAU7ERmGdJ7vp1q3xjqvR7oKe0sTRn2xmK7KqheIU7Hb4acvxRjXmcgnfqShub+MyR1gBTsM2YZWWSsdJr79EOG7q6ulNemD0jbhNyzYEC3LI91bEWs1yslGN1wpWK7cvQ+Zl4QgrwInYvBQwRJvBjqwZxSzvZCVNnzdf+ClaDreTKfrwAcvxRjXpmsJvsHUDa6wA52VjxOr+H1zCdn+ZChFr6bLPSrWKtz70t5MJLjFlrwgdb7kPTkiJnfz2NggrwInYJqzpHUbxQwVeqmjzFu8r8bakMRS+XJrcBi0r7myNLUvbyQih8UctB3XkdDSsMHl7m+F7hBXgNKx58upU1L2v9tst8+QVwBnhXQEAAJVBWAEAKoOwAgBUBmEFAKgMwgoAUBmEFQCgMggrAEBlEFYAgMogrAAAlUFYAQAqg7ACAFQGYQUAqAzCCgBQmf8DUZB42i1JWUUAAAAASUVORK5CYII=" alt="" />

  关于这里的 123 为什么会是同一个对象我在python的序列中已经讲过了,这里写出了只是为了说明这里的删除在本质上只是删除一个引用对象而已,而何为引用我在python的赋值操作中讲过。

3.del 关键字

   python中del这个关键字是专门用来删除对象的,而我们说过元素即是对象,所以我们可以通过索引,或者切片的方式取到对象,然后用del关键字删除掉。

a = ['scolia', 456, 123, 123, 123]
del a[1]
print a
del a[1:4]
print a

aaarticlea/png;base64,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" alt="" />

  注意:每次进行列表的修改都会刷新列表,在仅仅是修改的时候体现不明显,但在增删操作的时候,元素的添加或删除是会刷新整个列表的索引值的。

  如这里,本来a[1]是456,但其被删掉了,后面元素的索引值就向前一位,所以我们a[1:4]得到的是剩下的三个123。


三、改

1.x[i]=y

  修改一个元素。

a = ['scolia', 'good', 123, 456]
a[1] = 'very good'
print a

aaarticlea/png;base64,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" alt="" />

  注意:这里的索引一旦超过是会报错的,要求的是精准操作。

2.x[i:j]=y

  修改多个元素

当数量是对应时:

a = ['scolia', 'good', 123, 456]
a[1:4] = 'very good', 111, 999
print a

aaarticlea/png;base64,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" alt="" />

数量不对应时:

a = ['scolia', 'good', 123, 456]
b = ['scolia', 'good', 123, 456]
a[1:4] = 'very good', 111, 999, 888
b[1:4] = 'very good', 111
print a
print b

aaarticlea/png;base64,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" alt="" />

数量不对应且只有一个时:

a = ['scolia', 'good', 123, 456]
b = ['scolia', 'good', 123, 456]
a[1:4] = 'very good'
print a
b[1:4] = 111
print b

aaarticlea/png;base64,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" alt="" />

  是数字等非序列时,直接报错,字符串则逐个字符拆分后填充。

当新修改的是字典时:

a = ['scolia', 'good', 123, 456]
b = ['scolia', 'good', 123, 456]
a[1:4] = {'abc':111}
b[1:4] = {'abc':111,'cdf':123}
print a
print b

aaarticlea/png;base64,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" alt="" />

  得到的键名,多于和少于是和上面的一样,但只有一个的时候,不会拆分。

  这里的情况比较多,不过一般很少出现这些特殊情况,我这里只是尽量列举特殊情况而已,记不住也不要钻牛角尖

3.  L.sort(cmp=None, key=None, reverse=False) -- stable sort

  将列表从小到大排序。reverse=True表示从大到小,即先从小到大排序,再将其顺序翻转。

a = ['scolia', 123, 123, 456]
a.sort()
print a

aaarticlea/png;base64,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" alt="" />

  不同类型的大小比较问题,我在python中的数字里关于比较运算符的总结。

4. L.reverse() -- reverse

  翻转列表的顺序,注意这里不是从大到小

a = ['scolia', 123, 123, 456, 'good']
a.reverse()
print a

aaarticlea/png;base64,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" alt="" />

5.  L.__reversed__() -- return a reverse iterator over the list

  翻转列表后,并将其生成可迭代对象。

a = ['scolia', 123, 123, 456, 'good']
print type(a.__reversed__())
for x in a:
print x

aaarticlea/png;base64,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" alt="" />

  可迭代对象一般用于迭代循环,我们以后会讲。


四、查

   关于索引、切片和成员判断也算是查的操作,不过已经讲过就不讲了。

1. L.count(value) -> integer -- return number of occurrences of value

  返回元素在列表中出现的次数(计数器)。和元祖里的差不多,就不多讲了。

a = ['scolia', 123, 123, 456]
print a.count(123)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAcIAAAAhCAIAAADF3TyKAAAFnElEQVR4nO2dS5brKAyGWRZL6I2EZTgruMw86t4B02LuVXjiHWQT7oHB5iEB8Svp6v8799S5SWEQkhBCdlJi3s00SDlM+69fGJXohDD2aD8U3y/hPVgjTtDDKWO9tCwrc1R1Vbe0+QStej7do05VyHXecqcf3otg3l/c/SnEU6iRb9PrQCtW+UvEU71h1V1OMA1SdPFYgczOWqmEe/m2ddtinaixss46ys6T7tsu3CmYNwentLIyX/pRXWktbe4nnHuVcz3qpeVZvb01iy/p+fPQYXTSvdSveZ7neVT8BhI0m13jxTmmQRa9ZNJD8NsdLhUsJGv8xj5qL7P13WUStnJYwgtptI5jSwHWWVw2nTDdmAYpyGVzkzJjC1571Ty/m2p93qPomcazOFOH1/X8BdBhNEziAtEz26en5sYwmvSzw6XCS9LLI13vPNcfl/A6Xq3WcY3z9PCi6cTphjVCGUXkvPcoc98ou2V7N9X6uEdVvYVr8209fwV0GG0X16pEO+FB271UdskZn0KYH/ef5d+2qrXuhXhumaM7sy/xwtWS0jZLwywj1nGDUEKrOiGMUp3v5w4JI4irej3FxbKoTc47zhSlAEQY3eowcRbpRvc6se5N/qp0rEXt8WFz6U32Upi/dS9EL2UnpHnIzmlsHW4TONNq2oaSJ7bgDzMLV9xYi0KE3Zu0Ec99VKJTygjxVMrwNh1V5IeZZ3Jj5b6RKyRvs1bAll2NnGliwao2SO+9v+fUDSqr+6IofDSMztYEVbZ8hW+nTqvz9by+7Py0l/d9wrXlknmbeSbP7HZIo08qYads3POVEsasieQ66BJowmJf3iahPYxyKUAhLc1HH5XoBHnmKI3l+rHKh8hQY8L8zKNy62T5yZ0tSK22nBWIfphZFHqmrZwd3qO5W7VM3NhptFNJq6kfUu/EY+Xy5GKTPtb5tIY9w1EJNaONkvfe3HNC4+o+n/qhfp5exeHLtvGRzho+pS8s79LKD5bohlXlFUX0c52ElK66bEddQkm5Tcir1TpptY4LHEmWlIzOBaksJ0rHSjLWaPQf9zL8mQhZljnbrdP8vSHUbglO++hMP3FWLvUQ34svaPUtR+J+lRu0xYLxm0Rtl9qKKt57b8/spMqr+3wabjHVbukGp2Y2TxGk1e3I+A2ZBURtJt2veqnVBxMJ8/38Egkpggjowp/fdbfDb94mpc06ZAqw5YOLqOtNuXRe2+jEYqauiseahoff4ZbsbOvZGnFyGM3lmXkLZj1HdfzkqoKVy3rulE4cLNdq3nPLWO3ZaOhjTkJipWwzzWu7jDbmgvfe2XNO4+o+n+oDT9XT03pq9pfkR1Fr4rTRt1TjthGpMapfELWSsM0/f23b15Mq/5ESLg16KX3F5EIJ10gRE1Wp1lPbSNVGy4+a1axD3ThOq4Hkg1Ph6EFBKtBPdhWdikZVYzv77E8ZJToh//jqofsZFATT2nqk1bQNM4vQgvQs1lqtecgueEKuo7QR1kbjfig9W2Xs/LI2GCu16aj1qCM/jD2Tk5mum8emz/3H90YYkbYg1SbtmfHe23qmt8aW1X0+XBh9izz9jqAO2jezSsilqx+X8FzufEbvNz8PWOPEuVdPrDy15wtr/JpnRT+2uk8JoxzjdqfsO3C3dKPs9bskBP9PMs9sYS0pnvIZk/88H1zdl4ZRAAD4/SCMAgDAIRBGAQDgEAijAABwCIRRAAA4BMIoAAAcAmEUAAAOgTAKAACHQBgFAIBDMGF00lI48AkfAAAowHxR3sN/uswqBFIAACjAfW1z8C20CKMAAMBTqY1OWkp87QEAAPCUwihiKAAAVGHDqFUCMRQAAKpwf0REBn+iQ6M2CgAAHNwtpgAkpQAAwIPH7wEA4BAIowAAcAiEUQAAOATCKAAAHAJhFAAADvEvbIJGkzNC3zUAAAAASUVORK5CYII=" alt="" />

2.  L.index(value, [start, [stop]]) -> integer -- return first index of value.

  在列表中寻找给定元素的第一次出现的索引值,也和元祖里的一样。返回的是索引值,不是出现次数。

a = ['scolia', 123, 123, 456]
print a.index(123)

aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAawAAAAnCAIAAADcqutUAAAFlElEQVR4nO2bzZH0KAyGFZZD2ESGMNwRLLe+7G4GXId7R+GLaxPoJLwHg41AYNxju3uH96mvpr7p4UdIQgjZTf8CAEDD0LsFAACAd4IgCABoGvoLAAAahiYAAGgYBEEAQNMgCAIAmua4IDg+uu4x/nSUQVFPZOwREsV8voTXYA0doIdD5nrqrqzMQW2ruqbNO6jV8+EedahCzvOWK/2wSGUQnJ31RnQjNeTb3HWwJqt8F7qpHTZ5yYTjo6OezxXI7HQdS/gqn7braqzDGivrrKPsNOp7XccXBfPmyCmtrMyn/trcJzVtridc+ybHetRTd0eNtmsVHzLybqqC4KjvnX5O0zRNg8oH76DZ5BrPph0fXdHGo34Ef33BIYJtYI0/VAftZbZ+uETCWn4s4YlUWsexHr/LKk5bTnjUj4+ORKe/SJncguf2mqa9ac77PUpeKV/FkTo8b+T9VAXBMIEKJk4sF983K4NgNM4LDhF2ibszTb14I/65hOfxrLWOa5ymZicthx/11pAySsg3r1Hma7O8LNveNOftHrXpLbk2nzbyK1QFwfrJrIrWFl5R3a/Kzvnajch8u//M/9Y9qfWd6LZmbe62O+92V0OJ28wNk2xU8wahhFb1REap3o9zhYQModddj7xIxNqk7HEFdvwKQXCtYPAMzs3udWLdh/le8Vyz2vk1bR6tu3dk/tZ3onvX9dSZr653GlumWwVOtBq3keThFvzOrMKVBZZyimD3Km3wtQ+KeqUM0U0pk7fpoJgfJp6Zmyv1jVQhaZuldjSfSeJKIwtuakP03utHjt1gY3fPHQ8OgpM1QXUp3Z/rfc3qdDcuv/Ze6Plzn+yseVzaZprE2659xLEjlrBXlo98poScJYlbJp3DRFjkSttE1AfB3PFbSAnT2QdFPYn5fmkuN45VPsCFGiPzPQ3Kefn8M5fXi1qtydOFcTKrKIwsWzm59rK1WzUv3NhxsGNJq7EfSp/wuVJ5UrFFH+t9UpK9P0nJbEYbJe+9eOSIyt29/zo8jc/idbKsWR+nrMknw4XNWdq3wQZbsaq8H4RxzpNQ0lWfnGZzICi3CXnWWieuUuW2fZShRLPnQkySj8RzRdkim/3b/Rr+jIQsy5yctXHuXBEo1+SifvbMODwj7vSDP/8taHWXI+X+lBq0xoL8Q6GmKR0kG9577cjZRZV39wsPRrYeIwb3zWyOQKLN7JCxungCszajvi+r2qqLRRKmZ+kpEkoE8csFL3/irdfGtE1MnXXE43fNxWZRl0dJ8brW2YWtKPXic42PL38+zZnROrI1dHAQTOWZ8hZMRmb166hXwcplPfdKRw6WajUduWau+kww9DEnobBT1pWmNc2MNqaC9145ckrl7t79iszmvWO5b/ou6SXOGp6y+ZZqWA8BNbB7u1AjCNv888d6dNykspcooVNT1/lKwYkSLvucw6ozy31nkGqC5ZeTtqwjPayMq2Diqzbh7EEhJtBP0ktOA1m11E4+81JGUU/dn75q5n4GhbC4psy0GrfJrCK0oLyKpUZpvro+eKeql7QR1gT5OJKerTJ2elobzBXbdNB60MwPuWfmZJbrxdz0qf/40QQjyhaU2sQjZ7z3spHlg61md5/yjZE0cWVIV9SLWSTMpYpvl/BYrnwn64Pe/7qcA9e+edfLs/VG2ha/5t3A2t195dfmhvXpzGfgHiOyzPGzJARtknhmDUsp7ZBvBPzvqd/d+O4wAKBpEAQBAE2DIAgAaBoEQQBA0yAIAgCaBkEQANA0CIIAgKZBEAQANA2CIACgaXYEQavwTQoAwG+jLghaRURECIIAgN9GfSZoFYIgAODXgSAIAGgaBEEAQNMgCAIAmgZBEADQNLueDuMJMQDgt4GXpQEATYMgCABoGgRBAEDTIAgCAJrmPyM127R3a0ECAAAAAElFTkSuQmCC" alt="" />

3. L.__sizeof__() -- size of L in memory, in bytes

  返回列表在内存中大小,单位是字节。


 五、列表解析

  所谓的列表解析就是可以在一行中使用一个for循环将所有值放在一个列表中。

aaarticlea/png;base64,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" alt="" />


  关于列表就先讲到这里了,以后有需要会继续补充。

  

最新文章

  1. 解决手机浏览器上input 输入框导致页面放大的问题(记录)
  2. WordPress 插件推荐
  3. 【转】JavaScript 经常忽略的 7 个基础知识点
  4. 【转】DBMS_STATS.GATHER_TABLE_STATS详解
  5. sql字符串插入函数STUFF
  6. LintCode &quot;4 Sum&quot;
  7. activiti源码分析(一)设计模式
  8. globalfifo设备驱动
  9. SGU 226.Colored graph(最短路)
  10. 《统计学习方法》P89页IIS的中间步骤Zw+δ(X)/Zw(X)的推导
  11. JavaScript(第二十二天)【动态加载js和css】
  12. MO_GLOBAL - EBS R12 中 Multi Org 设计的深入研究(1)
  13. Windows上安装配置SSH教程(5)——win10下使用Cygwin+Expect自动登陆ssh
  14. HTTP请求的502、504、499错误
  15. html之css选择器学习
  16. 『TensotFlow』转置卷积
  17. angular 禁止缓存
  18. sklearn的K折交叉验证函数KFold使用
  19. git 放弃本地修改
  20. 反转链表(python)

热门文章

  1. (续篇3):飞测独家のJmeter秘籍,限量发放
  2. Jmeter如何设置关联
  3. Orchard官方文档翻译(十) 管理Widgets
  4. windows bat 文件
  5. 数据结构(一)之HelloWord
  6. Java 获取*.properties配置文件中的内容 ,常见的两种方法
  7. 三味书屋 bbb
  8. Android基础总结(12)——XML和JSON解析
  9. linux程序调试常用命令
  10. 蘑菇街iOS客户端应用源码