zoukankan      html  css  js  c++  java
  • Python-04-数据结构

    一、数字

    整数

      Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例如:1100-80800,等等。

      计算机由于使用二进制,所以,有时候用十六进制表示整数比较方便,十六进制用0x前缀和0-9,a-f表示,例如:0xff000xa5b4c3d2,等等。

    浮点数

      浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比如,1.23x109和12.3x108是完全相等的。浮点数可以用数学写法,如1.233.14-9.01,等等。但是对于很大或很小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x109就是1.23e9,或者12.3e8,0.000012可以写成1.2e-5,等等。

      整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮点数运算则可能会有四舍五入的误差。

    常用方法:

    • int    将字符串转化为数字
    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    a = '123'
    print(type(a), a)
    a = int(a)
    print(type(a), a)
    
    #输出
    <class 'str'> 123
    <class 'int'> 123
    
    • bit_length   当前数字的二进制至少用几位表示
    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    age = 10
    r = age.bit_length()
    print(r)
    
    #输出
    4
    

     二、字符串

    1. 常用方法

    • capitalize    把字符串的第一个字符大写

        mystr.capitalize()

    • casefold     lower    转换 mystr 中所有大写字符为小写    casefold可以识别特殊字符

        mystr.lower()

    • upper    转换 mystr 中的小写字母为大写

        mystr.upper()

    • swapcase    大小写切换

        mystr.swapcase()

    test = 'sFHVahKHJss'
    v = test.swapcase()
    print(v)
    
    #输出
    SfhvAHkhjSS
    
    • center    返回一个原字符串居中,并使用fillchar填充至长度 width 的新字符串

        mystr.center(width, fillchar=” ”)

    • count    返回str在start和end之间 在 mystr里面出现的次数

        mystr.count(str, start=0, end=len(mystr))

    • endswith    检查字符串是否以obj结束,如果是返回True,否则返回 False.

        mystr.endswith(obj)

    • startswith    检查字符串是否是以 obj 开头, 是则返回 True,否则返回 False

        mystr.startswith(obj)

    • find    检测str是否包含在 mystr中,如果包含返回开始的索引值,否则返回-1

        mystr.find(str, start=0, end=len(mystr))

    • index    跟find()方法一样,只不过如果str不在 mystr中会报一个异常

        mystr.index(str, start=0, end=len(mystr))

    • format    字符串格式化
    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    test = 'my name is {name},age is {age}'
    print(test)
    mstr = test.format(name='Tom', age=15)
    print(mstr)
    
    #输出
    my name is {name},age is {age}
    my name is Tom,age is 15
    
    # format的三种玩法
    res1 = '{} {} {}'.format('egon', 18, 'male')
    res2 = '{1} {0} {1}'.format('egon', 18, 'male')
    res3 = '{name} {age} {sex}'.format(sex='male', name='egon', age=18)
    print(res1)
    print(res2)
    print(res3)
    
    #输出
    egon 18 male
    18 egon 18
    egon 18 male
    
    • format_map    类似于format,但传入的参数是一个字典
    #!/usr/bin/env python
    # -*- coding:utf-8 -*-
    test = 'my name is {name},age is {age}'
    print(test)
    mstr = test.format_map({"name":"Tom", "age":"15"})
    print(mstr)
    
    #输出
    my name is {name},age is {age}
    my name is Tom,age is 15
    
    • replace    把 mystr 中的 str1 替换成 str2,如果 count 指定,则替换不超过 count 次

        mystr.replace(str1, str2,  mystr.count(str1))

    name = 'alex say :i have one tesla,my name is alex'
    print(name.replace('alex', 'SB', 1))
    
    #输出
    SB say :i have one tesla,my name is alex
    
    • split    以 str 为分隔符切片 mystr,如果 maxsplit有指定值,则仅分隔 maxsplit 个子字符串

        mystr.split(str=" ", maxsplit)

    name = 'root:x:0:0::/root:/bin/bash'
    print(name.split(':'))  # 默认分隔符为空格
    name = 'C:/a/b/c/d.txt'  # 只想拿到顶级目录
    print(name.split('/', 1))
    
    #输出
    ['root', 'x', '0', '0', '', '/root', '/bin/bash']
    ['C:', 'a/b/c/d.txt']
    
    • rsplit    类似split,但从右边开始
    • title    把字符串的每个单词首字母大写

        mystr.title()

    • ljust    返回一个原字符串左对齐,并使用fillchar填充至长度 width 的新字符串

        mystr.ljust(width, fillchar=” ”)

    • rjust    返回一个原字符串右对齐,并使用fillchar填充至长度 width 的新字符串

        mystr.rjust(width, fillchar=” ”)

    • zfill    返回指定长度的字符串,原字符串右对齐,前面填充0

        mystr.zfill(width)

    • lstrip    删除 mystr 左边的空白字符   也可以去除指定的字符

        mystr.lstrip()

    #!/usr/bin/env python
    # -*- encoding:utf-8 -*-
    test = 'asdfghh'
    v = test.lstrip('8assdf') # 消除所有匹配到的字符
    print(v)
    
    #输出
    ghh
    
    • rstrip    删除 mystr 右边的空白字符   也可以去除指定的字符

        mystr.rstrip()

    • strip    删除mystr字符串两端的空白字符   也可以去除指定的字符

        mystr.strip()

    • rfind    类似于 find()函数,不过是从右边开始查找

        mystr.rfind(str, start=0,end=len(mystr) )

    • rindex   类似于 index(),不过是从右边开始.

        mystr.rindex( str, start=0,end=len(mystr))

    • partition    把mystr以str分割成三部分,str前,str和str后

        mystr.partition(str)

     

    test = 'ahjsyklsuiyska'
    v = test.partition('s')
    print(v)
    
    #输出
    ('ahj', 's', 'yklsuiyska')
    

     

    • rpartition    类似于 partition()函数,不过是从右边开始.

        mystr.rpartition(str)

    • splitlines    按照行分隔,返回一个包含各行作为元素的列表

        mystr.splitlines()

    test = 'ahjsykls
    uiyska
    vjshgk
    dhvgks'
    v1 = test.splitlines(True)
    print(v1)
    v2 = test.splitlines(False)
    print(v2)
    
    #输出
    ['ahjsykls
    ', 'uiyska
    ', 'vjshgk
    ', 'dhvgks']
    ['ahjsykls', 'uiyska', 'vjshgk', 'dhvgks']
    
    • isupper    判断字符串否全是大写字母

        mystr.isupper()

    • islower    判断字符串否全是小写字母

        mystr.islower()

    • isalpha    如果 mystr 所有字符都是字母 则返回 True,否则返回 False

        mystr.isalpha()

    • isdigit    isdecimal    isnumeric    如果 mystr 只包含数字则返回 True 否则返回 False。isdigit可以判断一些特殊字符例如②。 isnumeric可以判断中文数字例如二。

        mystr.isdigit()

    #!/usr/bin/env python
    # -*- encoding:utf-8 -*-
    test = '②'
    v1 = test.isdecimal()
    v2 = test.isdigit()
    print(v1, v2)
    
    #输出
    False True
    test = '二'
    v1 = test.isdecimal()
    v2 = test.isdigit()
    v3 = test.isnumeric()
    print(v1, v2, v3)
    
    #输出
    False False True
    
    • isalnum    如果 mystr 所有字符都是字母或数字则返回 True,否则返回 False

        mystr.isalnum()

    • isspace    如果 mystr 中只包含空格,则返回 True,否则返回 False

        mystr.isspace()

    • istitle    如果字符串的每个单词的首字母都是大写,则返回True,否则返回False

        mystr.istitle()

    • isprintable    判断字符串是否能够被打印

        mystr.isprintable()

    test = '
    '
    v = test.isprintable()
    print(v)
    
    #输出
    False
    
    • join    将字符串、元组、列表中的元素以mystr连接生成一个新的字符串

        mystr.join(str)

    mystr = ' '
    print(mystr.join(["haha", "hehe", "heihei"]))
    mystr = '-'
    print(mystr.join(["haha", "hehe", "heihei"]))
    
    # 运行结果:
    haha hehe heihei
    haha-hehe-heihei
    
    •  expandtabs 方法把字符串中的 tab 符号(' ')转为空格,tab 符号(' ')默认的空格数是 8。从头开始数,数到第一个 正好为8个空格,不足则补空格,如果还有 ,接着从第一个 数到第二个 仍然为8个空格,以此类推直到最后一个 结束。
        S.expandtabs([tabsize=8])
    #!/usr/bin/python3
     
    S = "this is	string example....wow!!!"
    print ("原始字符串: " + S)
    print ("替换 \t 符号: " +  S.expandtabs())
    print ("使用16个空格替换 \t 符号: " +  S.expandtabs(16))
    """
    以上实例输出结果如下:
    原始字符串: this is     string example....wow!!!
    替换 	 符号: this is string example....wow!!!
    使用16个空格替换 	 符号: this is         string example....wow!!!
    """
    
    #!/usr/bin/env python
    #-*- encoding:utf-8 -*-
    
    S = "username	email	password
    laiying	ying@q.com	123
    laiying	ying@q.com	123
    laiying	ying@q.com	123"
    v = S.expandtabs(20)
    print(v)
    

     

    • translate   替换字符串中指定的字符
    test = 'ahjsykliuiyjka'
    m = str.maketrans('aeiou','12345')
    v = test.translate(m)
    print(v)
    
    #输出
    1hjsykl353yjk1
    
    

     重点:

      1、strip,lstrip,rstrip

      2、lower,upper

      3、startswith,endswith

      4、format的三种玩法

      5、split,rsplit

      6、join

      7、replace

      8、isdigit

    2. 下标切片

    字符串中"下标"的使用

    字符串实际上就是字符的数组,所以支持下标索引。

    如果有字符串:name = 'abcdef',在内存中的实际存储如下:

    如果想取出部分字符,那么可以通过下标的方法,(注意python中下标从 0 开始)

    name = 'abcdef'
    print(name[0])
    print(name[1])
    print(name[2])
    
    运行结果:
    a
    b
    c

    切片

    切片是指对操作的对象截取其中一部分的操作。

    切片的语法:变量名[起始:结束:步长]

    注意:选取的区间属于左闭右开型,即从"起始"位开始,到"结束"位的前一位结束(包含起始位本身但不包含结束位本身)。结束位可以不写,那么默认按照步长一直到末尾。

    如果取出一部分,则可以在中括号[]中

    示例1:
    name = 'abcdef'
    print(name[0:3])  # 取下标0~2 的字符
    运行结果:
    abc
    
    示例2:
    name = 'abcdef'
    print(name[2:])  # 取下标为2开始到最后的字符
    运行结果:
    cdef
    
    示例3:
    name = 'abcdef'
    print(name[len(name)-1])  # 取下标为字符长度-1的字符
    print(name[-1])  # 取下标为倒数第一个的字符
    运行结果:
    f
    f
    
    示例4:
    name = 'abcdef'
    print(name[1:-1])  # 取第2个到倒数第2个字符切片
    print(name[0::2])  # 从第一个字符开始每次步长为2取切片
    运行结果:
    bcde
    ace
    
    示例5:
    name = 'abcdef'
    print(name[-1:-5:-1])  # 逆向取倒数第一个到倒数第4个字符切片
    print(name[-1::-1])  # 逆向取倒数第一个到末尾的字符切片
    print(name[::-1])  # 倒序字符的切片
    运行结果:
    fedc
    fedcba
    fedcba
    

     三、列表

    1. 添加元素("增"append, extend, insert)

    append:通过append可以向列表添加元素,并且默认添加在列表末尾。

    示例:

    namesList = ['tom', 'jerry', 'jhon']
    print("----添加之前,列表中的元素----")
    print(namesList)
    print("----添加之后,列表中的元素----")
    namesList.append("james")
    print(namesList)
    运行结果: ----添加之前,列表中的元素---- ['tom', 'jerry', 'jhon'] ----添加之后,列表中的元素---- ['tom', 'jerry', 'jhon', 'james']

    extend:通过extend可以将另一个集合中的元素逐一添加到列表中

    示例:

    print("----使用append添加----")
    a = ['a', 'b', 'c']
    b = ['1', '2', '3']
    a.append(b)
    print(a)
    print("----使用extend添加----")
    a = ['a', 'b', 'c']
    b = ['1', '2', '3']
    a.extend(b)
    print(a)
    
    运行结果:
    ----使用append添加----
    ['a', 'b', 'c', ['1', '2', '3']]
    ----使用extend添加----
    ['a', 'b', 'c', '1', '2', '3']
    

    insert:insert(index, object) 在指定位置index前插入元素object

    示例:

    a = ['a', 'b', 'c']
    a.insert(1, "haha")
    print(a)
    
    运行结果:
    ['a', 'haha', 'b', 'c']
    

    2. 删除元素("删"del, pop, remove,clear)

    del:根据下标进行删除

    示例:

    movieName = ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
    print('------删除之前------')
    print(movieName)
    print('------删除之后------')
    del movieName[2]
    print(movieName)
    
    运行结果:
    ------删除之前------
    ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
    ------删除之后------
    ['绿巨人', '钢铁侠', '雷神', '洛基']
    

    pop:删除最后一个元素

    示例:

    movieName = ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
    print('------删除之前------')
    print(movieName)
    print('------删除之后------')
    movieName.pop()  # 也可以传入下标作为参数,删除该下标的元素
    print(movieName)
    
    运行结果:
    ------删除之前------
    ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
    ------删除之后------
    ['绿巨人', '钢铁侠', '超人', '雷神']
    

    remove:根据元素的值进行删除

    示例:

    movieName = ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
    print('------删除之前------')
    print(movieName)
    print('------删除之后------')
    movieName.remove('超人')
    print(movieName)
    
    运行结果:
    ------删除之前------
    ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
    ------删除之后------
    ['绿巨人', '钢铁侠', '雷神', '洛基']
    

    clear:清空所有元素

    mlist = [1, 2, 3, 4, 5, 6, 7]
    mlist.clear()
    print(mlist)
    
    运行结果:
    []
    

    3. 修改元素("改")

    修改元素的时候,要通过下标来确定要修改的是哪个元素,然后对其重新赋值

    示例:

    movieName = ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
    print('------修改之前------')
    print(movieName)
    print('------修改之后------')
    movieName[2] = '美国队长'
    print(movieName)
    
    运行结果:
    ------修改之前------
    ['绿巨人', '钢铁侠', '超人', '雷神', '洛基']
    ------修改之后------
    ['绿巨人', '钢铁侠', '美国队长', '雷神', '洛基']
    

    4. 查找元素("查"in, not in, index, count)

    in, not in

    示例:

    name_list = ['tom', 'jerry', 'alice', 'james']
    print('tom' in name_list)
    print('tom' not in name_list)
    
    运行结果:
    True
    False
    

    index, count

    示例:

    name_list = ['tom', 'jerry', 'alice', 'james', 'jerry']
    print(name_list.index('jerry', 1, 3))
    print(name_list.index('jerry', 4, 6))
    print(name_list.count('jerry'))
    
    运行结果:
    1
    4
    2
    

    5. 排序(sort, reverse)

    • sort方法是将list按特定顺序重新排列,默认为由小到大,参数reverse=True可改为倒序,由大到小。
    • reverse方法是将list逆置。

    示例:

    a = [1, 4, 2, 3, 6, 5, 9, 8, 7]
    print('----原列表----')
    print(a)
    print('----reverse----')
    a.reverse()
    print(a)
    print('----sort----')
    a.sort()
    print(a)
    print('----sort(reverse=True)----')
    a.sort(reverse=True)
    print(a)
    
    运行结果:
    ----原列表----
    [1, 4, 2, 3, 6, 5, 9, 8, 7]
    ----reverse----
    [7, 8, 9, 5, 6, 3, 2, 4, 1]
    ----sort----
    [1, 2, 3, 4, 5, 6, 7, 8, 9]
    ----sort(reverse=True)----
    [9, 8, 7, 6, 5, 4, 3, 2, 1]
    

     四、元组

    python的元组与列表类似,不同之处在于元组的元素不能修改。元组使用小括号,列表使用方括号。

    tuple = (1, 2, 3, 4)

    1. 访问元组

    tuple = (1, 2, 3, 4)
    print(tuple[0])
    print(tuple[2])
    
    运行结果:
    1
    3
    

    2. 元组的内置函数count, index

    tuple = ('tom', 'jerry', 'alice', 'james')
    print(tuple.index('alice', 1, 3))
    print(tuple.count('jerry'))
    
    运行结果:
    2
    1
    

     五、字典

    字典的创建
    person = {"name": "sb", 'age': 18}
    或
    person = dict(name='sb', age=18)
    person = dict({"name": "sb", 'age': 18})
    person = dict((['name','sb'],['age',18]))
    
    {}.fromkeys(seq,100) #不指定100默认为None
    注意:
    
    >>> dic={}.fromkeys(['k1','k2'],[])
    >>> dic
    {'k1': [], 'k2': []}
    >>> dic['k1'].append(1)
    >>> dic
    {'k1': [1], 'k2': [1]}
    

    变量info为字典类型:

    info = {'name':'孙悟空', 'id':100, 'sex':'男', 'address':'花果山'}

    说明:

    • 字典和列表一样,也能够存储多个数据
    • 列表中找某个元素时,是根据下标进行的。字典中找某个元素时,是根据'名字'(就是冒号:前面的那个值,例如上面代码中的'name'、'id'、'sex')
    • 字典的每个元素由2部分组成,键:值。例如 'name':'孙悟空' ,'name'为键,'孙悟空'为值

    1. 根据键访问值

    info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    print(info['name'])
    print(info['address'])
    
    运行结果:
    孙悟空
    花果山
    
    若访问不存在的键,则会报错:
    info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    print(info['haha'])
    
    运行结果:
    Traceback (most recent call last):
      File "X:/xxx/xxx/xxx.py", line 2, in <module>
        print(info['haha'])
    KeyError: 'haha'
    
    在我们不确定字典中是否存在某个键而又想获取其值时,可以使用get方法,还可以设置默认值:
    info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    print(info.get('name'))
    print(info.get('haha'))
    print(info.get('haha', 'haha'))
    
    运行结果:
    孙悟空
    None
    haha
    

    2. 修改元素

    字典的每个元素中的数据是可以修改的,只要通过key找到,即可修改

    info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    print('----修改前----')
    print(info)
    print('----修改后----')
    info['name'] = "齐天大圣"
    print(info)
    
    运行结果:
    ----修改前----
    {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    ----修改后----
    {'name': '齐天大圣', 'id': 100, 'sex': '男', 'address': '花果山'}
    

    3. 添加元素

    如果在使用变量名['键'] = 数据时,这个“键”在字典中,不存在,那么就会新增这个元素

    info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    print('----修改前----')
    print(info)
    print('----修改后----')
    info['age'] = 500
    print(info)
    
    运行结果:
    ----修改前----
    {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    ----修改后----
    {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山', 'age': 500}
    

    4. 删除元素

    del删除指定的元素

    info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    print('----删除前----')
    print(info)
    print('----删除后----')
    del info['sex']
    print(info)
    
    运行结果:
    ----删除前----
    {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    ----删除后----
    {'name': '孙悟空', 'id': 100, 'address': '花果山'}
    

    clear清空整个字典

    info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    print('----清空前----')
    print(info)
    print('----清空后----')
    info.clear()
    print(info)
    
    运行结果:
    ----清空前----
    {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}
    ----清空后----
    {}
    

    pop删除指定元素,若删除的元素不存在,可以指定返回值

    dic = {
        'k1': 'v1',
        'k2': 'v2'
    }
    v = dic.pop('k1')
    print(dic, v)
    # 运行结果
    {'k2': 'v2'} v1
    
    dic = {
        'k1': 'v1',
        'k2': 'v2'
    }
    v = dic.pop('k111', 1)
    print(dic, v)
    # 运行结果
    {'k1': 'v1', 'k2': 'v2'} 1
    

    5. keys

    返回一个包含字典所有KEY的列表

    >>> info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}

    >>> info.keys()

    dict_keys(['name', 'id', 'sex', 'address'])

    >>> 

    6. values

    返回一个包含字典所有value的列表

    >>> info = {'name': '孙悟空', 'id': 100, 'sex': '男', 'address': '花果山'}

    >>> info.values()

    dict_values(['孙悟空', 100, '男', '花果山'])

    >>> 

    7. items

    返回一个包含所有(键,值)元组的列表

    >>> info = {'name': '孙悟空', 'address': '花果山'}

    >>> info.items()

    dict_items([('name', '孙悟空'), ('address', '花果山')])

    >>> 

    8. has_key和in

    python3去除了has _key替换为in

    如果key在字典中,返回True,否则返回False

    >>> info = {'name': '孙悟空', 'address': '花果山'}

    >>> 'name' in info

    True

    >>> 'age' in info

    False

    >>> 

    看看python2中的has_key,当然python2中in也可以使用

    >>> info = {'name': '孙悟空', 'address': '花果山'}

    >>> 'name' in info

    True

    >>> info.has_key('name')

    True

    >>> info.has_key('age')

    False

    >>> 

    9. update

    dic = {
        'k1': 'v1',
        'k2': 'v2'
    }
    dic.update({'k1': 123, 'k3': 456})
    print(dic)
    # 运行结果 {'k1': 123, 'k2': 'v2', 'k3': 456}

    10. 字典遍历

    info = {'name': '孙悟空', 'address': '花果山'}
    print('----遍历字典的key(键)----')
    for key in info.keys():
        print(key, end='	')
    print()
    print('----遍历字典的value(值)----')
    for value in info.values():
        print(value, end='	')
    print()
    print('----遍历字典的项(元素)----')
    for item in info.items():
        print(item, end='	')
    
    运行结果:
    ----遍历字典的key(键)----
    name    address
    ----遍历字典的value(值)----
    孙悟空   花果山  
    ----遍历字典的项(元素)----
    ('name', '孙悟空')  ('address', '花果山')
    

    六、集合

     1. 定义

      定义:由不同元素组成的集合,集合中是一组无序排列的可hash值,可以作为字典的key

      特点:

      • 不同元素组成
      • 无序
      • 每个元素必须是不可变类型

    2. 集合的创建

       {1,2,3,1}
      或
      定义可变集合set
      >>> set_test=set('hello')
      >>> set_test
      {'l', 'o', 'e', 'h'}
      改为不可变集合frozenset
      >>> f_set_test=frozenset(set_test)
      >>> f_set_test
      frozenset({'l', 'e', 'h', 'o'})

    3.  常用操作

    add    添加元素

    s = {1, 2, 3}
    s.add(4)
    print(s)
    
    运行结果
    {1,2,3,4}
    

    pop    随机删除一个元素

    s = {'b', 123, 2, 3, 'a'}
    s.pop()
    print(s)
    
    #运行结果
    {3, 'b', 'a', 123}
     

    remove    删除指定元素,删除不存在的元素时会报错

    s = {'b', 123, 2, 3, 'a'}
    s.remove('a')
    print(s)
    
    # 运行结果
    {2, 3, 'b', 123}
    

    discard    删除指定元素,删除不存在的元素时不会报错

    intersection  或  &     交集

    s = {'b', 123, 2, 3, 'a'}
    b = {'a', 2, 5, 123}
    sb = s.intersection(b)
    print(sb)
    print(s & b)
    # 运行结果
    {2, 123, 'a'}
    {2, 123, 'a'}

    union  或  |    并集

    s = {'b', 123, 2, 3, 'a'}
    b = {'a', 2, 5, 123}
    sb = s.union(b)
    print(sb)
    print(s | b)
    
    # 运行结果
    {2, 3, 'a', 5, 'b', 123}
    {2, 3, 'a', 5, 'b', 123}
    

    difference  或  -    差集

    s = {'b', 123, 2, 3, 'a'}
    b = {'a', 2, 5, 123}
    sb = s - b
    bs = b - s
    print(sb, bs)
    
    # 运行结果
    {3, 'b'} {5}
    

    symmetric_difference   或  ^     交叉补集(两个集合不共有的部分)

    s = {'b', 123, 2, 3, 'a'}
    b = {'a', 2, 5, 123}
    sb = s.symmetric_difference(b)
    print(sb)
    
    # 运行结果
    {3, 5, 'b'}
    

    difference_update     返回两集合的差集

    s = {'b', 123, 2, 3, 'a'}
    b = {'a', 2, 5, 123}
    s.difference_update(b) # 将两集合的差集返回给s
    print(s)
    
    # 运行结果
    {3, 'b'}
    

    isdisjoint     如果两集合的交集为空集,返回True

    s = {'b', 2, 3, }
    b = {'a', 5, 123}
    v = s.isdisjoint(b)
    print(v)
    
    # 运行结果
    True
    

    issubset    如果s1是s2的子集,返回True

    s1 = {1, 2}
    s2 = {1, 2, 3}
    v = s1.issubset(s2)
    print(v)
    
    #运行结果
    True
    

     issuperset    如果s1包含s2父集,返回True

    s1 = {1, 2}
    s2 = {1, 2, 3}
    v = s1.issuperset(s2)
    print(v)
    
    # 运行结果 
    False

    update    更新

    s1 = {1, 2}
    s2 = {1, 2, 3}
    s1.update(s2)
    print(s1)
    
    # 运行结果
    {1,2,3}
    
  • 相关阅读:
    leetcode 190 Reverse Bits
    vs2010 单文档MFC 通过加载位图文件作为客户区背景
    leetcode 198 House Robber
    记忆化搜索(DP+DFS) URAL 1183 Brackets Sequence
    逆序数2 HDOJ 1394 Minimum Inversion Number
    矩阵连乘积 ZOJ 1276 Optimal Array Multiplication Sequence
    递推DP URAL 1586 Threeprime Numbers
    递推DP URAL 1167 Bicolored Horses
    递推DP URAL 1017 Staircases
    01背包 URAL 1073 Square Country
  • 原文地址:https://www.cnblogs.com/lsf123456/p/11132809.html
Copyright © 2011-2022 走看看