下面全部都比较简洁，作为自己复习$python$的时候看一下。

通用序列操作

Python中有六种内置序列，其中有三种基本序列比较常见：列表、元组和字符串。

Python中的大部分序列都可以进行通用操作，包括索引、切片、相同类型序列相加、乘法、成员资格、长度、最大值和最小值。

下面以列表为例来做一些操作的说明。

索引

列表可以根据索引下标来获取元素的值，例如：

a=[1,2,3,4]
print(a[0])
结果为1
print(a[1])
结果为2

由上面代码可知，序列中的元素是从“0”开始从左往右编号的，元素通过编号进行访问。索引使用的语法就是：变量后面加中括号，在括号中输入所需元素的编号。

在Python中，索引不仅可以从左往右编号，还可以从右往左编号，也就是负数代表从右往左编号。需要注意的是，从右往左编号是从-1开始的。例如：

a[1,2,3,4]
print(a[-1])
#4
print(a[-2])
#3

切片

切片是为了获取序列中的一段元素。例如：

a=[1,2,3,4]
print(a[0:3])
#[1,2,3]

从执行结果中我们可以看到，我们需要用一段元素两头的两个元素作为边界，并且用“ : ”隔开。这样看上去貌似是截取从下标为0的元素到下标为3的元素，但执行结果并不是这样。左边的元素包含在切片内，右边的元素不包含在元素内，就相当于是数学中的$[a,b)$（左闭右开）。

同样地，切片也支持负数，也就是按从右往左的顺序的索引获取切片，例如：

a=[1,2,3,4]
print(a[-3:3])
#[2,3]

从右往左数，-3的位置就是2，从左往右数，3的位置就是4，于是得到$[2,4)$，也就是$[2,3]$了。

同时，序列的下边可以超过真实的索引长度，例如：

a=[1,2,3,4]
print(a[3:10])
#4

所有序列的切片都有个默认的边界值，例如：

