[阶段一] 4. Python列表常用方法

冷不防 2022-09-04 13:45 212阅读 0赞

### python列表常用方法 ###

`len` 函数可以计算除了数字类型以外，其他所有数据类型的长度。

`in` 判断某个元素是否在列表（或元组）中；`not in` 判断某个元素是否不在列表（或元组）中。

*  `append` 函数：

`append` 函数的功能是将一个元素添加到当前列表中，新元素会被添加到列表的最后。

用法：`list.append(item)`，参数 `item` 表示添加进列表的新元素。示例：

>>> person = ['xiaobai', 18, 'hangzhou']
    
    >>> person.append('student')
    
    >>> person
    ['xiaobai', 18, 'hangzhou', 'student']

*  `insert` 函数：

`insert` 函数的功能是将一个元素插入到当前列表的指定位置，新元素。

用法：`list.insert(index, item)`，参数 `index` 表示插入位置的索引，`item` 表示插入进列表的新元素。示例：

>>> person
    ['xiaobai', 18, 'student']
    
    >>> person.insert(2, 'hangzhou')
    
    >>> person
    ['xiaobai', 18, 'hangzhou', 'student']

`append` 函数与 `insert` 函数的区别：

append 只能添加元素到列表的结尾，而 insert 可以选择任意位置插入
    
    如果 insert 传入的索引在列表中不存在，则将新元素添加到列表结尾
    
    字符串、列表和元组的索引都是从 0 开始

*  `count` 函数：

`count` 函数的功能是返回当前列表中某个元素的个数。

用法：`inttpye = list.count(item)`，参数 `item` 表示 想查询个数的元素。示例：

>>> list_1 = [1, 1, 3, 'b', 'b', 'a', 'c', 'a', 2, 'a']
    
    >>> list_1.count(1)
    2
    
    >>> list_1.count('a')
    3
    
    >>> list_1.count('c')
    1

使用 `count` 函数需要注意：

如果查询的元素不存在，则返回 0
    
    列表只会检查完整元素是否存在需要计算的内容

*  `remove` 函数：

`remove` 函数的功能是将一个元素从当前列表中删除。

用法：`list.remove(item)`，参数 `item` 表示从列表中删除的元素。示例：

>>> person
    ['xiaobai', 18, 'hangzhou', 'student']
    
    >>> person.remove('hangzhou')
    
    >>> person
    ['xiaobai', 18, 'student']

>>> person
    ['xiaobai', 18, 'hangzhou', 'student']
    
    >>> person.append(18)
    
    >>> person
    ['xiaobai', 18, 'hangzhou', 'student', 18]
    
    >>> person.remove(18)
    
    >>> person
    ['xiaobai', 'hangzhou', 'student', 18]

使用 `remove` 函数需要注意：

如果删除的元素不存在，则会报错
    
    如果被删除的元素有多个，只会删除第一个
    
    remove 不会返回一个新的列表，而是在原先列表中对元素进行删除

*  `reverse` 函数：

`reverse` 函数的功能是对当前列表元素的顺序进行反转。

用法：`list.reverse()`，括号内无参数。示例：

>>> person
    ['xiaobai', 'hangzhou', 'student', 18]
    
    >>> person.reverse()
    
    >>> person
    [18, 'student', 'hangzhou', 'xiaobai']

*  `sort` 函数：

`sort` 函数的功能是对当前列表元素按照一定规律进行排序，列表中元素需要是同一类型。

用法：`list.sort(com=None, key=None, reverse=False)`，参数 `cmp` 是可选参数，表示制定排序方案的函数；`key` 表示参数比较；`reverse` 表示排序规则，`reverse=True` 降序，`reverse=False` 升序。示例：

>>> person
    [18, 'student', 'hangzhou', 'xiaobai']
    
    >>> person.sort()
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: '<' not supported between instances of 'str' and 'int'               #字符串类型无法与整型进行比较，因此无法排序

>>> person.remove(18)
    
    >>> person.sort()
    
    >>> person
    ['hangzhou', 'student', 'xiaobai']
    
    >>> person.sort(reverse=True)
    
    >>> person
    ['xiaobai', 'student', 'hangzhou']

*  `clear` 函数：

`clear` 函数的功能是将当前列表中的元素清空，使之成为一个空列表。

用法：`list.clear()`，括号内无参数。示例：

>>> person
    ['xiaobai', 'student', 'hangzhou']
    
    >>> person.clear()
    
    >>> person
    []

*  `copy` 函数：

`copy` 函数的功能是将当前的列表复制为新的列表，新列表与当前的列表内容相同，但内存空间不同。

用法：`new_list = list.copy()`，括号内无参数。示例：

>>> person = ['xiaobai', 'student', 'hangzhou']
    
    >>> new_person = person.copy()
    
    >>> new_person
    ['xiaobai', 'student', 'hangzhou']

>>> a = [[1, 2, 3], [4, 5, 6]]
    
    >>> b = a.copy()
    
    >>> b
    [[1, 2, 3], [4, 5, 6]]
    
    >>> b[0].append(7)
    
    >>> b
    [[1, 2, 3, 7], [4, 5, 6]]
    
    >>> a
    [[1, 2, 3, 7], [4, 5, 6]]

