1. 列表

1.1 简介

• 变量可以存储一个元素，而列表是一个“大容器”，可以存储N多个元素，程序可以方便地对这些数据进行整体操作
• Python中的列表相当于Java语言中的数组
• 与Java不同的是，它的列表更具”包容性“，Python中的列表中可以加入不同的数据类型

# 列表中可以加入不同的数据类型
list = [1, 3.14, 'hello', [1,2,3], None]
print(list)
print('id: ', id(list))
print('类型：', type(list))
1
2
3
4
5

列表特点

• 列表元素按顺序有序排序
• 索引映射唯一一个数据
• 列表可以存储重复数据（集合不可以）
• 任意数据类型混存，如 [1, 3.14, ‘hello’]
• 根据需要动态分配和回收内存，

1.2 列表创建方式

1. 使用 []
2. 使用内置函数list()

# 方式1，使用[]
list1 = [1, 3.14, 'hello']
# 方式2，使用内置函数list()
list2 = list(['hello', '13', 56])
1
2
3
4

1.3 操作列表

1.3.1 查询

1. 查询单个元素

list1 = [1, 3.14, 'hello', 6, 89]
# 获取索引值为1的元素
print(list1[1])
# 获取列表中最后一个元素
print(list1[-1])
# 获取列表中倒数第2个元素
print(list1[-2])
# 索引值超出列表长度，报IndexError
print(list1[5])
1
2
3
4
5
6
7
8
9

2. 查询多个元素

切片操作

• 语法格式：列表名[start:stop:step]
• 遵循左闭右开规则，[start, stop)，step默认为1
• 切片结果是原列表片段的拷贝，id值不同

lst = [0, 1, 2, 3, 4, 5, 6, 7, 8]
# start=1 stop=6 左闭右开， step=1
a = lst[1:6:1]
# 输出切片结果
print(a)
# id值不同
print(id(a) == id(lst))
# 默认步长为1
print('[1, 6)，默认步长为1：', lst[1:6])
print('[1, 6)，默认步长为1：', lst[1:6:])
# 步长为2
print('[1, 6)，step=2：', lst[1:6:2])
# start=0 stop=6 左闭右开， step=2
print('[0, 6)，step=2：', lst[:6:2])
# start=1 左闭右开， step=2
print('start=1 step=2：', lst[1::2])
print('\n')
# 逆序输出
print('逆序输出：', lst[::-1])
# 逆序输出，step=2
print('逆序输出，step=2：', lst[::-2])
# [7, 1)，步长为1，逆序
print('[7, 1)，步长为1，逆序：', lst[7:1:-1])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3. index()函数

• 根据元素查找并返回元素索引
• 索引值从0开始
• 若列表中没有该元素，则抛出ValueError
• 若列表中有多个相同元素，只返回第一个元素的索引值
• 可以在指定区间查找

list3 = [1, 3.14, 'hello', 6, 89]
print(list3.index(6))   # 返回3
print(list3.index(0))  # 报异常
1
2
3

list3 = [1, 3.14, 'hello', 6, 89]
# 在索引值1~3之间查找元素值为'value'的索引值，区间为[1, 3)
print(list3.index('hello', 1, 3))
1
2
3

4. 元素判断、列表遍历操作

# 元素判断
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8]
print(3 in lst)
print(9 in lst)
print(4 not in lst)
1
2
3
4
5

# 列表遍历
lst = [0, 1, 2, 3, 4, 5, 6, 7, 8]
for i in lst:
    print(i)
1
2
3
4

1.3.2 增、删、改操作

1. 添加操作

lst = [1,3,7]
print('添加元素前标识值：', id(lst))
print('列表值：', lst)
lst.append(10)
print('添加元素后标识值：', id(lst))
print('append 10 后列表值：', lst)
lst.extend(['hello', 'world'])
print('extend [\'hello\', \'world\'] 后列表值：', lst)
lst.insert(1, 'swy')
print('在索引值1处insert \'swy\' 后列表值：', lst)
1
2
3
4
5
6
7
8
9
10

切片操作：

# 切片
lst = [0, 1, 2, 3, 4, 5, 6]
lst2 = [11, 22, 33]
# 在索引值1处切片，后面添加lst2的元素
lst[1:] = lst2
print(lst)
1
2
3
4
5
6

