08元组_集合_布尔_类型的内置方法已经增删查改操作

【一】元组类型的内置方法(tuple)

【1】元组类型的定义

元组是Python中的一种有序、不可变的数据类型。
元组使用（）来定义，可以包含任意类型的元素，包括数字、字符串、列表等。

【2】定义

在Python中，可以使用，来创建元组。通常也会建议使用小括号、尽管小括号并不是必须的。例如：

#使用逗号
my_tuple = 1, 2, 3
#使用小括号
my_tuple_explicit = (1, 2, 3)

【3】内置方法

（1）类型强转

能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
使用 tuple() 函数可以将其他可迭代对象转换为元组

# 示例
numbers_list = [1, 2, 3, 4, 5]
numbers_tuple = tuple(numbers_list)
print(numbers_tuple)  # 输出: (1, 2, 3, 4, 5)

（2）索引取值

正索引取值

fruit_tuple = ('apple', 'banana', 'cherry')
print(fruit_tuple[1])  # 输出: banana

负索引取值

fruit_tuple = ('apple', 'banana', 'cherry')
print(fruit_tuple[-1])  # 输出: cherry

只能取值，不能改值

fruit_tuple = ('apple', 'banana', 'cherry')
print(fruit_tuple[3])  # 抛出 IndexError

（3）切片操作

与列表一样，元组也支持切片操作（顾头不顾尾）

fruit_tuple = ('apple', 'banana', 'cherry', 'date', 'elderberry')
print(fruit_tuple[1:4])  # 输出: ('banana', 'cherry', 'date')

# 步长示例
numbers_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
print(numbers_tuple[::2])  # 输出: (1, 3, 5, 7, 9)

（4）计算长度

使用 len() 函数可以获取元组的长度

# 示例
fruit_tuple = ('apple', 'banana', 'cherry')
print(len(fruit_tuple))  # 输出: 3

（5）成员运算

元组支持 in 和 not in 运算符

# in
fruit_tuple = ('apple', 'banana', 'cherry')
print('banana' in fruit_tuple)  # 输出: True
print('orange' not in fruit_tuple)  # 输出: True

# not in
fruit_tuple = ('apple', 'banana', 'cherry')
print('orange' not in fruit_tuple)  # 输出: True

（6）遍历循环

使用 for 循环可以遍历元组的每个元素

# 示例
fruit_tuple = ('apple', 'banana', 'cherry')
for fruit in fruit_tuple:
    print(fruit)
# 输出:
# apple
# banana
# cherry

（7）元组拼接

使用 + 运算符可以将两个元组拼接成一个新的元组

# 示例
tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
result_tuple = tuple1 + tuple2
print(result_tuple)  # 输出: (1, 2, 3, 'a', 'b', 'c')

（8）元组重复

使用 * 运算符可以将元组重复指定次数

# 示例
fruit_tuple = ('apple', 'banana', 'cherry')
result_tuple = fruit_tuple * 2
print(result_tuple)
# 输出: ('apple', 'banana', 'cherry', 'apple', 'banana', 'cherry')

【二】布尔类型的内置方法(bool)

【1】强制类型转换

num = 1  # 为真的情况能转为 True
print(bool(num), type(bool(num)))  # True <class 'bool'>

name = 'dream'  # 为真的情况能转为 True
print(bool(name), type(bool(name)))  # True <class 'bool'>

num_one = 0  # 为假的情况能转为 False
print(bool(num_one), type(bool(num_one)))  # False <class 'bool'>

name = ''  # 为假的情况能转为 False
print(bool(name), type(bool(name)))  # False <class 'bool'>

【三】集合类型的内置方法(set)

【1】定义

集合的定义方式使用大括号 {} 并将元素用逗号 , 分隔。

# 示例
my_set = {1, 2, 3, 4, 5}
print(my_set)  # 输出: {1, 2, 3, 4, 5}


#无序性
print(set('dream'))
# 第一次 ： {'a', 'm', 'r', 'd', 'e'}
# 第二次 ： {'r', 'd', 'a', 'm', 'e'}


