# #  集合：
# se1 =  { 1,3,4,5,'a'} # 如果直接添加元素，不能直接添加可变元素
# se2 = set()      #   定义一个空集合
# se3 = {'a'}      #   定义个单元素的集合
# print(se1)       #   {'a', 1, 3, 4, 5}  证实 set 是无序的
# ##  唯一性，去重，

# #   交集       两个集合中相同元素组成的集合
# se1 = { 1,3,4,5 }
# se2 = { 2,3,4,6 }
# print( se1 & se2 )      #  {3, 4}

# #    并集   两个集合中所有不同元素组成的集合
# se1 = { 1,3,4,5 }
# se2 = { 2,3,4,6 }
# print( se1 | se2 )      # {1, 2, 3, 4, 5, 6}

# #   差集
# se1 = { 1,3,4,5 }
# se2 = { 2,3,4,6 }
# print( se1 - se2 )      # {1, 5} 输出se1存在，se2不存在的，
# print( se2 - se1 )      # {2, 6}} 输出se2存在，se1不存在的，

# 集合的方法 （可变的数据类型）
# se1 = { 1,3,4,5 }
# se1.add('abc')            #    添加进集合    {1, 3, 4, 5, 'abc'}
# se1.update( 'fkoi')         #   拆分后添加每个元素进集合（不可以是嵌套的列表 ）{1, 'i', 'f', 3, 4, 5, 'o', 'k'}
# se1.pop()                   #    弹出一个元素
# se1.remove(4)                 #   删除指定元素   {1, 3, 5}      删除不存在则报错
# se2 = { 1,4 }
# print( se2.isdisjoint(se1) )    #   判断集合是否存在交集，是则返回 False
# print( se1.issuperset(se2) )    #   判断 se2j 是否为 se1 的子集合，是则返回 True

# 字典　　　　（无序）
　　key 不可以是 列表，字典 ，value 可以是任意类型，
#   可变的散列类型，以键值对的形式 key : value 存储数据
# di1 = { 'key':'value' }
#     key 的值是唯一的，不能是可变类型
#     value 可以是可变类型
#    其是无序的

# 字典的方法
  di = dict()     #  di{}
  di.clear()      #   清空字典
  di.setdefault(1,3)   #  如果 key 存在则查询，如果 不存在则添加，
di = { 1:2, 3:4, 5:5 }
　del di[ kye的值 ]  　　　　删除指定的 key 的键值
  di.pop(1)               #  删除指定的 key 的键值对并返回， 不存在则报错
  di.popitem()            #  随机删除，
　x = di[ kye的值 ]　　　　　　获取指定 key 的 value
  x = di.get(0)            #  获取指定 key 的 value ，不存在则返回 None
　x = di.get( key,返回值 )　# 获取指定 key 的 value ，不存在则返回 参数2的值，　
  x = di.keys()               #  取出所有的键 key     dict_keys([1, 3, 5])
　　for i in di.keys():
　　　　print( i )　　　　　　　　迭代 key 值 
  x = di.values()             #  取出所有的 value       dict_values([2, 4, 5])
　　for i in di.values():
　　　　print( i )　　　　　　　　迭代 values 值
　　for i in di.keys():　　　　　取 key ，values 值 
    　 print(i,di[i])

　　for k,v in di.items():　　　　　取 key ，values 值 
    　 print(k,v)
  x = di.items()                #   取出所有的键值对
  di.update({1:2,2:3,5:1})        #   将新的字典和老的字典整合，key 重复的，瓣的覆盖老的

#   返回个新字典，key 是第一个参数的拆分，value 是第二个参数
di = dict.fromkeys((1,3,4,5,7),'斌彬')        #   {1: '斌彬', 3: '斌彬', 4: '斌彬', 5: '斌彬', 7: '斌彬'}
print(di)

  **kwargs

运算符：
　　　　**　　　　　　　　　　　　　　　---->>　　幕运算
　　　　+，-　　　　　　　　　　　　　　---->>　　一元运算（正负号）
　　　　*，/，%　 
　　　　+，-　　　　　　　　　　　　　　---->>　　算术运算符
　　　　<，>,<=,>=　 　　　　　　　　　---->>　　比较运算符
　　　　=，%=，/=，-=，+=，*=，**=　　---->>　　赋值运算符
　　　　is, is not 　　　　　　　　　　---->>　　身份运算符
　　　　in, not in 　　　　　　　　　　---->>　　成员运算符
　　　　not,  and,  or　　　　　　　　---->>　　逻辑运算符

isinstance( 1, int )　　　　判断参数1，是否为参数2的类型

　　可变数据类型：列表list，字典dict；

　　不可变数据类型：整型int、浮点型float、字符串型string和元组tuple。

用一句话来概括上述过程就是：“python中的不可变数据类型，不允许变量的值发生变化，如果改变了变量的值，相当于是新建了一个对象，而对于相同的值的对象，在内存中则只有一个对象，内部会有一个引用计数来记录有多少个变量引用这个对象；可变数据类型，允许变量的值发生变化，即如果对变量进行append、+=等这种操作后，只是改变了变量的值，而不会新建一个对象，变量引用的对象的地址也不会变化，不过对于相同的值的不同对象，在内存中则会存在不同的对象，即每个对象都有自己的地址，相当于内存中对于同值的对象保存了多份，这里不存在引用计数，是实实在在的对象。