在信息检索或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中可以基于数组来创建索引。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()) 
 

如果要索引数组类型的字段，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 } )
 

方法一： 利用数组自身的特性 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