一、列表（list）

列表的所有元素放在一对[]内，相邻元素之间用逗号分隔
列表没有长度限制，元素类型可以不同，不需要预定义长度
列表内元素有顺序，可以使用索引
线性的数据结构
列表是可变的

a = [12,2,3,45,21]
b = ['python',2,"java"]
c = [{'C++':229,'C':129},[41,55,52,36]]
d = ["cake",{2},{5:6},(2,)]
print(a+b+c+d)[12, 2, 3, 45, 21, 'python', 2, 'java', {'C++': 229, 'C': 129}, [41, 55, 52, 36], 'cake', {2}, {5: 6}, (2,)]

1、列表的创建

a_list = [‘python’] 使用方括号创建列表
list() list()函数把可迭代对象转换为列表类型
列表不可以预定义大小

2、列表的访问

与字符串访问一致，[0,n-1],[-n,-1]

ls = ['book',23,[2010,'stud1'],20]
print(ls[2][1][-1])1

3、列表的操作方法

count(value) # 返回列表中value的个数
append(x) # 列表尾部追加元素，返回值为None，表示就地修改
insert(index,x) # 在指定的索引index处插入元素x
extend(iterable) # 将可迭代对象的元素添加进来，返回None
remove(value) # 从左到右查找第一个匹配的value值，移除该元素，返回None
pop(index) # 将列表下标为index的元素删除并返回
reverse() # 列表元素反转
clear() # 清除，列表所有元素，剩下一个空列表
sort(key = None,reverse = False) # 将列表元素反转，返回None，reverse = True，反转，降序
index(value[start,stop]) # 通过value值，从指定区间查找表内的元素是否匹配
copy() # 生成一个新的列表，复制s中的所有元素

# (1)append()、insert()、extend()
# 这3个方法均可用于向列表中添加元素，而且都属于原地操作，不影响列表对象在内存中的起始位置
x = [11,22,33]
print(id(x))
print(x.append(44))
print(id(x))
print(x.insert(2,55))
print(id(x))
print(x.extend([1,2,3]))
print(id(x))
print(x)1537460285632
None
1537460285632
None
1537460285632
None
1537460285632
[11, 22, 55, 33, 44, 1, 2, 3]

# (2)pop()、remove()、clear()
# 这3个方法均可用于删除列表中的元素，而且也都属于原地操作，不影响列表对象在内存的地址，另外del语句删除列表中的指定元素
x = [1,2,3,4,5,6,7]
x.pop()  # 删除并弹出尾部元素
print(x)
x.remove(3)  # 删除首个值为3的元素
print(x)
del(x[4])  # 删除指定位置的元素
print(x)
x.clear()  # 删除所有元素
print(x)[1, 2, 3, 4, 5, 6]
[1, 2, 4, 5, 6]
[1, 2, 4, 5]
[]

# (3)count()、index()
# count()用于返回列表中指定元素出现的次数，index()用于返回指定元素在列表中首次出现的位置，如果该元素不在列表中则抛出异常
x = [1,2,1,3,4,1,5,1,5,1,4,2,1,3]
print(x.count(1))  # 元素1出现的次数
print(x.index(3))  # 元素3在列表中首次出现的索引
print(x.index(6))  # 列表中不存在的元素，抛出异常6
3
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
D:\temp/ipykernel_6064/1335204714.py in <module>4 print(x.count(1))  # 元素1出现的次数5 print(x.index(3))  # 元素3在列表中首次出现的索引
----> 6 print(x.index(6))  # 列表中不存在的元素，抛出异常ValueError: 6 is not in list

# (4)sort()、reverse()
# sort()方法按照指定的规则对所有元素排序，默认升序;reverse()将所有列表元素逆序或反转
x = [5,4,21,6,5,1,3,11,2,1]
x.sort()
print(x)
x.sort(reverse = True)
print(x)
x.reverse()
print(x)
# sort()和reverse()方法分别对列表进行原地排序和逆序，没有返回值[1, 1, 2, 3, 4, 5, 5, 6, 11, 21]
[21, 11, 6, 5, 5, 4, 3, 2, 1, 1]
[1, 1, 2, 3, 4, 5, 5, 6, 11, 21]

# (4)列表支持的运算符
x = [1,2,3]
print(id(x))
x = x + [4]  # 增加元素，返回新列表
print(x)
print(id(x))
x += [5]  # 原地操作
print(x)
print(id(x))
x = [1,2]
print(id(x))
x = x * 2  # 列表重复，返回新列表
print(x)
print(id(x))
x *= 2  # 原地操作
print(x)
print(id(x))1537460286272
[1, 2, 3, 4]
1537460282752
[1, 2, 3, 4, 5]
1537460282752
1537460289472
[1, 2, 1, 2]
1537460286272
[1, 2, 1, 2, 1, 2, 1, 2]
1537460286272

S = 'Pame'
for i in range(len(S)):print(S[-i],end = '')Pema

s = [4,2,9,1]
s.insert(2,3)
print(s)[4, 2, 3, 9, 1]

a = [[1,2,3],[4,5,6],[7,8,9]]
s = 0
for c in a:for j in range(3):s += c[j]
print(s)45

二、元组（tuple）

所有元素放在圆括号()内
如果元组中只有一个元素，必须在最后增加一个逗号
使用tuple创建空元组
支持双向索引
元组是不可变的

x = (1,2,3)
print(x[-1])
x = (2,)
x = tuple()
print(type(x))3
<class 'tuple'>

