列表是Python中7个序列的内置类型（列表，元组，range，str，bytes，bytearray，memoryview）的一种
列表是最常用的Python数据类型，非常适合利用顺序和位置定位某一元素，而且其元素不需要类型相同。列表是可变的，可以直接对原始列表进行修改：添加、删除、覆盖元素。列表中具有相同值的元素允许出现多次。
只要把逗号分隔的不同的数据项使用方括号（）括起来即可。或者使用内置的函数。[]、list()
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。
list('abc')
# ['a','b','c']
a_tuple = ('a','b','c')
list(a_tuple)
# ['a','b','c']
索引切片
与字符串索引切片类似
列表嵌套列表可以包括各种类型的元素，包括列表：
lower_alphas = list('abcdefg')
upper_alphas = list('abcdefg'.upper())
alphas = [lower_alphas, upper_alphas]
alphas
# [['a', 'b', 'c', 'd', 'e', 'f', 'g'], ['A', 'B', 'C', 'D', 'E', 'F', 'G']]
添加元素
使用函数在列表末尾添加元素；append()
alist = [1, 2, 3] alist.append(4) alist #[1,2,3,4]
使用函数函数在指定的元素，第一个参数要指定要插入的位置（偏移量），第二个参数指定要插入的元素。如果指定偏移量超过了列表的尾部，则插入到列表最后。insert()
alist = [1, 2, 3] alist.insert(0, 0) alist.insert(10, 10) alist #[0, 1, 2, 3, 10]修改元素
通过索引（偏移量）访问某列元素，并可以通过赋值操作对其进行修改：
alist = [1, 2, 3] alist[0] = 'modified' alist[1:4] = 'a', 'b', 'c' alist # ['modified', 'a', 'b', 'c']删除元素：
使用删除指定位置的元素，当列表中的元素被删除后，位于其后面的元素自动迁移补填空位，且长度减去删除元素个数 del
删除指定值元素remove()
blist = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
blist.remove('b')
blist
#['a', 'c', 'd', 'e', 'f', 'g']
####获取并删除指定位置的元素
使用可以获取列表中指定位置的元素，并将此元素从列表中删除。如果未，则未指定参数，则默认返回列表末尾的元素，使用将返回列表头部的元素。当列表为空或索引超出范围时，将触发异常 pop()
清空列表元素使用函数清空列表中所以有元素：clear()
合并列表使用函数或操作并列表：extend()或 +=
clist = ['a', 'b', 'c'] dlist = ['d'] elist = ['e', 'f'] clist.extend(elist) #clist = clist + elist # 创建了一个新对象 #clist += elist # 修改原来的clist对象 clist # ['a', 'b', 'c', 'e', 'f']查询具有特定指的元素的位置
使用index()函数查询具有特定值的元素在列表中的位置（偏移量）：
成员关系判断使用in判断元素是否包含于某个列表
'e' in clist # True 'h' not in clist # True记录特定值出现的次数
使用count()记录特定值在列表中出现的次数
clist.count('a')
列表的元素排列
- 使用列表对象方法sort()队员列表进行排序，改变源列表进行排序，改变原列表内容
- 使用通用函数sorted()返回排好序的列表副本，原列表内容不变
如果列表当中的元素是数字，默认排序方式是从小到大的升序。如果元素都是字符串，则按照字母顺序排序。默认的排序都是升序的，通过添加参数reverse=True可以改为降序排列
numbers = [2, 1, 4.0, 3] numbers.sort(reverse=True) sorted_numbers = sorted(numbers) #通过复制的方式生成副本 print(numbers) print(sorted_numbers) #[4.0, 3, 2, 1] #[1, 2, 3, 4.0]复制列表
通过下面三种方法，将一个列表复制到另外一个新列表中：
- 列表copy()函数
- list()转换函数
- 列表切片[:]
a = [1,2,3]
b.copy(a)
c = list(a)
d = a[:]
print('a: ', a, 'nb: ', b, 'nc: ', c, 'nd: ', d)
# 列表复制 复制的是引用，对于不可变类型他复制的就是值，对于可变类型（列表的嵌套），他复制的就是引用
#a: [1, 2, 3]
#b: [1, 2, 3]
#c: [1, 2, 3]
#d: [1, 2, 3]
import copy a=[1,2,3,[4,5]] b = a.copy() c = list(a) d=a[:] e=copy.deepcopy(a) #a: [1, 2, 3, [4, 5]] #b: [1, 2, 3, [4, 5]] #c: [1, 2, 3, [4, 5]] #d: [1, 2, 3, [4, 5]] #d [1, 2, 3, [4, 5]]元组
元组与列表有很多地相似之处，但他是一种不可变容器。元组一旦被定义后，便不可更改。它能够用来做一些列表不能做地事，如用作一个字典地键。鉴于其他列表很大程度上是相似的，所以这里着重描述元组和列表地不同之处
1. 创建元素列表用[]或者list()、元组用（）或tuple()
创建一个或多个元素地元组时，每一个元素后面都需要跟着一个逗号，即使只包含一个元素也不能省略。如果创建元组所包含地元组所包含地元素数量超过1，最后一个元素后面地逗号可以省略
2. 元组解包将元组赋值给多个变量，这个过程就是元组解包
atuple = ('mon', 'tue', 'wed')
btuple = ('mon', 'tue', 'wed')
这里需要地变量地数量必须跟元组元素地数量是一样的，如果个数不匹配就会产生异常
实际上，这种解包赋值可以用在任何可迭代的对象上面，包括元组、列表、字符串、文本对象、迭代器和生成器
使用tuple()构造器可将其他可迭代类型对象转换成元组：
tuple() # 空元组
tuple(range(5)) # (0, 1, 2, 3, 4)
tuple('abcdefg') # ('a', 'b', 'c', 'd', 'e', 'f', 'g')
元组是不可以更新的但是如果元组的某个成员是列表，那么这个成员是可以更改的
字典字典是python中唯一的“映射”类型。一个函数f将键（key，定义域）映射到值（value，值域）。
1.创建和赋值使用{}创建字典。使用dict()构造器可从其他对象创建字典
empty_dict = {}
dict2 = {'name':'earth','port':80}
# {'name': 'earth', 'port': 80}
dict3 = dict((['x':1,['y':2]]))
# {'x': 1, 'y': 2}
dict4 = dict(['ab','cd','ef'])
# {'a': 'b', 'c': 'd', 'e': 'f'}
dict5 = dict(one=1,two=2)
#{'one': 1, 'two': 2}
dict6 = dict(zip(['one','two'],[1,2]))
# {'one': 1, 'two': 2}
dict7 = {}.fromkeys(('x','y'),-1)
# {'x': -1, 'y': -1}
dict8 = {}.fromkeys(('x','y'))
# {'x': None, 'y': None}
fromkeys()可以使用一个可迭代的序列作为键集合创建一个默认字典，第二个参数是默认值，如果忽略的话默认值为None
2.获取元素使用键来获取元素
dict1 = {'name': 'earth', 'port': 80}
dict1['name']
#'earth'
如果试图访问的键在字典中不存在，则会引发一个异常
3.修改元素dict1['name'] = 'moon'
dict1['port'] = 777
dict1['age'] = 20 # 添加新元素
dict2 = {'name': 'mars', 'port': 888}
dict1.update(dict2) # update a dict with another
dict1
# {'name': 'mars', 'port': 888, 'age': 20}
4.合并字典
-
最简单的原地更新，即使用update方法，用于把另外一个字典更新到子集上
profile = {'name':'xiaoming','age':27} ext_info = {'gender':'male'} profile.update(ext_info) print(profile) # {‘name’: ‘xiaoming’, ‘age’: 27, ‘gender’: ‘male’}
如果想用updata方法，但又不愿意改变原值，就可以生成一个新的对象，用来存储
-
先解包在合并字典，先使用**解包，解包完之后在使用dict或者{}合并
profile = {"name": "xiaoming", "age": 27} ext_info = {"gender": "male"} full_profile01 = {**profile, **ext_info} full_profile02 = dict(**profile, **ext_info) #{‘name’: ‘xiaoming’, ‘age’: 27, ‘gender’: ‘male’} -
借助itertools内置模块，可迭代对象。正好字典也是可迭代对象，自然就可以使用itertools.chain()函数先将多个字典（可迭代对象）串联起来，组成一个更大的可迭代对象，然后再使用dict转成字典
import itertools profile = {"name": "xiaoming", "age": 27} ext_info = {"gender": "male"} dict(itertools.chain(profile.items(), ext_info.items())) #{'name': 'xiaoming', 'age': 27, 'gender': 'male'} -
借助ChainMap()如果可以引入一个辅助包，那就可以达到与itertools一样的效果
from collections import ChainMap profile = {"name": "xiaoming", "age": 27} ext_info = {"gender": "male"} dict(ChainMap(profile, ext_info)) #{'name': 'xiaoming', 'age': 27, 'gender': 'male'}但是需要注意的是，当字典间有重复的键值时，ChainMap只会取第一个值，排在后面的键值并不会更新掉前面的（使用itertools就不会出现这个问题）
from collections import ChainMap profile = {"name": "xiaoming", "age": 27} ext_info={"age": 30} dict(ChainMap(profile, ext_info)) #{'name': 'xiaoming', 'age': 27} -
如果键已存在，则用新值更新键值，否则加入新键值对
del dict1['name'] # 删除“键”为“name”的条目
dict1.pop('age') # 删除并返回“键”为“name”的条目
dict1.clear() # 删除dict1中的所有条目
del dict1 # 删除dict1这个字典
dict1 # NameError: name 'dict1' is not defined
内建方法
- dict.clear()删除字典中的所有元素，并返回一个浅拷贝的副本
- dict.fromkeys(seq, val=None)以序列seq中的元素作为键，创建并返回一个新字典，val为键值对的默认value
- dict.item()返回一个字典中的键值对元组view object
- dict.get(key,default=None)对字典中的key，返回value，若key不存在，返回default
- dict.keys()返回字典中键的view object
- dict.pop(key,[default])和方法get相似，区别在于不仅返回，还要删除
字典中的值可以是任何Python对象，甚至是字典以及用户定义类型，但对于键却是有一些限制的
不允许一个键对对应多个值dict1 = {'name': 'green', 'age': 20, 'name': 'marry'}
dict1
#{'name': 'marry', 'age': 20}
键必须是可哈希的
可哈希的对象才可以作为键，列表、字典这样的可变类型是不可哈希的，所以不能作为键。所有不可变类型都是可哈希的，都可以作为字典的键。对于数字类型来说值相等的数字表示相同的键
对于可变对象，如果事先调用__hash__()方法并返回一个整型，那它的hash值也是不变的，因此这类对象可以作为键，这是一种特例。
元组中只包括数字、字符串这样的不可变类型，才可以作为字符串的有效键
集合可变集合（可以进行添加和删减元素，但不可哈希，不可以作为字典的值，可不能作为其他集合的元素）和不可变集合（可哈希）
创建集合使用大括号将一系列以逗号隔开的值包裹起来就创建了一个集合，另外可以使用内建的set()和frozenset()构造器创建集合
even_numbers = {0, 2, 4, 6, 8}
# 以下用三种方式创建了三个相同的可变集合
set1 = set('abcde')
set2 = set(('a', 'b', 'c', 'd', 'e'))
set3 = set(['a', 'b', 'c', 'd', 'e'])
# 以下用三种方式创建了三个相同的不可变集合
set4 = frozenset('abcde')
set5 = frozenset(('a', 'b', 'c', 'd', 'e'))
set6 = frozenset(['a', 'b', 'c', 'd', 'e'])
当字典作为参数传入set()构造器时，只有键会被时使用
set({'apple': 'red', 'orange': 'orange', 'cherry': 'red'})
#{'apple', 'cherry', 'orange'}
访问集合成员
myset = set(['apple', 'pear', 'grape', 'banana'])
print('apple' in myset)
print('orange' in myset)
for fruit in myset:
print(fruit)
# True
# False
# pear
# banana
# apple
# grape
更新集合
只有可变集合（set）支持更新
myset = set(['apple', 'pear', 'grape', 'banana'])
myset.add('orange') # 添加元素
myset
myset.remove('pear') # 删除元素
newfruit = set(('coco', 'watermelon'))
myset.update(newfruit) # 更新集合
myset
del newfruit # 删除集合
集合类型操作符和内建方法
标准类型操作符：
- 成员关系判断：in、not in
- 集合等价/不等价：==、!、=
- 子集/超级判定：<、<=、>、>=
集合类型操作符(用于可变集合和不可变集合)：
s = set('abcde')
t = set('defgh')
print(s | t) # 联合操作，或称OR操作，也就是算并集
print(s & t) # 求交集操作，或称AND操纵
print(s - t) # 求差集/相对补集
print(s ^ t) # 对称差分，类似C中异或操作XOR
集合操作符（用于可变集合）：
s = set((1, 3, 5, 7)) t = set((5, 7, 9, 0)) s |= t print(s) s &= t print(s) s -= t print(s) s ^= t print(s)集合类型的内建方法
# 用于所有集合的方法
s.issubset(t) # 如果s是t的子集，返回True
s.issuperset(t) # 如果s是t的超级，返回True
s.union(t) # 返回一个新集合（s和t的并集）
s.intersection(t) # 返回一个新集合（s和t的交集）
s.difference(t) # 返回一个新集合（s - t）
s.symmetric_difference(t)
# 返回一个新集合（s ^ t）
s.copy() # 返回一个新集合，它是s的浅复制
# 仅用于可变集合的方法
s.update(t) # 用t中的元素更新s
s.intersection_update(t) # s中现在是s和t的交集
s.difference_update(t) # s中现在是（s - t）
s.symmetric_difference_update(t)
# s中现在是s和t异或的结果
s.add(obj) # 在s中添加对象obj
s.remove(obj) # 从s中删除对象obj，如果不存在则引发KeyError异常
s.discard(obj) # 如果obj是s的元素，就从s中删除
s.pop() # 删除s中任意一个对象，并返回
s.clear() # 删除集合s中的所有元素
