Python数据类型

# 列表 #

    #查  切片 []

        print(a)#打印所有列表
        print(a[1:3]) #从索引1开始到3结束，但是不包括3
        print(a[1::2]) #从索引1开始到结束，步长为2,隔一个去取
        print(a[1:-1]) #从索引1开始到倒数第二
        print(a[1::-1]) #从索引1开始到结束，从右往左取
        print(a[-2::-1]) #从右往左取，从倒数第二个开始到最左边（结束）
        print(a[1::-1]) #从右往左取，从索引为1开始到结束
        
        b=a.count("ligang")#根据内容查找该元素在列表中出现的次数（计数）
        print(b)
        inde=a.index('sanpang')#根据内容找其对应的位置（索引）
        print(inde)
        conten='sanpang' in a#in的用法，判断元素是否在列表中，在就返回True，否则返回False
        print(conten)

    #添加 append insert

        a.append('wangyuan')#直接追加在列表最后面
        a.insert(2,'liyifen')#设置索引，指定添加位置，可以添加到任意位置
        print(a)
        a.extend(t)#扩展列表，将2个列表合并，这里将t列表融入到a列表中
        print(a)

    #修改

    　　a[1]='wangmei'#根据a[index]取出列表中的元素，然后重新赋值
        print(a)
        a[1:4]=['a','b']#切片取出列表中的元素，取出元素为列表，赋值也需要列表，如果重新赋值的元素个数小于取出的元素个数，则默认删除
        print(a)

    #删除 remove pop del

        remove("内容")
        a.remove('wuchao')#根据内容删除，不能一次删多个
        print(a)

        pop(index)#不加索引默认删除列表的最后一个元素
        a.pop(1)#根绝索引删除
        b=a.pop(2)#pop删除之后会返回删除的内容
        print(a)

        del a, del a[index]
        del a[1]#直接根据索引删除内容、
        print(a)
        del a#直接删除列表a

        a.clear() 清空列表中的元素
        print(a)

    #排序

        t.sort()#排序,默认升序
        print(t)
        a.reverse()#排序,将原有的列表元素倒置
        print(a)1
        t.sort(reverse=True)#先将列表t排序，在倒置，reverse默认为False
        print(t)

    #身份判断

        tp=type(a) is list#判断a的类型是否为列表，是返回True，否则返回False
        print(tp)

#元组#
    Python 的元组与列表类似，不同之处在于元组的元素不能修改。
    元组使用小括号，列表使用方括号。
    元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
    元组与字符串类似，下标索引从0开始，可以进行截取，组合等。
    ## 创建空元组

 tup = ()

    ##元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：
        

tup1 = (5,)

    #访问元组，元组可以使用下标索引来访问元组中的值

        print(tup1[2])#读取第三个元素
        print(tup2[2:6])#截取元素，从第三个开始到第6个元素不包括第6。
        print(tup2[-2])#反向读取；读取倒数第二个元素

    #修改元组，元组中的元素值是不允许修改的，但我们可以对元组进行连接组合

        tup3 = tup1+tup2
        print(tup3)

    #删除元组,元组中的元素值不允许删除，但可以使用del语句来删除整个元组

　　　　del tup3

   

   #in 语句，存在返回true,不存在返回false

　　　　print(1 in tup3)

   

   #元组运算符，与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组

        len((1, 2, 3))            结果3 #计算元素个数
        (1, 2, 3) + (4, 5, 6)    结果(1, 2, 3, 4, 5, 6)    #连接
        ('Hi!',) * 4            结果('Hi!','Hi!','Hi!','Hi!')#复制
        3 in (1, 2, 3)            结果True    #元素是否存在
        for x in (1, 2, 3): 
            print (x,)            结果1 2 3    #迭代

    #元组内置函数

        print(len(tup3))#元组tup3的长度
        print(max(tup2))#读取元组tup2中的最大值，只能比较数值
        print(min(tup2))#读取元组tup2中的最小值，只能比较数值
        print(tuple(list))#将列表转换为元组

