建设网站的建筑公司b站官方推广

引入

在内存中存储的数据可以是不同的数据类型。比如名字可以使用字符串存储，年龄可以使用数字存储，python有6种基本数据类型，用于各种数据的存储，分别是：numbers(数字类型)、string(字符串)、List(列表)、Tuple(元组)、Dictionary(字典).

本文介绍字典和集合。

字典类型(Dict)

定义

字典是可变类型的容器数据类型，可以存储任意数据类型的对象。{}内用逗号分隔开多个key：value，其中value可以是任意类型的值，key必须是不可变类型(字符串、数字、元组)，一般是对value具有描述性质的字符串，键一般是唯一的，如果重复最后的一个键值对会替换前面的，值不需要唯一。

# 创建字典的两种方式
dic = {'x': 'x', 'y': 'y'}  # 方式一
dic = dict(x='x', 'y'=y)  # 方式二

操作字典的方法

按照key存/取值

d={'k1':111}#针对赋值操作：key存在，则修改
d['k1']=222#针对赋值操作：key不存在，则创建新值
d['k2']=3333
print(d)  # {'k1': 222, 'k2': 333}

len()

字典的键值对个数，当有key重复的时候，只记一次。

d={'k1':111,'k2':2222,'k1':3333,'k1':4444}
print(d)  # {'k1': 4444, 'k2': 2222}
print(len(d))  # 2

成员运算

判断key是否包含在字典中

d={'k1':111,'k2':2222}
print('k1' in d)  # True
print(111 in d)   # False

删除操作

del

通用删除，没有返回值

d={'k1':111,'k2':2222}
del d['k1']
print(d)  # {'k2': 2222}

pop()

根据key删除元素，会返回被删除的key对应的value

d={'k1':111,'k2':2222}
res=d.pop('k2')
print(d)  # {'k1': 111}
print(res)  # 2222

popitem()

popitem随机删除一组键值对，将被删除的键值对以元组的方式返回

d={'k1':111,'k2':2222}  
res=d.popitem()
print(d)  # {'k1': 111}
print(res)  # ('k2', 2222)

keys() values() items()

在Python2中得到的分别是字典的所有key的列表、所有value的列表、所有键值对元组的列表，缺点是如果数据量非常大会很占用内存空间。

>>> d={'k1':111,'k2':2222}
>>> d.keys()
['k2', 'k1']>>> d.values()
[2222, 111]>>> d.items()
[('k2', 2222), ('k1', 111)]

在python3中得到的是会'下'出每个值的老母鸡，不会占用内存空间。

>>> d = {'name':'python','age':12}
>>> d.keys()
dict_keys(['name', 'age'])
>>> d.values()
dict_values(['python', 12])
>>> d.items()
dict_items([('name', 'python'), ('age', 12)])

循环遍历

遍历字典中的key

for k in d.keys():print(k)for k in d:print(k)

遍历字典的value

for value in d.values():print(value)

遍历字典中的键值对

for key, value in d.items():print(key, value)

其他内置方法

clear()

清空字典

d = {'name':'python','age':12}
d.clear()
pritn(d)  # {}

update()

用其他字典更新当前字典，存在的键值对进行覆盖，不存在的进行添加

d = {'name':'python','age':12}
d.update({'sex': ',male', 'name': 'tony'})
print(d)  # {'name': 'tony', 'age': 12, 'sex': ',male'}

get()

根据key取值，容错性高，弥补了使用[]取值时key不存在报错的问题

d = {'a':'gg','k':21}
# 弥补当key不存在时会报错的问题,不会报错，会返回None
print(d['k3'])  # 会报错
d.get('k3')    # 会返回none,容错性好

集合(Set)

定义

在{}内用 , 分隔开多个元素，

s = {}  # 空的花括号默认定义的是空字典
print(type(s))  # <class 'dict'>s = set()  # 通过这种方式得到的才是空集合

集合内的元素必须满足以下三个条件：

1.集合内的元素必须为不可变类型

s2 = {[1,2,3],1}  
print(s2)
# 会报错
TypeError: unhashable type: 'list'  # 不可哈希是可变类型

2.集合内元素无序

s = {1,2,'a',(1,4)}  # 底层是调用了set()功能
print(s)

3.集合内元素没有重复,可以进行去重操作

s = {1,1,1,1,1,2,2}
print(s)  # {1， 2}

类型转换

相当于底层调用for循环，取出每一个值放在集合中

# 对字符串进行转换，会自动将字符串中重复的去掉
s = set('hellollllop'))# 对列表进行转换
s = set([1,2,3,4,5,6])
# s = set([1,2,3,4,5,6,[1,2]])  会报错
# print(s)# 对字典进行转换
s = set({'k1':12,'k2':13}.items())
s = set({'k1':12,'k2':13})
s = set({'k1':12,'k2':13}.values())

操作集合的方法

关系运算

两个集合可以进行数学中的交集、并集等运算。

a = {1, 2, 3}
b = {2, 3, 4}

交集

求两个集合共同的值，两种方法

res = a & b  # {2, 3}
res1 = a.intersection(b)  # {2, 3}

并集

两个集合所有的值，重复的去掉， 两种方式

res = a | b  # {1, 2, 3, 4}
res1 = a.union(b)  # {1， 2， 3， 4}

差集

比如，取a集合独有的值，a为被减，两种方式

res = a - b  # {1}
res1 = a.difference(b)  # {1}

对称差集

两个集合分别独有的值组成一个新的集合，两种方式

res = a ^ b  # {1, 4}
res1.symmetric_difference(b)  # {1, 4}

父子集

判断一个集合是否是另一个集合的父集/子集，如果两个集合相等，互为父子集

s4 = {1,2,3}
s5 = {1,2}res = s4.issubset(s5)  # False 判断s4是否是s5的子集
res1 = s4.issuperset(s5)  # True 判断s4是否是s5的父集

去重操作

集合的去重操作有局限性，只能对不可变类型的数据进行去重，并且无法保证原来的顺序。针对可变类型数据的去重操作，需要自己编写代码完成功能。

# 去掉列表中重复的字典
l=[{'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 = []
for info in l:if info not in new_l:new_l.append(info)l = new_l
l = new_l

len()

集合中元素的数量

a = {1, 2, 3, 4}
print(len(a))  # 4

成员运算

判断某个元素是否包含在集合中，结果是True或者False

print(1 in a)  # True
print(5 not in a)  # True

循环遍历

for i in a:print(a)

其他内置方法

discard() remove() pop()

# discard()删除指定元素，元素不存在不会报错，do nothing
a = {1, 2, 3, 4}
a.discard(5)
print(a)  # {1, 2, 3, 4}
a.discard(4)
print(a)  # {1, 2, 3}# remove()删除指定元素，元素不存在报错
a.remove(4)  # KeyError: 4# pop()随机删除，返回被删除的元素
res = a.pop()
print(res)  # 1

update()

使用另一个集合对当前集合进行更新，自动进行去重

a = {1, 2, 3, 4}
a.update({1, 2, 3, 4, 5})
print(a)  # {1, 2, 3, 4, 5}

add()

为集合增加新的值

a.add(8)

isdisjoint()

判断两个集合是否完全独立，没有相同的部分

print(a.isdisjoint({1,2,3}))  # False