列表和元组的相同点：
1）通过切片访问，del删除
2）有序序列，双向索引
列表：
1）可变序列
2）可修改
3）不可作为字典的建
元组：
1）不可变序列
2）不可修改
3）可作为字典的键

三、字典（dict）

dict()生成一个空字典
键和值通过冒号连接组成的集合
{<键1>:<值1>,<键2>:<值2>,…,<键n>:<值n>}
字典内的键值对没有顺序且不能重复
元素类型可以不同
用花括号{}表示
字典中是以键值对存储的，因此键就是值的索引
字典是可变的，可以存储任意类型

d = dict()
print(d)
d = {'name':'Jack','age':'18','sex':'man'}
print(d){}
{'name': 'Jack', 'age': '18', 'sex': 'man'}

2、字典元素的访问

字典中的每个元素表示一种映射或对应关系，根据提供的“键”作为下标可以访问对应的“值”，如果改“键”不存在，则抛出异常

d = {'name':'Jack','age':'18','sex':'man'}
print(d['name'])
print(d['tel'])
# 字符串、列表、元组等采用数字索引，字典采用字符索引Jack
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
D:\temp/ipykernel_6064/1479183229.py in <module>1 d = {'name':'Jack','age':'18','sex':'man'}2 print(d['name'])
----> 3 print(d['tel'])4 # 字符串、列表、元组等采用数字索引，字典采用字符索引KeyError: 'tel'

2、字典的操作方法

查询
d.keys():返回字典中所有的键信息
d.values():返回字典中所有的值信息
d.items():返回字典中所有的键值对,(键值对以元组类型表示)
d.get(key,default):键存在则返回相应值，不存在则返回默认值default查询
删除
clear():删除所有键值对，清空字典
popitem():随机从字典取出一个键值对，以元组形式返回，同时将该键值对从字典中删除
pop(key,default):键存在则返回相应值，同时删除键值对，否则返回默认值default

# (1)get(key,default)
# 返回指定“键”对应的“值”，并且允许该键不存在时返回特定的“值”。第二个元素可以省略，省略时则默认为空
d = {'name':'Jack','age':'18','sex':'man'}
print(d.get('name'))
print(d.get('tel','131157258451'))Jack
131157258451

# (2)d.items()
# 返回字典中所有键值对信息，返回结果是Python的一种内部数据类型dict_items。如果希望更好地使用返回结果，可以转换为列表类型，键值对以元组类型表示
d = {'name':'Jack','age':'18','sex':'man'}
print(d.items())
print(list(d.items()))dict_items([('name', 'Jack'), ('age', '18'), ('sex', 'man')])
[('name', 'Jack'), ('age', '18'), ('sex', 'man')]

# (3)d.value()
# 返回字典中所有值的信息，返回结果是Python的一种内部数据类型dict_values。如果希望更好地使用返回结果，可以转换为列表类型
d = {'name':'Jack','age':'18','sex':'man'}
print(d.values())
print(list(d.values()))dict_values(['Jack', '18', 'man'])
['Jack', '18', 'man']

# (4) d.clear()
# 删除字典中所有键值对，如果想要删除字典中的某一个元素，可以使用del命令
d = {'name':'Jack','age':'18','sex':'man'}
del d['sex']
print(d)
d.clear()
print(d){'name': 'Jack', 'age': '18'}
{}

四、集合（set）

集合中的元素不可重复；
元素类型只能是不可变类型；
集合元素没有顺序，不能比较，不能排序；
用花括号{}表示，没有索引和位置的概念；
可使用set()创建。

S = {101,'Python',23.2}
print(type(S))
S = set((1,2,3,4,5))
print(S)<class 'set'>
{1, 2, 3, 4, 5}

1、集合4个操作符

S - T 返回新的集合，元素包含在S但不在T中
S & T 返回新的集合，元素同时包含在S和T中
S ^ T 返回新的集合，包含S和T中的非共同元素
S | T 返回新的集合，包括S和T的所有元素

2、集合操作方法

add(x):若x不在集合中，则把x增加到该集合中；
remove(x):若x在，则从该集合移除，不在则产生KeyError异常；
clear():移除集合中所有元素；
update():合并集合中的元素；
pop():随机删除并返回集合中的一个元素；
x in s:x是集合的元素，返回True，不是返回False；
x not in s:x不是集合的元素，返回True,是，返回False；
discard():从集合中删除一个特定的元素。

# (1)update()、add()
# add()方法增加新元素，如果改元素已经存在则忽略改操作，不会抛出异常；update()方法合并另外一个集合中的元素到当前集合中，并自动去除重复元素
s = {1,2,3}
s.add(4)
print(s)
s.update({5,6})
print(s){1, 2, 3, 4}
{1, 2, 3, 4, 5, 6}

# (2)discard()、clear()、remove()、pop()
# discard()方法从集合中删除一个特定的元素，如果元素不在集合中则忽略该操作
# clear()方法清空集合
# remove()方法删除集合中的元素，指定元素不存在则抛出异常
# pop()方法随机删除集合中的元素
s = {1,2,3}
s.pop()
print(s)
s.discard(5)
s.remove(3)
s.clear()
print(s){2, 3}
set()

3、集合运算

Python集合还支持数学意义上的交集、并集、差集等运算

a_set = {1,2,3,4,5}
b_set = set([5,6,7,8,9])
print(a_set | b_set)  # 并集
print(a_set & b_set)  # 交集
print(a_set - b_set)  # 差集
print(a_set ^ b_set)  # 对称差集{1, 2, 3, 4, 5, 6, 7, 8, 9}
{5}
{1, 2, 3, 4}
{1, 2, 3, 4, 6, 7, 8, 9}