Python学习笔记(一):list属性及方法浅析

列表学习。

List是python中的基本数据结构之一。创建一个列表的方法

L = [1,2,3,'a']

通过help(list)查看列表的属性及方法。

>>> help(list)
Help on class list in module builtins:

class list(object)
 |  list() -> new empty list
 |  list(iterable) -> new list initialized from iterable's items
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self  |  
 |  __mul__(self, value, /)
 |      Return self*value.n
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(...)
 |      L.__reversed__() -- return a reverse iterator over the list
 |  
 |  __rmul__(self, value, /)
 |      Return self*value.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(...)
 |      L.__sizeof__() -- size of L in memory, in bytes
 |  
 |  append(...)
 |      L.append(object) -> None -- append object to end
 |  
 |  clear(...)
 |      L.clear() -> None -- remove all items from L
 |  
 |  copy(...)
 |      L.copy() -> list -- a shallow copy of L
 |  
 |  count(...)
 |      L.count(value) -> integer -- return number of occurrences of value
 |  
 |  extend(...)
 |      L.extend(iterable) -> None -- 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) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(...)
 |      L.reverse() -- reverse *IN PLACE*
 |  
 |  sort(...)
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None



下面分别来解析：
list() -> new empty list   新建一个空的列表

In [1]: a = list()

In [2]: a
Out[2]: []

list(iterable) -> new list initialized from iterable's items
将可迭代的items转换为列表，例如字符串和元组

In [6]: s = "hello world!"

In [7]: L = list(s)

In [8]: L
Out[8]: ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!']

__add__(self, value, /)   Return self+value.列表相加

In [1]: a = [1,2]

In [2]: b = [1,2]

In [3]: a.__add__(b)   # 返回a+b，a,b本身没有改变
Out[3]: [1, 2, 1, 2]

In [4]: a
Out[4]: [1, 2]    

In [5]: b
Out[5]: [1, 2]

In [6]: c = a.__add__(b)

In [7]: c
Out[7]: [1, 2, 1, 2]

In [8]: d = a+b

In [9]: c == b
Out[9]: False

In [10]: c == d
Out[10]: True

__contains__(self, key, /)    Return key in self.     判断列表是否包含某对象

In [11]: L = [1,2,3,4]

In [12]: L.__contains__(1)
Out[12]: True

In [13]: L.__contains__(2)
Out[13]: True

In [14]: L.__contains__(0)
Out[14]: False

In [15]: L.__contains__('a')
Out[15]: False

In [16]: L.__contains__(L)   #并不包含本身
Out[16]: False


In [18]: L in L
Out[18]: False

In [19]: 2 in L
Out[19]: True

In [20]: 0 in L
Out[20]: False

__delitem__(self, key, /)    Delete self[key].    删除某对象

In [21]: L = [1,2,3]

In [22]: L.__delitem__(0)   #删除第0个对象

In [23]: L
Out[23]: [2, 3]    

In [24]: del L[1]      #删除第1个对象

In [25]: L
Out[25]: [2]

__eq__(self, value, /)     Return self==value.   判断列表是否等于某列表

In [36]: a = [1,2,3,4]

In [37]: b = [1,2]

In [38]: a.__eq__(1)
Out[38]: NotImplemented   #没有实现该功能

In [39]: a.__eq__([1,2])
Out[39]: False

In [40]: a.__eq__(b)
Out[40]: False

In [41]: a.__eq__([1,2,3,4])
Out[41]: True

In [42]: a.__eq__((1,2,3,4))
Out[42]: NotImplemented

与 == 略有差异

In [43]: a = [1,2,3,4]

In [44]: b = [1,2]

In [45]: a == 1
Out[45]: False

In [46]: a == [1,2]
Out[46]: False

In [47]: a == [1,2,3,4]
Out[47]: True

In [48]: a == b
Out[48]: False

In [49]: a == (1,2,3,4)
Out[49]: False

__ge__(self, value, /)     Return self>=value.判断列表是否不小于某列表。与__eq__类似


__getattribute__(self, name, /)    Return getattr(self, name).

In [63]: a = [1,2,3,4]

In [64]: a.__getattribute__('__len__')
Out[64]: 

In [65]: b = a.__getattribute__('__len__')

In [66]: b()
Out[66]: 4



In [67]: a
Out[67]: [1, 2, 3, 4]

In [68]: a.__getattribute__('copy')
Out[68]: 

In [69]: b = a.__getattribute__('copy')

In [70]: c = b()

In [71]: c
Out[71]: [1, 2, 3, 4]

__getitem__(...)     x.__getitem__(y) <==> x[y]   #返回某索引下的对象

In [1]: a = [1,2,3,"hello",(1,2,3)]

In [2]: a.__getitem__(0)
Out[2]: 1

In [3]: a.__getitem__(3)
Out[3]: 'hello'

In [4]: a.__getitem__(4)
Out[4]: (1, 2, 3)

In [5]: a.__getitem__(5)     无法访问越界的对象
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in ()
----> 1 a.__getitem__(5)