# 字典 #

    字典是另一种可变容器模型，且可存储任意类型对象；无序，键唯一。
    字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
        d = {key1 : value1, key2 : value2 }
    键必须是唯一的，但值则不必。
    值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
    一个简单的字典实例：
        dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

    #访问字典里的值

        #把相应的键放入到方括号中
        dic = {"name":"ccy","age":23,"address":"安徽"}
        print(dic["name"],dic["age"])#根据键取值

    #字典的修改

        #向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
        dic["age"]=33#键存在，不改动，修改字典中相应的键对应的值
        print(dic)#此时对应的键值为33
        dic["sex"]="男"#键不存在，在字典中中增加新的键值对
        ret = dic.setdefault("age",33)#键存在，不改动，返回字典中相应的键对应的值
        print(ret)  #23
        ret1 = dic.setdefault("sex","男")#键不存在，在字典中中增加新的键值对，并返回相应的值
        print(dic)#{'name': 'ccy', 'age': 23, 'address': '安徽', 'sex': '男'}
        print(ret1) #男
        
        print(dic.keys())#返回字典中所有的键
        print(dic.values())#返回字典中所有的值
        print(dic.items())#返回字典中所有的键值对,以列表形式返回
        dic.update(dic1)#将两个字典拼接，如果键存在，则替换值，键不存在，则直接后面添加

    #字典的删除

        #能删单一的元素也能清空字典
        dic.clear() # 清空字典
        del dic['name'] #删除字典中指定键值对
        del dic #删除整个字典
        print(dic.pop("name"))#删除字典中指定键值对，并返回该键值对的值
        ret = dic.popitem()#删除最后一组键值对，并以元组方式返回值

    #字典的其他用法

        #in 的用法
        print(5 in dic)#判断参数5在不在字典dic里面，存在返回True,不在返回False
        

        #字典迭代，for用法
        for i in dic:
            print(i,dic[i])#键值一一对应，高效
        
        for i,v in dic.items():#键值一一对应，需要Items转换dict_items类型，较慢
            print(i,v)

        #dict.get()返回指定键的值，如果值不在字典中返回默认值 None。
        dict = {'Name': 'Runoob', 'Age': 27}
        print ("Age 值为 : %s" %  dict.get('Age'))
        print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))

        #len(dict) 计算字典元素个数，即键的总数
        #str(dict) 输出字典，以可打印的字符串表示
        #type(dict) 返回输入的变量类型，如果变量是字典就返回字典类型。

#字符串（String）#

        字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。
        str = "this is bnanana"
        print(str*4)#字符串的乘运算
        print(str[4:])#字符串的切片，截取
        print(str[4::-1])#字符串的反向切片，截取
        print("123"+str)#字符串用“+”进行拼接
        #in 的用法