a=[1,2,3,4]
print(a[:2]
#[1,2]
print(a[2:]
#[3,4]
print(a[:]
#[1,2,3,4]

由此可知，省略左边边界元素，则默认为下标0；省略右边边界元素，则默认为到序列的最后（包括最后一个元素）。

在上面的例子中，我们通过切片都是获得连续的序列，也就是1,2,3这样连续的数字，那么我们如何获得非连续的序序列呢？对于这种情况，Python的切片提供了第三个参数：步长。默认情况下步长为1。例如：

a=[1,2,3,4,5,6,7]
print(a[0:4])
#[1,2,3,4]
print(a[0:4:1])
#[1,2,3,4]
print(a[0:4:2])
#[1,3]
print(a[0:4:3])
#[1,4]

当步长为负数时（步长不能为0），Python会从序列的尾部开始向左获取元素，直到第一个元素为止。整数的步长则是从序列的头部开始从左往右获取元素。

序列相加

用“+”进行连接。例如

a=[1,2,3,4]
print(a)
#[1,2,3,4]
a=[1,2,3,4]+[5,6,7]
print(a)
#[1,2,3,4,5,6,7]
print(a+[7,8,9])
#[1,2,3,4,5,6,7,8,9]

序列和序列相加后的结果还是相同类型的序列。注意：不同类型的序列是不能相加的。

序列重复

用“*”做乘法。例如：

a=[1,2]
print(a)
#[1,2]
a=[1,2]*2
print(a)
#[1,2,1,2]
print(a*2)
#[1,2,1,2,1,2,1,2]

成员资格

成员资格指判断一个元素是否包含在序列中，python中使用运算符“in”来判断。“in”运算符会判读左边的元素是否包含在右边的序列中，如果包含就返回$True$（真），如果不包含就返回$False$（假）。例如：

print(3 in [1,2,3,4])
#True
print(5 in [1,2,3,4])
#False

注意：只有当序列中元素的类型和值都完全一致，才算是包含在序列中，比如数字“5”和字符串“ " 5 " ”就是两种不同的元素。

长度、最小值、最大值、求和

直接看下面代码：

a=[1,2,3,4]
print(len(a))
#4
print(min(a))
#1
print(max(a))
#4
print(sum(a))
#10

从执行结果可以看出，$len$函数可以获取序列的长度，$min$函数可以获取序列的最小值，$max$函数可以获取序列的最大值。需要注意的是，$sum$函数求和的要求是序列的元素必须是$int$，比如$sum$函数无法对字符串序列求和。

列表

列表更新

列表可以通过索引获取其中的单个元素，也可以通过索引更新其中的元素，使用方法就和变量赋值一样。例如：

a=[1,2,3,4]
print(a[2])
#3
a[2]="hello"
print(a)
#[1,2,'hello',4]

由执行结果可以看出，一个列表可以存储不同类型的数据，并且修改的新元素也不需要和原来的元素类型一致。需要注意的是：更新列表的索引必须是已存在的索引，不能对超出列表长度的索引更新元素。·

增加元素

$append$
列表不能通过索引来添加元素，索引只能修改更新现有的元素。如果要想添加新元素，可以用$append$方法在列表的最后追加新元素。

a=[1,2,3,4]
a.append(5)
print(a)
#[1,2,3,4,5]
a.append([6])
print(a)
#[1,2,3,4,5,[6]]
a.append([7,8])
print(a)
#[1,2,3,4,5,[6],[7,8]]

$extend$
$append$只能增加一个元素，如果要想追加多个元素，则用$extend$，例如：

a=[1,2,3,4]
a.extend([5,6])
print(a)
#[1,2,3,4,5,6]
a.extend([7])
print(a)
#[1,2,3,4,5,6,7]
a,extend(8)
print(a)
#报错

$insert$
在列表中间插入用$insert$，它需要传递两个参数，第一个参数为插入的位置，第二个参数表示插入的元素，它只能插入一个元素。例如：

a=[1,2,3,4]
a.insert(2,'a')
print(a)
#[1,2,'a',3,4]
a.insert(5,5)
print(a)
#[1,2,'a',3,4,5]
a.insert(6,[6])
print(a)
#[1,2,'a',3,4,5,[6]]
a.insert(7,[7,8])
print(a)
#[1,2,'a',3,4,5,[6],[7,8]]

删除元素

$pop$
用于移除列表中指定的一个元素，默认是最后一个元素（默认是不带参数的意思），它的参数是元素的下标，并可以返回该元素的值。例如：

a=[1,2,3,4]
a.pop()
print(a)
#[1,2,3]
a.pop(1)
print(a)
#[1,3]
b=a.pop(0)	#用b接收返回值
print(a)
#[3]
print(b)
#1

$remove$
根据元素内容来对元素进行删除，如果有多个相同的元素，只会删除查找到的第一个元素，并且没有返回值。

a=[1,2,3,4,3]
a.remove(1)
print(a)
#[2,3,4,3]
a.remove(3)
print(a)
#[2,4,3]

$del$
用于删除指定的元素。

a=['A','B','C','D']
del a[1]
print(a)
#['A','C','D']

查找元素

$index$
它有返回值，返回的是元素的下标。如果元素不在列表中（有返回值的可以直接打印，也可以用一个变量来接收），会报错。例如

a=['A','B','C','D']
print(a.index('C'))
#2
b=a.index('D')
print(b)
#3
print(a.index('E'))
#ValueError: 'E' is not in list

其它操作

$reverse$
反转列表，和“$[::-1]$”相似，但是$reverse$修改的是原来的列表，没有返回值。例如：

a=['A','B','C','D']
a.reverse()
print(a)
#['D','C','B','A']

$count$
用于统计某个元素在列表中出现的次数。例如：

a=[1,2,3,4,1,2,3,2]
print(a.count(1))
#2
print(a.count(2))
#3
print(a.count(3))
#2

$sort$
用于对列表进行排序，没有返回值。

a=[1,3,2,5,4]
a.sort()
print(a)
#[1,2,3,4,5]
print(a.sort())
#None

元组

元组和列表十分相似，但列表可以修改、删除，元组创建之后就不能修改，不能删除单个元素，但是可以删除整个元组。

定义：元组只是边界变成了“ ( ”、“ ) ”。例如：

a=(1,2,3,4)
print(a)
#(1,2,3,4)

删除元组

$del$
用这个删除整个元组，例如：

a=(1,2,3,4)
del a
print(a)
#NameError: name 'a' is not defined

其它操作

$count$
跟列表一样
$index$
跟列表一样

字典

字典的元素由键值对组成，键和值中间有冒号。整个字典用花括号“ { } ”括起来，空字典可以直接用“ { } ”表示。字典的键必须唯一，不能重复。例如：

a={
    'A':1,
    'B':2,
    'C':3,
    'D':4
}
print(a)
#{'A':1,'B':2,'C':3,'D':4}
b={}
print(b)
#{}

使用字典

查找
用键去查找值。

a={
    'A':1,
    'B':2,
    'C':3,
    'D':4,
}
print(a['A'])
#1

注意：查找的时候用的是“ [ ] ”。
若变量名后面接了函数等，都不能用“ [ ] ”，若只是变量名才可以用“ [ ] ”。

修改 值

a = {
    'A':1,
    'B':2,
    'C':3,
    'D':4,
}
a['B'] = 5
print(a)
#{'A':1,'B':5,'C':3,'D':4}
a['E'] = 6
print(a)
#{'A':1,'B':5,'C':3,'D':4,'E',6}

删除 值

a = {
    'A': 1,
    'B': 2,
    'C': 3,
    'D': 4,
}
del a['A']
print(a)
#{'B':2,'C':3,'D':4}

$clear$
清空字典的所有元素，使其变成空字典。

a = {
    'A': 1,
    'B': 2,
    'C': 3,
    'D': 4,
    }
a.clear()
print(a)
#{}

$copy$
返回一个具有相同键值对的新字典

a = {
    'A': 1,
    'B': 2,
    'C': 3,
    'D': 4,
    }
b = a.copy()
print(b)
#{'A': 1, 'B': 2, 'C': 3, 'D': 4}
del b['A']
print(b)
#{'B': 2, 'C': 3, 'D': 4}
print(a)
#{'A': 1, 'B': 2, 'C': 3, 'D': 4}

对从$copy$得到的字典做修改，不会影响到原字典。

$fromkeys$
用于创建一个新字典，用序列中的元素作为字典的键，第一个参数为该序列名，第二个参数为字典所有参数对应的初始值，例如：

a = ['A','B','C']
b = dict.fromkeys(a)
print(b)
#{'A': None, 'B': None, 'C': None}
c = dict.fromkeys(a,1)
print(c)
#{'A': 1, 'B': 1, 'C': 1}

$get$
用于返回键对应的值

a = {
    'A' : 1,
    'B' : 2,
    'C' : 3,
    'D' : 4,
}
print(a.get('A'))
#1

$keys、values$
前者返回包含全部键的一个列表，后者返回包含全部值的列表

a = {
    'A' : 1,
    'B' : 2,
    'C' : 3,
    'D' : 4,
}
print(a.keys())
#dict_keys(['A', 'B', 'C', 'D'])
print(a.values())
#dict_values([1, 2, 3, 4])

$items$
用于返回一个包含所有键值对的类似于$list$的一个结构。

a = {
    'A' : 1,
    'B' : 2,
    'C' : 3,
    'D' : 4,
}
print(a.items())
#dict_items([('A', 1), ('B', 2), ('C', 3), ('D', 4)])

集合

它与列表类似，唯一的区别就是它不含重复值，且用花括号“ { } ”括起来。
可用$set()$函数来定义集合。

a = set((1,2,3))
print(a)
#{1,2,3}
b = set([1,2,3])
print(b)
#{1,2,3}
c = set()
print(c)
#set()
d = {1,2,3}
print(d)
#{1,2,3}

$set()$的括号里可以是其它的数据结构，但输出出来的都是花括号，也可以直接用括号定义。但空集合必须要用$set()$。