#去重性
print(set('dreame'))
# 第一次 ： {'d', 'e', 'a', 'r', 'm'}
# 第二次 ： {'e', 'a', 'd', 'r', 'm'}

【2】内置方法

（1）类型强转

能被 for 循环的遍历的数据类型都可以传给 set() 转换成集合类型

# 【1】字符串类型可以强转成集合类型
name_str = 'dream'
name_str_set = set(name_str)
print(name_str_set, type(name_str_set))
#  {'m', 'r', 'd', 'a', 'e'} <class 'set'>

# 【2】字典也可以去重 , 一般我们只对字典的值去重
# 因为字典的键一般情况下都是唯一的，不需要更改
# 【2.1】默认将字典的键转换为集合
name_dict = {'name': "dream", "age": 18, "sex": 18}
name_dict_set = set(name_dict)
print(name_dict_set, type(name_dict_set))
# {'name', 'age', 'sex'} <class 'set'>

# 【2.2】可以选择将字典的值转换为集合并去重
name_dict_values = name_dict.values()
name_dict_values_set = set(name_dict_values)
print(name_dict_values_set, type(name_dict_values_set))
# {18, 'dream'} <class 'set'>

# 【3】列表类型是可以转成集合类型
num_list = [1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7]
num_list_set = set(num_list)
print(num_list_set, type(num_list_set))
# {1, 2, 3, 4, 5, 6, 7} <class 'set'>

# 【4】元组类型可以转换为集合类型
num_tuple = (1, 2, 3, 4, 5, 6, 6, 6, 6, 6)
num_tuple_set = set(num_tuple)
print(num_tuple_set, type(num_tuple_set))
# {1, 2, 3, 4, 5, 6} <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(1.0))
# TypeError: 'float' object is not iterable

（2）添加元素

【1】添加单个元素（add()）

add(element) 方法用于向集合中添加单个元素

# 示例
my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出: {1, 2, 3, 4}

【2】添加多个元素（update()）

update(iterable) 方法用于向集合中添加多个元素，参数是一个可迭代对象。

# 示例
my_set = {1, 2, 3}
my_set.update([3, 4, 5])
print(my_set)  # 输出: {1, 2, 3, 4, 5}

（3）删除元素

【1】删除指定元素（remove()）

remove(element) 方法用于移除集合中的指定元素，如果元素不存在则会引发 KeyError

# 示例
my_set = {1, 2, 3, 4, 5}
my_set.remove(3)
print(my_set)  # 输出: {1, 2, 4, 5}

【2】删除指定元素（discard()）

discard() 方法用于移除集合中的指定元素，如果元素不存在则不会引发报错。

# 示例
my_set = {1, 2, 3, 4, 5}
my_set.discard(3)
print(my_set)  # 输出: {1, 2, 4, 5}

【3】随机删除元素（pop()）

pop() 是基于HashMap实现的，它总是「删除」集合中的「第一个元素」，由于集合是「无序」的，所以它看起来就像是「随机」删除元素。
pop() 方法用于随机移除集合中的一个元素，如果集合为空则引发 KeyError。

# 示例
my_set = {1, 2, 3, 4, 5}
removed_element = my_set.pop()
print(removed_element)  # 输出: 随机移除的元素
print(my_set)           # 输出: 移除后的集合

当集合中的元素是「纯数字」时，集合会按照从小到大的顺序排列元素，「最小」的数值会别排在第一个，所以pop()时，会删除最小的那个元素。

set1 = {1, 5, 3, 9, 2}

print('删除前：', set1)
set1.pop()
print('删除后：', set1)

# 删除前： {1, 2, 3, 5, 9}
# 删除后： {2, 3, 5, 9}

# 多执行几次，我们可以发现， pop() 每次都删除1，因为1是最小的，总是被排在第一个。

当集合中的元素是「纯字符串」时，集合无法保证元素的排序，由于 pop() 总是删除第一个元素，所以这种情况看起来就是随机删除。

set1 = {'aaa', 'bbb', 'ccc', 'ddd'}

print('删除前：', set1)
set1.pop()
print('删除后：', set1)

# 第一次 ： 删除了 bbb
# 删除前： {'bbb', 'ddd', 'aaa', 'ccc'}
# 删除后： {'ddd', 'aaa', 'ccc'}