IndexError: list index out of range       #越界报错



In [6]:  a = [1,2,3,"hello",(1,2,3)]

In [7]: a[0]
Out[7]: 1

In [8]: a[3]
Out[8]: 'hello'

In [9]: a[4]
Out[9]: (1, 2, 3)

In [10]: a[5]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
 in ()
----> 1 a[5]

IndexError: list index out of range

 __gt__(self, value, /)    Return self>value.  判断列表是否大于某列表。与__eq__类似


__iadd__(self, value, /)   Implement self+=value.   self+=value   value可以是任何可迭代对象。

In [3]: a = [1,2,3,4]

In [4]: a.__iadd__("hello")     
Out[4]: [1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o']      #先将字符串转换为列表，然后再相加，列表会改变

In [5]: a.__iadd__((1,2,3))
Out[5]: [1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o', 1, 2, 3]  #先将元组转换为列表，然后再相加，列表会改变

In [6]: a.__iadd__([1111,1113])   #列表相加，列表会改变
Out[6]: [1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o', 1, 2, 3, 1111, 1113]

In [7]: a    #a已改变
Out[7]: [1, 2, 3, 4, 'h', 'e', 'l', 'l', 'o', 1, 2, 3, 1111, 1113]

__imul__(self, value, /)      Implement self*=value.  self*=value   value必须是integer类型

In [15]: a = [1,2,3,'abc']

In [16]: a.__imul__(2)      #*2并返回给a
Out[16]: [1, 2, 3, 'abc', 1, 2, 3, 'abc']

In [17]: a              #a已改变
Out[17]: [1, 2, 3, 'abc', 1, 2, 3, 'abc']

In [18]: a.__imul__([1,2])  #参数不是integer类型，报错
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 a.__imul__([1,2])

TypeError: 'list' object cannot be interpreted as an integer

__init__(self, /, *args, **kwargs)  Initialize self.  See help(type(self)) for accurate signature.   列表初始化

In [23]: a = []

In [24]: b = [1,2,3,4]

In [25]: a.__init__(b)

In [26]: a
Out[26]: [1, 2, 3, 4]

In [27]: a.__init__((1,2,3))  #先将元组转换为列表，再初始化给a

In [28]: a
Out[28]: [1, 2, 3]

__iter__(self, /)   Implement iter(self).

In [34]: a = [1,2,3,4,54]

In [35]: for i  in a.__iter__():
    ...:     print (i)
    ...:
1
2
3
4
54

In [36]: a.__iter__
Out[36]: 

In [37]: a.__iter__()   #列表类型的迭代器
Out[37]: 

__le__(self, value, /)      Return self<=value.  判断列表是不大于某列表。与__eq__类似

__len__(self, /)     Return len(self).   返回列表长度，即元素个数

In [38]: a = [1,2,3,"abc",(111,222,333)]

In [39]: a.__len__()
Out[39]: 5

In [40]: a.__len__
Out[40]: 

__lt__(self, value, /)    Return self



__mul__(self, value, /)    Return self*value.n   与__imul__类似，但本身不会改变

In [41]: a = [1,2,3,"abc",(111,222,333)]

In [42]: a.__mul__(2)
Out[42]: [1, 2, 3, 'abc', (111, 222, 333), 1, 2, 3, 'abc', (111, 222, 333)]

In [43]: a
Out[43]: [1, 2, 3, 'abc', (111, 222, 333)]

__ne__(self, value, /)    Return self!=value.判断列表是不等于某列表。与__eq__类似


__new__(*args, **kwargs) from builtins.type
   Create and return a new object.  See help(type) for accurate signature. 创建一个新的列表对象。

In [1]: a = [1,2,3,4]

In [2]: b = a.__new__(list)

In [3]: b
Out[3]: []

In [4]: b = a.__new__(str)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 b = a.__new__(str)

TypeError: list.__new__(str): str is not a subtype of list

In [5]: b = a.__new__(tuple)
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
 in ()
----> 1 b = a.__new__(tuple)

TypeError: list.__new__(tuple): tuple is not a subtype of list

__repr__(self, /)   Return repr(self).   相当于repr函数

In [12]: a = [1,2,3,4]

In [13]: b = a.__repr__()

In [14]: b
Out[14]: '[1, 2, 3, 4]'   #字符串

In [15]: a
Out[15]: [1, 2, 3, 4]

__reversed__(...)   L.__reversed__() -- return a reverse iterator over the list   返回列表的逆序迭代器，列表本身不会改变

In [19]: a = [1,2,3,4]

In [20]: a.__reversed__()
Out[20]: 

In [21]: a
Out[21]: [1, 2, 3, 4]

In [22]: b = a.__reversed__()

In [23]: for i in b:
    ...:     print (i)
    ...:
4
3
2
1

__rmul__(self, value, /)     Return self*value.      不知道与__mul__  有啥区别。

In [34]: a = [1,2,3,4,"abc"]

In [35]: a.__mul__(-1)
Out[35]: []

In [36]: a.__mul__(0)
Out[36]: []

In [37]: a
Out[37]: [1, 2, 3, 4, 'abc']

In [38]: a.__mul__(2)
Out[38]: [1, 2, 3, 4, 'abc', 1, 2, 3, 4, 'abc']

__setitem__(self, key, value, /)       Set self[key] to value.   改变列表某位置的对象。

In [39]: a
Out[39]: [1, 2, 3, 4, 'abc']

In [40]: a.__setitem__(2,"aaa")

In [41]: a
Out[41]: [1, 2, 'aaa', 4, 'abc']

In [43]: a
Out[43]: [1, 2, 3, 4, 'abc']

__sizeof__(...)    L.__sizeof__() -- size of L in memory, in bytes  返回列表所占内存

In [44]: a = []

In [45]: a.__sizeof__
Out[45]: 

In [46]: a.__sizeof__()
Out[46]: 20

In [47]: a = [1]

In [48]: a.__sizeof__()
Out[48]: 24

In [49]: a = [1,2,3]

In [50]: a.__sizeof__()
Out[50]: 32

In [51]: a = ['a']

In [52]: a.__sizeof__()
Out[52]: 24

In [53]: a = ['abc']

In [54]: a.__sizeof__()
Out[54]: 24

append(...)   L.append(object) -> None -- append object to end   添加对象到列表末尾

In [55]: a = [1]

In [56]: a.append(2)

In [57]: a
Out[57]: [1, 2]

In [58]: a.append('2')

In [59]: a
Out[59]: [1, 2, '2']

In [60]: a.append([1,2])

In [61]: a
Out[61]: [1, 2, '2', [1, 2]]

In [62]: a.append((3,4))

In [63]: a
Out[63]: [1, 2, '2', [1, 2], (3, 4)]

 clear(...)    L.clear() -> None -- remove all items from L   清空列表

In [64]: a
Out[64]: [1, 2, '2', [1, 2], (3, 4)]

In [65]: a.clear()

In [66]: a
Out[66]: []

copy(...)   L.copy() -> list -- a shallow copy of L   列表浅拷贝

In [67]: a = [1,2,3,4]

In [68]: b = a.copy()

In [69]: a
Out[69]: [1, 2, 3, 4]

In [70]: b
Out[70]: [1, 2, 3, 4]

count(...)   L.count(value) -> integer -- return number of occurrences of value  返回列表中某对象的个数。

In [71]: a = [1,2,3,'a','aa',[1,2]]

In [72]: a.count(1)
Out[72]: 1

In [73]: a.count('a')
Out[73]: 1

In [74]: a.count([1,2])
Out[74]: 1

In [75]: a.count(0)
Out[75]: 0

extend(...)   L.extend(iterable) -> None -- extend list by appending elements from the iterable    将迭代器对象转换为列表并添加到列表末端。

In [80]: a = [1,2,3]

In [81]: a.extend((1,2,3))

In [82]: a
Out[82]: [1, 2, 3, 1, 2, 3]

In [83]: a.extend([4,5,6])

In [84]: a
Out[84]: [1, 2, 3, 1, 2, 3, 4, 5, 6]

index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value.
 |      Raises ValueError if the value is not present.

In [85]: a
Out[85]: [1, 2, 3, 1, 2, 3, 4, 5, 6]

In [86]: a.index(2)
Out[86]: 1     #返回第一个出现对象的位置

In [87]: a.index(7)  #列表中不存在是时报错
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
 in ()
----> 1 a.index(7)

ValueError: 7 is not in list

insert(...)
 |      L.insert(index, object) -- insert object before index  在index位置插入任何对象

In [90]: a.insert(0,"abc")

In [91]: a
Out[91]: ['abc', 1, 2, 3, 1, 2, 3, 4, 5, 6]

 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.
 删除index位置处的对象并返回该对象，列表本身改变

In [92]: a.pop(2)
Out[92]: 2

In [93]: a
Out[93]: ['abc', 1, 3, 1, 2, 3, 4, 5, 6]

remove(...)
 |      L.remove(value) -> None -- remove first occurrence of value.
 |      Raises ValueError if the value is not present.
删除某个第一次出现的值，返回None

In [100]: a = [1,1,2,2,3,3,4,4,"aa",'aa']

In [101]: a.remove(1)

In [102]: a
Out[102]: [1, 2, 2, 3, 3, 4, 4, 'aa', 'aa']

In [103]: a.remove('aa')

In [104]: a
Out[104]: [1, 2, 2, 3, 3, 4, 4, 'aa']

 reverse(...)
 |      L.reverse() -- reverse *IN PLACE*   列表逆序

In [105]: a = [1,2,3]

In [106]: a.reverse()

In [107]: a
Out[107]: [3, 2, 1]

sort(...)   对列表进行排序，列表元素必须是同一类型
 |      L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*

In [112]: a = [1,9,2,3,7,4]

In [113]: a.sort()

In [114]: a
Out[114]: [1, 2, 3, 4, 7, 9]