1.列表list()
空列表[ ]
创建只有一个元素的列表
[1,]
创建含有不同数据类型的列表
['a',1,3.14,[1,2,3,4]]
列表基本操作-列表相加相乘操作
[1,2] + [3.4]
[1, 2, 3.4]
# 不支持列表之间的相减操作
[1,2] * 5
[1, 2, 1, 2, 1, 2, 1, 2, 1, 2]
[1,2] / [3,4] # 不支持列表之间的相除操作
# list.count (x) # 统计列表中x出现的次数，若不存在则返回0
x = [1,2,3,4,2]
x.count(5)
0
# list.append(x) # 向列表尾部追加成员x
a = [1,2,3]
a.append(4)
print(a)
[1, 2, 3, 4]
# list.extend(l) # 向列表尾部追加另外一个列表
b = [4,5,6]
b.extend([7,8,9])
print([4, 5, 6, 7, 8, 9])
# list.index(x) # 返回参数x在列表中的序号，若不存在则报错
c = [7,8,9]
print(c.index(8))
运行结果：1
# list.insert(index,object) # 向列表指定位置插入数据x
d = ['a','b','c']
d.insert(2,'d')
d
['a', 'b', 'd', 'c']
# list.pop() # 默认删除列表尾部成员，并返回删除的成员x
e = [10,11,12,13]
e.pop()
13
[10, 11, 12]
# list.remove(x) # 删除列表中指定成员（有多个则只删除第一个），若指定成员不存在则报错
f = [14,15,16,14,15]
f.remove(14)
print(f)
运行结果：[15, 16, 14, 15]
# list.reverse() # 将列表中的成员顺序颠倒
g = [17,10,20]
g.reverse()
print(g)
[20, 10, 17]
# list.sort() # 将列表中的成员排序（要求成员间可排序，否则报错）
h = [21,30,23]
h.sort()
h
[21, 23, 30]
元组
tuple()
# 元组的元素一旦创建，是不可变的。 # 元组的元素不可变，但当元组元素为列表或字典数据类型时，列表或字典内的内容是可以变的。
创建只有一个元素的元组
(1,)
访问元组元素
a = (1,2,3)
a[0]
1
元组元素为列表或字典数据类型时，列表或字典内的内容是可以变的。
b = (1,2,3,[4,5,6])
b[3][0] = 10
b
(1, 2, 3, [10, 5, 6])
元组常见函数
c = (1,2,5,8,9)
len(c)
5
max(c)
9
min(c)
1
字典Dict
大括号{}
# 基本格式：大括号 { } 包围的数据集合，通过键访问成员，而不能通过序号位置。 # 字典，是Python中比较常用的数据类型，每个成员以键值对的形式存在。
创建一个简单字典
fruits = {"lemon":5,"apple":10}
fruits['lemon']
5
更新字典成员
fruits = {"lemon":5,"apple":10}
fruits['lemon'] = 20
fruits
{'lemon': 20, 'apple': 10}
fruits['pear'] = 15
fruits
{'lemon': 20, 'apple': 10, 'pear': 15}
字典删除操作
del fruits['pear']
fruits
{'lemon': 20, 'apple': 10}
fruits.clear()
fruits
{}
（一）字典的键是不可变的，值可以为任何数据类型。
键的数据类型，可以为字符串、数字和元组不可变数据类型，不能为列表类型
（二）字典的键最好唯一。
创建时如果同一个键被赋值多次，最后一个值会被记住。
fruits = {'lemon':1,'lemon':10,'lemon':20,'apple':10,'apple':5,'pear':6}
fruits
{'lemon': 20, 'apple': 5, 'pear': 6}
复制字典
# dict.copy()
fruit1 = {'lemon':5,'apple':10}
fruit2 = fruit1.copy()
print(fruit2)
{'lemon': 5, 'apple': 10}
获取字典的健
# dict.get(key,default=None) # 获取key对应的值，若key不存在则返回default
fruit1 = {'lemon':5,'apple':10}
fruit1.get('pear','该键不存在')
'该键不存在'
字典的迭代
# dict.items() 获取由键和值组成的迭代器 # dict.keys() 获取键的迭代器 # dict.values() 获取值的迭代器
fruit1 = {'lemon':5,'apple':10}
fruit1.items()
fruit1.keys()
dict_keys(['lemon', 'apple'])
fruit1.values()
dict_values([5, 10])
删除字典成员
# dict.pop(key,[default]) # 删除key:value的指定成员对。若key不存在，则返回default
fruit1 = {'lemon':5,'apple':10,'pear':20}
fruit1.pop('lemon')
5
# dict.popitem() # 从字典末尾删除key:value，并返回key:value
fruit1 = {'lemon':5,'apple':10,'pear':20}
fruit1.popitem()
('pear', 20)
更新字典成员
# dict.update({key:value}) 从另外一个字典更新成员（若不存在就创建，存在则覆盖）
fruit1 = {'lemon':5,'apple':10,'pear':20}
fruit1.update({'lemon':10})
fruit1
{'lemon': 10, 'apple': 10, 'pear': 20}
设置字典默认值
# dict.setdefault(key,default=None) # 若字典存在key，则返回对应的值（不会覆盖原值）。若不存在，则建立一个key:default的字典成员
集合set
集合（set）是一个无序的，不重复的数据集合
set()
# 注意：创建一个空集合必须用 set() 而不是 {}，因为 {} 是用来创建一个空字典。
集合特点--无序的
无法通过序号访问
集合特点--唯一性
b = {1,1,3,3,2,2,4,4}
b
{1, 2, 3, 4}
集合常见操作
1.len() 求出集合长度
a = {1,2,3,4,5,6}
b = {3,4}
len(a)
6
2.判断元素是否在集合中
7 in a
False
3.求出集合间的差集
a - b
{1, 2, 5, 6}
4.求出集合间的交集
a & b
{3, 4}
5.求出集合间的并集
a | b
{1, 2, 3, 4, 5, 6}