二次赋值的变量与原始变量享有相同的内存空间，而 `copy` 函数生成的变量与原始变量的内存空间不同，不同享数据变更。

只能对数据结构的第一层进行拷贝，如果数据结构里有更深层次的数据，则无法进行拷贝，深层次的数据对于原始变量和新生成的变量来说是共享的，这就是浅拷贝。通过上面示例可以看到，`copy` 就属于浅拷贝。

*  `copy.deepcopy` 函数：

`copy.deepcopy` 函数的功能是将当前的列表复制为新的列表，新列表与当前的列表内容相同，但内存空间不同。

用法：`new_list = copy.deepcopy(list)`，参数 `list` 表示当前要复制的列表。示例：

>>> import copy
    
    >>> person = ['xiaobai', 'student', 'hangzhou']
    
    >>> new_person = copy.deepcopy(person)
    
    >>> new_person
    ['xiaobai', 'student', 'hangzhou']

>>> a = [[1, 2, 3], [4, 5, 6]]
    
    >>> b = copy.deepcopy(a)
    
    >>> b
    [[1, 2, 3], [4, 5, 6]]
    
    >>> b[0].append(7)
    
    >>> b
    [[1, 2, 3, 7], [4, 5, 6]]
    
    >>> a
    [[1, 2, 3], [4, 5, 6]]

不仅仅对数据结构的第一层进行拷贝，对深层次的数据也进行了拷贝，原始变量和新生成的变量完全不共享数据，这就是深拷贝。通过上面示例可以看到，`copy.deepcopy` 就属于深拷贝。

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>列表、字典</th> 
   <th>数字、字符串</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>浅拷贝 copy()</td> 
   <td>拷贝父对象，不会拷贝对象内部的子对象</td> 
   <td>等同于赋值操作</td> 
  </tr> 
  <tr> 
   <td>深拷贝 copy.deepcopy()</td> 
   <td>完全拷贝父对象及其子对象</td> 
   <td>等同于赋值操作</td> 
  </tr> 
 </tbody> 
</table>

深拷贝：与原始变量内存空间不相同，不共享数据。浅拷贝：对最外层的数据创建一个新的内存空间来存储，而对内层的数据内存地址进行引用。

*  `extend` 函数：

`extend` 函数的功能是将其它列表或元组中的元素一次性倒入到当前列表中。

用法：`list.extend(iterable)`，参数 `iterable` 表示可迭代对象，如列表或元组。示例：

>>> person = ['xiaobai', 'student', 'hangzhou']
    
    >>> another_person = ['xiaohei', 'teacher', 'shenzhen']
    
    >>> person.extend(another_person)
    
    >>> person
    ['xiaobai', 'student', 'hangzhou', 'xiaohei', 'teacher', 'shenzhen']
    
    >>> another_person
    ['xiaohei', 'teacher', 'shenzhen']

--------------------

### 列表的索引与切片 ###

*  什么是索引？

从数据结构的最左边记录的位置就是索引。

字符串、列表和元祖才有索引，索引用数字表示，起始从 0 开始。因此，字符串、列表和元祖的最大索引就是它们的长度 - 1。

*  什么是切片？

索引用来对单个元素进行访问，切片则是对一定范围内的元素进行访问。

切片通过 `:` 在 `[]` 内把相隔的两个索引查找出来，如 `[0: 10]`。切片得到的对象与原来对象无关，不共享内存空间。示例：

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    >>> numbers[2: 8]
    [3, 4, 5, 6, 7, 8]
    
    >>> numbers[1: 5]
    [2, 3, 4, 5]
    
    >>> numbers[:]
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    >>> numbers[0:]
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

从上面可以看出，切片的规则是 左含右不含（包含左边索引的元素，不包含右边索引的元素），切片 `[:]` 和 `[0:]` 表示对所有范围的元素进行访问，不影响原来的字符串、列表和元祖。

>>> numbers[1: 9: 2]
    [2, 4, 6, 8]
    
    >>> numbers[6: 1: -1]
    [7, 6, 5, 4, 3]
    
    >>> numbers[10 :: -1]
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    
    >>> numbers[::-1]
    [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

切片时第三个参数是步长，不指定默认为1。切片 `[::-1]` 表示对所有范围的元素进行反向访问。

只能对已存在的索引进行切片，超出索引范围则会报错。字符串、列表和元祖也无法通过添加新索引的方式赋值。

*  `index` 函数：

`index` 函数的功能是获取元素的索引。

用法：`list.index(ietm)`，参数 `item` 表示要查找索引的元素。示例：

>>> numbers
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    >>> numbers.index(9)
    8

*  `pop` 函数：

`pop` 函数的功能是根据元素索引取出元素，原来对象会删除取出的元素。

用法：`list.pop(index)`，参数 `index` 表示要取出元素的索引。示例：

>>> numbers
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    >>> numbers.pop(9)
    10
    
    >>> numbers
    [1, 2, 3, 4, 5, 6, 7, 8, 9]

使用 `del` 函数可以删除索引，`del list[index]`，如果索引不存在则会报错。

*  索引、切片在元组中的特殊性：