zoukankan      html  css  js  c++  java
  • 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

  • 相关阅读:
    Best HTTP
    Unity3D游戏轻量级xlua热修复框架
    线段树
    7.1
    BZOJ 3011: [Usaco2012 Dec]Running Away From the Barn( dfs序 + 主席树 )
    BZOJ 3585: mex( 离线 + 线段树 )
    2015暑假集训
    BZOJ 3398: [Usaco2009 Feb]Bullcow 牡牛和牝牛( dp )
    BZOJ 2693: jzptab( 莫比乌斯反演 )
    2015.7.31
  • 原文地址:https://www.cnblogs.com/ccy7863257/p/11883628.html
Copyright © 2011-2022 走看看