时间戳

首页 > 技术文章 > 数据类型：dict、tuple、set 的基本使用及内置方法，数据类型总结

数据类型：dict、tuple、set 的基本使用及内置方法，数据类型总结

gengfenglog 2020-12-23 20:24 原文

数据类型的基本使用

zidian

字典dict的基本使用

  • 用途：按照key:value的方式存放多个值，其中key对value应该有描述性的效果
  • 定义方式：在{}内用逗号分隔开多个元素，每个元素都是key:value的组合，其中value可以是
    任意类型但是key必须是不可变类型，通常是字符串类型，并且key不能重复
d={1:11111, 1.1:22222, "k1":333333, (1,2,3):44444, [1,2,3]:5555}  # d=dict(...)
print(d[1])  # 报错  TypeError: unhashable type: 'list'

# dict数据类型转换 (数据类型的转换比较狭窄)
res = dict([("name", "jack"), ["age", 18], ["gender", "male"]])
print(res)  # {'name': 'egon', 'age': 18, 'gender': 'male'}

res = dict(a=1, b=2, c=3)  # 可以用这种方式造字典
print(res)  # {'a':1, 'b':2, 'c':3}

d = {}  # 造空字典
d = dict()
print(type(d))  # <class 'dict'>

# {} + fromkeys 可以快速初始化字典

res = {}.fromkeys(['name', "age", "gender"], None)  # 前面每一个值都跟None配对
res = {}.fromkeys(['name', "age", "gender"], 11)  # 前面每一个值都跟11配对
res["name"] = 666  # 只有name值变了，其余的都不变

# key先准备好，value值先置空None，保证初始状态之后再赋值给value
# 通常都是None
res = {}.fromkeys(['name', "age", "gender"], [])

res["name"] = 666
print(res)  # {'name': 666, 'age': [], 'gender': []}


res["name"].append(111)
print(res)  # {'name': [111], 'age': [111], 'gender': [111]}

dict 常用操作

优先掌握的操作：

1、按key存取值：可存可取，key不存在会直接报错

d = {"k1": 111, 'k2': 222}

print(d['k1'])  # 111

d['k1'] = 6666  # key存在为修改值
d['k3'] = 6666  # 字典是可以根据不存在的key往里面加值的

print(d)  # {'k1': 6666, 'k2': 222, 'k3': 6666}

2、统计字典内部键值对的个数 len

d = {"k1": 111,'k2':222}

print(len(d))  # 2

**3、成员运算in和not in: **判断的是key

d = {"name": "jack",'age':18}

print("jack" in d)  # False
print("name" in d)  # True

4、删除元素

d = {"name": "jack", 'age': 18}

# 方式一：万能删除法
del d["name"]
print(d)  # {'age': 18}

# 方式二：指定k弹出键值对 给出v
v = d.pop("name")  # 指定key删除
print(d)  # {'age': 18} 显示key已经删除
print(v)  # jack  pop删除功能会把删除key对应的value值返回 

# 方式三：弹出键值对 组织成元组的形式 第一个元素是k第二个元素是v(了解)
item = d.popitem()
print(item)  # ('age', 18) popitme删除法会把删除的key和value值存成元组返回
print(d)  # {}

5、键keys()，值values()，键值对items()

# keys() values() items() 在python2中是列表 在python3中是迭代器(老母猪)

d = {"name": "jack", 'age': 18, "gender": "male"}

# 获取字典所有的键 看成列表即可
print(d.keys())  # dict_keys(['name', 'age', 'gender'])

# 获取字典所有的值 看成列表即可
print(d.values())  # dict_values(['jack', 18, 'male'])

# 获取字典里面所有的键值对 组织成列表套元组的形式 元组内有两个元素 第一个是k第二个是v
print(d.items())  # dict_items([('name', 'jack'), ('age', 18), ('gender', 'male')])

6、循环

d={"name":"jack",'age':18,"gender":"male"}
for k in d.keys():
    print(k)
    
for k in d:  # 同上，不加.keys()默认就是
    print(k)    
'''
name
age
gender
'''
    
for v in d.values(): # 只遍历value
    print(v)
'''
jack
18
male
'''
for k,v in d.items():  # k,v = ('gender', 'male'),
    print(k,v)
'''
name jack
age 18
gender male
'''

