元组、布尔、集合内置方法以及数据类型内置方法总结

最新推荐文章于 2024-09-23 09:50:33 发布

唯有聪明绝顶

最新推荐文章于 2024-09-23 09:50:33 发布

阅读量598

点赞数 10

文章标签： windows

本文链接：https://blog.csdn.net/g1446992400/article/details/137357582

版权

昨日内容回顾

【一】列表类型内置方法

（一）类型强制转换

字符串可以转换成列表字符串中的每一个元素
字典转换为列表以后是字典的键
元组转换为列表
集合转换为列表集合的去重性和无序性 ---> 一旦转换成功这个列表就定死

（二）按照索引取值

正向：从0开始
反向：从-1开始
可以取值并将取到的值位置的索引值替换掉
索引取值的情况下，如果没有索引的值就会报错

（三）切片

顾头不顾尾：range
[起始位置：截止位置：步长]
[：：-1] ：翻转
负索引取值的时候第一个起始位置要从右向左取
[：：-2]

name = 'gdyandhyt'
print(name[0:4:2])          # gy

从右向左开始

name = 'gdyandhyt'
print(name[-1:-4:-1])       # tyh

（四）计算长度

语法：len(变量名)

（五）成员运算

可以判读当前元素是否在当前列表
in
not in
可以将字典的键转换为列表用成员运算判断当前输入的用户名是否存在于当前列表中

（六）操作方法

（1）增加

extend(直接放列表)
insert(索引位置，值)
- 插入到指定索引位置上
append() 将元素默认追加到结尾

（2）查看

直接打印列表
索引取值

（3）删除

pop() ：如果不写参数则默认删除最后位置的元素可以将元素弹出可以用变量名接受
pop(索引)：直接弹出指定索引位置的元素
remove(值) ：在列表中存在的值才能被remove
del 列表[索引位置]：将从列表中按照索引位置取出来的值删除掉

（4）修改

直接索引取值 = 修改的新值

（七）颠倒元素

列表.reverse(): 将列表中的所有元素翻转
list(reversed(列表))

（八）对列表中的元素进行排序

列表.sort() : 将原来的列表进行排序 ---> 影响到的是原来的列表
sorted(列表)：有返回值，返回值就是排序后的列表，并且原本的列表不受影响
有一个参数 reverse=True:将排序号的结果翻转

（九）遍历列表

for 循环获取列表中每一个元素
for + range 关键：可以放指定区间 ---> 根据索引坐标获取列表值
while 列表的长度：内部有count 根据索引指定索引对应的值

【二】字典类型内置方法

【1】定义风格

在一个{}里面放一个k:v键值对

【2】字典操作

（1）增加

有则修改，无则添加
字典[key] = value
字典.update({k:v}) ---> 更新原来的字典
字典.update(k=v) ---> 更新原来的字典
setdefault(k,v) ---> 有返回值返回值是你设置进去的键值对的值

（2）查看

字典[key] 取值 ---> 拿到指定键对应的值，取不到会报错
字典.get(key) 取值 ---> 拿到指定键对应的值，取不到的话不会报错
查看字典的键对字典.keys() dict.keys 支持成员运算
值对字典.values()
键值对字典.items() ：在列表中存在的一个个的元组 (key,value)
for key,value in 字典.items(): 解压赋值

（3）修改

（4）删除

pop() ---> 弹出最后的元素
del 字典[key]：把查询的键和对应的值全部删除
清空字典字典.clear()
删除键值对字典.popitem()

【3】遍历循环

for key in user: 拿到的值就是键

今日内容

元组内置方法

【一】元组的定义

在元组的内部，只有一个元素的时候 + “，”

【二】类型强制转换

整数类型和布尔类型不可以

print(tuple([1,2,3]))
print(tuple('dream'))
print(tuple({1,2,2}))
print(tuple({'username':"dream"}))

【三】索引取值

num_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
print(num_tuple[0])

切片：顾头不顾尾
不支持根据索引修改指定的索引值

num_tuple[0] = 999

【四】计算元素个数

print(len((1,2,3)))             # 3

【五】成员运算

print(4 in (1,2,3))             # False

【六】支持遍历

for i in (1,2,3,4):
    print(i)                    # 结果：将1234输出一遍
# for + range ---> 索引取值

【七】元组拼接

两个列表+起来，可以得到一个新列表，其中包括了两个列表的元素

print([1, 2, 3] + [4, 5, 6])            # [1, 2, 3, 4, 5, 6]

两个元组+起来，可以得到一个新元组，其中包括两个元组的的元素

print((1, 2, 3) + (4, 5, 6))            # (1, 2, 3, 4, 5, 6)

【八】* 号运算

print((1, 2, 3) * 6)            # (1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3)

布尔类型的内置方法

【一】强制类型转换

强制将其他类型转换为布尔类型

print(bool(0))              # False
print(bool(1))              # True
print(bool(2))              # True

# 在python中结果为假的情况
# 布尔值false
# 空值

集合类型的内置方法

【一】集合的定义

集合是用{}的定义的，并且每一个元素但是单独的，区分与字典的是，字典中是键值对
集合内部的元素不能放可变数据类型

【二】集合的特性

无序性
- 相对于其他类型来说
数字类型的hash值是死的

print({1, 2, 3, 4, 5, 6, 999, 55, 'a', 77, 'c', 44})

去重性
- 在一个集合内不会出现重复的元素

【三】其他类型的数据强转

强转的时候会沿用集合的特性，无序且去重

name = 'hanyutong'
print(set(name))            # {'u', 'h', 'y', 'a', 'o', 'n', 't', 'g'}
print(set({'username': "hyt", 'password': "123"}))          # {'username', 'password'}

【四】集合操作

【1】添加元素

num_set = {1, 2, 3}
num_set.add(999)            # add的方法只能添加一个元素
print(num_set)              # {1, 2, 3, 999}

num_set.update([1, 2, 3, 4])
num_set.update((4, 5, 6))       # 无论是列表还是元组添加进来之后都是以集合的形式存在 
print(num_set)                  # {1, 2, 3, 4, 5, 6, 999}

把注册过的用户名全部扔到集合中
利用集合的去重性判断当前用户是否注册过

username_tuple = {'gdy', 'hyt'}
username = input(':>>>')
username_tuple.add(username)

【2】删除元素

删除已经存在的值

num_set = {1, 2, 3,999}
num_set.remove(999)
print(num_set)              # {1, 2, 3}

remove 删除集合中不存在的值是会报错

num_set.remove(999)         #直接报错
print(num_set)

discard 删除不存在的元素时不会报错，而是返回原来的集合

num_set.discard(999)        #{1, 2, 3}
print(num_set)

pop 在其他的数据类型可以指定参数，但是在集合中不能指定参数，默认删除左1

num_set = {1, 2, 3,999}
num_set.pop()
print(num_set)          # {2, 3, 999}

【五】集合的运算

交集：两个集合中共有的元素

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

并集：将两个集合中的元素合并到一起

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

差集：你有但是我没有的数据

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

判断两个集合是否相等

is_equal = set1 == set2
print(is_equal)                 # 输出: False

将列表转成了集合

list = ['a','b',1,'a']
num = set(list) 
print(num)              # {'a', 'b', 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'}
]
'''