首页 > 其他分享 >08元组_集合_布尔_类型的内置方法已经增删查改操作

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

时间：2024-04-06 13:00:30浏览次数：28  
标签：set name tuple 08 元组 集合 查改 set1 print

【一】元组类型的内置方法(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'}
]
'''

标签：set,name,tuple,08,元组,集合,查改,set1,print
From： https://www.cnblogs.com/chosen-yn/p/18117340

相关文章

  • 8086 汇编学习 Part 2
    寄存器及数据存储CPU组成运算器进行信息处理寄存器进行信息存储控制器协调各种器件进行工作内部总线先实现CPU内各个器件之间的联系寄存器寄存器是CPU内部的信息存储单元。8086CPU有14个寄存器：通用寄存器：AX,BX,CX,DX变址寄存器：SI,DI指针寄存器：SP,BP指令指......
  • 8086 汇编学习 Part 2
    寄存器及数据存储CPU组成运算器进行信息处理寄存器进行信息存储控制器协调各种器件进行工作内部总线先实现CPU内各个器件之间的联系寄存器寄存器是CPU内部的信息存储单元。8086CPU有14个寄存器：通用寄存器：AX,BX,CX,DX变址寄存器：SI,DI指针寄存器：SP,BP指令......
  • 信息学奥赛一本通题目解析：1085：球弹跳高度的计算（循环）
    【题目描述】一球从某一高度hℎ落下(单位米)，每次落地后反跳回原来高度的一半，再落下。编程计算气球在第1010次落地时，共经过多少米?第1010次反弹多高？输出包含两行，第1行：到球第1010次落地时，一共经过的米数。第2行：第1010次弹跳的高度。【输入】输入一个整数hℎ，表示球的初始......
  • 黑马程序员Java从入门到起飞(上) P103 字符串-08-较难练习练习-金额转换
    文章目录标题：黑马程序员Java从入门到起飞(上)P103字符串-08-较难练习练习-金额转换前言一、案例的使用场景是什么？二、输入输出情况三、思路四、什么是查表法？五、代码实现六、完整代码总结标题：黑马程序员Java从入门到起飞(上)P103字符串-08-较难练习练习-金额转......
  • 洛谷 P1006 [NOIP2008 提高组] 传纸条
    题意：传纸条，跟方格取数一样，但是两条路径不能有重复的。思路：还是一样的走，但是x1跟x2不能相等，包括现在跟上一个状态。总结：看了题解，发现题解大多数都是逻辑不正确的，更有离谱的是数组范围都不加特判，数组访问越界但是可以ac的情况，数据太烂了，放个自以为正确的思路吧，发现之前自己提交的......
  • 01-元组、列表
    列表和元组的区别：'''1.列表是动态数组，它们可变且可以重设长度（改变其内部元素的个数）。2.元组是静态数组，它们不可变，且其内部数据一旦创建便无法改变。3.元组缓存于Python运行时环境，这意味着我们每次使用元组时无须访问内核去分配内存。'''tup1=(1,2,3)print(type(tup1))......
  • 8086 汇编学习 Part 1
    学习汇编语言的重要性编程语言发展不可替代性效率：用于开发软件的核心部件，可以快速执行和实时响应。底层：开发操作系统内核，嵌入式系统等计算机及外围设备的驱动程序作用：直击计算机系统的核心，可以加深对计算机原理和操作系统的理解。学习内容理解硬件结构，掌握指令集，理解......
  • 30 天精通 RxJS （08）：简易拖拉实作 - take， first， takeUntil， concatAll
    我们今天要接着讲take，first，takeUntil，concatAll这四个operators，并且实作一个简易的拖拉功能。Operatorstaketake是一个很简单的operator，顾名思义就是取前几个元素后就结束，范例如下varsource=Rx.Observable.interval(1000)varexample=source.take(3)example.......
  • MySQL数据库 数据库基本操作(二):表的增删查改(上)
    1.CRUDCRUD即增加(Create)、查询(Retrieve)、更新(Update)、删除(Delete)四个单词的首字母缩写,就是数据库基本操作中针对表的一系列操作.2.新增(create)-->insert语法:insertinto表名[列名1,列名2…]values(val1,val2…)[注意]列名可以没有,如果没有列名,所......
  • 元组、布尔、集合内置方法以及数据类型内置方法总结
    昨日内容回顾【一】列表类型内置方法（一）类型强制转换字符串可以转换成列表字符串中的每一个元素字典转换为列表以后是字典的键元组转换为列表集合转换为列表集合的去重性和无序性--->一旦转换成功这个列表就定死（二）按照索引取值正向：从0开始反向：从-1开始可......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99