# 用list的方式还原成Python 2 的样子
print(list(d.keys()))  # ['name', 'age', 'gender']
print(list(d.values()))  # ['egon', 18, 'male']
print(list(d.items()))  # [('name', 'jack'), ('age', 18), ('gender', 'male')]

7、d.get()（取值方式）

d={"name": "jack", 'age': 18, "gender": "male"}
# 方式一：
print(d["name"])  # jack 
print(d["xxx"])  # key不存在直接报错，按k取值不太推荐使用该方式

# 方式二：
print(d.get("name"))  # jack

# 没取到key返回None，key值不存在的时候采用此种方式
print(d.get("xxx", '哈哈哈'))  # None 第二个参数 可以在k不存在的时候自定义返回信息

dict 内置的方法

需要掌握的操作：
d = {"name": "egon", 'age': 18, "gender": "male"}

# clear()：清空字典里面的key和value值
d.clear()  # 清空字典
print(d)  # {}

# copy()：浅copy 复制
d.copy()
print(d) # {'name': 'jack', 'age': 18, 'gender': 'male'}

d = {"name": "jack", 'age': 18}
if "gender" not in d:
    d['gender'] = "male"
print(d)  # {'name': 'jack', 'age': 18, 'gender': 'male'}

# setdefault()：key不存在则添加key:value,key如果存在则什么都不做
d.setdefault("gender","male")  # 与上面if 同种功能

print(d)  # {'name': 'jack', 'age': 18, 'gender': 'male'}


# update()  # 更新字典，不相同的加入老字典，相同的新替旧
d = {"name": "jack", 'age': 18, "gender": "male"}
d.update({"k1": 111, "name": "xxx"}) 

print(d)  # {'name': 'xxx', 'age': 18, 'gender': 'male', 'k1': 111}

  • 该类型总结

    • 存多个值
      • 无序
        • 可变

元组tuple 的基本使用

  • 用途：元组就相当于一种不可变的列表，所以说元组也是按照位置存放多个任意类型的元素
  • 定义方式：在 () 内用逗号分隔开多个任意类型的元素，但是元组内元素不支持‘修改’(索引指向的元素的内存地址不能改变)
x = (11)
print(x, type(x))  # 11 <class 'int'>

#   整型  浮点型  字符串    列表
t = (11, 11.33, "xxx", [44,55])
print(t[-1][0])  # 44
print(type(t))  # <class 'tuple'>

# tuple数据类型转换:只要是可迭代的(支持for循环)数据类型都可以转换成元组tuple

# print(tuple(111))  # TypeError: 'int' object is not iterable

# print(tuple(11.11))  # TypeError: 'int' object is not iterable

print(tuple('hello'))  # ('h', 'e', 'l', 'l', 'o')

print(tuple([11, 22, 33]))  # (11, 22, 33)

print(tuple({'name': 'jason', 'pwd': 123}))  # ('name', 'pwd')


# 注意：如果元组内只有一个元素，那么必须用逗号分隔

t = (11,)
print(type(t))  # <class 'tuple'>

tuple 常用操作

优先掌握的操作：

1、按索引取值（正向取+反向取）：只能取，不能改

t = (11, 22, 33)
print(t[1])  # 22
print(t[-1])  # 33

# t[0] = 7777  # 元组不支持赋值操作

2、切片（顾头不顾尾，步长）

t = (11, 22, 33, 44, 55, 666)
# 切片
print(t[1:5])  # (22, 33, 44, 55)
# 步长
print(t[0:4:2])  # (11, 33)

3、长度

t = (11, 22, 33, 44, 55, 666)

print(len(t))  # 6

4、成员运算in和not in

t = (11, 22, 33, [44, 55, 666])

print([44, 55, 666] in t) # True

5、循环

t = (11, 22, 33, [44, 55, 666])
for x in t:
	print(x)
'''
11
22
33
[44, 55, 666]
'''

tuple 内置方法

需要掌握的操作：
t = (33, 22, 33, [44, 55, 666])
# count()：统计某个元素出现的个数
print(t.count(33))  # 2  

# index()：指定范围从1开始找
print(t.index(33, 1, 4)) # 2 

"""
元组指的不可变，是元组索引对应的内存地址不可变，
如果元组内子元素是列表的话是可以改的
"""

  • 该类型总结

    • 存多个数
      • 有序
        • 不可变

集合类型set的基本使用

  • 用途：去重和关系运算

    • （1）无法保证顺序
    msg = "hello"