2. 删除操作

print('-------remove-------')
lst = [0, 1, 2, 3, 4, 5, 6, 1]
# 删除值为1的元素
lst.remove(1)
print(lst)
1
2
3
4
5

print('\n-------pop-------')
lst = [0, 1, 2, 3, 4, 5, 6, 1]
# 删除索引为7的元素
lst.pop(7)
print(lst)
# 删除最后一个元素
lst.pop()
print(lst)
1
2
3
4
5
6
7
8

print('\n-------clear-------')
lst = [0, 1, 2, 3, 4, 5, 6, 1]
lst.clear()
print(lst)
1
2
3
4

print('\n-------del-------')
lst = [0, 1, 2, 3, 4, 5, 6, 1]
del(lst)
print(lst)
1
2
3
4

3. 修改操作

lst = [1, 2, 3, 4]
lst[0] = 111
print(lst)
# lst列表中[1, 3)区间的元素替换成后面的列表元素
lst[1:3] = [11, 22, 33]
print(lst)
1
2
3
4
5
6

1.3.3 排序

• sort() 在原列表上排序，不会生成新列表
• 内置函数sorted() 会生成新列表

print('---------sort---------')
# sort默认升序，在原列表上排序，没有生成新列表
lst = [45, 98, 1, 45, 31, 99, 12, 71, 79, 14]
lst.sort()
print(lst)

lst = [45, 98, 1, 45, 31, 99, 12, 71, 79, 14]
# 降序排序，在原列表上排序，没有生成新列表
lst.sort(reverse = True)
print(lst)
1
2
3
4
5
6
7
8
9
10

print('\n---------内置函数sorted---------')
# sorted默认升序，会生成新列表
lst = [45, 98, 1, 45, 31, 99, 12, 71, 79, 14]
new_lst = sorted(lst)
print(new_lst)

new_lst = sorted(lst, reverse = True)
print(new_lst)
1
2
3
4
5
6
7
8

2. 字典

2.1 概念

• 字典是Python内置的数据结构之一，与列表一样是一个可变序列
• 以键值对的方式存储数据，字典是一个无序的序列
• 使用 ‘{}’ 定义，类似于json
• 类似于Java中的map
• 键不允许重复，若重复会被后面覆盖
• 字典会浪费较大的内存，以空间换时间

字典格式如下：

d = {key1 : value1, key2 : value2 }

2.2 字典创建方式

• 使用花括号
• 使用内置函数dict()

print('---------使用{}创建---------')
s = {'id': 10, 'name': 'swy', 'age': 23}
print(s)
print(type(s))
1
2
3
4

print('---------使用dict()创建---------')
s1 = dict(name = 'jack', age = 20)
print(s1)
print(type(s1))
1
2
3
4

2.3 字典操作

2.3.1 元素获取

s1 = dict(name = 'jack', age = 20)
print('-----------使用get()方式-----------')
print(s1.get('name'))
# 使用默认值-1，当字典中没有'id'时，返回默认值，若不设默认值，则返回None
print(s1.get('id', -1))
1
2
3
4
5

print('-----------使用[]方式-----------')
print(s1['name'])
print(s1['id'])
1
2
3

2.3.2 字典元素增、删、改

s = {'id': 10, 'name': 'swy', 'age': 23}
print('------------key的判断------------')
# key的判断
print('name' in s)
1
2
3
4

s = {'id': 10, 'name': 'swy', 'age': 23}
print('------------删除key------------')
# 删除key
del s['id']
print(s)
1
2
3
4
5

s = {'name': 'swy', 'age': 23}
print('------------清空字典------------')
s.clear()
print(s)
1
2
3
4

print('------------新增元素------------')
s = {'id': 10, 'name': 'swy', 'age': 23}
s['sex'] = '男'
print(s)
1
2
3
4

{'id': 10, 'name': 'swy', 'age': 23, 'sex': '男'}
print('------------修改元素------------')
s['sex'] = '女'
print(s)
1
2
3
4

2.3.3 获取字典视图

s = {'id': 10, 'name': 'swy', 'age': 23}
print('------------获取所有键------------')
keys = s.keys()
print(keys)
print(type(keys))
# 视图转换成列表
print(list(keys))
1
2
3
4
5
6
7

