精华内容
下载资源
问答
  • Set是Java集合类的重要组成部分,它用来存储...看起来枚举类型和集合是很相似的。然而枚举类型中的元素不能随意的增加、删除,作为集合而言,枚举类型非常不实用。EnumSet是专门为enum实现的集合类,本实例将演示其用法
  • 列表(List):有序,可更改,可以有重复的成员 元组(tuple):有序,不可更改,可以有重复的成员 集合(set):无序,无索引,没有重复的成员。 字典 (Dictionary):无序,可更改,有索引,没有重复的成员 列表...
  • Redis有序集合

    千次阅读 2019-05-15 20:31:36
    有序集合,顾名思义,元素有序且唯一的集合,满足有序性、唯一性、确定性,sorted set、zset都是指的有序集合。 二、常用命令介绍 有序集合共有25个相关命令,这里只介绍常用的命令,其他的可以去官方文档查看。 添....

    一、有序集合介绍

    有序集合,顾名思义,元素有序且唯一的集合,满足有序性、唯一性、确定性,sorted set、zset都是指的有序集合。

    二、常用命令介绍

    有序集合共有25个相关命令,这里只介绍常用的命令,其他的可以去官方文档查看。

    添加元素

    ZADD key [NX|XX] [CH] [INCR]score member [score member …]

    key:有序集合的键;

    NX:不存在才添加该元素,类似HashMap的putIfAbsent;

    XX:存在时才添加元素,也就是覆盖;

    CH:返回值将会是元素产生改变的数量,不加这个选项只改变分数是不会计数的;

    INCR:在原分数的基础上加上新的分数,而不是覆盖;

    score:元素的分数,分数越小,排名越靠前,排名从0开始,分数相同的情况下再按照字典序进行排序;

    member:元素成员

    元素加分

    ZINCRBY key increment member

    increment:待加分数

    等同于ZADD key INCRY score member

    查询元素个数

    ZCARD key

    统计分数范围内的元素个数

    ZCOUNT key min max

    min:最小分数

    max:最大分数

    使用示例:

    分数在负无穷到正无穷范围内的元素个数,也就是所有元素个数,效果同ZCARD

    ZCOUNT myzset -inf +inf

    统计分数大于1小于等于3的元素个数

    ZCOUNT myzset (1 3

    按排名范围查找

    ZRANGE key start stop [WITHSCORES]

    start:开始索引

    stop:结束索引

    WITHSCORES:同时查询出分数

    使用示例:

    ZRANGE myset 0 -1 WITHSCORES

    按分数范围查找

    ZRANGEBYSCORE key min max [WITHSCORES] [LIMIT offset count]

    LIMIT offset count类似mysql的用法,不再赘述

    按排名倒序范围查询

    ZREVRANGE key start stop [WITHSCORES]

    按分数倒序范围查询

    ZREVRANGEBYSCORE key max min [WITHSCORES] [LIMIT offset count]

    查询元素分数

    ZSCORE key member

    查询元素排名

    ZRANK key member

    排名从0开始

    查询元素倒序排名

    ZREVRANK key member

    删除元素

    ZREM key member [member …]

    按排名范围删除元素

    ZREMRANGEBYRANK key start stop

    按分数范围删除元素

    ZREMRANGEBYSCORE key min max

    lex相关的命令是分数相同时按字典序进行相关操作的命令,使用较少,这里不做介绍,有兴趣的自己查看官方文档:https://redis.io/commands

    三、有序集合数据结构

    Redis的五种数据结构在Redis的实现中都表示为一个Redis对象,对象包含了类型、编码、具体的数据等信息,有序集合的编码可以是zipList或skipList,ziplist编码的压缩列表对象使用压缩列表作为底层实现,每个集合元素使用两个紧挨在一起的压缩列表节点来保存,第一个节点保存元素的成员(member),而第二个元素则保存元素的分值(score)。

    压缩列表内的集合元素按分值从小到大进行排序,分值较小的元素被放置在靠近表头的方向,而分值较大的元素则被放置在靠近表尾的方向。

    在这里插入图片描述

    在这里插入图片描述

    skiplist编码的有序集合对象使用zset结构作为底层实现,一个zset结构同时包含一个字典和一个跳跃表:

    typedef struct zset {
        zskiplist *zsl;
        dict *dict;
    } zset;
    

    在这里插入图片描述

    在这里插入图片描述

    为什么有序集合需要同时使用跳跃表和字典来实现?

    在理论上,有序集合可以单独使用字典或者跳跃表的其中一种数据结构来实现,但无论单独使用字典还是跳跃表,在性能上对比起同时使用字典和跳跃表都会有所降低。
    举个例子,如果我们只使用字典来实现有序集合,那么虽然以O(1)复杂度查找成员的分值这一特性会被保留,但是,因为字典以无序的方式来保存集合元素,所以每次在执行范围型操作一一一比如ZRANK、ZRANG等命令时,程序都需要对字典保存的所有元素进行排序,完成这种排序需要至少O(NlogN)时间复杂度,以及额外的O(N)内存空间(因为要创建一个数组来保存排序后的元素)。
    另一方面,如果我们只使用跳跃表来实现有序集合,那么跳跃表执行范围型操作的所有优点都会被保留,但因为没有了字典,所以根据成员查找分值这一操作的复杂度将从O(1)上升为O(logN)。因为以上原因,为了让有序集合的查找和范围型操作都尽可能快地执行,Redis选择了同时使用字典和跳跃表两种数据结构来实现有序集合。

    采用哪种编码由什么决定?

    当有序集合对象可以同时满足以下两个条件时,对象使用ziplist编码:

    • 有序集合保存的元素数量小于128个;
    • 有序集合保存的所有元素成员的长度都小于64字节;

    不能满足以上两个条件的有序集合对象将使用skiplist编码。

    以上两个条件的上限值可以通过zset-max-ziplist-entries(默认128)和zset-max-ziplist-value(默认64)来调整,当编码从ziplist转换成skiplist后,即便删除元素满足了上述条件,编码也不会从skiplist重新转换成ziplist。

    压缩列表

    压缩列表(zset)是列表键和哈希键的底层实现之一。当一个列表键只包含少量列表项,并且每个列表项要么就是小整数值,要么就是长度比较短的字符串,那么Redis就会使用压缩列表来做列表键的底层实现。

    压缩列表的构成

    压缩列表是Redis为了节约内存而开发的,是由一系列特殊编码的连续内存块组成的顺序型(sequential)数据结构。一个压缩列表可以包含任意多个节点(entry),每个节点可以保存一个字节数组或者一个整数值。

    在这里插入图片描述

    压缩列表各个组成部分的说明

    属性类型长度用途
    zlbytesuint32_t4字节记录整个压缩列表占用的内存字节数:在对压缩列表进行内存重分配,或者计算zlend的位置时使用
    zltailuint32_t4字节记录压缩列表表尾节点距离压缩列表的起始地址有多少字节:通过这个偏移量,程序无须遍历整个压缩列表就可以确定表尾节点的地址
    zllenuint16_t2字节记录了压缩列表包含的节点数量:当这个属性的值小于UINT16_MAX(65535)时,这个属性的值就是压缩列表包含节点的数量;当这个值等于UINT16_MAX时,节点的真实数量需要遍历整个压缩列表才能计算得出
    entryX列表节点不定压缩列表包含的各个节点,节点的长度由节点保存的内容决定
    zlenduint8_t1字节特殊值0xFF(十进制255),用于标记压缩列表的末端

    压缩列表节点的构成

    每个压缩列表节点可以保存一个字节数组或者一个整数值,其中,字节数组可以是以下三种长度的其中一种:

    • 长度小于等于63(26一1)字节的字节数组;
    • 长度小于等于16383(2]4一1)字节的字节数组;
    • 长度小于等于4294967295(232一1)字节的字节数组;

    而整数值则可以是以下六种长度的其中一种:

    • 4位长,介于0至12之间的无符号整数
    • 1字节长的有符号整数;
    • 3字节长的有符号整数;
    • uint16_t类型整数;
    • uint32_t类型整数;
    • uint64_t类型整数。

    在这里插入图片描述

    previous_entry_length

    节点的属性以字节为单位,记录了压缩列表中前一个节点的长度。

    previousentry_length属性的长度可以是1字节或者5字节:

    • 如果前一节点的长度小于254字节,那么previous_entry_length属性的长度为1字节:前一节点的长度就保存在这一个字节里面。
    • 如果前一节点的长度大于等于254字节,那么previous_entry_length属性的长度为5字节:其中属性的第一字节会被设置为0xFE(十进制值254),而之后的四个字节则用于保存前一节点的长度。

    encoding

    节点的encoding属性记录了节点的content属性所保存数据的类型以及长度:

    • 一字节、两字节或者五字节长,值的最高位为00、01或者10的是字节数组编码:这种编码表示节点的content属性保存着字节数组,数组的长度由编码除去最高两位之后的其他位记录;
    • 一字节长,值的最高位以11开头的是整数编码:这种编码表示节点的content属性保存着整数值,整数值的类型和长度由编码除去最高两位之后的其他位记录。

    content

    每个压缩列表节点可以保存一个字节数组或者一个整数值,其中,字节数组可以是以下三种长度的其中一种:

    • 长度小于等于63(26一1)字节的字节数组;
    • 长度小于等于16383(2]4一1)字节的字节数组;
    • 长度小于等于4294967295(232一1)字节的字节数组;

    而整数值则可以是以下六种长度的其中一种:

    • 4位长,介于0至12之间的无符号整数
    • 1字节长的有符号整数;
    • 3字节长的有符号整数;
      在这里插入图片描述

    压缩列表操作API

    函数作用算法复杂度
    ziplistNew创建一个新的压缩列表O(1)
    ziplistPush创建一个包含给定值的新节点,并将这个新节点添加到压缩列表的表头或者表尾平均O(N),最坏O(N^2)
    ziplistlnsert将包含给定值的新节点插人到给定节点平均O(N),最坏O(N^2)
    ziplistlndex返回压缩列表给定索引上的节点O(N)
    ziplistFind在压缩列表中查找并返回包含了给定值的节点因为节点的值可能是一个字节数组,所以检查节点值和给定值是否相同的复杂度为O(N),而查找整个列表的复杂度则为O(N^2)
    ziplistNext返回给定节点的下一个节点O(1)
    ziplistPrev返回给定节点的前一个节点O(1)
    ziplistGet获取给定节点所保存的值O(1)
    ZiplistDelete从压缩列表中删除给定的节点平均O(N),最坏O(N^2)
    ziplistDeleteRange删除压缩列表在给定索引上的连续多个节点平均O(N),最坏O(N^2)
    ziplistBlobLen返回压缩列表目前占用的内存字节数O(1)
    ziplistLen返回压缩列表目前包含的节点数量节点数量小于65535时为O(1),大于65535时为O(N^2)

    跳跃表

    跳跃表(skiplist)是一种有序数据结构,它通过在每个节点中维持多个指向其他节点的指针,从而达到快速访问节点的目的。

    跳跃表支持平均O(logN)、最坏O(N)复杂度的节点查找,还可以通过顺序性操作来批处理节点。
    在大部分情况下,跳跃表的效率可以和平衡树相媲美,并且因为跳跃表的实现比平衡树要来得更为简单,所以有不少程序都使用跳跃表来代替平衡树。
    Redis使用跳跃表作为有序集合键的底层实现之一,如果一个有序集合包含的元素数量比较多,又或者有序集合中元素的成员(member)是比较长的字符串时,Redis就会使用跳跃表来作为有序集合键的底层实现。

    在这里插入图片描述

    跳跃表操作API

    函数作用时间复杂度
    zslCreate创建一个新的跳跃表O(1)
    zslFree释放给定跳跃表,以及表中包含的所有节点O(N),N为表的长度
    zsIInsert将包含给定成员和分值的新节点添加到跳跃表中平均O(logN),最坏O(N),N为跳跃表长度
    zsIDeIete删除跳跃表中包含给定成员和分值的节点平均O(logN),最坏O(N),N为跳跃表长度
    zslGetRank返回包含给定成员和分值的节点在跳跃表中的排位平均O(logN),最坏O(N),N为跳跃表长度
    zsIGetEIementByRank返回表在给定排位上的节点平均O(logN),最坏O(N),N为跳跃表长度
    zslIsInRange给定一个分值范围,有至少一个节点的分值在该范围内,返回1,否则返回0通过跳跃表的表头节点和表尾节点,这个检测可以用O(1)复杂度完成
    zsIFirstInRange给定一个分值范围,返回跳跃表中第一个符合这个范围的节点平均O(logN),最坏O(N),N为跳跃表长度
    zs1LastInRange给定一个分值范围,返回跳跃表中最后一个符合这个范围的节点平均O(logN),最坏O(N),N为跳跃表长度
    zs1De1eteRangeByScore给定一个分值范围,删除跳跃表中所有在这个范围之内的节点O(N),N为被删除节点数量
    zs1De1eteRangeByRank给定一个排位范围,删除跳跃表中所有在这个范围之内的节点O(N),N为被删除节点数量
    展开全文
  • **python中列表 元组 字典 集合

    千次阅读 2021-01-30 05:45:01
    列表 元组 字典 集合的...列表的特点:有序,数据可变,数据可重复,数据类型可不同,可嵌套。创建一个列表:tl = [1, 'Hello', 1, "你好", [2, 'World']]初步可以看到它的语法、数据可重复、数据类型可不同、可嵌套...

    列表 元组 字典 集合的区别是python面试中最常见的一个问题。这个问题虽然很基础,但确实能反映出面试者的基础水平。

    1.列表

    列表是以方括号“[]”包围的数据集合,不同成员以“,”分隔。

    列表的特点:有序,数据可变,数据可重复,数据类型可不同,可嵌套。

    创建一个列表:tl = [1, 'Hello', 1, "你好", [2, 'World']]

    初步可以看到它的语法、数据可重复、数据类型可不同、可嵌套等特点,如果用print函数多输出几次就会发现它是有序的,下面我们看一下列表的常用操作,同时也证明列表数据可变。

    (1)list.append()追加成员,添加到末尾

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    print(tl)

    tl.append('test')

    print(tl)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, '你好', [2, 'World'], 'test']

    (2)list.pop(i)删除第i个成员,并可将删除的数据赋值给变量

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    print(tl)

    a = tl.pop(3)

    print(tl)

    print(a)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, [2, 'World']]

    你好

    (3)list.remove(s)直接删除值为s的成员,如果该值有多个只删除第一个,注意与pop的区别

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    print(tl)

    tl.remove("你好")

    print(tl)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, [2, 'World']]

    (4)list.index(x)获得参数x在列表中的位置

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    print(tl.index([2, 'World']))

    输出:

    4

    (5)list.insert(a,b)向列表中的a位置插入数据b

    tl = [1, 'Hello', 1, "你好", [2, 'World']]

    tl.insert(2, '位置二')

    print(tl)

    输出:

    [1, 'Hello', '位置二', 1, '你好', [2, 'World']]

    (6)list.copy()拷贝列表,两者互相独立

    tx = [1, 'Hello', 1, "你好", [2, 'World']]

    ty = tx.copy()

    print(tx)

    print(ty)

    tx.pop(4)

    print(tx)

    print(ty)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, '你好', [2, 'World']]

    [1, 'Hello', 1, '你好']

    [1, 'Hello', 1, '你好', [2, 'World']]

    (7)list.extend(L)向列表中追加另一个列表L

    tx = [1, 'Hello', 1, "你好", [2, 'World']]

    ty = [9, 8, 7, 6]

    tx.extend(ty)

    print(tx)

    输出:

    [1, 'Hello', 1, '你好', [2, 'World'], 9, 8, 7, 6]

    (8)list.count(y)计算列表中参数y出现的次数,想知道列表长度可以用len(L)

    ty = [9, 8, 7, 6, 8]

    print(ty.count(8))

    输出:

    2

    (9)list.sort()将列表中的成员排序,前提是成员数据类型一致

    tx = ['1', 'Hello', '1', "你好"]

    ty = [9, 8, 7, 6, 8]

    ty.sort()

    print(ty)

    tx.sort()

    print(tx)

    输出:

    [6, 7, 8, 8, 9]

    ['1', '1', 'Hello', '你好']

    (10)list.reverse()将列表中成员的顺序颠倒

    (11)list.clear()将列表清空

    2.元组

    元组是以圆括号“()”包围的数据集合,不同成员以“,”分隔。

    元组的特点:有序,数据不可变,数据可重复,数据类型可不同,可嵌套。元组通常在需要一组安全稳定的值的时候使用。

    元组和列表的区别除了语法就只有一个:数据不可变,也正是这个特点导致元组没有操作数据的方法,比列表要掌握的东西少得多。

    (1)tuple.index(x)获得参数x在列表中的位置

    (2)tuple.count(y)计算列表中参数y出现的次数

    3.字典

    字典是以大括号“{}”包围的数据集合,成员内部用“:”分隔,不同成员以“,”分隔。

    元组的特点:无序,数据可变,键不可重复,数据类型可不同,可嵌套。通过键来访问成员。

    创建一个字典:td = {'k': 'v', 'g': 'd'},下面我们看一下字典的常用操作:

    (1)dict.get('k') 获取键为'k'的值

    (2)dict.copy() 拷贝字典,两者互相独立

    (3)dict.pop('k') 删除键为'k'的值,并可将删除的值赋值给变量

    (4)dict.popitem() 随机删除一对键值,并可将删除的键值赋给变量,注意此时变量的类型将变成元组

    td = {'k': 'v', 'g': 'd'}

    print(td)

    x = td.popitem()

    print(td)

    print(x, type(x))

    输出:

    {'g': 'd', 'k': 'v'}

    {'k': 'v'}

    ('g', 'd')

    (5)dict.values() 获取字典中所有的“值”

    td = {'k': 'v', 'g': 'd'}

    print(td)

    x = td.values()

    for i in x:

    print(i)

    输出:

    {'g': 'd', 'k': 'v'}

    d

    v

    (6)dict.keys() 获取字典中所有的“键”

    (7)dict.items() 获取字典的所有键值对,以元组返回

    td = {'k': 'v', 'g': 'd'}

    print(td)

    x = td.items()

    for i in x:

    print(i)

    输出:

    {'g': 'd', 'k': 'v'}

    ('g', 'd')

    ('k', 'v')

    (8)dict.fromkeys(seq[,value]))  用于创建一个新字典,以序列seq中元素做字典的键,value为字典所有键对应的初始值。

    a = ('d', 'g', 's')

    b = {}

    b = b.fromkeys(a, 'test')

    print(a, b)

    td = {'k': 'v', 'g': 'd'}

    print(td)

    x = td.fromkeys('k')

    print(x)

    y = td.fromkeys(td.values(), 1000)

    print(y)

    输出:

    ('d', 'g', 's') {'s': 'test', 'd': 'test', 'g': 'test'}

    {'g': 'd', 'k': 'v'}

    {'k': None}

    {'v': 1000, 'd': 1000}

    (9)dict.setdefault('k','v')   和get()方法类似, 如果键不存在于字典中,将会添加键并将值设为默认值。

    dict = {'Name': 'Zara', 'Age': 7}

    print("Value : %s" % dict.setdefault('Age', 10))

    print("Value : %s" % dict.setdefault('Sex', 'f'))

    print(dict)

    输出:

    Value : 7

    Value : f

    {'Name': 'Zara', 'Sex': 'f', 'Age': 7}

    (10)dict.update(dict2) 函数把字典dict2的键/值对更新到dict里,即dict2中的成员是一定会保留的。

    dict1 = {'Name': 'Zara', 'Age': 7}

    dict2 = {'Sex': 'female', 'Age': 11}

    dict1.update(dict2)

    print("Value : %s" % dict1)

    输出:

    Value : {'Sex': 'female', 'Age': 11, 'Name': 'Zara'}

    (11)dict.clear() 清空

    4.集合

    集合的特点:无序,数据可变,数据不可重复,数据类型可不同,不可嵌套。集合最好的应用是去重和关系操作(交集、并集等)。集合没有特殊的表示方法,而是通过一个set函数转换成集合。

    创建一个字典:t = set("Hello"):

    a = set('asdsf')

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    print(a)

    print(b)

    输出:

    {'d', 's', 'f', 'a'}

    {'xx', 5, 7, 8, 10, 'asdf'}

    可以看到将一个字符串转换为集合,会把字符串每个字符分开,最终成为一个集合。

    下面我们看一下字典的常用操作:

    (1)set.add(x) 添加x元素到集合。

    a = set(['asdsf', 10])

    a.add('iis')

    print(a)

    输出:

    {'iis', 'asdsf', 10}

    (2)set.remove(y)  删除集合中的y元素,如果y不存在会报错

    a = set(['asdsf', 10])

    a.remove('asdsf')

    print(a)

    输出:

    {10}

    (3)set.discard(x)  删除集合中的x元素,如果x不存在,不会报错,注意和remove的区别

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    b.discard(9)

    print(b)

    输出:

    {5, 7, 8, 10, 'asdf', 'xx'}

    (4)set.pop()  随机删除一个集合元素,可将删除的元素赋值给变量

    a = set(['asdsf', 10])

    x = a.pop()

    print(a)

    print(x)

    输出:    #注意:删除是随机的,多执行几次结果会有变化

    {'asdsf'}

    10

    (5)set.copy() 拷贝一个集合

    a = set(['asdsf', 10])

    x = a.copy()

    print(a)

    print(x)

    a.remove(10)

    print(a, x)

    x.remove('asdsf')

    print(a, x)

    输出:

    {10, 'asdsf'}

    {10, 'asdsf'}

    {'asdsf'} {10, 'asdsf'}

    {'asdsf'} {10}

    可见,对两个集合的操作互不影响

    (6)set.union()和set.update()  将两个集合取并集,这两个方法效果一样,但是union字面意思好理解一些。

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    a = ['kk','vv']

    b.update(a)

    print(b)

    b.union(a)

    print(b)

    输出:

    {'asdf', 5, 7, 8, 10, 'vv', 'xx', 'kk'}

    {'asdf', 5, 7, 8, 10, 'vv', 'xx', 'kk'}

    (7)set.intersection()  将两个集合取交集。

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    xx = b.intersection(s)

    print(xx)

    输出:

    {10, 'asdf', 5}

    (8)b.intersection_update(s)  将两个集合取交集,并将所取的交集覆盖到集合b中

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    b.intersection_update(s)

    print(b)

    输出:

    {10, 'asdf', 5}

    (9)yy = b.difference(s)  将b中存在但s中不存在的元素放到集合yy中

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    yy = b.difference(s)

    print(yy)

    输出:

    {8, 'xx', 7}

    (10)b.difference_update(s)  将b中存在但s中不存在的元素覆盖到集合b中

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([8, 5, 7,'xx', 10, 'asdf'])

    b.difference_update(s)

    print(b)

    输出:

    {'xx', 7, 8}

    (11)b.issunset(s)  判断b是不是s的子集

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([5, 10, 'asdf'])

    x = b.issubset(s)

    y = s.issubset(b)

    print(x)

    print(y)

    输出:

    True

    False

    (12)set.issuperset()  和上一个相反,判断超集

    (13)x = s.isdisjoint(b)  判断s和b没有交集,没有返回True,有返回False。

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([6, 10, 'asdf'])

    c = set([6, 8, 0])

    x = s.isdisjoint(b)

    y = s.isdisjoint(c)

    print(x)

    print(y)

    输出:

    False

    True

    (14)x = s.symmetric_difference(b)   将s和b两个集合的非重复项合并为一个新的集合。

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([6, 10, 'asdf'])

    x = s.symmetric_difference(b)

    print(x)

    输出:

    {3, 5, 6, 'asdsf', 9}

    (15)s.symmetric_difference_update(b)   将s和b两个集合的非重复项合并为一个新的集合并赋值给s。

    s = set([3, 5, 9,'asdsf', 10, 'asdf'])

    b = set([6, 10, 'asdf'])

    s.symmetric_difference_update(b)

    print(s)

    输出:

    {3, 5, 6, 'asdsf', 9}

    展开全文
  • 任意对象的有序集合列表是一组任意类型的值,按照一定顺序组合而成的。组成列表的值叫做元素(Elements)。每一个元素被标识一个索引,第一个索引是0,序列的功能都能实现。 特点:可重复,类型可不同。 运用方法 ...
  • 获取有序集合元素的数量 zcard 集合的键

    获取有序集合元素的数量

    zcard 集合的键
    
    展开全文
  • python中的列表是一种有序数据的集合。其中的元素按照一定的顺序编号存放在存储空间当中,编号从0开始,最后一个编号为n-1,n表示列表中存储数据的数量。值得一提的是,列表是用方括号(square bracket)括起来,...

    python中的列表是一种有序数据的集合。其中的元素按照一定的顺序编号存放在存储空间当中,编号从0开始,最后一个编号为n-1,n表示列表中存储数据的数量。值得一提的是,列表是用方括号(square bracket)括起来,我们同时也可以用方括号来进行引用,列表中的元素可以是字符串、数字等等。我们可以对列表进行增删改查等操作。

    示例代码:

    bicycles = ['trek','cannondale','redline','specialized']
    print(bicycles)
    print(bicycles[0])
    print(bicycles[0].title())
    
    message = "My first bicycle was a " + bicycles[0].title() + "."
    print(message)```
    
    输出结果:
    
    ```python
    ['trek', 'cannondale', 'redline', 'specialized']
    trek
    Trek
    My first bicycle was a Trek.**
    

    以上相当于完成了列表的“查”操作,对于“改”操作,可以使用list_name[index] = content语句来实现新的值对旧的值得覆盖操作,如以下代码演示的那样:

    motorcycles = ['honda','yamaha','suzuki']
    print(motorcycles)
    motorcycles[0] = 'ducati'
    print(motorcycles)
    

    运行之后,我们看到第一个元素“honda”已经在操作之后被替换为“ducati”了:

    ['honda', 'yamaha', 'suzuki']
    ['ducati', 'yamaha', 'suzuki']
    [Finished in 1.0s]
    

    对于“增”操作,则可以使用append方法和insert方法,append可以在李彪的末尾增加新的指定元素,而insert方法则可以给定index值指定插入元素的位置,演示代码如下:

    motorcycles = ['honda','yamaha','suzuki']
    print(motorcycles)
    motorcycles.append('ducati')
    print(motorcycles)
    motorcycles.insert(1,'toyota')
    print(motorcycles)
    

    运行结果如下:

    ['honda', 'yamaha', 'suzuki']
    ['honda', 'yamaha', 'suzuki', 'ducati']
    ['honda', 'toyota', 'yamaha', 'suzuki', 'ducati']
    [Finished in 0.9s]
    

    对“删”操作,python提供了del/pop/remove等多种方法,他们的使用要点如下:

    • del命令:作为命令使用,后面接上需要删除的列表地址list[index]
    • pop命令:作为列表的一种属性方法使用,后面()中可加index参数,不加的话默认是最后一个元素的index,该方法有返回值,也就是被删除的元素
    • remove命令:需要指定被删除元素的值,作为一种方法属性来使用。

    演示程序如下:

    motorcycles = ['honda','yamaha','suzuki','ducati','yasakawa','fanuc']
    print(motorcycles)
    del motorcycles[1]
    print(motorcycles)
    poped_motocycle1 = motorcycles.pop()
    print(poped_motocycle1)
    print(motorcycles)
    poped_motocycle2 = motorcycles.pop(2)
    print(poped_motocycle2)
    print(motorcycles)
    motorcycles.remove('yasakawa')
    print(motorcycles)
    

    结果如下:

    ['honda', 'yamaha', 'suzuki', 'ducati', 'yasakawa', 'fanuc']
    ['honda', 'suzuki', 'ducati', 'yasakawa', 'fanuc']
    fanuc
    ['honda', 'suzuki', 'ducati', 'yasakawa']
    ducati
    ['honda', 'suzuki', 'yasakawa']
    ['honda', 'suzuki']
    [Finished in 0.9s]
    
    展开全文
  • 获取有序集合中指定值的序号 zscore 集合的键 值
  • Redis中的有序集合类型,实际上是在集合类型上,为每个元素都关联一个分数,有序实际上说的是分数有序,我们根据分数的范围获取集合及其他操作。集合元素依然是不能够相同的,但是分数可以相同。 下面列举有序集合...
  • 一、相似之处 1、二者都是有序的。 2、二者都可以获得某一范围的元素。...3、列表中不能简单的调整某个元素的位置,但是有序集合可以(通过更改这个元素的分数)。 4、有序集合要比列表类型更耗费内存
  • redis之有序集合

    千次阅读 2018-03-26 09:09:27
     有序集合类型和列表的共同点 1、二者都是有序的 2、二者都一个获取某一个范围的元素 但是二者也有很大的区别二、命令1、ZADD key score number [score number ......] 向有序集合加入一个元素和该元素的分数,...
  • 一、序列序列是 python 中最基本的数据结构,序列中的元素都有对应的位置值,该位置值称为索引,其中序列类型包括字符串、列表、元组、集合和字典,区别在于:1)字符串、列表、元组支持索引、切片、相加、相乘通用的...
  • 它的内部实现用的是一种叫做「跳跃列表」的数据结构。 zset 中最后一个 value 被移除后,数据结构自动删除,内存被回收。 zset 可以用来存粉丝列表,value 值是粉丝的用户 ID,score 是关注时间。我们可以对粉丝列表...
  • 有序集合集合一样,都可以包含任意数量的、各不相同的元素( element),不同于集合的是,有序集合的每个元素都关联着一个浮点数格式的分 值(score),并且有序集合会按照分 值,以从小到大的顺序来排列有序集合...
  • Python中的集合列表

    千次阅读 2018-09-26 14:12:33
    在java开发中我们会用到各种集合比较常用的有List和Map,用于初始化原始数据或者作为数据源传入一个方法中,在Python中主要有集合或者说列表list[],dict{},set{},tuple()这几种,本人将逐一列举之: 1:首先是list,...
  • 集合有序集合

    千次阅读 2018-07-09 17:27:55
    无序集合类型(用值为空的散列表实现,支持集合的差、交、并运算,加入、删除、判断存在等操作的时间复杂度均为O(1)) 可以使用tagSet id1 .. idn来通过集合运算实现“取出指定条件标签的文章” 增加集合元素 ...
  • List(列表):元素有序,元素可以重复 (有索引)。 通过元素的equals()方法判断是否重复。ArrayList:https://blog.csdn.net/houyanhua1/article/details/80494916Demo.java:package cn.xxx.demo; import java.util....
  • 有序集合类型在某些方面和列表类型有些相似。 (1)二者都是有序的。 (2)二者都可以获得某一范围的元素。 但是二者有着很大的区别,这使得它们的应用场景也是不同的。 (1)列表类型是通过链表实现的,获取靠近两...
  • python中的列表和元组都有哪些区别

    千次阅读 2021-01-15 01:09:05
    列表(list)和元组(tuple)的一些基础list和tuple都是一个可以放置任意数据类型的有序集合,都是既可以存放数字、字符串、对象等list和tuple都支持负索引In [8]: nums[-2]Out[8]: 'ad'In [9]: tp[-2]Out[9]: '33'list...
  • redis删除有序集合部分过期元素

    千次阅读 2014-04-02 16:02:52
    最近老大让看看redis中数据类型,list中单个element元素,能不能设置过期(不是针对整个list),整个list是可以直接设置过期的。网上搜结果list单个元素不支持自动过期设置expire ...②使用有序集合,来实现。(每...
  •  列表(list)类型是用来存储多个字符串,元素从左到右组成一个有序集合.列表中的每个字符串被称为元素(element),一个列表最多可以存储(2的32次方)-1个元素.在redis中,可以对列表两端插入(push)和弹出(pop),还可以...
  • 概述 继承Collection接口,是Collection的子类 ...存储顺序一致,有对应的...元素允许重复元素因此可以用equals方法来比较,自定义对象话我们要重写hashCode和equals方法 常用方法 public void add(int i...
  • 任意对象的有序集合列表是一组任意类型的值,按照一定顺序组合而成的2.通过偏移读取组成列表的值叫做元素(Elements)。每一个元素被标识一个索引,第一个索引是0,序列的功能都能实现3.可变长度,异构以及任意嵌套...
  • package ... import scala.collection.mutable.ListBuffer /** * List有序可重复集合列表List基本使用 */ object ListDemo { def main(args: Array[String]): Unit = { // 创建空列表 ...
  • 1、元组 任意对象(任意数据类型 )的有序集合,属于不可变序列序列类型(没有增删改) 2、创建元组 元组用()定义 ,创建空元组:元组名=() 3、数据之间用 ,(逗号)分割,元组 中只包含一个元素时,一定记得要...
  • 有序单链表表示集合,能够完成集合的并、交、差等运算。要求:1)集合元素限定为英文字母;2)输出结果以字符序列形式输出。
  • python redis详解(七)ZSET有序集合

    千次阅读 2019-07-13 20:13:43
    redis有序集合: Redis zset 和 set 一样也是string类型元素集合,且不允许重复的成员。 不同的是每个元素都会关联一个double类型的分数。redis正是通过分数来为集合中的成员进行从小到大的排序。 zset的成员是唯一...
  • 对于集合我们再熟悉不过了,在面试的过程中,也是必不可少的环节,我们都知道Collection是一个接口,Set,List分别实现了该接口,Map存放是元素是以键值对的形式存放的,并且我们也都知道Set存放的是无序不可重复,...
  • 用户可以根据元素的整数索引(在列表中的位置)访问元素,并搜索列表中的元素。 与 set 不同,列表通常允许重复的元素。 List接口成员方法 拥有父类所有方法 void add(int index,E element) 在指定位置添加元素 E ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 121,666
精华内容 48,666
关键字:

列表是有序的元素集合