本文发表于知乎专栏：/p/59740559
也同步更新于我的个人网站：/blog/id=97
更新时间：.10.27
更新内容：
“2.14加入sorted函数”
“2.3”加入一种删除元素的方法
”二、字典“新增1.5，字典的常用操作
1.1字典的创建增加四种创建方式
增加“三、元组”的部分内容
修复了一些错误。（感谢@裚絮 ！）
一、list（列表）
list作为Python中最常用的数据结构之一，与其他编程语言的数组有相似的特点，但是它具有着更为强大的功能，接下来将详细地为大家介绍一下list的所有操作。
（注：tuple元组类型与list类似，但是tuple的元素不能修改；set集合与list也类似，但是集合中的元素是无序的，且会自动除去重复元素）
1. list列表的创建
创建一个列表（不赋初值）:
a = []a = list()
创建一个列表，并对其赋初值
a = [1,2,3]
列表更高级的创建方法——用表达式创建
a = [i for i in range(1, 11)]#创建一个元素分别为1,2，...10的列表a = [i for i in range(1, 11) if i % 2 == 0]#创建一个1-10，且元素为偶数的列表
用list函数将其他（可迭代）数据转换为列表
list("ab c") #列表为["a", "b", " ", "c"]
2. list列表的常用操作
2.1 列表的索引
直接用中括号[ ]索引其下标即可，或用for循环遍历所有的值
注意，当下标为负数时则代表从后往前所以（或理解为长度+负下标），即-1代表最后一个元素，-2代表倒数第2个元素
a = [1,2,3]print(a[1]) #输出2,因为一个list列表的下标从0开始，按照0, 1, 2,...的顺序排列print(a[-1]) #输出3for i in a: print(i) #输出1 2 3
注意，字典dict中可以用.keys()和.values()分别遍历dict的键和值
字典dict中.get()函数可以返回指定键的值，相比于dict[“key”]访问的好处是如果字典中没有指定的key则返回None，而不会直接报错
a = {"one":1, "two":2}for i in a.values(): print(i) #输出1 2a.get(key, default) #default_value不设置的话默认为None，设置的话即如果找不到则返回default设定的值
2.2 列表的分片操作（slice）
用[左边界下标：右边界下标：步长]截取list中特定的一段，注意是左闭右开的区间，即包含左边界，但是不包含右边界
其中：步长可以省略，默认为1。步长即每次截取一个元素，到下一次截取元素距离几个元素（默认为1，即紧挨着截取）
特别注意，冒号：的左右两侧都可以不写，其中左侧默认为0，即list第一个数据，右侧默认为数据个数+1，即list的最后一个数据
左边界和右边界也可以超出list的范围，最长只能截取到list的范围内
一般情况下，左边界<=右边界。若左边界>右边界，则要设置步长为负数，否则输出为空（此情况也就是从右向左截取）
a = [1,2,3,4,5]print(a[1:3]) #输出[2,3]print(a[:4]) #输出[1,2,3,4]print(a[2:]) #输出[3,4,5]print(a[2:10] #输出[3,4,5]print(a[0:3:2]) #输出[1,3]print(a[2:0:-1]) #输出[3,2]
2.3 列表删除元素
用del函数删除列表指定位置的元素
python del(list1[index] #删除list1中index位置的元素（index也可以表示一个范围，如[1, 3]）
用pop函数剔除队尾元素，并将其返回
python a = list1.pop(index) #将list1中index位置元素剔除并赋值给a，默认删除最后一个元素
用remove函数删除列表中值为指定值的元素
python list1.remove(value) #删除list中值为value的元素
用clear函数彻底清空列表全部内容
python list1.clear() #清空list1的全部内容
用分片赋值空列表的办法删除元素
python list1 = [1, 2, 3, 4, 5] list1[2:] = [] list1 # 输出[1, 2]
注意：集合中只有remove和discard，其中discard删除不存在的元素不会报错，但是remove与list中一样，会报错
2.4 列表的拼接
可以简单的用 + 将两个列表连接起来
a = [1, 2]b = [3]c = a + b那么c = [1, 2, 3]
用extend函数拼接两个列表
list1.extend(list2) #在list1后面接上list2
2.5 列表的重复
可以将一个列表直接乘一个数字n获得n倍重复后的列表，相当于n个这样的列表连接起来
a = [0]b = a * 5那么b = [0, 0, 0, 0, 0]
2.6 元素成员判断（判断一个元素是否存在一个列表中）
a = [1, 2, 3, 4, 5]b = 2print(b in a)# 输出Trueprint(b not in a)# 输出False
若in前面的元素在列表中则运算值为真；否则为假 not in与in刚好相反
2.7 求列表的长度
len([1, 2, 3]) #列表的长度为3
2.8 求列表的最大、最小值
max([1, 2, 3]) #最大值为3
2.9 在列表中插入元素
append函数在队尾插入元素
list1.append(5) #在list1的最后插入元素5
insert函数在任意位置插入元素
list1.insert(index, data) #在指定位置（index处）插入元素data
extend()函数在尾部扩展一个新列表
list1 = [1]list1.extend([2, 3]) # list1为[1, 2, 3]
注意，集合set中没有append和insert，取代的是add
set1.add(2) #向集合中加入元素2
2.10 反转一个列表
list1.reverse() #翻转整个列表，即第一个与最后一个互换，第二个与倒数第二个互换....
2.11 计算列表中指定元素x的个数
times = list.count(x)
2.12 查找列表中指定元素的位置
语法：index(X) 查找list中元素X的位置（若重复出现，则以第一次出现的为准）
a = [1, 2, 3, 4, 5] a.index(2) #结果为1
2.13 （浅）复制一个list
list2 = list1.copy() #将list1的内容复制给list2#注意这里与list2 = list1是有区别的，python中列表的直接赋值是一个传址操作，即改变list2的值也会同时影响list1的值#但是copy函数进行的是一个传值操作，即改变list2的值对list1无影响#浅复制的意思是若列表中嵌套一个列表，则对内部的列表仍然是传址复制
2.14 列表的排序：sort方法与sorted函数
sort方法
参数：
key:主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。(/python/att-list-sort.html)
reverse：是否降序(True为降序，不指定该参数为升序)
list1 = [(1,6),(3,4),(2,5)]list1.sort(key=lambda x:x[1], reverse=True) # 根据第二个元素，降序排列# 输出:[(1, 6), (2, 5), (3, 4)]
sorted()函数：
与sort方法功能类似，但是sorted()函数有返回值，返回的是排序后的结果。
二、字典（dict）
字典与列表最大的区别就是字典强调的是“键值对”，key与value一一对应，字典中的存放顺序并不重要，重要的是“键”和“值的对应关系”
1.1 字典的创建(字典中每一对数据都是“键”和“值”相对应的)
a = {key1:value1, key2:value2} # 第一种a = dict(key1=value1, key2=value2) # 第二种，注意此种情况下键必须为字符串a = {}a[key1] = value1 a[key2] = value2 # 第三种a = dict([(key1, value1), (key2, value2)]) # 第四种a = dict(zip([key1, key2], [value1, value2])) # 第四种衍生，使用zip函数把键列表和值列表打包成键值对一一对应的元组（即第四种方法）a = dict.fromkeys([key1, key2], value) # 第五种，这种情况适用于多个键对应相同值的情况a = {x: x**2 for x in [1, 2, 3]} # 第六种，字典推导表达式
1.2 字典的索引
dict1[key] #key是字典的键，返回的是对应的值valuedict1.get(key)#get方法获取键的值，若键不存在，则返回设定的默认值default（默认为None）--与`[key]`获取值的区别是，get方法遇到键不存在的时候会返回设定值，而直接索引遇到键不存在时会报错“missing-key”
1.3 字典的遍历
for i in dict1.keys(): print(i, dict1[keys]) # 遍历字典中所有的键，并输出键值对for i in dict1: # 该方法与上述方法等价 ...for keys, values in dict1.items(): # 遍历字典中所有的键值对 ...
1.4 字典的排序
对字典的排序有两种方法：
1.借助.keys()方法和list()函数将键提取成list，对list排序后输出
# ExampleD = {"a":1, "c":3, "b":2}D1 = list(D.keys())D1.sort()for i in D1: print(i, D[i])# 输出：# a 1# b 2# c 3
2.借助内置的sorted()函数可对任意对象类型排序，返回排序后的结果
tips:对于sorted（字典）来说，返回的是排序好的keys（以list的形式）
# ExampleD = {"a":1, "c":3, "b":2}for i in sorted(D): print(i, D[i])# 输出：# a 1# b 2# c 3
1.5 字典的常用操作
| 操作 | 解释 | | --------------------- | ------------------------------------------------------------ | | .keys() | （方法）获取所有键 | | .values() | （方法）获取所有值 | | .items() | （方法）获取所有“键+值”元组 | | len() | 获取键值对的数量 | | .get(key, default) | （方法）获取键的值，若键不存在，则返回设定的默认值default（默认为None）--与[key]获取值的区别是，get方法遇到键不存在的时候会返回设定值，而直接索引遇到键不存在时会报错“missing-key” | | dict1.update(dict2) | （方法）合并两个字典 |
三、元组（tuple）
元组类似于列表，是一个基于位置的有序对象集合，但是元组一旦创建之后就不能更改，因此列表中修改元素的操作对于元组都不适用。
为什么要使用元组？
元组和其他不可变量类似于其他语言中“常量”的声明，它的不可变性提供了某种一致性，这样可以确保元组在程序中不会被另一个引用修改。
Mark Lutz——《Learning Python》中文版
1.1 元组的创建
t = (1, 2, 3)t = tuple([1, 2])...
特别说明，当元组中仅有一个元素时，要以逗号结尾。这是因为小括号同样可以把表达式括起来，为了与此区分开来，因此在单一对象元组是要在括号内加一个,用以区分。
t = (1) # 表达式 t = (1,) # 元组
1.2 元组的方法
由于元组并不能够像列表一样修改，因此元组并没有特别多的方法
>>> t = (1, 2, 3, 1, 2)# index方法：根据元素找到其位置>>> t.index(1, 2) # 寻找第2个元素1的位置3# count方法：返回元素的个数>>> t.count(2)2
1.3 namedtuple -有名元组
python标准库的collections模块提供了namedtuple有名元组，实现了同时支持使用序号和属性名访问。有名元组的属性来自类，因此并不与字典的键完全一样，但他们方便记忆：
>>> from collections import namedtuple>>> A = namedtuple("tt", ["a","b","c"])>>> bon = A("d","e","f")>>> bontt(a="d", b="e", c="f")# namedtuple的访问：>>> A = namedtuple("tt", ["a","b","c"])>>> bon = A("d","e","f")>>> bontt(a="d", b="e", c="f")
四、集合（set）
Python中的集合类似于数学中的集合概念，它是一组无序、不可重复数据的组合。集合用{ ...}创建，某种程度上可以把集合看作是没有值的字典。
1.1 集合的创建
s = {"s", "e", "t"}s = set(["a, b, c, d, e"])#注意，python中{}为空字典类型，并非空集合。空集合需要用set()函数创建s = set() #创建一个空集合#集合也可以用表达式（推导）的方式创建{x * 2 for x in "abc"} #{"aa", "bb", "cc} {x **2 for x in range(1,5)} #{1, 4, 9, 16}
1.2 集合的常用操作
set1 `&` set2 #交运算set1 `|` set2 #并运算set1 `-` set2 #差运算，set1减去set1 `&` set2部分
1.3 集合的常用方法
set1.add("x") #添加元素。注意：集合中只能包含可哈希的对象，即list，dict都不能嵌入到集合中set1.union(...) #取并集，效果等同于 | ,但是括号里可以是list，tuple，其他dict甚至是dictset1.intersection(...) #取交集，同上set1.issubset(set2) #判断set1是否是set2的子集
1.4 集合的不可变性与frozenset
注意：集合只能包含不可变的（可哈希化的）对象类型。因此，列表和字典甚至另一个集合都不能作为集合的元素，但是元组可以（因为元组是不可变的）。
由于集合本身是可变的，因此，要想在一个集合中嵌入另一个集合，需要用frozenset创建一个不可变的集合。
a = frozenset([1, 2, 3])b = set([1, 2, a]) #b为{frozenset({1, 2, 3}), 1, 2}
1.5 为什么使用集合？
由于集合内元素是不重复的，因此可以将list或其他类型的数据转换成集合，从而过滤掉其中的重复元素
通过集合的交并补等操作，可以比较列表、字符串以及其他可迭代对象的差异。