s = {'id': 10, 'name': 'swy', 'age': 23}
print('\n------------获取所有值------------')
values = s.values()
print(values)
print(type(values))
# 视图转换成列表
print(list(values))
1
2
3
4
5
6
7

s = {'id': 10, 'name': 'swy', 'age': 23}
print('\n------------获取所有键值对------------')
items = s.items()
print(items)
print(type(items))
# 视图转换成包含元组的列表
print(list(items))
1
2
3
4
5
6
7

2.3.4 字典常用操作

遍历

s = {'id': 10, 'name': 'swy', 'age': 23}
for key in s:
    print(key, s.get(key))
1
2
3

2.4 字典生成式

内置函数zip()：将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，返回由这些元组组成的列表

items = ['name', 'id', 'age']
data = ['swy', '26', '23']

d = { item:data for item,data in zip(items, data)}
print(d)
1
2
3
4
5

3. 元组

3.1 概念

元组是Python的内置的数据结构之一，是一个不可变序列

t=( ‘java’, ‘C++’, ‘Python’ )

3.2 元组的创建方式

元组的创建方式

print('------------使用()------------')
t = ('C++', 'Python', 'Java')
print(t)
print(type(t))
1
2
3
4

print('\n------------使用tuple()------------')
t = tuple(('C++', 'Python', 'Java'))
print(t)
print(type(t))
1
2
3
4

print('\n------------只包含一个元素时，使用, 和 ()------------')
t = (1, )
print(t)
print(type(t))
1
2
3
4

print('\n------------空元组------------')
t = ()
t = tuple()
print(t)
1
2
3
4

3.3 元组的遍历

元组是可迭代对象，可以使用for…in进行遍历

t = tuple(('C++', 'Python', 'Java'))

for i in t:
    print(i)
1
2
3
4

4. 集合

4.1 概念

• Python的内置数据结构
• 属于可变类型的序列
• 集合是没有value的字典

4.2 集合的创建方式

• {}
• 内置函数set()

print('------------通过{}创建------------')
s = {2, 3, 4, 5, 6, 7}
print(s)

print('\n------------内置函数set()------------')
print(set([2, 3, 4, 5, 6, 7]))
print(set((1, 2, 3, 4, 5)))
print(set({2, 3, 4, 5}))
print(set(range(10)))
print(set())
1
2
3
4
5
6
7
8
9
10

4.3 集合操作

集合元素判断操作

添加操作

删除操作

print('------------判断是否存在集合中------------')
s = {2, 3, 4, 5, 6, 7}
print(10 in s)
print(2 in s)
1
2
3
4

print('\n------------集合中新增元素------------')
s = {1 ,2}
s.add(100)
print(s)
s.update({200, 300})
print(s)
s.update([11, 22, 33])
print(s)
1
2
3
4
5
6
7
8

print('\n------------集合中删除元素------------')
s = {2, 3, 4, 5, 6, 7}
s.remove(6)
print(s)
s.discard(3)
print(s)
s.pop()
print(s)
s.clear()
print(s)
1
2
3
4
5
6
7
8
9
10

4.4 集合间关系

s1 = {1, 2, 3, 4, 5, 6}
s2 = {2, 4, 6}
s3 = {1, 8, 9}
print('s2是s1的子集吗？', s2.issubset(s1))
print('s1是s2的超集吗？', s1.issuperset(s2))
print('s1与s2是否不相交？', s1.isdisjoint(s3))
1
2
3
4
5
6

集合间的数学关系如下：

具体用法如下表所示：

s1 = {1, 2, 3, 4, 5, 6}
s3 = {1, 8, 9}

print('交集：', s1.intersection(s3))
print('交集：', s1 & s3)
print('并集：', s1.union(s3))
print('并集：', s1 | s3)
print('差集：', s1.difference(s3))
print('差集：', s1 - s3)
print('对称差集：', s1.symmetric_difference(s3))
print('对称差集：', s1 ^ s3)
1
2
3
4
5
6
7
8
9
10
11

4.5 集合生成式

s = { i*i for i in range(10) }
print(s)
1
2

5. 总结