python_python 列表包含

组合数据类型

集合、列表、元组、字典和范围等均属于组合数据类型。组合数据类型的对象是一个数组容器，可以包含多个有序或无序的数据项。

 

 

一、集合

1.基本特点

元素具有唯一、无序和不可改变等特点

2.表达形式

（1）声明一个集合：常量{} 内置函数 set()
（2）向集合中添加值： 如果是单个值，通过常量完成，如果是多个值通过内置函数完成

3.集合运算

4.集合基本操作

集合对象元素的值不支持修改，但是可以复制集合、为集合添加或删除元素。

集合元素是不可改变的，因此不能将可变对象放入集合中；集合、列表和字典对象均不能加入集合；元组可以作为一个元素加入集合。

二、列表

1.基本特点

列表常量用方括号表示

，也可以使用list()函数来创建，列表的主要特点如下：

1. 列表可以包含任意类型的对象：数字、字符串、列表、元组或其他对象。
2. 列表是一个有序序列，与字符串类似，可通过位置偏移量执行索引和分片操作。
3. 列表是可变的。列表的长度可变，即可添加或删除列表成员。列表元素的值也可改变。
4. 每个列表元素存储的是对象的引用，而不是对象本身，类似于C/C++的指针数组。

列表基本操作包括：创建列表、求长度、合并、重复、迭代、关系判断、索引和分片等。

# 创建列表
list1 = [1,2,3,4,5]
print(list1)                               
# 求长度
print(len([1,2,3,4,5]) ) 
# 合并
print([1,2,3,4,5] + [20])
# 重复
print([1,2,3,4,5] * 5)
# 关系判断
print(2 in [1,2,3,4,5])
# 索引
list1 = [1, 2, 3, ['a', 'b', 'c']]
list1[2] = 100
print(list1[0], list1[2], list1[-1])
 
# 分片，与字符串类似，可通过分片来获取列表中的连续多个数据，也可以通过分片将连续多个数据替换成新的数据。
list1 = list(range(10))
print(list1[2:5])      # [2, 3, 4]
print(list1[2:])       # [2, 3, 4, 5, 6, 7, 8, 9]
print(list1[:5])       # [0, 1, 2, 3, 4]
print(list1[3:10:2])   # [3, 5, 7, 9]
print(list1[10:3:-2])  # [9, 7, 5]
list1[2:5] = 'abc'
print(list1)           # [0, 1, 'a', 'b', 'c', 5, 6, 7, 8, 9]
list1[2:5] = [10, 20]

# 声明一个列表
list1 = []
# 追加元素
list1.append(12)
list1.append(3)
list1.append(1)
# 修改指定索引的元素值
list1[0] = 100
# 移除元素
list1.remove(100)
# 反转
list1.reverse()
# 排序，默认升序
list1.sort()
list1.sort(reverse=True)
 
print(len(list1) , list1)

2.常用的列表方法

三.元组

1.基本特点与操作

元组可以看作是不可变的列表，它的使用与字符串类似。元组常量用圆括号表示，例如：(1,2)、('a','b','c')，也可以使用tuple()方法来创建元组对象。元组的主要特点如下：

• 元组可包含任意类型的对象。
• 元组是有序的，元组中的对象可通过位置进行索引和分片。
• 元组的大小不能改变，即不能为元组添加对象，也不能删除元组中的对象。
• 元组中存储的是对象的引用，而不是对象本身。

元组的基本操作包括：创建元组、求长度、合并、重复、迭代、关系判断、索引和分片等。

# 创建元组
声明方式：t1 = (1,) 如果只有一个值，则需要加上一个逗号，否则就是int类型
             t1 = tuple(序列)
print((2,))  # 包含一个对象的元组，不能缺少逗号  (2,)
print(tuple('abcde'))  # 参数为可迭代对象  ('a', 'b', 'c', 'd', 'e')
print(tuple(item * 2 for item in range(5)))  # 使用解析结构创建元组  (0, 2, 4, 6, 8)
 
# 求长度
print(len((1, 2, 3, 4, 5)))  # 5
 
# 合并
t1 = (1, 2) + ('ab', 'cd') + (2.45,)  # (1, 2, 'ab', 'cd', 2.45)
print(t1)
 
# 重复
print((1, 2) * 3)  # (1, 2, 1, 2, 1, 2)
 
# 关系判断
print(2 in t1)  # True
 
