Python内置数据结构--列表

本节内容：

• 列表
• 元组
• 字符串
• 集合
• 字典

本节先介绍列表。

 

1、列表

一种容器类型。列表能够包含任何种类的对象，好比说数字、子串、嵌套其余列表、嵌套元组。

任意对象的有序集合，经过索引访问其中的元素。其长度可变，支持异构(在一个列表中能够包含多种不一样类型的元素)，能够任意嵌套。

列表是可变对象，支持在原处修改。列表的可变变如今其内部的每个元素存储在列表中不是对象自己，而是对象的引用。所以其修改的是对象的引用。

help()是ipython里特有的函数，能够打印出类、函数的一些信息。

In [1]: 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.
 |  
...

　　

1. 初始化列表

list()，里面能够什么都不放，也能够放可迭代对象。

直接一个[]

In [2]: lst = list()

In [3]: lst = []

In [4]: lst
Out[4]: []

In [5]: lst = [1, 2, 3]

In [6]: lst
Out[6]: [1, 2, 3]

　　

2. 下标/索引操做

python中list的索引从0开始。绝大多数语言的下标是从0开始的，也有少部分例外，好比awk、lua。

负数的索引表示从后往前数，由-1开始，-1表示最后一个元素。

In [6]: lst
Out[6]: [1, 2, 3]

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

In [8]: lst[-1]
Out[8]: 3

若是索引超出范围，将引起IndexError。

In [9]: lst[-4]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-9-7ea420056b9a> in <module>()
----> 1 lst[-4]

IndexError: list index out of range

In [10]: lst[3]
---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-10-298ffefac8cf> in <module>()
----> 1 lst[3]

IndexError: list index out of range

修改元素的时候，若是超出索引范围，也会引起IndexError。

 

　　

 

3. 列表的操做

• 增：append、extend、insert
• 删：clear、pop、remove
• 改：reverse、sort
• 查：count、index
• 其余：copy

 

（1）给list增长元素

append：

append方法原地修改list，给list最后增长一个元素。append方法的返回值是None。

 

insert：

insert方法操做的索引超出范围时，若是是正索引，等效于append，若是是负索引，等效于insert(0, object)

insert的时间复杂度是O(n)，append的时间复杂度是O(1)。由于insert是要作一个遍历的。

 

extend：

extend的时间复杂度是O(n)，这个n是可迭代对象的长度，并非原有list的长度n。

 

（2）删除元素

pop：

能够传入index，默认从最后移除一个元素，而且把这个元素返回回来。

index默认是-1，即最后一个元素，若是index超出索引范围，会抛出IndexError。

 

remove：

pop是弹出索引对应的值，remove是删除最左边的一个值。

pop针对的是索引，remove针对的是值。

remove的时候，若是值不存在，会抛出ValueError。

 

pop和remove的时间复杂度都是O(n)

 

clear：

clear方法删除列表的全部元素。

 

（4）查找/统计元素

能够利用index查询

 

index：

 

start包含，stop不包含。即[start, stop)

index方法根据值查找索引。

 

count：

count返回指定的value在List中出现的次数。

len函数

不是List的方法，它是python的一个内置函数，用于检查List元素个数。并不只仅是针对List，能够针对不少对象。

 

（5）修改列表

sort：

原处是指直接修改List

 

reverse：

原处是指直接修改List

 

（6）其余方法

 copy：

 

如何删除后面的2？

若是不想在原List上作修改：

lst2 = lst，只是一个指针指到lst指到的那块内存，所以操做lst2的时候，lst也被修改了。由于它们两个都是指针，指到同一块内存。这就用到List的copy函数了。

搞错了，不是深copy，只是一层copy。

 

id()打印出引用指向的内存块的地址。

 

成员关系判断

• in

• not in

 

【举例】:如何去除List中的重复元素

 

列表相加：合并两个列表，生成了一个新列表。不会修改原列表。这个和子串的相加是同样的，生成新的子串。

 

序列相乘：就是重复元素屡次。都是生成新对象。

子串乘法：

列表乘法：

 

 

4. 切片

切片一般是用来访问数据的，若是你对切片赋值的话，产生的结果是不可预料的。切片操做老是返回一个新的list，不会改变原有的list

 

 

seq[start, end]     [start, end)

　　

若是想获取到最后一个元素，省略end

 

 

以上都是从左往右切片，因此左边的数字要小于右边的数字。

start超出索引范围从0开始，end超出索引范围到到len(lst)结束。

 

 

start为0时能够省略，end省略表示打印到最后一个元素，start和end都省略就是copy。

 

切片还有一个第3个参数：step，默认是1

 

当step为负数的时候，从后往前数，此时start应该大于end，不然返回空列表。

 

 

 

 

切片赋值

对切片赋值，会替换切片原来的元素。

 

一般咱们是不会对切片进行赋值的，会形成不少的误解。

5. 解包/封包

看一个例子，传统的swap

可是在python里面不须要这么作

 

原来中间的3行代码变成了如今的1行代码，这就是解包/封包。

最简单的解包就是以下：把右边的元组或者列表(可迭代对象都行)解开成了左边的两个变量，这种就是解包。

 

封包就是把一组变量，变成元组。把若干变量或常量封装到一个变量里，这就是封包。

咱们显式的使用封包比较少，可是解包用的不少。

 

应用场景：

 

 

 

 

解包是把集合里的元素赋值给变量(集合能够是可迭代对象)，赋值完的变量要么是一个值，要么是个list，而无论右侧集合是列表仍是元组。

封包是把变量构建成元组。下面的这种用法python2是不支持的。

 

好比我想取出list中的下标是0,1,3元素，切片是很差作的：

 

下划线_ 是指当咱们要丢弃一个变量时使用的。

再如，咱们取一头一尾：

 

 

再看两个复杂点的：

只要两边结构是同样的，解包多少层都是能够的。