ot in 则相反
        print("i" in str)#判断"i"是否在字符串str里，在的话返回true,否则返回false
        
        #原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
        print(R"456
123")#原始字符串,相当于转义了

        print(r"456
123")#原始字符串,相当于转义了

# 字符串格式化输出： #
    占位符：
       %s  s = string
       %d  d = digit 整数
       %f  f = float 浮点数，约等于小数
    

    试例：
    name = input("Name:")
    age = int(input("Age:"))
    job = input("Job:")
    salary = input("Salary:")

    if salary.isdigit(): #长的像不像数字,比如200d , '200'
        salary = int(salary)
    #else:
        #exit("must input digit") #退出程序

    msg = '''
    --------- info of %s --------
    Name: %s
    Age : %d
    Job : %s
    Salary: %f
    You will be retired in %s years
    -------- end ----------
    ''' % (name,name ,age ,job ,salary, 65-age )

    print(msg)

## python字符串格式化符号 ##
        符号        描述
        %c        格式化字符及其ASCII码
        %s        格式化字符串
        %d        格式化整数
        %u        格式化无符号整型
        %o        格式化无符号八进制数
        %x        格式化无符号十六进制数
        %X        格式化无符号十六进制数（大写）
        %f        格式化浮点数字，可指定小数点后的精度
        %e        用科学计数法格式化浮点数
        %E        作用同%e，用科学计数法格式化浮点数
        %g        %f和%e的简写
        %G        %f 和 %E 的简写
        %p        用十六进制数格式化变量的地址

## 格式化操作符辅助指令 ##
        符号          功能
        *          定义宽度或者小数点精度
        -          用做左对齐
        +          在正数前面显示加号( + )
        <sp>      在正数前面显示空格
        #在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
        0          显示的数字前面填充'0'而不是默认的空格
        %          '%%'输出一个单一的'%'
        (var)      映射变量(字典参数)
        m.n.      m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

## 字符串的内置方法 ##
        #join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
        
        print(str.count("i"))#统计元素个数
        print(st.endswith('tty3')) #  判断是否以某个内容结尾
        print(st.startswith('he')) #  判断是否以某个内容开头
        print(str.center(50,'*'))#居中，指定50字符，不够用指定的数据代替
        print(str.find("i"))#查找字符串中第一个元素，并返回其索引值,未找到则返回-1
        print(str.rfind("i"))#从右边查找字符串中的第一个元素，并返回其索引值,未找到则返回-1
        print(str.index("i"))#跟find一样，找到返回一个索引值，找不到报错

        #格式化输出.format  / .format.map     
        #str1 = "my {name} is {who} and {age} 岁"
        print(str1.format(name="chen",who="ccy",age="12"))#格式化输出
        print(st.format_map({'name':'alex','age':22}))#格式化输出的,传入的是键值对
        print('My tLtle'.lower())#将字符串全部小写
        print('My tLtle'.upper())#将字符串全部大写
        print(str.islower())#判断字符串是否全小写
        print(str.isupper())#判断字符串是否全大写
        print('	My tLtle
'.strip())#
        print('My title title'.replace('itle','lesson',1))#
        print('My title title'.split('i',1))#
        print(str.isalnum())#判断字符串是否是一个数字，是的话返回true,不是则返回一个false
        print(str.isnumeric())#如果字符串全是数字则返回True,否则返回false
        print(str.isspace())#如果字符串全为空格，则返回True,否则为false
        print('My title title'.title())#每个元素的首字母大写
        print(str.replace("i","d",1))#将指定的字符i替换成d,1表示替换的个数，默认全部

        #strip()方法用于移除字符串头尾指定的字符（默认为空格）或字符序列，注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符
        print(str.strip("*"))#删除字符串左右指定的字符
        print(str.lstrip("*"))#删除字符串左边指定的字符
        print(str.rstrip("*"))#删除字符串右边指定的字符
        print(str.split(" ",1))#split()通过指定分隔符对字符串进行切片，1表示只对一个分隔符切片

# 字典 #
    字典是另一种可变容器模型，且可存储任意类型对象；无序，键唯一。
    字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
        d = {key1 : value1, key2 : value2 }
    键必须是唯一的，但值则不必。
    值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
    一个简单的字典实例：
        dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}


    #访问字典里的值
        #把相应的键放入到方括号中
        dic = {"name":"ccy","age":23,"address":"安徽"}
        print(dic["name"],dic["age"])#根据键取值


    #字典的修改
        #向字典添加新内容的方法是增加新的键/值对，修改或删除已有键/值对
        dic["age"]=33#键存在，不改动，修改字典中相应的键对应的值
        print(dic)#此时对应的键值为33
        dic["sex"]="男"#键不存在，在字典中中增加新的键值对
        ret = dic.setdefault("age",33)#键存在，不改动，返回字典中相应的键对应的值
        print(ret)  #23
        ret1 = dic.setdefault("sex","男")#键不存在，在字典中中增加新的键值对，并返回相应的值
        print(dic)#{'name': 'ccy', 'age': 23, 'address': '安徽', 'sex': '男'}
        print(ret1) #男
        
        print(dic.keys())#返回字典中所有的键
        print(dic.values())#返回字典中所有的值
        print(dic.items())#返回字典中所有的键值对,以列表形式返回
        dic.update(dic1)#将两个字典拼接，如果键存在，则替换值，键不存在，则直接后面添加


    #字典的删除
        #能删单一的元素也能清空字典
        dic.clear() # 清空字典
        del dic['name'] #删除字典中指定键值对
        del dic #删除整个字典
        print(dic.pop("name"))#删除字典中指定键值对，并返回该键值对的值
        ret = dic.popitem()#删除最后一组键值对，并以元组方式返回值

    #字典的其他用法
        dict.fromkeys(seq[, value])#seq 中元素做字典的键，value 为字典所有键对应的初始值，如：
        dic=dict.fromkeys(['host1','host2','host3'],'test')
        print(dic)#打印结果为{'host3': 'test', 'host1': 'test', 'host2': 'test'}
        dic=dict.fromkeys(['host1','host2','host3'],['test1','tets2'])
        print(dic)#打印结果为{'host2': ['test1', 'tets2'], 'host3': ['test1', 'tets2'], 'host1': ['test1', 'tets2']}

        #in 的用法
        print(5 in dic)#判断参数5在不在字典dic里面，存在返回True,不在返回False
        

        #字典迭代，for用法
        for i in dic:
            print(i,dic[i])#键值一一对应，高效
        
        for i,v in dic.items():#键值一一对应，需要Items转换dict_items类型，较慢
            print(i,v)

        #dict.get()返回指定键的值，如果值不在字典中返回默认值 None。
        dict = {'Name': 'Runoob', 'Age': 27}
        print ("Age 值为 : %s" %  dict.get('Age'))
        print ("Sex 值为 : %s" %  dict.get('Sex', "NA"))

        #len(dict) 计算字典元素个数，即键的总数
        #str(dict) 输出字典，以可打印的字符串表示
        #type(dict) 返回输入的变量类型，如果变量是字典就返回字典类型。
        
        

#字符串（String）#
        字符串是 Python 中最常用的数据类型。我们可以使用引号( ' 或 " )来创建字符串。
        str = "this is bnanana"
        print(str*4)#字符串的乘运算
        print(str[4:])#字符串的切片，截取
        print(str[4::-1])#字符串的反向切片，截取
        print("123"+str)#字符串用“+”进行拼接
        #in 的用法 ot in 则相反
        print("i" in str)#判断"i"是否在字符串str里，在的话返回true,否则返回false
        
        #原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
        print(R"456 123")#原始字符串,相当于转义了
        print(r"456 123")#原始字符串,相当于转义了

## python字符串格式化符号 ##
        符号        描述
        %c        格式化字符及其ASCII码
        %s        格式化字符串
        %d        格式化整数
        %u        格式化无符号整型
        %o        格式化无符号八进制数
        %x        格式化无符号十六进制数
        %X        格式化无符号十六进制数（大写）
        %f        格式化浮点数字，可指定小数点后的精度
        %e        用科学计数法格式化浮点数
        %E        作用同%e，用科学计数法格式化浮点数
        %g        %f和%e的简写
        %G        %f 和 %E 的简写
        %p        用十六进制数格式化变量的地址

## 格式化操作符辅助指令 ##
        符号          功能
        *          定义宽度或者小数点精度
        -          用做左对齐
        +          在正数前面显示加号( + )
        <sp>      在正数前面显示空格
        #在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
        0          显示的数字前面填充'0'而不是默认的空格
        %          '%%'输出一个单一的'%'
        (var)      映射变量(字典参数)
        m.n.      m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

## 字符串的内置方法 ##
        #join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
        
        print(str.count("i"))#统计元素个数
        print(st.endswith('tty3')) #  判断是否以某个内容结尾
        print(st.startswith('he')) #  判断是否以某个内容开头
        print(str.center(50,'*'))#居中，指定50字符，不够用指定的数据代替
        print(str.find("i"))#查找字符串中第一个元素，并返回其索引值,未找到则返回-1
        print(str.rfind("i"))#从右边查找字符串中的第一个元素，并返回其索引值,未找到则返回-1
        print(str.index("i"))#跟find一样，找到返回一个索引值，找不到报错

        #格式化输出.format  / .format.map     
        #str1 = "my {name} is {who} and {age} 岁"
        print(str1.format(name="chen",who="ccy",age="12"))#格式化输出
        print(st.format_map({'name':'alex','age':22}))#格式化输出的,传入的是键值对
        print('My tLtle'.lower())#将字符串全部小写
        print('My tLtle'.upper())#将字符串全部大写
        print(str.islower())#判断字符串是否全小写
        print(str.isupper())#判断字符串是否全大写
        print(' My tLtle '.strip())#
        print('My title title'.replace('itle','lesson',1))#
        print('My title title'.split('i',1))#
        print(str.isalnum())#判断字符串是否是一个数字，是的话返回true,不是则返回一个false
        print(str.isnumeric())#如果字符串全是数字则返回True,否则返回false
        print(str.isspace())#如果字符串全为空格，则返回True,否则为false
        print('My title title'.title())#每个元素的首字母大写
        print(str.replace("i","d",1))#将指定的字符i替换成d,1表示替换的个数，默认全部

        #strip()方法用于移除字符串头尾指定的字符（默认为空格）或字符序列，注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符
        print(str.strip("*"))#删除字符串左右指定的字符
        print(str.lstrip("*"))#删除字符串左边指定的字符
        print(str.rstrip("*"))#删除字符串右边指定的字符
        print(str.split(" ",1))#split()通过指定分隔符对字符串进行切片，1表示只对一个分隔符切片

# 集合（set） #

    集合可以通过可迭代对象（字符串、元组、列表等）进行创建；
    集合中的元素不可重复；
    集合中的元素无序排列。

#1.定义一个集合

    set0 = {"a","b","c"}#直接创建一个集合
    sets = set("hello")# 将字符串分解为单个字符，作为集合的元素创建集合
    sets1 = set(("hello","thanks","your"))# 将元组分解为单个元素，作为集合元素创建集合
    sets2 = set(["今天","明天","后天"])## 将列表分解为单个元素，作为集合元素创建集合
    print(set0)
    print(sets)
    print(sets1)
    print(sets2)   

 
#2.给集合添加一个元素,集合添加元素的方法有两种

    #添加单个元素,使用add(element)函数，参数element为集合允许添加的元素（例如数字、字符串、元组等）
    sets = set("hello")
    sets.add("s")
    print(sets)
    
    添加多个元素：使用update(iterable)函数，参数iterable为可迭代对象。
    sets = set("123")
    sets.update("4","5","6")
    print(sets)

#3.删除集合中的元素,集合删除元素的方法有两种。

    # 第一种：使用remove(element)方法删除指定元素，参数element为需要删除的元素。
    sets = set("123")
    sets.pop()#随机删除集合中的一个元素,返回删除的元素
    sets.remove("2")#删除集合中指定的元素
    sets.discard("2")#删除集合中指定的元素
    print(sets)
    #set 的discard 和 remove
    #使用discard和remove都可以删除set当中的元素，区别就是remove的元素在set当中没有的话会报错，而discard不会。
    #第二种：使用discard(element)方法删除指定元素，参数element为需要删除的元素。

#4、清空集合

    s = set(['Python','Java','C','C++','C#'])
    s.clear()#清空集合
    del s#直接从内存中删除集合s，这时打印会报错
    print(s)

#5、交集/并集/补集/差集

    #交集
    A = set("123456")
    B = set("456789")
    C = set("012789")
    
    print(A & B)#交集----A和B的交集部分
    print(A.intersection(B))#交集----A和B的交集部分
    print(A.intersection(B,C))#交集----A、B和C的交集部分

    #并集
    print(A | B)#并集----A和B去重后的全部内容
    print(A.union(B))#并集----A和B去重后的全部内容
    
    #补集
    print(A - B)#补集----A去除与B相交部分后的内容
    print(B - A)
    
    A.difference_update(B)#移除两个集合中都存在的元素
    print(A)#{'3', '1', '2'}

    #差集
    print(A ^ B)#差集----A和B不相交部分的全部内容
    print(A.difference(B,C))#差集----A和B和C不相交部分的全部内容
    print(A.symmetric_difference(B))#差集----A和B和C不相交部分的全部内容
    A.symmetric_difference_update(B)#移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
    print(A)

    #其他函数
    A = set("123456")
    B = set("456789")
    x = {"a", "b", "c"}
    y = {"f", "e", "d", "c", "b", "a"}
    print(A.isdisjoint(B))#判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
    
    print(x.issubset(y))#判断集合的所有元素是否都包含在指定集合中（判断x是否在y中），如果是则返回 True，否则返回 False
    print(x.issuperset(y))#判断指定集合的所有元素是否都包含在原始的集合中(判断y是否在x中)，如果是则返回 True，否则返回 False

# 集合（set） #
    集合可以通过可迭代对象（字符串、元组、列表等）进行创建；
    集合中的元素不可重复；
    集合中的元素无序排列。
#1.定义一个集合
    set0 = {"a","b","c"}#直接创建一个集合
    sets = set("hello")# 将字符串分解为单个字符，作为集合的元素创建集合
    sets1 = set(("hello","thanks","your"))# 将元组分解为单个元素，作为集合元素创建集合
    sets2 = set(["今天","明天","后天"])## 将列表分解为单个元素，作为集合元素创建集合
    print(set0)
    print(sets)
    print(sets1)
    print(sets2)    
#2.给集合添加一个元素,集合添加元素的方法有两种
    #添加单个元素,使用add(element)函数，参数element为集合允许添加的元素（例如数字、字符串、元组等）
    sets = set("hello")
    sets.add("s")
    print(sets)
    
    添加多个元素：使用update(iterable)函数，参数iterable为可迭代对象。
    sets = set("123")
    sets.update("4","5","6")
    print(sets)

#3.删除集合中的元素,集合删除元素的方法有两种。
    # 第一种：使用remove(element)方法删除指定元素，参数element为需要删除的元素。
    sets = set("123")
    sets.pop()#随机删除集合中的一个元素,返回删除的元素
    sets.remove("2")#删除集合中指定的元素
    sets.discard("2")#删除集合中指定的元素
    print(sets)
    #set 的discard 和 remove
    #使用discard和remove都可以删除set当中的元素，区别就是remove的元素在set当中没有的话会报错，而discard不会。
    #第二种：使用discard(element)方法删除指定元素，参数element为需要删除的元素。


#4、清空集合
    s = set(['Python','Java','C','C++','C#'])
    s.clear()#清空集合
    del s#直接从内存中删除集合s，这时打印会报错
    print(s)

#5、交集/并集/补集/差集
    #交集
    A = set("123456")
    B = set("456789")
    C = set("012789")
    
    print(A & B)#交集----A和B的交集部分
    print(A.intersection(B))#交集----A和B的交集部分
    print(A.intersection(B,C))#交集----A、B和C的交集部分

    #并集
    print(A | B)#并集----A和B去重后的全部内容
    print(A.union(B))#并集----A和B去重后的全部内容
    
    #补集
    print(A - B)#补集----A去除与B相交部分后的内容
    print(B - A)
    
    A.difference_update(B)#移除两个集合中都存在的元素
    print(A)#{'3', '1', '2'}

    #差集
    print(A ^ B)#差集----A和B不相交部分的全部内容
    print(A.difference(B,C))#差集----A和B和C不相交部分的全部内容
    print(A.symmetric_difference(B))#差集----A和B和C不相交部分的全部内容
    A.symmetric_difference_update(B)#移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
    print(A)

    #其他函数
    A = set("123456")
    B = set("456789")
    x = {"a", "b", "c"}
    y = {"f", "e", "d", "c", "b", "a"}
    print(A.isdisjoint(B))#判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False
    
    print(x.issubset(y))#判断集合的所有元素是否都包含在指定集合中（判断x是否在y中），如果是则返回 True，否则返回 False
    print(x.issuperset(y))#判断指定集合的所有元素是否都包含在原始的集合中(判断y是否在x中)，如果是则返回 True，否则返回 False