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

左手的ㄟ右手 2022-06-08 04:14 674阅读 0赞

列表学习。  
  
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<value.  
|  
| \_\_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]: <method-wrapper '__len__' of list object at 0x02558EE0>
    
    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]: <function list.copy>
    
    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)
    <ipython-input-5-3a58e3eacf6a> in <module>()
    ----> 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)
    <ipython-input-10-b6a934feab86> in <module>()
    ----> 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)
    <ipython-input-18-58ca78754a99> in <module>()
    ----> 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]: <method-wrapper '__iter__' of list object at 0x024B7D00>
    
    In [37]: a.__iter__()   #列表类型的迭代器
    Out[37]: <list_iterator at 0x25586b0>

\_\_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]: <method-wrapper '__len__' of list object at 0x024C44B8>

\_\_lt\_\_(self, value, /) Return self<value. 判断列表是小于某列表。与\_\_eq\_\_类似  
  
  
  
  
\_\_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)
    <ipython-input-4-6fee1f0c3d80> in <module>()
    ----> 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)
    <ipython-input-5-18991a398a58> in <module>()
    ----> 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]: <list_reverseiterator at 0x2538c50>
    
    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]: <function list.__sizeof__>
    
    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)
    <ipython-input-87-e64802c95647> in <module>()
    ----> 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]