list列表常用方法
列表是Python中常用的功能,我们知道,列表可以用来存储很多信息,掌握列表的功能有助于我们处理更多的问题,下面来看看列表都具有那些属性:
1.append(self,p_object)
def append(self, p_object): # real signature unknown; restored from __doc__
""" L.append(object) -> None -- append object to end """
pass
append(self,p_object)是向列表末尾添加元素(append object to end),向列表末尾添加元素,经常在列表转换验证的时候使用,定义一个空的列表,把一个列表中的元素遍历到空的列表中,实例如下:
>>> users = ["alex","tom","aoi","marry","kong"]
>>> names = []
>>> while users:
... name = users.pop()
... names.append(name)
...
>>> print(names)
['kong', 'marry', 'aoi', 'tom', 'alex']
2.clear(self)
def clear(self): # real signature unknown; restored from __doc__
""" L.clear() -> None -- remove all items from L """
pass
clear(self)清楚列表中所有的元素,就是把一个列表中的元素情况,实例如下:
>>> users = ['kong', 'marry', 'aoi', 'tom', 'alex']
>>> users.clear()
>>> users
[]
下面我们来测试一个实例,我们知道Python中a = b是把a的地址关联到b上,那么清楚b的内容a会变成什么,实例如下:
>>> a = [2,34]
>>> c = a
>>> c
[2, 34]
>>> c.clear()
>>> c
[]
>>> a
[]
上面代码,我们给a定义了一个列表,然后把a列表赋给了c,清除c列表中的元素,结果a列表也变成空的了。
在Python中,列表是存储在内存中,相同的列表关联在同一个内存地址,清除这个列表后,这个内存地址里面的元素消失了。地址还存在,但是元素没有了,并没有开辟新的空间。因而在列表中经常使用索引,因为索引是新开辟的空间,不使用索引一不小心就会清楚原本的列表。
3.copy(self)
def copy(self): # real signature unknown; restored from __doc__
""" L.copy() -> list -- a shallow copy of L """
return []
复制列表元素,形成一个新的列表,如下:
>>> names = ["alex","sb","aoi","marry"]
>>> users = names.copy()
>>> users
['alex', 'sb', 'aoi', 'marry']
>>> users.clear()
>>> names
['alex', 'sb', 'aoi', 'marry']
>>> users
[]
copy(self)在Python中新开辟了一个空间,为什么我们不直接用users = names,因为这样只是关联到同一个地址,而copy()是新开辟了一个内存,用于存放users,users和names之间没有关联。
4.count(self,value)
def count(self, value): # real signature unknown; restored from __doc__
""" L.count(value) -> integer -- return number of occurrences of value """
return 0
count(self,value)统计元素在列表中出现的次数。如果不存在返回0,实例如下:
>>> names = ['alex', 'sb', 'aoi', 'marry']
>>> names.count("alex")
1
>>> names.count("SB")
0
5.extend(self,iterable)
def extend(self, iterable): # real signature unknown; restored from __doc__
""" L.extend(iterable) -> None -- extend list by appending elements from the iterable """
pass
extend(self,iterable)是列表的拼接,
>>> names = ['alex', 'sb', 'aoi', 'marry']
>>> users = ["gg","bb","ss"]
>>> names.extend(users)
>>> names
['alex', 'sb', 'aoi', 'marry', 'gg', 'bb', 'ss']
>>> name = "ww"
>>> names.extend(name)
>>> names
['alex', 'sb', 'aoi', 'marry', 'gg', 'bb', 'ss', 'w', 'w']
6.index(self,value,start=None,stop=None)
def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0
index(self,value,start=None,stop=None)查找元素在列表中的位置索引,可以指定起始位置,实例如下:
>>> names = ['alex', 'sb', 'aoi', 'marry', 'gg', 'bb', 'ss', 'w', 'w', 'alex', 'bb', 'alex']
>>> names.index("alex")
0
>>> names.index("bb")
5
>>> names.index("alex",2)
9
>>> names.index("Alexsb")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 'Alexsb' is not in list
上面我们查找指定元素,可以指定起始位置,当元素不存在列表中的时候会报错。
7.insert(self,index,p_object)
def insert(self, index, p_object): # real signature unknown; restored from __doc__
""" L.insert(index, object) -- insert object before index """
"""向列表指定位置插入元素,index指定索引,object插入元素
pass
append(object)是向列表末尾添加元素,而insert(self,index,object)是向列表中我们指定的位置索引处插入元素,实例如下:
>>> names = ['alex', 'sb', 'aoi', 'marry', 'bb', 'ss', 'alex', 'bb', 'alex']
>>> names.insert(1,"is")
>>> names
['alex', 'is', 'sb', 'aoi', 'marry', 'bb', 'ss', 'alex', 'bb', 'alex']
8.pop(self,index=None)
def pop(self, index=None): # real signature unknown; restored from __doc__
"""
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
"""
pass
pop(self,index=None)弹出列表中的元素,并将它赋给另外一个变量,可以指定弹出哪个位置的值(index),在遍历的时候经常结合append()一起使用,pop()是弹出元素,可以再利用弹出的元素,而remove()是删除元素,没有返回值的:实例如下:
>>> names = ['alex', 'is', 'sb', 'aoi', 'marry', 'bb', 'ss', 'alex', 'bb', 'alex']
>>> name1 = names.pop()
>>> name2 = names.pop(4)
>>> name1
'alex'
>>> name2
'marry'
9.remove(self,value)
def remove(self, value): # real signature unknown; restored from __doc__
"""
删除列表中特定的值
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
"""
pass
remove(self,value)删除列表中特定的值,我们知道这个value并且删除它。实例如下:
>>> names = ['alex', 'is', 'sb', 'aoi', 'bb', 'ss', 'alex', 'bb']
>>> names.remove("ss")
>>> names
['alex', 'is', 'sb', 'aoi', 'bb', 'alex', 'bb']
10.reverse(self)
def reverse(self): # real signature unknown; restored from __doc__
""" L.reverse() -- reverse *IN PLACE* """
"""颠倒列表中的元素,反转列表中的元素"""
pass
reverse(self)把列表中的元素倒置,反转列表元素,实例如下:
>>> names = ['alex', 'is', 'sb', 'aoi', 'bb', 'alex', 'bb']
>>> names.reverse()
>>> names
['bb', 'alex', 'bb', 'aoi', 'sb', 'is', 'alex']
11.sort(self,key=None,reverse=False)
def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
""" L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
pass
sort(self,key=None,reverse=False)把列表中的元素进行排序,在排序的时候也可以对列表进行导致,只需要设置reverse = True,开启导致的参数。实例如下:
>>> names = ['bb', 'alex', 'bb', 'aoi', 'sb', 'is', 'alex']
>>> names.sort()
>>> names
['alex', 'alex', 'aoi', 'bb', 'bb', 'is', 'sb']
>>> names.sort(reverse=True)
>>> names
['sb', 'is', 'bb', 'bb', 'aoi', 'alex', 'alex']
上面代码可以看出,进行排序之后列表有进行倒置。
12.__add__(self,*args,**kwargs)
def __add__(self, *args, **kwargs): # real signature unknown
""" Return self+value. """
"""两个列表进行拼接"""
pass
__add__(self,*args,**kwargs)两个列表的元素相加,实例如下:
>>> names = ['sb', 'is', 'bb', 'bb', 'aoi', 'alex', 'alex']
>>> li = [11,22]
>>> names.__add__(li)
['sb', 'is', 'bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
>>> names
['sb', 'is', 'bb', 'bb', 'aoi', 'alex', 'alex']
>>> names.extend(li)
>>> names
['sb', 'is', 'bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
我们知道,两个列表的元素拼接可以使用extend(self,list),使用extend()拼接之后,原来的列表发生了变化,是把元素添加到原来的列表中,而__add__(self,*args,**kwargs)是新生成了一个列表,并不修改原来列表中的值,我们在使用的时候要看不改变原来的列表还是改变原来的列表。
13.__contains__(self,*args,**kwargs)
def __contains__(self, *args, **kwargs): # real signature unknown
""" Return key in self. """
pass
__contains__(self,*args,**kwargs)判断列表中是否包含指定的元素,实例如下:
>>> names = ['sb', 'is', 'bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
>>> names.__contains__("alex")
True
>>> names.__contains__("TOM")
False
14.__delitem__(self,*args,**kwargs)
def __delitem__(self, *args, **kwargs): # real signature unknown
""" Delete self[key]. """
pass
__delitem__(self,*args,**kwargs)删除列表中某个元素,相当于del self[key],实例如下:
>>> names = ['sb', 'is', 'bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
>>> names.__delitem__(0)
>>> del names[0]
>>> names
['bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
15.__eq__(self,value)
def __eq__(self, *args, **kwargs): # real signature unknown
"""__eq__(self,value)等价于判断 self == value,判断是否与要求的数字相等"""
""" Return self==value. """
pass
__eq__()是中的eq是单词equal的缩写,equal是相等的意思,判断两个数字是否相等。如下:
16.__ne__(self,value)
def __ne__(self, *args, **kwargs): # real signature unknown
"""判断两个数字是否不想等,如果不想等返回True;否则返回布尔值False."""
""" Return self!=value. """
pass
判断两个数字是否相等,相等返回True,否则返回False。__ne__(self,value)是单词not equal的缩写,表示不等于的
含义,下面我会进行总结:
17.__ge__(self,value)
def __ge__(self, *args, **kwargs): # real signature unknown
"""__ge__(self,value)是用来判断self>=value,如果self大于等于要比较的value值,则返回布尔值True,否则返回
False"""
""" Return self>=value. """
pass
__ge__(self,value)是大于等于的含义,比较self>=value,ge是单词greater than or equal to的缩写,表示大于等于:
判断如下:
18.__gt__(self,value)
def __gt__(self, *args, **kwargs): # real signature unknown
"""__gt__(self,value)判断self是否大于给定的值value"""
""" Return self>value. """
pass
判断self是否大于给定的值value,如果大于返回True;否则返回Fasle.__gt__(self,value)中的ge是单词greater than的
缩写,表示大于。
19.__le__(self,value)
def __le__(self, *args, **kwargs): # real signature unknown
"""__le__(self,value)判断self <= value,如果条件成立返回True,否则返回False."""
""" Return self<=value. """
pass
__le__(self,value)是用于判断self是否小于等于value的,如果成立返回True;否则返回False.__le__(self,value)中le是
单词less than equal的缩写,函数是小于等于。
20.__lt__(self,value)
def __lt__(self, *args, **kwargs): # real signature unknown
"""用于判断self<value是否成立"""
""" Return self<value. """
pass
__lt__(self,value)是用来判断self是否小于给定值value,如果条件成立,则返回True;否则返回False。__lt__中lt是单
词less than的缩小,表示小于,用来比较一个数是否小于另外一个数,实例如下:
下面总结了int类中几种相似的方法,以及简写和单词含义,可以帮助我们进行记忆:
21.__getattribute__(self,*args,**kwargs)
def __getattribute__(self, *args, **kwargs): # real signature unknown
""" Return getattr(self, name). """
pass
22.__getitem__(self,y)
def __getitem__(self, y): # real signature unknown; restored from __doc__
""" x.__getitem__(y) <==> x[y] """
pass
__getitem__(self,y)获取列表中指定位置索引的值,等价于x[y],示例如下:
>>> names = ['bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
>>> names.__getitem__(2)
'aoi'
>>> names[2]
'aoi'
23.__iadd__(self,*args,**kwargs)
def __iadd__(self, *args, **kwargs): # real signature unknown
""" Implement self+=value. """
pass
__iadd__(self,*args,**kwargs)两个列表的合并,把另外一个列表中的值添加到原列表中,等价于extend()方法,实例如下:
>>> names = ['bb', 'bb', 'aoi', 'alex', 'alex']
>>> li = [11, 22]
>>> names.__iadd__(li)
['bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
>>> names
['bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
我们上面了解过__add__()是生成一个新的列表,并不改变原来的列表,而__iadd__()是把另外一个列表中的元素添加到列表中,与extend()方法类似,改变了列表的元素值。
24.__imul__(self,*args,**kwargs)
def __imul__(self, *args, **kwargs): # real signature unknown
""" Implement self*=value. """
pass
25.__init__(self,seq=())
def __init__(self, seq=()): # known special case of list.__init__
"""
list() -> new empty list
list(iterable) -> new list initialized from iterable's items
# (copied from class doc)
"""
pass
__init__(self,seq=())是类中的方法,在类中经常使用。
26.__iter__(self,*args,**kwargs)
def __iter__(self, *args, **kwargs): # real signature unknown
""" Implement iter(self). """
pass
27.__len__(self,*args,**kwargs)
def __len__(self, *args, **kwargs): # real signature unknown
""" Return len(self). """
pass
__len__(self)是统计列表中元素的个数,等价于len(self),示例如下:
>>> names = ['bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
>>> names.__len__()
7
>>> len(names)
7
28.__mul__(self,*args,**kwargs)
def __mul__(self, *args, **kwargs): # real signature unknown
""" Return self*value.n """
pass
29.__new__(*args,**kwargs)
def __new__(*args, **kwargs): # real signature unknown
""" Create and return a new object. See help(type) for accurate signature. """
pass
30.__repr(self,*args,**kwargs)
def __repr__(self, *args, **kwargs): # real signature unknown
""" Return repr(self). """
pass
31.__reversed__(self)
def __reversed__(self): # real signature unknown; restored from __doc__
""" L.__reversed__() -- return a reverse iterator over the list """
pass
__reversed__(self)列表反转,与方法reverse()一样,用于列表反转,颠倒。示例如下:
>>> names = ['bb', 'bb', 'aoi', 'alex', 'alex', 11, 22]
>>> list(names.__reversed__())
[22, 11, 'alex', 'alex', 'aoi', 'bb', 'bb']
32._setitem__(self,*args,**kwargs)
def __setitem__(self, *args, **kwargs): # real signature unknown
""" Set self[key] to value. """
pass
__setitem__(self,index,value)向列表中添加元素,向列表中指定位置添加元素,并替换之前位置的值,在之前列表索引处添加一个值,替换当前值,实例如下:
>>> names = ['bb', 'bb', 'tom', 'alex', 'alex', 11, 22]
>>> names.__setitem__(1,"xia")
>>> names
['bb', 'xia', 'tom', 'alex', 'alex', 11, 22]
>>> names.__setitem__(3,"sb")
>>> names
['bb', 'xia', 'tom', 'sb', 'alex', 11, 22]
__setitem__(self,index,value)相当于修改元素,修改原来位置的元素,self[index] = value.
33.__sizeof__(self)
def __sizeof__(self): # real signature unknown; restored from __doc__
""" L.__sizeof__() -- size of L in memory, in bytes """
pass
__sizeof__(self)返回占有的字节,但是一直没有弄懂,因为是内部的编码,这个以后遇到了重新梳理。