字典：

字典:是复合型数据
    定义:是具有键值映射关系的一组无序数据组合，可以修改 --》无序可变
    特点:
        标识符:{}
        关键字:dict
        无序数据，即没有索引值
        字典中的元素是 key:value 的形式存储数据 键值对
        key:是唯一的不能修改的数据，支持数据类型有:int, float, bool,str,元组
        value:可以修改的数据，支持任何数据类型

空字典;
    #1、通过 创建空字典,然后赋值
        a = {}
        a = dict()  # dict() 这样的方法去创建一个空字典; list(),tuple()
        
# a = {"key":"value"}   # 非空字典
# print(a["key"])       # 通过key值得到对应的value值

a.update({"key":{"key":"value"}})   
# update方法会先去字典里找key这个键值对，如果找到则更新这条数据，如果没找到则添加本条数据到字典中
a.update({
    "key1" : "value1",
    "key2": "value2",
    "key3": "value3",
})
print(a)        # 输出字典全部内容
# { ' key': '{ "key" : "value"}','key1': 'value1', 'key2': 'value2'，'key3 ': 'value3'}
print(a.keys())     # 输出字典所有 key值
# dict_keys([ ' key', 'key1' , 'key2 ', 'key3 ' ])

a = {"'name " :"长风","age " : "34","sxe ":"男"}
print(a)
# {'name' :'长风','age': '34', 'sxe': '男'}

# 虽然字典我们说是无序的,但是在数据存贮过程中是有序的
a = {"'name " :"长风","age " : "34","sxe ":"男"}
a.popitem()     # 从后往前删
print(a)
# { 'name' :'长风','age' : '34'}

a = {"'name " :"长风","age " : "34","sxe ":"男"}
a.pop("name")   # 删除字典里的一条数据
print(a)
# { 'age' : '34' , 'sxe' : '男'}

a = {"'name " :"长风","age " : "34","sxe ":"男"}
a[ "name"] = None   # 字典中的键值对必须一一对应删除和修改关系;
print(a)
# { 'name ' : None, 'age ' : '34','sxe ': '男'}

字典是无序,但是它的存贮过程是有序的;

集合：

集合是一组特定数据的无序集合，所有元素不会重复
特点:
    标识符:set()或者{}
    关键字:set
    数据类型:int,float, bool,元组，
    不支持：列表、字典、集合类型
    无序数据，即没有索引值
    所有数据不会重复

使用场景:
    进行成员关系测试
    刮除重复元素:身份证号码，订单号

    # dict和set这样的数据类型，set完全无序，dict是存储过程是有序的

# 增加
    s3 = {4,2，3, 'python '}
    s3.add( ' hello huace ')
    s3.add( "test")
    print(s3)
    # {'python'，2，3，4, 'test','hello huace'}

# 删除
    # s3.pop()  # 随机删除集合内一个数据
    # s3.remove("python")   # 删除集合内制定数据，如果集合内没有此数据会报错 KeyError:'python'
    # set 和 dict 都会触发 KeyError ，一般情况出现KeyError就是 字典或集合中出了问题

集合运算
    并集:集合1 │ 集合2    或者      集合1.union(集合2)
    交集:集台1 & 集合2    或者      集合1.intersection(集合2)
    差集:集合1 - 集合2    或者      集合1.difference(集合2) [不一样的东画] 
    
    集合中不能有重复的内容，所以集合可以去重；
    
    s1={1，2，3，4，5，6}
    s2= {10，20，30，3，4，5}
    
    # 并集
    print(s1 | s2)
    # {1，2，3，4，5，6，10，20,30}
    
    # 交集
    print(s1 & s2)
    # {3,4,5}
    
    # 差集1:s1中存在，但是s2中不存在的数据
    print(s1 - s2)
    # {1,2,6}
    
    # 差集2:s2中存在，但是s1中不存在的数据
    print(s2 - s1)
    # {10,20,30}

在python中，我们常用的数据类型:str、int、list,dict、tuple、bool
不常用的数据:set/float

a = "str"   # str
b = "int"   # str
a1 = "1"    # str
a2 = "0.1235"   # str
a3 = 1      # int
a4 = 1.0    # float
a5 = "[1,2,3,4,5]"  # str
a6 = [1，2，3，4，5]    # list 列表
a7 = {""，""，""} # set 集合
a8 = {"name" : 1，"":1,"a" :22}  # dict 字典
a9 = (1,'a',3.13,'hello',True,[1，2，3],('a', 'b ','c ')) # tuple 元组
a10 = ()    # 空元组 (或者 a10 = tuple())
a11 = []    # 空列表 (或者 a11 = list())
a12 = {}    # 空字典 (或者 a12 = dict()) 
a13 = set() # 空集合只能用 set() 构建

冒泡排序:

list1 = [16,29,90,9,13,2,34,56,773,735,883,834,56,34,13]
# len == 获取长度
# range() 通过整数返回，一次返回内容
# list1[0], list1[1] = list1[1], list1[0]   # 实现list1中 2个数据的位置互换

a = 0   # 统计循环次数
# 方式一:
for i in range(len(list1)):
    for j in range(len(list1) - 1):
        a += 1
        if list1[j] > list1[j + 1]:   # 升序排列
            list1[j], list1[j + 1] = list1[j + 1], list1[j]
print(list1)
print("程序循环了 {} 次".format(a),end="")    # 循环210次


# 方式二:
for i in range(len(list1) -1):
    for j in range(len(list1) - i - 1):
        a += 1
        if list1[j] > list1[j + 1]:
            list1[j], list1[j + 1] = list1[j + 1], list1[j]
print(list1)
print("程序循环了 {} 次".format(a),end="")    # 循环105次