精华内容
下载资源
问答
  • 在信息检索或top-n推荐中,...# 按列表a中元素的值进行排序,并返回元素对应索引序列 a = [1, 3, 4, 5, 2, 7, 9] print('a:', a) sorted_id = sorted(range(len(a)), key=lambda k: a[k], reverse=True) print('元素

    在信息检索或top-n推荐中,我们会为用户推荐一个有序产品列表,这里的“有序”体现在列表中前面的产品相比于列表后面的产品被算法预测为更容易被用户选择,这要求我们按每个产品出现的概率对产品进行排序。可以参考以下示例:

    # 按列表a中元素的值进行排序,并返回元素对应索引序列
    a = [1, 3, 4, 5, 2, 7, 9]
    print('a:', a)
    sorted_id = sorted(range(len(a)), key=lambda k: a[k], reverse=True)
    print('元素索引序列:', sorted_id)

    结果为: 

    a: [1, 3, 4, 5, 2, 7, 9]
    元素索引序列: [6, 5, 3, 2, 1, 4, 0]

    可以看到这里用到了sorted函数,改函数可以指定键对可迭代对象进行排序,功能比较强大。关于该函数的具体使用方法可以参考:

    Python3 sorted() 函数

     

    展开全文
  • MongoDB 多键索引

    千次阅读 2016-12-22 14:56:45
    在MongoDB中可以基于数组来创建索引。MongoDB为数组每一个元素创建索引值。多键索引支持数组字段的高效查询。多键索引能够基于字符串,数字数组以及嵌套文档进行创建。本文主要描述多键索引并给出演示示例。

    在MongoDB中可以基于数组来创建索引。MongoDB为数组每一个元素创建索引值。多键索引支持数组字段的高效查询。多键索引能够基于字符串,数字数组以及嵌套文档进行创建。本文主要描述多键索引并给出演示示例。

    一、多键索引

        基于一个数组创建索引,MongoDB会自动创建为多键索引,无需刻意指定
        多键索引也可以基于内嵌文档来创建
        多键索引的边界值的计算依赖于特定的规则
        注,多键索引不等于在文档上的多列创建索引(复合索引)
    
        创建语法
                db.coll.createIndex( { <field>: < 1 or -1 > } )
    
        复合多键索引
                对于一个复合多键索引,每个索引最多可以包含一个数组。
                在多于一个数组的情形下来创建复合多键索引不被支持。
    
        假定存在如下集合
                { _id: 1, a: [ 1, 2 ], b: [ 1, 2 ], category: "AB - both arrays" }
    
        不能基于一个基于{ a: 1, b: 1 }  的多键索引,因为a和b都是数组
    
        假定存在如下集合
                { _id: 1, a: [1, 2], b: 1, category: "A array" }
                { _id: 2, a: 1, b: [1, 2], category: "B array" }
    
                则可以基于每一个文档创建一个基于{ a: 1, b: 1 }的复合多键索引
                原因是每一个索引的索引字段只有一个数组
    
        一些限制
                不能够指定一个多键索引为分片片键索引
                哈希索引不能够成为多键索引
                多键索引不支持覆盖查询
    
        基于整体查询数组字段
                当一个查询筛选器将一个数组作为整体实现精确匹配时,MongoDB可以使用多键索引查找数组的第一个元素,
                但不能使用多键索引扫描寻找整个数组。相反,使用多键索引查找查询数组的第一个元素后,MongoDB检索
                相关文档并且过滤出那些复合匹配条件的文档。                       
    

    二、示意图

    如下图,基于集合上的数组创建多键索引,且数组为内嵌文档
    多键索引

    三、创建多键索引

    1、演示环境

        > db.version()
        3.2.10
    
        >db.inventory.insertMany([
        { _id: 5, type: "food", item: "aaa", ratings: [ 5, 8, 9 ] },
        { _id: 6, type: "food", item: "bbb", ratings: [ 5, 9 ] },
        { _id: 7, type: "food", item: "ccc", ratings: [ 9, 5, 8 ] },
        { _id: 8, type: "food", item: "ddd", ratings: [ 9, 5 ] },
        { _id: 9, type: "food", item: "eee", ratings: [ 5, 9, 5 ] }])
    
        //下面基于ratings列创建一个多键索引
        > db.inventory.createIndex( { ratings: 1 } )
        {
                "createdCollectionAutomatically" : false,
                "numIndexesBefore" : 1,
                "numIndexesAfter" : 2,
                "ok" : 1
        }
    
        //查询数组上为5,9的文档
        > db.inventory.find( { ratings: [ 5, 9 ] } )
        { "_id" : 6, "type" : "food", "item" : "bbb", "ratings" : [ 5, 9 ] }
    
        //下面查看其执行计划
        > db.inventory.find( { ratings: [ 5, 9 ] } ).explain()
        {
         "queryPlanner" : {
               ........
                 "inputStage" : {
                         "stage" : "IXSCAN",
                         "keyPattern" : {
                                 "ratings" : 1
                         },
                         "indexName" : "ratings_1",
                         "isMultiKey" : true,   //这里表明查询使用到了多键索引
                          .......
                         "direction" : "forward",
                         "indexBounds" : {
                                 "ratings" : [
                                         "[5.0, 5.0]",
                                         "[[ 5.0, 9.0 ], [ 5.0, 9.0 ]]"
              ..........
         "ok" : 1
        }
    
        //在上面的示例中,使用了多键索引进行扫描,MongoDB寻找在ratings数组任意位置包含5的文档
        //然后MongoDB检索这些文档,并过滤出那些等于[ 5, 9 ]的文档
    

    2、基本索引数组

        假定存在下列集合
        { _id: 1, item: "ABC", ratings: [ 2, 5, 9 ] }
    
        在ratings上创建索引
        db.survey.createIndex( { ratings: 1 } )
    
        这个多键索引则包括2,5,9三个索引键,每一个分别指向相同的文档
    

    3、基于内嵌文档的索引数组

        //创建演示文档
        > db.inventory.drop()
        > db.inventory.insertMany([
        {
          _id: 1,
          item: "abc",
          stock: [
            { size: "S", color: "red", quantity: 25 },
            { size: "S", color: "blue", quantity: 10 },
            { size: "M", color: "blue", quantity: 50 }
          ]
        },
        {
          _id: 2,
          item: "def",   // Author : Leshami
          stock: [       // Blog   : http://blog.csdn.net/leshami
            { size: "S", color: "blue", quantity: 20 },
            { size: "M", color: "blue", quantity: 5 },
            { size: "M", color: "black", quantity: 10 },
            { size: "L", color: "red", quantity: 2 }
          ]
        },
        {
          _id: 3,
          item: "ijk",
          stock: [
            { size: "M", color: "blue", quantity: 15 },
            { size: "L", color: "blue", quantity: 100 },
            { size: "L", color: "red", quantity: 25 }
          ]
        }])
    
        //下面基于内嵌文档的2个键来创建索引
        > db.inventory.createIndex( { "stock.size": 1, "stock.quantity": 1 } )
        {
                "createdCollectionAutomatically" : false,
                "numIndexesBefore" : 1,
                "numIndexesAfter" : 2,
                "ok" : 1
        }
    
        //查询内嵌文档stock.size为M的执行计划
        > db.inventory.find( { "stock.size": "M" } ).explain()
        {
         "queryPlanner" : {
            ........
            "winningPlan" : {
                    "stage" : "FETCH",
                    "inputStage" : {
                            "stage" : "IXSCAN",  //基于索引的扫描
                            "keyPattern" : {
                                    "stock.size" : 1,
                                    "stock.quantity" : 1
                            },
                            "indexName" : "stock.size_1_stock.quantity_1",
                               .......
                            "indexBounds" : {
                                    "stock.size" : [
                                            "[\"M\", \"M\"]"
                                    ],
                                    "stock.quantity" : [
                                            "[MinKey, MaxKey]"
                                    ]
                            }
                    }
            },
        }
    
        //基于内嵌文档2个键查询的执行计划
        > db.inventory.find( { "stock.size": "S", "stock.quantity": { $gt: 20 } } ).explain()
        {
         "queryPlanner" : {
           ..........
           "winningPlan" : {
                   "stage" : "FETCH",
                   "filter" : {
                           "stock.quantity" : {
                                   "$gt" : 20
                           }
                   },
                   "inputStage" : {
                           "stage" : "IXSCAN",  //此时同样也使用到了索引扫描
                           "keyPattern" : {
                                   "stock.size" : 1,
                                   "stock.quantity" : 1
                           },
                           "indexName" : "stock.size_1_stock.quantity_1",
                           "isMultiKey" : true,
                            .........
                           "indexBounds" : {
                                   "stock.size" : [
                                           "[\"S\", \"S\"]"
                                   ],
                                   "stock.quantity" : [
                                           "[MinKey, MaxKey]"
                   ............
         "ok" : 1
        }
    
        //基于内嵌数组排序查询
        > db.inventory.find( ).sort( { "stock.size": 1, "stock.quantity": 1 } ).explain()
        {
                "queryPlanner" : {
                        ........
                        "winningPlan" : {
                                "stage" : "FETCH",
                                "inputStage" : {
                                        "stage" : "IXSCAN", //内嵌数组排序查询也使用到了索引
                                        "keyPattern" : {
                                                "stock.size" : 1,
                                                "stock.quantity" : 1
                                        },
                                        "indexName" : "stock.size_1_stock.quantity_1",
                                        "isMultiKey" : true,
                                         ...........
                                        "indexBounds" : {
                                                "stock.size" : [
                                                        "[MinKey, MaxKey]"
                                                ],
                                                "stock.quantity" : [
                                                        "[MinKey, MaxKey]"
                                                ]
                                        }
                                }
                        },
                        "rejectedPlans" : [ ]
                },
        }
    
        //基于内嵌数组一个键作为过滤,一个键作为排序查询的执行计划
        > db.inventory.find( { "stock.size": "M" } ).sort( { "stock.quantity": 1 } ).explain()
        {
         "queryPlanner" : {
           ..........
           "winningPlan" : {
                   "stage" : "FETCH",
                   "inputStage" : {
                           "stage" : "IXSCAN",
                           "keyPattern" : {
                                   "stock.size" : 1,
                                   "stock.quantity" : 1
                           },
                           "indexName" : "stock.size_1_stock.quantity_1",
                           "isMultiKey" : true,
                           "isUnique" : false,
                           "isSparse" : false,
                           "isPartial" : false,
                           "indexVersion" : 1,
                           "direction" : "forward",
                           "indexBounds" : {
                                   "stock.size" : [
                                           "[\"M\", \"M\"]"
                                   ],
                                   "stock.quantity" : [
                                           "[MinKey, MaxKey]"
           "rejectedPlans" : [ ]
           .......
         "ok" : 1
        }
    

    更多参考
    MongoDB 单键(列)索引
    MongoDB 复合索引
    MongoDB执行计划获取(db.collection.explain())
    DBA牛鹏社(SQL/NOSQL/LINUX)

    展开全文
  • MongoDB多键索引(数组上建立索引)

    万次阅读 2018-08-21 16:52:42
    这种多键索引可以有效的支持数组元素查询。多键索引建立在具体的值(比如字符串、数字)或内嵌文档的数组上。     一、创建多键索引 创建多键索引的语法:db.collection.createIndex() db.coll.createIndex...

    如果要索引数组类型的字段,MongoDB可以在数组每个元素上创建索引。这种多键索引可以有效的支持数组元素查询。多键索引建立在具体的值(比如字符串、数字)或内嵌文档的数组上。

     

     

    一、创建多键索引

    创建多键索引的语法:db.collection.createIndex()

    db.coll.createIndex({<field>:<1 or -1>})

    MongoDB会自动在数组字段上面创建多键索引,不需要我们做特别的声明

     

    二、索引边界

    如果是多键索引,索引边界的计算需要遵循特殊的规则

    索引的扫描边界定义了查询过程中索引查找的范围。当多个查询的条件字段在索引中存在时,MongoDB将会使用交集或者并集来判断这些条件字段的边界最终产生一个最小的扫描边界。

     

    1、多键索引的交集边界

    交集边界是多个边界的逻辑相交,例如:给定两个边界:【3,+∞)和(-∞,6】,则两个边界相交的结果就是【3,6】

    对于给定的数组字段,假定一个查询使用了数组的多个条件字段并且可以使用多键索引。如果使用了$elemMatch连接了条件字段,则MongoDB将会相交多键索引边界

    例如:一个survey集合包含的文档里面有一个item字段和一个ratings数组字段

    { _id: 1, item: "ABC", ratings: [ 2, 9 ] } { _id: 2, item: "XYZ", ratings: [ 4, 3 ] }

    在ratings数组上创建多键索引:

    db.survey.createIndex({ratings:1})

    下面的查询使用$elemMatch来查询数组中最少有一个元素匹配下面的条件:

    db.survey.find({ratings:{$elemMatch:{$gte:3,$lte:6}}})

    分别处理查询条件:

    大于等于3的查询条件

    小于等于6的查询条件

    因为查询使用了$elemMatch来连接这两个查询条件,所以MongoDB会相交这两个边界得到:

    ratings:[[3,6]]

    如果查询没有使用$elemMatch来连接数组字段,则MongoDB不会相交多键边界。看下面的查询:

    db.survey.find( { ratings : { $gte: 3, $lte: 6 } } )

    这个查询查找的是ratings数组的元素里面至少有一个元素大于等于3且至少有一个元素小于等于6.因为单个元素不需要同时匹配这两个条件,所以MongoDB不需要取【3,+∞)或(-∞,6】的交集,使用者两个边界中的一个就行了。MongoDB没有承诺将会选择这两个边界的哪一个。

    对于在具体的值上声明的特定条件的查询,MongoDB不会使用组合多键索引来连接具体值字段的边界,即使查询的条件就是具体的值。

     

    2、多键索引的并集

    并集常常用在确定多键组合索引的边界。例如:给定的组合索引{a:1,b:1},在字段a上有一个边界:【3,+∞),在字段b上有一个边界:(-∞,6】,相并这两个边界的结果是:

    { a: [ [ 3, Infinity ] ], b: [ [ -Infinity, 6 ] ] }

    如果MongoDB没法并集这两个边界,MongoDB将会强制使用索引的第一个字段的边界来进行索引扫描,在这种情况下就是: a: [ [ 3, Infinity ] ]

     

    3、数组字段的组合索引

    假如一个组合多键索引,比如一个组合索引的索引字段是数组,

    例子::一个survey集合包含的文档里面有一个item字段和一个ratings数组字段

    { _id: 1, item: "ABC", ratings: [ 2, 9 ] } { _id: 2, item: "XYZ", ratings: [ 4, 3 ] }

    在item字段和ratings字段创建一个组合索引:

    db.survey.createIndex( { item: 1, ratings: 1 } )

    下面的查询条件声明了索引包含的两个key:

    db.survey.find( { item: "XYZ", ratings: { $gte: 3 } } )

     

    分别处理查询条件:

    • item: "XYZ" -->  [ [ "XYZ", "XYZ" ] ];
    • ratings: { $gte: 3 } -->  [ [ 3, Infinity ] ].

    MongoDB使用并集边界来组合这两个边界:

    { item: [ [ "XYZ", "XYZ" ] ], ratings: [ [ 3, Infinity ] ] }

     

    4、内嵌文档的数组上建立组合索引

    如果数组包含的是内嵌文档,想在包含的内嵌文档字段上建立索引,需要在索引声明中使用逗号来分隔字段名。

    例如:给定的内嵌文档数组:

    ratings: [ { score: 2, by: "mn" }, { score: 9, by: "anon" } ]

    则score的逗号字段名称就是:ratings.score

     

    5、在不是数组类型的字段和数组类型字段上进行并集

    假设有一个survey2集合包含如下文档:

    { _id: 1, item: "ABC", ratings: [ { score: 2, by: "mn" }, { score: 9, by: "anon" } ] } { _id: 2, item: "XYZ", ratings: [ { score: 5, by: "anon" }, { score: 7, by: "wv" } ] }

     

    在item和数组字段ratings.score和ratings.by上创建一个组合索引:

    db.survey2.createIndex( { "item": 1, "ratings.score": 1, "ratings.by": 1 } )

     

    下面的查询使用到这三个条件字段:

    db.survey2.find( { item: "XYZ", "ratings.score": { $lte: 5 }, "ratings.by": "anon" } )

     

    分别对查询条件进行处理:

    • item: "XYZ"  --> [ [ "XYZ", "XYZ" ] ];
    • score: { $lte: 5 } -->  [ [ -Infinity, 5 ] ];
    •  by: "anon" --> [ "anon", "anon" ].

    MongoDB可以组合 item键的边界与 ratings.score和ratings.by两个边界中的一个,到底是score还是by这取决于查询条件和索引键的值。MongoDB不能确保哪个边界和item字段进行并集。

    例子:MongoDB可能选择组合item边界和ratings.score边界:

    { "item" : [ [ "XYZ", "XYZ" ] ], "ratings.score" : [ [ -Infinity, 5 ] ], "ratings.by" : [ [ MinKey, MaxKey ] ] }

    或者MongoDB可能选择组合item边界与ratings.by字段

    { "item" : [ [ "XYZ", "XYZ" ] ], "ratings.score" : [ [ MinKey, MaxKey ] ], "ratings.by" : [ [ "anon", "anon" ] ] }

     

    然而,如果想组合ratings.score和ratings.by边界,则查询必须使用$elemMatch。

     

    6、数组字段索引的并集边界

    在数组内部并集索引键的边界:

    • 除了字段名称外,索引键必须有相同的字段路径
    • 查询的时候必须在路径上使用$elemMatch进行声明

    对于内嵌的文档,使用逗号分隔的路径,比如a.b.c.d是字段d的路径。为了在相同的数组上并集索引键的边界,需要$elemMatch必须使用在a.b.c的路径上

    例子:在ratings.score和ratings.by字段上创建组合索引:

    db.survey2.createIndex( { "ratings.score": 1, "ratings.by": 1 } )

    字段ratings.score和ratings.by拥有共同的路径ratings。下面的查询使用$elemMatch则要求ratings字段必须包含一个元素匹配这两个条件:

    db.survey2.find( { ratings: { $elemMatch: { score: { $lte: 5 }, by: "anon" } } } )

    分别对查询条件进行处理:

    • score: { $lte: 5 } --> [ -Infinity, 5 ];
    • by: "anon"--> [ "anon", "anon" ].

    MongoDB可以使用并集边界来组合这两个边界:

    { "ratings.score" : [ [ -Infinity, 5 ] ], "ratings.by" : [ [ "anon", "anon" ] ] }

     

    7、不使用$elemMatch进行查询

    如果不使用$elemMatch来连接数组索引字段的条件,MongoDB不会并集他们的边界。看如下的查询:

    db.survey2.find( { "ratings.score": { $lte: 5 }, "ratings.by": "anon" } )

    因为一个数组内嵌文档不需要都匹配这两个规则,MongoDB不会并集他们的边界。当使用到组合索引的时候,如果MongoDB不能使用索引的所有字段,mongod会使用排在前面的索引字段,比如这个例子的ratings.score

    { "ratings.score": [ [ -Infinity, 5 ] ], "ratings.by": [ [ MinKey, MaxKey ] ] }

     

    8、不完整的路径上使用$elemMatch

    如果查询语句没有在内嵌文档字段的路径上使用$elemMatch,则MongoDB也是不能并集索引建边界

    例子:survey3集合包含一个item字段和ratings数组:

    { _id: 1, item: "ABC", ratings: [ { scores: [ { q1: 2, q2: 4 }, { q1: 3, q2: 8 } ], loc: "A" }, { scores: [ { q1: 2, q2: 5 } ], loc: "B" } ] } { _id: 2, item: "XYZ", ratings: [ { scores: [ { q1: 7 }, { q1: 2, q2: 8 } ], loc: "B" } ] }

     

    在ratings.scores.q1和ratings.scores.q2上创建组合索引:

    db.survey3.createIndex( { "ratings.scores.q1": 1, "ratings.scores.q2": 1 } )

    ratings.scores.q1和ratings.scores.q2的公共路径是ratings.scores,$elemMatch必须用在这个路径上面

    下面的查询,使用了$elemMatch但是并没有用在要求的路径上:

    db.survey3.find( { ratings: { $elemMatch: { 'scores.q1': 2, 'scores.q2': 8 } } } )

    在这种情况下,MongoDB不会并集边界,并且在索引扫描的时候,ratings.score.q2不会使用索引。为了并集边界,查询必须在路径ratings.scores上使用$elemMatch:

    db.survey3.find( { 'ratings.scores': { $elemMatch: { 'q1': 2, 'q2': 8 } } } )

     

    三、限制

    1、组合多键索引

    对于一个组合多键索引,每个索引文档最多只能有一个索引字段的值是数组。如果组合多键索引已经存在了,不能在插入文档的时候违反这个限制。

    例如:假设有个集合包含如下文档:

    { _id: 1, a: [ 1, 2 ], b: [ 1, 2 ], category: "AB - both arrays" }

     

    不能在{a:1,b:1}上创建组合多键索引,因为a,b都是数组

     

    再看下面的文档:

    { _id: 1, a: [1, 2], b: 1, category: "A array" } { _id: 2, a: 1, b: [1, 2], category: "B array" }

    允许在上面的各个文档上面创建多键索引{ a: 1, b: 1 },因为只有一个字段是数组类型。没有文档同时是数组。当创建这个组合多键索引之后,如果想插入一个文档包含A,B两个数组的话,那么就会插入失败。

     

    2、分片键

    不能声明一个多键索引作为分片键索引

    然而如果分片键索引是一个组合索引的前缀,如果其他的键(例如这些键不是分片键的一部分)中的一个在数组上建立了索引,则这个组合索引可以变成组合多键索引。组合多键索引对性能有影响。

     

    3、哈希索引

    哈希索引不能拥有多键

     

    4、覆盖查询

    多键索引不能进行覆盖查询

     

    5、把数组作为一个整体进行查询

    当一个查询声明把数组整体作为精确匹配的时候,MongoDB可以使用多键索引来查找这个查询数组的第一个元素,但是不能使用多键索引扫描来找出整个数组。代替方案是当使用多键索引查询出数组的第一个元素之后,MongoDB再对过滤之后的文档再进行一次数组匹配

    例子:inventory集合包含如下的文档:

    { _id: 5, type: "food", item: "aaa", ratings: [ 5, 8, 9 ] } { _id: 6, type: "food", item: "bbb", ratings: [ 5, 9 ] } { _id: 7, type: "food", item: "ccc", ratings: [ 9, 5, 8 ] } { _id: 8, type: "food", item: "ddd", ratings: [ 9, 5 ] } { _id: 9, type: "food", item: "eee", ratings: [ 5, 9, 5 ] }

     

    集合上面建立了一个多键索引:

    db.inventory.createIndex( { ratings: 1 } )

    下面的查询是查找文档的ratings是数组【5,9】:

    db.inventory.find({ratings:[5,9]})

     

    MongoDB可以使用多键索引找到文档中包含5的ratings数组,然后MongoDB再检索这些文档中的数组等于数组【5,9】

     

    例子:

    1、索引基本数组

    假如survey有如下的文档

    { _id: 1, item: "ABC", ratings: [ 2, 5, 9 ] }

    在字段ratings上面创建索引:

    db.survery.createIndex({ratings:1})

    因为ratings字段是一个数组,所以该索引是一个多键索引,该多键索引包含下面三个索引键,每个都指向相同的文档:

    • 2,
    • 5,
    • 9.

    2、索引数组内嵌文档

    可以在数组字段的内嵌对象上创建多键索引

    假如inventory集合有如下文档:

    { _id: 1, item: "abc", stock: [ { size: "S", color: "red", quantity: 25 }, { size: "S", color: "blue", quantity: 10 }, { size: "M", color: "blue", quantity: 50 } ] } { _id: 2, item: "def", stock: [ { size: "S", color: "blue", quantity: 20 }, { size: "M", color: "blue", quantity: 5 }, { size: "M", color: "black", quantity: 10 }, { size: "L", color: "red", quantity: 2 } ] } { _id: 3, item: "ijk", stock: [ { size: "M", color: "blue", quantity: 15 }, { size: "L", color: "blue", quantity: 100 }, { size: "L", color: "red", quantity: 25 } ] }

     

    下面的操作将会在stock.size和stock.quantity上面创建多键索引:

    db.inventory.createIndex({"stock.size":1,"stock.quantity":1})

    这个组合多键索引支持查询条件中包含这两个索引字段,也支持仅仅包含字段:stock.size的查询。见下面的例子中:

    db.inventory.find( { "stock.size": "M" } ) db.inventory.find( { "stock.size": "S", "stock.quantity": { $gt: 20 } } )

     

    组合多键索引也支持排序操作,见下例:

    db.inventory.find( ).sort( { "stock.size": 1, "stock.quantity": 1 } ) db.inventory.find( { "stock.size": "M" } ).sort( { "stock.quantity": 1 } )

    展开全文
  • python列表中查找某个元素索引

    千次阅读 2021-03-01 14:47:50
    方法一: 利用数组自身的特性 a.index(target), 其中a是你的目标list,target是你需要的下标对应的值 a=[72, 56, 76, 84, 80, 88] print(a.index(76)) output: 2 参考:...
    方法一: 利用数组自身的特性 a.index(target), 其中a是你的目标list,target是你需要的下标对应的值
    a=[72, 56, 76, 84, 80, 88]
    print(a.index(76))
    output:
    2
    

    参考:https://blog.csdn.net/qq_38412868/article/details/90246614

    展开全文
  • 算法:键索引计数法

    千次阅读 2014-01-12 09:36:34
    假设数组a[]中的每个元素都保存了一个名字和一个组号,其中组号在0到R-1之间,以组号为进行分组排序;    二、步骤  频率统计:使用int数组计算每个出现的频率;  将频率转换成索引:使用count[]...
  • Golang map的多键索引

    千次阅读 2019-05-20 16:39:18
    在大多数的编程语言中,映射容器的必须以单一值存在。这种映射方法经常被用在诸如信息索引上,如根据通讯簿的名字进行检索。但随着查询条件越来越复杂,检索也会变得越发困难。 代码示例: package main ...
  • python列表索引总结

    万次阅读 多人点赞 2019-06-03 19:17:25
    Python包含6种内建序列: 列表 元组 字符串 Unicode字符串 buffer对象 ...序列中的每个元素都有编号,即其位置或索引,其中第一个元素索引为0,第二个元素索引为1,依此类推。在有些编程语...
  • 集合是否包含某些元素,获取元素索引位置,元素排序
  • Python中字典和列表索引效率

    万次阅读 2018-07-26 19:28:31
     Python有多种内建的序列,所有序列都可以做某些特定的操作,大致上常用的是:加,乘,索引,分片以及检查某个元素是否属于序列的成员。 在这里我们重点讨论两种,字典与列表。并且只讨论其索引效率   列表  ...
  • golang:map的多键索引

    千次阅读 2019-03-31 15:03:00
    if _, ok := map[key]; ok { //存在 } 原文:https://blog.csdn.net/xielingyun/article/details/49996247
  • 使用Python按照索引查找元素

    千次阅读 2019-03-21 09:11:06
    #Search elements in every row using index X = np.random.randint(1,10, [5,6]) print(X) Y = np.array([0,3,2,4,5]) length = len(X) B = [] ...for i in range(length): ... Index = np.take(X[i],Y[i]...
  • 列表索引

    千次阅读 2014-05-07 10:17:40
    一种直接的办法是将大小为M的数组中的每个元素指向一条链表,链表中的每个节点都存储了散列值为该元素索引的键值对。这种方法称为 拉链法 。 这个方法的 基本思想 就是选择足够大的M,使得所有链表都尽可能短...
  • mysql索引详解

    万次阅读 多人点赞 2021-07-07 21:40:09
    分别为:表定义文件、数据文件、索引文件。第一个文件的名字以表的名字开始,扩展名指出文件类型。.frm文件存储表定义。数据文件的扩展名为.MYD (MYData)。索引文件的扩展名是.MYI (MYIndex)。 InnoDB:所有的表都...
  • HTML——标签元素索引

    千次阅读 2016-09-21 14:15:23
    <event> 代表事件状态,如事件发生的元素,键盘状态,鼠标位置和鼠标按钮状态。 <external> 允许访问由 Microsoft? Internet Explorer 浏览器组件宿主应用程序提供的附加对象模型。 <fieldSet> 在字段集包含的...
  • 数组排序并找出元素索引

    千次阅读 2017-11-11 22:01:10
    题目描述:先给数组排序,然后找到指定的值在数组的位置,最后返回位置对应的索引。举例:where([1,2,3,4], 1.5) 应该返回 1。因为1.5插入到数组[1,2,3,4]后变成[1,1.5,2,3,4],而1.5对应的索引值就是1。同理,where...
  • MongoDB 唯一索引

    万次阅读 2016-12-22 17:02:58
    MongoDB支持的索引种类很多,诸如单键索引,复合索引,多键索引,TTL索引,文本索引,空间地理索引等。同时索引的属性可以具有唯一性,即唯一索引。唯一索引用于确保索引字段不存储重复的值,即强制索引字段的唯一性...
  • 字典是非常常用的一种数据结构,它与json格式的数据非常相似,核心就是以键值对的形式存储数据...字典不再是序列,无法通过位置索引完成元素值的获取,只能通过键索引实现。 字典与列表一样,都是可变类型的数据结构。
  • python 列表list中元素添加的四种方式

    千次阅读 2020-11-19 08:48:46
    python 列表list中元素添加的四种方式(append,extend,insert,“+”号...3.insert(index,value) 将一个元素插入到列表中,有参数有两个,第一个参数index是索引点,即插入的位置,第二个参数value是插入的元素。...
  • 其实思路和获取列表索引的道理一样。如果你还不知道如何获取列表索引,那么现在我先给大家介绍一下: 1. 大家都知道小程序的.wxss文件类似于css文件,主要用于处理视图的样式。所以,第一步,我们在.wxss文件中...
  • 在python中,有几种重要的操作可以适用于所有的序列,其中...我们可以通过索引的方式获取元素,这种方式适应于所有的序列,当使用负索引时,Python将从最后一个元素开始往左数,因此(-1)是最后一个元素的位置。 ...
  • list 列表中插入元素

    万次阅读 2018-03-14 10:02:47
    list.append(x) 从末尾加入元素xlist.extend([x,y]) 将整个参数列表连接到原列表后面list.insert(i,x)将元素x加入列表的第i个索引'+' 两个列表直接相加,后面的连接到前面的后面...
  • 索引数组转换成按指定做key的关联数组,没有相应key的元素将被舍弃
  • 在Yii1.x中,查询特定列为(key)的数组,
  • 排序(二) 以上排序算法都有一个性质:在排序的最终结果中,各元素的次序依赖于它们之间的比较。...键索引计数法(计数排序) 计数排序假设n个输入元素中的每一个都是在0到k区间的一个整数,其中k为
  • array_key_exists — 检查给定的名或索引是否存在于数组中 bool array_key_exists ( mixed $key , array $search ) array_key_exists() 在给定的 key 存在于数组中时返回 TRUE。key 可以是...
  • 一、插入相同键元素操作 (1)insert方法 在map中的必须是唯一的,当想map中连续插入相同但值不同的元素时,编译和运行时都不会发生任何错误,系统会忽略后面的对已存在的的插入操作,如 1 mapint,...
  • js查找指定元素在数组中的索引

    千次阅读 2019-04-24 16:04:20
    多读多写多记录,多学多练多思考。----------- Grapefruit.Banuit Gang(香柚帮) function findIndex(l, o) { var objStr = JSON.stringify(o) return l.reduce((index, ele, i) => { if (JSON.stringify(ele...
  • Mysql索引

    千次阅读 2019-12-02 13:21:26
    好记忆不如烂笔头, 能记下点什么, 就记下点什么, 方便后期的巩固. 一.介绍 1.什么是索引? 2.... 1.MySQL的索引分类 2.各索引应用场景 3.索引类型 4.操作索引 5.唯一索引 四.测试...
  • MySQL索引的创建与使用

    万次阅读 多人点赞 2018-08-06 18:49:59
    索引有很多,且按不同的分类方式,又有很多种分类。不同的数据库,对索引的支持情况也不尽相同。 声明:本人主要简单示例MySQL中的单列索引、组合索引的创建与使用。 索引的创建: 建表时创建: CREATE TABLE ...
  • 索引数组

    千次阅读 2018-11-09 15:27:51
    数字索引数组 是最常见的数组类型,绝大多数编程语言都有数字索引数组,PHP数字索引数组一般表示数组元素在数组中的位置,它由数字组成,下标从0开始。数字索引数组默认索引值就是从数字0开始的,不需要特别指定。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 193,588
精华内容 77,435
关键字:

列表通过键索引元素