版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
1.字典(dict)
字典：类似json数据，在python中，以键值对的形式定义在{}中的数据，就是字典
特点：{key:value}，key键是唯一的，不能重复，value值可以重复，字典是无序的,字典和列表一样是可变的数据类型。
- 创建及表示
# 创建空字典
d1 = {}
# 创建非空字典方式 1：直接使用{}
dict1 = {"name":"张三","age":18}
print(dict1) # {'name': '张三', 'age': 18}
# 创建非空字典方式 2：使用关键字参数
dict2 = dict(name="李四",age=18)
print(dict2) # {'name':'李四','age':18}
# 创建非空字典方式 3：使用zip()函数进行配对，zip配对的序列以较短长度的序列为准
keys = ["name","age","sex","job"]
values = ["小强",20,"男","coder"]
print(dict(zip(keys,values))) # {'name': '小强', 'sex': '男', 'age': 20, 'job': 'coder'}
# 创建非空字典方式 4：使用一个可迭代的键序列和相同的值value创建，根据需要修改值
keys = ["name","age","sex","job"]
print(dict.fromkeys(keys,None)) # {'job': None, 'sex': None, 'name': None, 'age': None
# 创建字典的方法还有推导式方法，在后面介绍推导式的时候再说
- 查【获取元素】
字典通过键(key)来获取对应的值value
dict1 = {"a":1,"b":2,"c":3,"d":4,"e":5}
# 使用key 键来获取值 value
print(dict1["a"]) # 1
# 使用dict.get(key)来获取值
print(dict1.get("b")) # 2
# 获取所有的键名 key，返回一个包含所有key的可迭代对象，如果要使用该数据，则可以进行类型转换
print(dict1.keys()) # dict_keys(['e', 'c', 'b', 'd', 'a'])
s = dict1.keys()
print(list(s)) # ['e', 'c', 'b', 'd', 'a']
# 获取所有的键值 value，返回一个包含所有value的可迭代对象
print(dict1.values()) # dict_values([3, 4, 5, 2, 1])
# 获取所有的键值对 items ，返回一个类似列表包元组的可迭代对象
print(dict1.items()) # dict_items([('c', 3), ('d', 4), ('e', 5), ('b', 2), ('a', 1)])
- 增
dict1 = {}
# 字典中添加元素,直接添加的方法是 变量名[key] = value
dict1["a"] = 1
dict1["b"] = 2
print(dict1) # {"a":1,"b":2} 如果原字典中已有key，则会修改原来的值 value
# setdefault(key,value) 如果原字典中没有该键，则添加，返回你添加的值，有则查询出原键值 value
dict1.setdefault("c",3)
print(dict1.setdefault("c",3)) # 3
print(dict1) # {'a': 1, 'b': 2, 'c': 3}
d = dict1.setdefault("a",4)
print(d) # 1
print(dict1) # {'a': 1, 'b': 2, 'c': 3}
- 删
dict1 = {"a":1,"b":2,"c":3,"d":4}
# pop(key) 根据键名删除，并获得键值 value
print(dict1.pop("a")) # 1
print(dict1) # {'b': 2, 'c': 3, 'd': 4}
# popitem() 在字典中删除最后一对键值对(随机，因为字典是无序的)，并以元组的形式获得该键值对(key,value)
print(dict1.popitem()) # ('f', 6)
print(dict1) # {'b': 2, 'c': 3}
# del 删除
del dict1["c"]
print(dict1) # {'b': 2}
# clear 清空
dict2 = {"a":1,"b":2,"c":3,"d":4}
dict2.clear()
print(dict2) # {}
- 改
dict1 = {"a":1,"b":2,"c":3}
# dict[key] = value 直接根据键名修改
dict1["a"] = 10
print(dict1) # {"a":10,"b":2,"c":3}
# update({key1:value1,key2:value2,...}) 批量修改,存在的键直接修改，不存在的键添加
dict1.update({"a":"a","b":"x","name":"zhangsan"})
print(dict1) # {"a":"a","b":"x","c":3,"name":"zhangsan"}
2.集合（set）
集合：python中集合的概念就和数学中的集合差不多，元素唯一性，无序性，但与数学中不同的是python的集合可以添加和删除元素。
- 创建【记住三个特性：元素唯一性，无序性，元素是不可变类型】
1、使用{}，set()这样创建的集合都是可变集合，这里的可变指的是，添加和删除元素，不能修改元素，也就是说这种方式创建的集合是不可哈希的【unhashable】，可哈希，就是不可变的序列，不可哈希当然就是可改变的序列。
2、使用 frozenset() 方法创建的集合就是完全不可变的集合，也就是可哈希的【hashable】
# 直接使用 {} 创建
s1 = {1,2,3,4,5,6,7}
print(type(s1)) # <class 'set'>
print(s1) # {1,2,3,4,5,6,7}
# 使用 set()创建,把数据直接丢进去进行了，放可迭代的数据，相当于转换类型
set2 = set("123456")
print(set2) # {'3', '2', '1', '6', '5', '4'}
set3 = set([1,2,3,4,1,2,3])
print(set3) # {1,2,3,4}
set4 = set({"a":1,"b":2,"c":3})
print(set4) # {'c', 'b', 'a'} 如果放进去的是字典，则会以键为元素创建集合
# 创建不可变集合
set3 = frozenset("55353003545")
print(set3) # frozenset({'0', '5', '3', '4'}) 集合最有效的一点就是去重
- 增
# add 添加单个元素
set1 = {1,2,3,4}
set1.add("hello")
print(set1) # {1，2，3，4，"hello"}
# update 添加多个元素,添加可迭代对象,单个元素也得是可迭代对象，不是可迭代对象会报错，与add不同的是相当于将可迭代数据打碎添加进去
set1.update("abcd")
print(set1) # {1, 2, 3, 4, 5, 'd', 'c', 'a', 'b'}
set1.update(10) # set1.update(10) TypeError: 'int' object is not iterable
- 删
# pop 随机删除并获得一个元素，集合为空则报错
set1 = {"a","b","c","d","e"}
print(set1.pop()) # c
print(set1) # {'a', 'd', 'b', 'e'}
# remove 指定值删除，如果不存在，则会报错 KeyError
set1.remove("a")
print(set1) # {'d', 'b', 'e'}
# discard() 指定值删除，存在则删除，不存在也不会报错
set1.discard("b")
print(set1) # {"d","e"}
# clear() 清空
set1,clear()
print(set1) # set()
- 其他方法 ，要传入参数的，都是可迭代对象
# 求交集 &
a = {1,2,3}
b = {3,4,5}
print(a & b) # {3}
# 求并集 |
print(a | b) # {1, 2, 3, 4, 5}
# 求差集 -
print(a - b) # {1,2}
print(b - a) # {4,5}
# 判断a 是否是b 的子集
print(a.issubset(b)) # False
# 判断是否 不存在 交集
print(a.isdisjoint(b)) # False
# 判断 b 是否是 a 的子集
print(a.issuperset(b)) # False
# different() 求不同，差集
print(a.difference(b)) # {1,2}
print(a.difference("ss")) # {1,2,3}
# intersection() 求相同，交集
print(a.intersection(b)) # {3}
print(a.intersection("faf")) # set() 空集
# 求并集
print(a.union(b)) # {1，2，3，4，5}
print(a.union("fasfs")) # {1, 2, 3, 's', 'a', 'f'}
集合最常用的还是给其他序列去重
list1 = [1,2,2,3,3,2,3,4,4]
print(list(set(list1))) # [1, 2, 3, 4]
tuple1 = (1,2,3,1,2,3,4)
print(tuple(set(tuple1))) # (1, 2, 3, 4)
# 其他类型同理，都是类型转换去重。说白了，就是利用集合的元素唯一性来去重，唯一不好的一点，就是有序数组用集合去重后，顺序会改变，所以这种办法只适用于不要求元素顺序的情况下
二进制字节数据（bytes）
二进制数据主要用于存储数据，编码/解码的时候用到
str1 = "你好"
str2 = str1.encode()
print(str2,type(str2)) # b'\xe4\xbd\xa0\xe5\xa5\xbd' <class 'bytes'>
# 还有就是图片/音视频等文件进行传送、存储在电脑上时，底层就是存储的字节数据
下面就以爬一张图片简单说一下
import requests
# 从网上找一张图片，拿到他的url
url = "http://photocdn.sohu.com/20111207/Img328224894.jpg"
# 使用requests库爬取该图片的数据
res = requests.get(url)
# 有兴趣的可以看一下，爬下来的图片数据就是字节码数据
print(res.content) # content 方法就是获取字节数据
# 爬到的数据就是字节类型的数据，写入文件的时候，采用wb模式以二进制的形式写入
with open("a.jpg","wb")as f:
f.write(res.content)
这就是图片的一部分字节数据，将爬取到的数据写入文件后，就可看到图片了
待更新！！！