res = set(msg)
print(res)  # 去重且无序，得到是集合类型
print(''.join(res))  # 转换回字符串得到的是乱序

names = ['jason', 'lxx', 'lili', "jason", "jason"]
print(set(names))  # {'jason', 'lili', 'lxx'} 转集合后，去重无序
print(list(set(names)))  # ['lxx', 'jason', 'lili'] 去重转回列表类型，去重且无法保证原始顺序
    • （2）只能针对不可变类型元素的去重
    students_info = [
    {"name":"jason", "age":18, "gender":"male"},
    {"name":"tom", "age":19, "gender":"male"},
    {"name":"jack", "age":38, "gener":"female"},
    {"name":"jason", "age":18, "gender":"male"},
    {"name":"jason", "age":18, "gender":"male"},
]
new_l = []
for info in students_info:
    if info not in new_l:
        new_l.append(info)  # 用l.append一点一点的遍历
print(new_l)  # 达到去重效果并且保证顺序，此种方式是去重常用

  • 定义方式：在{ }内用逗号分隔开多个元素，集合内元素的特点有三个

​ (1）集合内元素必须是不可变类型

​ （2）集合内元素不能重复

​ （3）集合内元素无序

#   整型 浮点型  字符串    元组     
s = {11, 3.1, "xxx", (1, 2, 3)}
print(s)  # {3.1, (1, 2, 3), 11, 'xxx'}

s = {11, 11, 11, 11, 11, 22, 33}  # s = set(...)
print(s)  # {33, 11, 22} 重复元素只能留一个
print(type(s))  # <class 'set'>


# 1.定义空集合需要使用关键字set
s1 = set()  # 定义空集合,必须得用set()
print(s, type(s))  # set()  <class 'set'>

# 2.类型转换:能够支持for循环的数据类型都可以转成集合(元素要是不可变类型)
res = set("hello")
print(res)  # {'o', 'h', 'l', 'e'} 注意：去重且无序

name_list = ['kevin', 'jason', 'jason', 'jason', 'kevin', 'kevin']
# 先将列表转换成集合
s1 = set(name_list)
# 再将去重之后的集合转换成列表
l1 = list(s1)
print(l1)  # ['jason', 'kevin']

# 小练习
ll = [33, 22, 11, 22, 11, 44, 33, 22, 55, 66, 77, 77, 66, 55, 44]
# 1.基本要求:去重即可
s1 = set(ll)
ll1 = list(s1)
print(ll1)  # [33, 66, 11, 44, 77, 22, 55]

# 2.拔高要求:去重并保留原来的顺序
# 1).先定义一个新列表
new_list = []
# # 2).for循环ll列表
for i in ll:
    # 3).判断当前元素是否在新列表中
    if i not in new_list:
        # 3.1) 如果不在 则添加到新列表
        new_list.append(i)
    # 3.2) 如果在 则不管
print(new_list)  # [33, 22, 11, 44, 55, 66, 77]

set 常用操作

优先掌握的操作：

（1）交集：取两个集合的共同部分：求两个用户的共同好友

friends1 = {"tom", "jack", "kevin", "jason", "goff"}
friends2 = {"ricky", "cindy", "mary", "jason", "goff", "Jerry"}

# 方式一
print(friends1 & friends2)  # {'goff', 'jason'}
# 方式二
print(friends1.intersection(friends2))  


# 将两个集合的交集结果赋值给 friends1
friends1 = friends1 & friends2  
# 方式一
print("friends1")
# 方式二
friends1.intersection_update(friends2)
print("friends1")

（2）并集：两个集合并到一起：求两个用户所有的好友

friends1 = {"tom", "jack", "kevin", "jason", "goff"}
friends2 = {"ricky", "cindy", "mary", "jason", "goff", "Jerry"}

# 方式一
print(friends1 | friends2)   
# 方式二
print(friends1.union(friends2)） 
# {'cindy', 'mary', 'Jerry', 'ricky', 'tom', 'kevin', 'goff', 'jack', 'jason'}

（3）差集： 一个集合减掉与另外一个集合共同的部分

friends1 = {"tom", "jack", "kevin", "jason", "goff"}
friends2 = {"ricky", "cindy", "mary", "jason", "goff", "Jerry"}

# 用户1独有的好友
# 方式一
print(friends1 - friends2)  # {'jack', 'tom', 'kevin'}
# 方式二
print(friends1.difference(friends2))     
      
# 求用户2独有的好友
# 方式一
print(friends2 - friends1)  # {'mary', 'ricky', 'cindy', 'Jerry'}
# 方式二 
print(friends2.difference(friends1))

(4) 交叉补集/对称差集：两个集合互相减，然后再并到一起：用户1和用户2各自的好友

friends1 = {"tom", "jack", "kevin", "jason", "goff"}
friends2 = {"ricky", "cindy", "mary", "jason", "goff", "Jerry"}

# 方式一: ^ 与 | 方式更简单 
res = (friends1 - friends2)| (friends2- friends1) 
res = friends1 ^ friends2   
print(res)  # ('mary', 'jack', 'cindy', 'tom', 'ricky', 'Jerry', 'kevin'}  
       
# 方式二
print(friends1.symmetric_difference(friends2)

（5）父子集合：当一个集合完全包含了另外一个集合，该集合才能称爹

s1 = {1, 2, 3}
s2 = {3, 4, 5}
# 没有包含关系，s1不包含s2所以无法成立，只能说明s1不是s2它爹
print(s1 >= s2)  # False 

# 大于等于和小于等于指的不是传统认知的比大小，指的是包含关系
print(s2 <= s1)  # False 


s1 = {1, 2, 3}
s2 = {1, 2}
# 有包含关系，集合成立说明s1包含s2，s1是s2它爹  
# 方式一
print(s1 >= s2)  # Ture 
# 方式二
print(s1.issuperset(s2)) # Ture 

# 有包含关系，集合成立说明s2继承自s1，s2是s1它儿子 
# 方式一               
print(s2 <= s1)  # Ture  
# 方式二
print(s2.issubset(s1))  # Ture

set 内置方法

需要掌握的操作：

1、update()：更新，把两个集合并到一起，去重

s1 = {1, 2, 3}
s1.update({3, 4, 5})

print(s1)  # {1, 2, 3, 4, 5} 相当于可以一次性加多个值

2、add()：加值，一次加一个值

s1 = {1, 2, 3}
s1.add(4)

print(s1)  # {1, 2, 3, 4}

3、删除

# 方式一：remove（）
s1 = {1, 2, 3}
s1.remove(3)  # 指定元素删除
print(s1) # {1, 2}

# 方式二：discard（）
s1 = {11, 22, 33, "xx", "yy", "zz"}
s1.remove(33333)  # 删除元素不存在 报错
s1.discard(33333)  # 删除元素不存在 啥事都不会做，不会报错
print(s1)

s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
res=s1.pop()  
print(s1)  # 随机删除元素
print(res)  # 返回删除值，相当于pop取走的值

s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
s1.clear()  # 整个清空掉
print(s1)  # set() 空集合

4、copy()：复制集合，无序

s1 = {11,22,33,44,55,"xx","yy","zz","aa"}
s1.copy()

print(s1)  # {33, 'aa', 'yy', 11, 44, 'zz', 22, 55, 'xx'}

5、isdisjoint()：判断两个集合完全没有共同部分，毫不相干

# 没有相同部分
s1 = {1, 2, 3}
s2 = {4, 5, 6}
print(s1.isdisjoint(s2))  # True  

# 有相同部分
s1 = {1, 2, 3}
s2 = {3, 4, 5, 6}
print(s1.isdisjoint(s2))  # False
  • 该类型总结
    • 存多个值
      • 无序
        • 可变
s1 = {1,2,3}
print(id(s1))    # 2048402597696
s1.add(4)      
print(s1)     # {1, 2, 3, 4}
print(id(s1))    # 2423667894080 id没变
# 集合本身纯粹的元素应该是不可变类型，但集合本身就是一个可变类型。

数据类型总结

  • 按存储空间的占用分（从低到高）
整型
浮点型
字符串
集合：无序，即无序存索引相关信息
元组：有序，需要存索引相关信息，不可变
列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
字典：无序，需要存key与value映射的相关信息，可变，需要处理数据的增删改

  • 按存值个数区分

  • 标量／原子类型（不可再分，只能存一个值）：整型，浮点型，字符串

  • 容器类型（能存多个值）：列表，元组，字典，集合

  • 按可变不可变区分

  • 可变：列表，字典，集合

  • 不可变：整型，浮点型，字符串，元组

  • 按访问顺序区分

  • 直接访问：整型，浮点型

  • 顺序访问（序列类型）：字符串，列表，元组

  • key值访问（映射类型）：字典

推荐阅读