【一】元祖类型(tuple)
【1】定义
- 元祖类型是有序且不可变的数据类型，通常使用小括号定义（也可以使用逗号）
#用逗号定义
num_tuple = 1, 2, 3, 4, 5
#用小括号定义
num_tuple = (1, 2, 3, 4, 5)
【2】内置方法
（1）类型强转
#使用tuple()函数将其他数据类型转换为元组类型
num_list = [1, 2, 3, 4, 5]
print(tuple(num_list))
#输出 (1, 2, 3, 4, 5)
（2）索引取值
[1]正索引取值
num_tuple = (1, 2, 3, 4, 5)
print(num_tuple[1])
#输出 2
[2]负索引取值
num_tuple = (1, 2, 3, 4, 5)
print(num_tuple[-1])
#输出 5
[3]只能取不能改
#与列表相同，如果索引不存在，会抛出IndexError
num_tuple = (1, 2, 3, 4, 5)
print(num_tuple[6])
'''
Traceback (most recent call last):
File "D:\Python\pythonProject\pythonProject1\dmeo2.py", line 328, in <module>
print(num_tuple[6])
IndexError: tuple index out of range
'''
（3）切片
#顾头不顾尾
num_tuple = (1, 2, 3, 4, 5)
print(num_tuple[0:3])
#输出 (1, 2, 3)
#步长
num_tuple = (1, 2, 3, 4, 5)
print(num_tuple[0:5:2])
#输出 (1, 3, 5)
（4）计算长度
#使用len()函数可以获取元组的长度
num_tuple = (1, 2, 3, 4, 5)
print(len(num_tuple))
#输出 5
（5）成员运算
#与列表相同，元组也支持in和not in运算符
num_tuple = (1, 2, 3, 4, 5)
print('2' in num_tuple) #输出 False
print('8' not in num_tuple) #输出 True
（6）遍历循环
#使用for循环可以遍历元组中的每个元素
num_tuple = (1, 2, 3, 4, 5)
for num in num_tuple:
print(num)
#输出 1 2 3 4 5
（7）元祖拼接
#使用+运算符可以将两个元组拼接成一个新的元组
num_tuple = (1, 2, 3, 4, 5)
num_tuple_add = (6, 7, 8)
print(num_tuple + num_tuple_add)
#输出 (1, 2, 3, 4, 5, 6, 7, 8)
（8）元祖重复
#使用*运算符可以将元组重复指定次数
num_tuple = (1, 2, 3, 4, 5)
repeated_tuple = num_tuple * 2
print(repeated_tuple)
#输出 (1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
【二】布尔类型(bool)
【1】强制类型转换
#布尔值为True为真
#非零数字（整数或浮点数）都为真
num1 = 1
num2 = 1.5
print(bool(num1), type(bool(num1))) # True <class 'bool'>
print(bool(num2), type(bool(num2))) # True <class 'bool'>
#非空字符串为真
name = 'ligo'
print(bool(name), type(bool(name))) # True <class 'bool'>
#非空列表、非空字典、非空集合都为真
num_list = [1, 2, 3, 4, 5]
print(bool(num_list),type(num_list)) # True <class 'list'>
#布尔值为False为假
#0为假
num_one = 0
print(bool(num_one), type(bool(num_one))) # False <class 'bool'>
#空字符串为假
name = ''
print(bool(name), type(bool(name))) # False <class 'bool'>
#空列表、空字典、空集合都为假
num_list = []
print(bool(num_list),type(num_list)) # False <class 'list'>
【三】集合类型(set)
【1】定义
- 集合是无序且不重复的数据类型，通常用大括号{}来定义，元素之间用逗号分隔
#定义
num_set = {1, 2, 3, 4, 5}
print(num_set) #输出 {1, 2, 3, 4, 5}
#无序性
num_set = {'c', 'a', 'b'}
print(set(num_set))
#输出两次
# {'b', 'c', 'a'}
# {'a', 'c', 'b'}
#去重性
num_set = {1, 2, 3, 4, 5, 3, 3, 3, 5}
print(num_set) #输出 {1, 2, 3, 4, 5}
【2】内置方法
（1）类型强转
- 能被for循环的遍历的数据类型都能转换成集合类型（遍历出的每一个值都必须为不可变类型）
# 【1】字符串类型转换成集合类型
name = 'ligo'
name_set = set(name)
print(name_set, type(name_set))
# 输出{'g', 'l', 'i', 'o'} <class 'set'>
# 【2】字典一般只对字典的值去重，因为字典的键一般情况下都是唯一的，不需要更改
# (1)默认将字典的键转换为集合
dict = {'username': 'ligo', 'password': '123'}
dict_set = set(dict)
print(dict_set, type(dict_set))
# 输出 {'username', 'password'} <class 'set'>
# (2)将字典的值转换为集合并去重
dict_values = dict.values()
dict_values_set = set(dict_values)
print(dict_values_set, type(dict_values_set))
# {'123', 'ligo'} <class 'set'>
# 【3】列表类型转换成集合类型
num_list = [1, 2, 3, 4, 5]
num_list_set = set(num_list)
print(num_list_set, type(num_list_set))
# {1, 2, 3, 4, 5} <class 'set'>
# 【4】元组类型转换为集合类型
num_tuple = (1, 2, 3, 4, 5)
num_tuple_set = set(num_tuple)
print(num_tuple_set, type(num_tuple_set))
# {1, 2, 3, 4, 5} <class 'set'>
# 【5】布尔类型不可以
print(set(True))
# TypeError: 'bool' object is not iterable
# 【6】整数类型不可以
print(set(1))
# TypeError: 'int' object is not iterable
# 【7】浮点数类型不可以
print(set(3.14))
# TypeError: 'float' object is not iterable
（2）添加元素
[1] 添加单个元素(add())
#add(element)方法用于向集合中添加单个元素
num_set = {1, 2, 3, 4, 5}
num_set.add(6)
print(num_set)
# 输出 {1, 2, 3, 4, 5, 6}
[2]添加多个元素(update())
#update(iterable)方法用于向集合中添加多个元素
num_set = {1, 2, 3, 4, 5}
num_set.update([6, 7, 8])
print(num_set)
# 输出 {1, 2, 3, 4, 5, 6, 7, 8}
（3）删除元素
[1] 删除指定元素(remove())
#remove(element)方法用于删除集合中的指定元素，元素不存在则会报错
num_set = {1, 2, 3, 4, 5}
num_set.remove(1)
print(num_set)
#输出 {2, 3, 4, 5}
[2] 删除指定元素(discard())
#discard(element)方法用于删除集合中的指定元素，元素不存在则不会引报错
num_set = {1, 2, 3, 4, 5}
num_set.discard(1)
print(num_set)
#输出 {2, 3, 4, 5}
[3] 随机删除元素(pop())
#pop()方法用于随机删除集合中的一个元素，如果集合为空则会报错
num_set = {1, 2, 3, 4, 5}
num = num_set.pop()
print(num) # 输出: 1
print(num_set) # 输出: {2, 3, 4, 5}
- 当集合中的元素是纯数字时，集合会从小到大排列元素，然后会删除最小的那个元素。
num_set = {1, 2, 3, 4, 5}
num_set.pop()
print(num_set)
#输出 {2, 3, 4, 5}
set = {'a', 'b', 'c', 'd'}
set.pop()
print(set)
# 输出 {'c', 'a', 'b'}
- 当集合中的元素有字符串、数字、元组等组合时，依旧会随机删除一个元素。
set = {'a', 'b', 'c', 'd', (1, 3), 1, 3}
set.pop()
print(set)
# 输出 {(1, 3), 3, 'c', 'd', 'b', 'a'}
set = {}
# 实际上，这并不是集合，而是字典
print(set, type(set))
# {} <class 'dict'>
set1.pop()
# TypeError: pop expected at least 1 argument, got 0
（4）集合操作
[1] 并集
#union()方法返回当前集合与其他集合的并集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.union(set2))
# 输出 {1, 2, 3, 4, 5, 6, 7, 8}
[2] 交集
#intersection()方法返回当前集合与其他集合的交集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.intersection(set2))
# 输出 {4, 5}
[3] 差集
#difference()方法返回当前集合与其他集合的差集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.difference(set2))
# 输出 {1, 2, 3}
[4] 对称差集
#symmetric_difference()方法返回当前集合与其他集合的对称差集
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}
print(set1.symmetric_difference(set2))
# 输出 {1, 2, 3, 6, 7, 8}
[5]父集
set1 = {1, 2, 3, 4, 5}
set2 = {1, 5}
# 判断 set1 是否是 set2 的父集
is_superset = set1.issuperset(set2)
print(is_superset)
# 输出: True
[6]子集
set1 = {1, 2, 3, 4, 5}
set2 = {1, 5}
# 判断 set2 是否是 set1 的子集
is_subset = set2.issubset(set1)
print(is_subset)
# 输出: True
[7]判断
set1 = {1, 2, 3, 4, 5}
set2 = {5, 6}
# 判断两个集合是否相等
is_equal = set1 == set2
print(is_equal)
# 输出: False
（5）去重
#如果集合中只有纯数字的单一元素，顺序是不会变的
num_set = {1, 2, 3, 4, 5, 3, 3, 3, 5}
print(num_set) #输出 {1, 2, 3, 4, 5}
#只能针对不可变类型，集合本身是无序的，去重之后无法保留原来的顺序
num_set = {'c', 'a', 'b'}
print(set(num_set))
#输出两次
# {'b', 'c', 'a'}
# {'a', 'c', 'b'}
# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
l_second = [
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'jack', 'age': 73, 'sex': 'male'},
{'name': 'tom', 'age': 20, 'sex': 'female'},
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'lili', 'age': 18, 'sex': 'male'},
]
new_l_second = []
for dic in l_second:
if dic not in new_l_second:
new_l_second.append(dic)
print(new_l_second)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
'''
[
{'name': 'lili', 'age': 18, 'sex': 'male'},
{'name': 'jack', 'age': 73, 'sex': 'male'},
{'name': 'tom', 'age': 20, 'sex': 'female'}
]
'''
（6）计算长度(len())
#使用len函数计算长度
num_set = {1, 2, 3, 4, 5}
print(len(num_set))
# 输出 5
（7）遍历循环
#使用for循环进行遍历
num_set = {1, 2, 3, 4, 5}
for num in num_set:
print(num)
# 输出 1 2 3 4 5
（8）成员运算
num_set = {1, 2, 3, 4, 5}
#用in运算符
print(1 in num_set) #输出 True
#用not in运算符
print(6 not in num_set) #输出 True
【四】数据类型总结
| 按存值个数区分 |
|
| 只能存一个值：可称为标量/原子类型 |
数字类型、字符串 |
| 可以存放多个值：可称为容器类型 |
列表、元祖、字典 |
| 按照访问方式区分 |
|
| 直接访问：只能通过变量名访问整个值 |
数字类型 |
| 顺序访问：可以通过索引访问指定的值，索引代表顺序，又称为序列类型 |
字符串、列表、元祖 |
| key访问：可以用key访问指定的值，又称为映射类型 |
字典 |
| 按可变不可变区分 |
|
| 可变类型 |
列表、字典 |
| 不可变类型 |
数字、字符串、元祖 |
浙公网安备 33010602011771号