# 索引和分片
t2 = tuple(range(10))  # (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
print(t2[1])           # 1
print(t2[-1])          # 9
print(t2[2:5])         # (2, 3, 4)
print(t2[2:])          # (2, 3, 4, 5, 6, 7, 8, 9)
print(t2[:5])          # (0, 1, 2, 3, 4)
print(t2[1:7:2])       # (1, 3, 5)
print(t2[7:1:-2])      # (7, 5, 3)
 
# 统计指定值出现的次数，如果不包含指定值时，返回0
t3 = (1, 2) * 4
print(t3.count(1))  # 4
 
# 查找指定范围内元素所在的索引
print(t3.index(2))  # 1
print(t3.index(2, ))  # 1
print(t3.index(2, 2, 7))  # 3

2.函数

四.字典

1.基本特点与操作

字典是一种无序的映射集合，包含一系列的键:值对。字典常量用大括号表示，例如，{'name':'John','age':25,'sex':'male'}，也可以使用dict()函数来创建。其中，字符串name、age和sex为键，字符串John和sex以及数字25为值。字典的主要特点如下：

• 字典的键名称通常采用字符串，也可以用数字、元组等不可变的类型。

• 字典的值可以是任意类型。
• 字典也可称为关联数组或散列表，它通过键映射到值。字典是无序的，它通过键来访问映射的值，而不是通过位置来索引。
• 字典属于可变映射，可修改键映射的值。
• 字典长度可变，可为字典添加或删除键:值对。
• 字典可以任意嵌套，即键映射的值可以是一个字典。
• 字典存储的是对象的引用，而不是对象本身。

字典的基本操作包括创建字典、求长度、关系判断和索引等。

# 创建字典
声明方式： d1 = {key:val,key:val,...}
            d2 = dict(name='马化腾',age=64)
            d3 = dict([('name','Tom'),('age',22)])
 
# 求长度
print(len({'name': 'John', 'age': 25, 'sex': 'male'}))  # 返回字典长度，即“键:值”对的个数
 
# 关系判断 - 判断字典是否包含某个键
print('name' in {'name': 'John', 'age': 25, 'sex': 'male'},  # True
      'date' in {'name': 'John', 'age': 25, 'sex': 'male'})  # False
 
# 索引
dict13 = {'book': {'Python编程': 100, 'C++入门': 99}, 'publish': '人民邮电出版社'}
print(dict13['book'])  # {'Python编程': 100, 'C++入门': 99}
print(dict13['book']['Python编程'])  # 100
dict13['publish'] = '清华大学出版社'  # 通过索引修改映射值
dict13['phone'] = 12345678900  # 为不存在的键赋值，为字典添加“键:值”对
del dict13['book']['C++入门']  # 删除“键:值”对

2.常用方法

x = dict(name='Tom', age=25)
y = x
# 复制字典对象
yc = x.copy()
print(y is x, yc is x)  # 判断是否引用相同对象 True False
 
 
# 获取或添加
print(x.setdefault('name'))  # 返回指定键的映射值  Tom
print(x.setdefault('sex'))  # 键不存在，为字典添加“键:值”对，映射值默认为None  None
print(x.setdefault('addr', 'CQ'))  # 添加“键:值”对  CQ
print(x)  # {'name': 'Tom', 'age': 25, 'sex': None, 'addr': 'CQ'}
 
# 添加或修改
x.update({'age': 30, 'sex': '女'})  # 添加“键:值”对，并覆盖同名键的映射值
print(x)  # {'name': 'Tom', 'age': 30, 'sex': '女', 'addr': 'CQ'}
x.update(name='Mike')  # 修改映射值
x.update(code=110, tel='123456')  # 添加“键:值”对
print(x)  # {'name': 'Mike', 'age': 30, 'sex': '女', 'addr': 'CQ', 'code': 110, 'tel': '123456'}
 
# 删除指定key的键值对象
print(x.pop('name'))  # 删除键并返回映射值  Mike
print(x.pop('id', 'xxx'))  # 删除不存在的键，返回default参数值  xxx
# print(x.pop('other'))  # 删除不存在的键，未指定default参数，出错 KeyError: 'other'
 
# 删除字典元素，并以元组的形式返回删除的元素，如果字典为空，则报错 KeyError: 'popitem(): dictionary is empty'
print(x.popitem())  # ('tel', '123456')
 

总结