# 第二次 ： 删除了 ccc
# 删除前： {'ccc', 'ddd', 'bbb', 'aaa'}
# 删除后： {'ddd', 'bbb', 'aaa'}

# 多次执行可以发现，每次集合中的元素排序都是随机的，而 pop() 也会 “随机” 的删除集合中的第一个元素。

当集合中的元素有字符串、整形、元组等「混合」组合时，元素的排序会变得随机，当然， pop() 仍然会固执地删除第一个元素。

set1 = {(1, 2), (5, 6), (9, 8), (3, 4), 'aaa', 1, 2}

print('删除前：', set1)
set1.pop()
print('删除后：', set1)

# 删除前： {1, 2, (1, 2), (3, 4), (9, 8), (5, 6), 'aaa'}
# 删除后： {2, (1, 2), (3, 4), (9, 8), (5, 6), 'aaa'}

使用 pop() 的集合，必须有元素，「空集合」会报错 KeyError。

（4）集合操作

[1] 并集(union())

union(*others) 方法返回当前集合与其他集合的并集。

# 示例
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set)  # 输出: {1, 2, 3, 4, 5}

[2] 交集(intersection())

intersection(*others) 方法返回当前集合与其他集合的交集。

# 示例
set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出: {3}

[3] 差集(difference())

difference(*others) 方法返回当前集合与其他集合的差集。

# 示例
set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference_set = set1.difference(set2)
print(difference_set)  # 输出: {1, 2}

[4] 对称差集(symmetric_difference())

symmetric_difference(other) 方法返回当前集合与其他集合的对称差集。

# 示例
set1 = {1, 2, 3}
set2 = {3, 4, 5}
symmetric_difference_set = set1.symmetric_difference(set2)
print(symmetric_difference_set)  # 输出: {1, 2, 4, 5}

[5]父集

set1 = {1, 2, 3, 4, 5}
set2 = {2, 4}

# 判断 set1 是否是 set2 的父集
is_superset = set1.issuperset(set2)
print(is_superset)
# 输出: True

[6]子集

set1 = {1, 2, 3, 4, 5}
set2 = {2, 4}

# 判断 set2 是否是 set1 的子集
is_subset = set2.issubset(set1)
print(is_subset)
# 输出: True

[7]判断（==）

set1 = {1, 2, 3, 4, 5}
set2 = {2, 4}

# 判断两个集合是否相等
is_equal = set1 == set2
print(is_equal)
# 输出: False

（5）去重

只能针对不可变类型，集合本身是无序的，去重之后无法保留原来的顺序

l_old = ['a', 'b', 1, 'a', 'a']
s = set(l_old)  # 将列表转成了集合
print(s)
# {'b', 'a', 1}

l_new = list(s)  # 再将集合转回列表
print(l_new)  # 去除了重复，但是打乱了顺序
# ['b', 'a', 1]


# 针对不可变类型，并且保证顺序则需要我们自己写代码实现，例如
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'}
]
'''

posted @ 2024-04-06 12:51 光头大炮阅读(3) 评论(0) 编辑收藏举报

chosen-yn

08元组_集合_布尔_类型的内置方法已经增删查改操作

【一】元组类型的内置方法(tuple)

【1】元组类型的定义

【2】定义

【3】内置方法

（1）类型强转

（2）索引取值

（3）切片操作

（4）计算长度

（5）成员运算

（6）遍历循环

（7）元组拼接

（8）元组重复

【二】布尔类型的内置方法(bool)

【1】强制类型转换

【三】集合类型的内置方法(set)

【1】定义

【2】内置方法

（1）类型强转

（2）添加元素

【1】添加单个元素（add()）

【2】添加多个元素（update()）

（3）删除元素

【1】删除指定元素（remove()）

【2】删除指定元素（discard()）

【3】随机删除元素（pop()）

（4）集合操作

[1] 并集(union())

[2] 交集(intersection())

[3] 差集(difference())

[4] 对称差集(symmetric_difference())

[5]父集

[6]子集

[7]判断（==）

（5）去重

公告