index 订阅
动漫作品《魔法禁书目录》中女主角。有着银色的长发、绿色的眼瞳、雪白的肌肤,年龄约十四五岁,却有着可爱的幼儿体型。英国清教所属修女,拥有完全记忆能力,是记忆了十万三千本魔法书的魔道书图书馆。身穿被称作“移动教会”的修道服。虽然语言学习能力优秀,不过对科学领域特别是关于机械的适应能力几乎等于零。 展开全文
动漫作品《魔法禁书目录》中女主角。有着银色的长发、绿色的眼瞳、雪白的肌肤,年龄约十四五岁,却有着可爱的幼儿体型。英国清教所属修女,拥有完全记忆能力,是记忆了十万三千本魔法书的魔道书图书馆。身穿被称作“移动教会”的修道服。虽然语言学习能力优秀,不过对科学领域特别是关于机械的适应能力几乎等于零。
信息
国    籍
英国
隶    属
第零圣堂区·必要之恶教会
配    音
井口裕香、杨凯凯(中国台湾) [1]
职    业
修女
职    位
魔道书图书馆
魔法名
Dedicatus545
出身地
伦敦
别    名
Index-Librorum-Prohibitorum(全名)
中文名
茵蒂克丝
宗    派
英国清教
身    高
148 cm
性    别
外文名
インデックス Index
年    龄
14、15岁
登场作品
《魔法禁书目录》 《科学超电磁炮》
茵蒂克丝人物形象
自幼在英国的圣乔治大圣堂里长大,隶属于英国清教第零圣堂区必要之恶教会的魔道书图书馆,正式名称为“Index-Librorum-Prohibitorum(禁书目录)”,“Index”是省略版。魔法名为“Dedicatus545(拉丁文原意:献身)”,寄托的意义为“献身的羔羊守护强者的知识”。因为拥有完全记忆能力,所以被课以沉重的使命,记忆里存放了十万三千本魔道书的内容,是“成为魔神之前的领域”的专家 [2]  ,教会则以确保大脑容量为理由,每年都要删除一次记忆。不过,在上条当麻为她解除了这道枷锁之后,就寄宿在学园都市的学生宿舍,成为了上条家的食客,还拥有学园都市的来宾临时ID。 少女有着一头及腰的银色长发,绿色的眼瞳和雪白的肌肤。年龄大约14、5岁 [3-4]  ,但和相同年纪的平均身高相较之下,她的个子略微娇小,所以会给人一种较为年幼的印象 [5]  。虽然个子娇小,体重也很轻,但是体温似乎要比正常人高一点。明明什么都没擦,肌肤却散发出淡淡的香甜 [4]  。茵蒂克丝所穿的、纯白丝质金线刺绣超豪华的修道服名曰“移动教会”。看起来就像是一件长度到达脚踝的连身洋装,但是头上的帽子却有别于一般,是用一块布包起来的。但是一般修道服应该是黑色的,茵蒂克丝的修道服却是纯白色的,并且每个角落都有金色的刺绣,让人联想到高级茶杯。本性和她的稚嫩外表相符,是一个毫无心机、天真烂漫的女孩,有着孩子般的言行 [6]  。虽然看起来温吞悠哉,但却实是拥有虔诚之心的修女 [6]  ,会竭尽所能照顾弱者。讨厌有人受伤,即使自己的生命有危险依然会担心他人,是个“为了他人而受伤,却依然能够带着笑容的少女” [7]  。能够微笑着接受“禁书目录”这个凄绝宿命,这也展现出了她刚强的一面。但是,博爱主义的茵蒂克丝,唯独讨厌科学家 [8]  。
收起全文
精华内容
下载资源
问答
  • 05.elasticsearch-index相关总结

    万次阅读 2020-10-19 16:27:57
    index常规设置1. static setting1. index.number_of_shards2. index.shard.check_on_startup3. index.codec4. index.routing_partition_size: 这个是自定义routing的时候可以做的一些设置5. index.load_fixed_...

    文章目录

    1. 简介

    index modules 主要是介绍index各个方面的特性,算是一些总结和补充
    主要内容有以下几方面

    1. 常见的index settings: 每个index在index level的设置,有static和dynamic之分,这些属性相对来说比较碎一些,相对来说不牵扯另一个完整的功能模块,而且有些直接是index自己的属性(比如name,shard数量等),所以放在这里
    2. index的各个功能特性
      1. analysis相关的特性设置
      2. index shard allocation 相关的设置
      3. maping 设置
      4. merging 设置,控制shard的background merge 进程的工作方式
      5. similarities 设置,自定义相似度计算模型来计算search的result的score
      6. slowlog 设置,控制记录慢查询
      7. store 设置,设置shard data存储的文件系统的类型
      8. tranlog , 控制transaction log和background flush 操作。
    3. x-pack index想过的设置
      1. index lifecycle management 索引生命周期管理

    2. index常规设置

    index的常规设置一般分为两类,一类是静态的static,这一类一般都是在index create的时候指定,之后不能再进行修改(或者在index close之后才能修改),
    还有一类设置被称为动态设置dynaic setting, 这一类的设置一般可以通过api进行直接的修改。

    1. static setting

    static的settin总共有以下相关的设置

    1. index.number_of_shards: index的primary shard 数量设置
    2. index.shard.check_on_startup: 在es启动的时候对shard做哪些检查
    3. index.codec: index数据存储的编码方式(压缩方式)
    4. index.routing_partition_size: 这个是自定义routing的时候可以做的一些设置
    5. index.load_fixed_bitset_filters_eagerly: 对于nested query 是否对filter操作做预加载

    1. index.number_of_shards

    index的primary shard 数量设置, 默认为1, 即使在closed index上也不能修改,每个index的shard被限制到1024个,
    这样做是为了防止一些意外创建的index(shard过多)占用比较多的资源导致cluster不稳定。
    这个最大值可以通过java options进行设置,比如

    export ES_JAVA_OPTS="-Des.index.max_number_of_shards=128"
    

    2. index.shard.check_on_startup

    在es启动的时候对shard做哪些检查

    false: (default) 不对shard的完整性做检查
    checksum: 只校验物理存储上的完整性
    true: 不仅会校验物理存储上的完整性,还会校验逻辑存储上的完整性,这对cpu和memory来讲可能是一个非常昂贵的开销,也有可能会消耗很多时间。

    3. index.codec

    index数据存储的编码方式(压缩方式)
    默认使用LZ4压缩方式,可以设置

    "index.codec" : "best_compression"
    

    来开启使用压缩率更好的算法DEFLATE,当担这个算法对cpu的消耗更大,所以也会再一定程度上影响写入的速度。
    如果你更新了这个设置,新的存储凡是会在segments merge之后生效。

    4. index.routing_partition_size: 这个是自定义routing的时候可以做的一些设置

    这个设置的作用不是很大,可以参考index的meta field _routing来理解
    这个字段的值理论上小于index.number_of_shards(只有index.number_of_shards=1的时候可以相等),默认值为1

    5. index.load_fixed_bitset_filters_eagerly

    对于nested query 是否对filter操作做预加载,这个可能看了nested filter之后能够更近异步理解

    index.load_fixed_bitset_filters_eagerly
    Indicates whether cached filters are pre-loaded for nested queries. Possible values are true (default) and false.

    2. dynamic setting

    动态的设置是指那些可以通过api动态修改的设置,相对static设置莱多,dynaimc 设置更多一些。

    1. index.number_of_replicas: 副本replica,默认为1
    2. index.auto_expand_replicas: 副本数基于cluster中的node数进行变化,可以设置一个上限或者下限,默认是false, 这种分配方式不是很好
    3. index.search.idle.after: 分片在多久时间内没有接收搜索请求会被认为是idle的shard (默认为30秒)。
    4. index.refresh_interval: 多久执行一次refresh操作,refresh操作让这些changes能够被后面的搜索搜到。默认是1s,可以通过设置为-1来禁用refresh,如果这一项没有做显示的设计的话,如果一个shard在 index.search.idle.after时间内没有接收到search请求的话,那么这个shard不会再进行background的refresh 知道搜到search请求之后才会进行refresh,对应的search请求也会等到执行完refresh之后才会执行。这种设置主要是为了又会bulk index操作。如果不想执行这个默认的逻辑,可以通过显示的设置这个属性为1s。
    5. index.max_result_window: 翻页搜索的总记录条数from+size的总数,默认不超过10000,防止占用过高的memory,如果想进行神翻翻页的话尝试使用scroll 或者 search after api。
    6. index.max_inner_result_window: 这个和上一个类似,主要设置的是返回结果中的结果,和agg的top数,默认是100.
    7. index.max_rescore_window: 在搜索此索引时,rescore请求的window_size的最大值。默认为index.max_result_window,即10000。搜索请求占用堆内存和时间与max(window_size,from + size)成比例,这限制了内存的使用
    8. index.max_docvalue_fields_search: 查询中允许的最大docvalue_field数,默认为100,Doc-value 字段成本很高,因为它们可能会导致每个字段的每个文档搜索。
    9. index.max_script_fields: 查询中允许的最大script_field数。默认为32。
    10. index.max_ngram_diff: NGramTokenizer和NGramTokenFilter的min_gram和max_gram之间允许的最大差异。默认为1。
    11. index.max_shingle_diff: ShingleTokenFilter的max_shingle_size和min_shingle_size之间允许的最大差异。默认为3。
    12. index.blocks.read_only: 设置为true以使索引和索引元数据只读,false设置为允许写入和元数据更改。感觉这个block和下面的几个相反,好奇怪。
    13. index.blocks.read_only_allow_delete: 与index.blocks.read_only相同,但允许删除索引以释放资源。
    14. index.blocks.read: 设置为true以禁用对索引的读取操作。
    15. index.blocks.write: 设置为true以禁用对索引的数据写入操作。与read_only不同,此设置不会影响元数据。例如,您可以使用write_block 关闭索引,但不能使用read_only_block 关闭索引。
    16. index.blocks.metadata: 设置为true以禁用索引元数据读取和写入。
    17. index.max_refresh_listeners: 索引的每个分片上可用的最大刷新侦听器数。 自定义实现了refresh=wait_for的listener
    18. index.analyze.max_token_count: _analyze API能够产生的token的最大数量,默认是10000.
    19. index.highlight.max_analyzed_offset: 高亮显示的最大字符数,这个设置仅仅针对那些indexing的时候不保存term的offset 且没有保存term vectors的feild.
    20. index.max_terms_count: Term查询中可以使用的最大Term数。默认为65536。
    21. index.max_regex_length: 正则查询中正则表达式的最大长度,默认1000.
    22. index.routing.allocation.enable: 控制此索引的分片分配。all: 默认,允许所有分片分配; primaries:只允许主片分配;new_primaries:只允许新创建的primaries shard分配; none: 不允许任何分片分配
    23. index.routing.rebalance.enable: 为此索引启用分片重新平衡, all: 默认,允许分片缺失等问题发生的时候进行重新平衡,primaries: 只允许primaries进行再平衡;replicas: 只允许replicas进行再平衡;none: 不允许进行再平衡,需要进行实例测试。
    24. index.gc_deletes: 允许已删除文档的版本号,仍可用于进一步版本化操作的时间长度。默认60s
    25. index.default_pipeline: 设置默认的pipeline,默认是没有的
    26. index.final_pipeline: 最后的pipeling

    3. index的各个功能模块

    index相关的其他的module级别的特性有

    1. analysis相关的特性设置
    2. index shard allocation 相关的设置
    3. maping 设置
    4. merging 设置,控制shard的background merge 进程的工作方式
    5. similarities 设置,自定义相似度计算模型来计算search的result的score
    6. slowlog 设置,控制记录慢查询
    7. store 设置,设置shard data存储的文件系统的类型
    8. tranlog , 控制transaction log和background flush 操作。

    1. analysis相关的特性设置

    这个不再赘述,前面有相关的文档介绍了anlysis
    主要是定义 analyzers, tokenizers, token filters and character filters.

    2. index shard allocation 相关的设置

    shard allocation主要控制了node上的shard分配相关的规则,他有一下能力

    1. Shard allocation filtering: 可以控制某个shard分配到某个node
    2. Delayed allocation: 在因为一个node离开cluster的时候会造成unassigned shard,这个设置可以控制这些unassigned的shard 延迟分配。
    3. Total shards per node: 一个index在一个node上面最多可以有多少个shard

    1. Shard allocation filtering: 可以控制某个shard分配到某个node

    你可以使用shard allocation filters 来控制index的shard会被分配到哪些node上面。这个针对每个index的filters会与cluster范围内的allocation filter和 allocation awareness 配合使用。
    shard allocation filters 可与基于node attribute, built-in _name, host_ip, publish_ip, _ip 和_host attributes进行过滤。 Index lifecycle management使用filters来决定如何如何对shard进行重分配。
    shard allocation filter 的主要配置是 cluster.routing.allocation这个设置是dynamic的,可以使live index的shard从当前的node上面迁移到别的上面。当然这些迁移不能打破其他的约束,比如不能吧primary和replica shard 放到同一个node上面。

    比如说,你可以自定义一些node attribute 来指明不同node的性能特性,然后使用使用shard allocation filtering 来将不同的shard route到具有不同的硬件特性的node当中,这里适用的一个场景就是日志系统的冷热分离,如果是按天产生的索引,可以把索引进行冷热分离,集群中的机器分为两种,cold和hot, cold是大磁盘,可能直接使用机械盘,成本低,适合低写入打存储,提取速度要求不高的场景,hot是高性能磁盘,一般为ssd,但是磁盘的容量偏小,适合高写入的场景,可以将昨天的日志index迁移到cold的node,今天新产生的分配到hot node 来满足大量的写需求,同时又能满足大存储的需求,可以降低很多成本。

    1. 使用shard allocation filter的一般方式

    1.给对应的node设置attribute,假如我们为每个node标记一个容量size属性,有small,medium,big三个属性,

    node.attr.size: medium
    
    或者
    ./bin/elasticsearch -Enode.attr.size=medium
    
    
    1. 为对应的索引增加routing allocations filter
    PUT test/_settings
    {
      "index.routing.allocation.include.size": "big,medium"
    }
    
    2. index.routing.allocation可以有的设置

    index.routing.allocation.include.{attribute}
    只需要node的attribute中有一个在当前index的配置当中即可

    index.routing.allocation.require.{attribute}
    对应的node必须有全部的当前配置的attribute才会将分片分配上去

    index.routing.allocation.exclude.{attribute}
    对应的node没有任何当前配置的的attribute才会将分片分配上去

    PUT test/_settings
    {
      "index.routing.allocation.include.size": "big",
      "index.routing.allocation.include.rack": "rack1"
    }
    
    

    这个配置就会将test index 移动到rack位rack1, size为big的node上面

    3. 支持的built-in attribute

    _name: Match nodes by node name

    _host_ip: Match nodes by host IP address (IP associated with hostname)

    _publish_ip: Match nodes by publish IP address

    _ip: Match either _host_ip or _publish_ip

    _host: Match nodes by hostname

    PUT test/_settings
    {
      "index.routing.allocation.include._ip": "192.168.2.*"
    }
    

    感觉这个不常用,因为可能会变化,机器做了下线重新部署ip就变了,_name就有唯一性,不容易聚类

    2. Delayed allocation

    在因为一个node离开cluster的时候会造成unassigned shard,这个设置可以控制这些unassigned的shard 延迟分配。

    1. node left之后master会做的操作

    在一个nodeA离开cluster后,正常情况下master会做下面这些操作

    1. 将cluster中其他的node拥有的nodeA中的primary shard 对应的replica 提升为primary(因为nodeA不在了,所有的primary也就丢了)
    2. 在node够用的情况下从新allocating 那些丢失了的 replica shar
    3. 在剩下的node中进行rabalance,以保证shard在集群中均匀分配

    这些行为都是为了让集群能够避免数据丢失而且是能够更加快速的被备份。即使es对cluster层面和node层面能够并行恢复的shard数量,但是他还是会对cluster带来挺大的额外的load,如果一node突然挂了,然后又很快(几分钟)又恢复了并重新加入了集群,急着进行shard recovery似乎是不划算的。

    想象一下下面的场景

    1. node5 和集群中的其他节点发生了网络隔离,被认为died
    2. master 提升了哪些node5上的primary shard 对应的其他node上的replica为primary shard
    3. master 在cluster上面的其他节点上为丢失的replica allocate shard
    4. 每个replica再从primary copy数据(通过network)
    5. reblace,shard在cluster中的不同node之间迁移,来让集群变得更加平衡
    6. node5在几分钟后又回来了
    7. master再次进行rebalance以便于把一些shards分配到node5上面

    在这个场景下,如果master在做完第二步之后啥都不做,等待个几分钟,在node5回来之后,丢失的shards会re-allocated到node5上面,但是这样的话需要通过网络拷贝的数据量大大减小
    对于那些已经auto sync-flushed 的idle shard(没有进行index 操作),恢复会更快。

    2. 延迟分配的设置

    index的延迟分配可以通过 index.unassigned.node_left.delayed_timeout参数进行设置

    
    PUT _all/_settings
    {
      "settings": {
        "index.unassigned.node_left.delayed_timeout": "5m"
      }
    }
    
    

    如果进行了延迟分配设置,上面的情况就会变成这样

    1. node5 和集群中的其他节点发生了网络隔离,被认为died
    2. master 提升了哪些node5上的primary shard 对应的其他node上的replica为primary shard
    3. master 输出一条延迟分配的日志,记录那些unassigned shards 以及delay time
    4. cluster 保持yellow状态(因为有unassigned shards)
    5. node5 在timeout 之前重新加入了集群
    6. node5在几分钟后又回来了
    7. 丢失的replica 被重新分配到node5(如果是sync-flushed shards 那么会立刻恢复)

    这个设置仅仅会对因为node丢失导致的shard missing起作用,对新索引创建等其他情况产生的没有影响。
    在整个集群重启之后,如果重启前有node left导致的shard missing那么重启后会进行恢复
    在master 失败的情况下,已经经过的dely time会丢失,然后重新计算

    3. 延迟分配的触发后的取消

    如果延迟的时间到了,就会进行shard的recovery.如果这个时间missing node又re-join 到cluster当中了,而且他的shard 仍然和primary shard有相同的sync-id, shard relocation会被cancelled,然后原来的那个shard被用来做recovery,所以,es将默认的delay time设置为 1 minute。

    如果你要将一个node永久移除,直接将延迟设置为0即可

    PUT _all/_settings
    {
      "settings": {
        "index.unassigned.node_left.delayed_timeout": "0"
      }
    }
    
    

    然后再missing shards 开始进行recover的时候需要将这个值重新设置回来。

    4. 查看unassigned shards

    有时候索引非常多,不容易发现到底是哪个index的哪个shard异常了,可以通过health API查看

    GET _cluster/health 
    
    5. recovery的顺序
    1. the optional index.priority setting (higher before lower)
    2. the index creation date (higher before lower)
    3. the index name (higher before lower)
      这说明默认情况下新新建的index比旧的的index先进行recovery

    3. Total shards per node: 一个index在一个node上面最多可以有多少个shard

    index.routing.allocation.total_shards_per_node
    对于一个index来说,最多有多少个shards分配到单个node上面

    cluster.routing.allocation.total_shards_per_node
    对于集群范围来说,单个node的shards总数最大值

    这两个设置都要谨慎使用,使用不当容易出错。

    3. maping 设置

    这个也不再赘述,前面已经阐述很多了

    4. merging 设置,控制shard的background merge 进程的工作方式

    每一个shard都是一个lucene index, 每个lucene又由很多个segments构成,segement是数据存储的基本单元,后台会周期性的将small segment 合并为更大的segment,同时也会将delete segment删除的文档去掉。
    这个过程会自动根据当前的硬件资源使用的情况进行限速throttling ,比如会考虑当前search的压力

    使用的是ConcurrentMergeScheduler 来实现以上行为。merges是通过多个独立的线程来进行,ConcurrentMergeScheduler可以使用的最大线程数是可以设置的。

    index.merge.scheduler.max_thread_count: 设置最大可以使用的线程数

    如果没有设置的话,默认使用

     Math.max(1, Math.min(4, Runtime.getRuntime().availableProcessors() / 2)) 
    
    

    这个计算方式对于ssd来说工作的很不错,如果你的是机械转盘,可以把这个降低到1更好。

    5. similarities 设置,自定义相似度计算模型来计算search的result的score

    similarity 也被称为scoring/ranking dodel, 主要是定义了doc如何被打分。每个field都可以定义自己的similarity。
    自定义similarity可以认为是一个专家级操作,正常情况下es的built-in similarities应该就足够了。
    built-in similarities有

    1. BM25 similarity
    2. DFR similarity
    3. DFI similarity
    4. IB similarity
    5. LM Dirichlet similarity
    6. LM Jelinek Mercer similarity
    7. Scripted similarity

    在配置的时候需要注意的是,如果filed没有特殊指出使用哪个similarity es会使用名字为 default的similarity

    1. 自定义similarity的方式

    可以在创建index的时候定一个similarity

    PUT /index
    {
        "settings" : {
            "index" : {
                "similarity" : {
                  "my_similarity" : {
                    "type" : "DFR",
                    "basic_model" : "g",
                    "after_effect" : "l",
                    "normalization" : "h2",
                    "normalization.h2.c" : "3.0"
                  }
                }
            }
        }
    }
    
    
    
    PUT /index/_mapping
    {
      "properties" : {
        "title" : { "type" : "text", "similarity" : "my_similarity" }
      }
    }
    
    

    2. built-in similarities

    1. BM25 similarity

    可以有的配置
    k1: 默认值1.2, 非线性的term frequency 归一化参数
    b: 默认值0.75,doc length 归一化参数
    discount_overlaps:

    2. DFR similarity
    3. DFI similarity
    4. IB similarity
    5. LM Dirichlet similarity
    6. LM Jelinek Mercer similarity
    7. Scripted similarity

    6. slowlog 设置,控制记录慢查询

    这个就像mysql的slow log一样,可以记录慢查询/写入

    1. slow search
    2. slow index

    1. slow search

    可以设置query和fetch两个阶段的慢日志

    PUT /twitter/_settings
    {
        "index.search.slowlog.threshold.query.warn": "10s",
        "index.search.slowlog.threshold.query.info": "5s",
        "index.search.slowlog.threshold.query.debug": "2s",
        "index.search.slowlog.threshold.query.trace": "500ms",
        "index.search.slowlog.threshold.fetch.warn": "1s",
        "index.search.slowlog.threshold.fetch.info": "800ms",
        "index.search.slowlog.threshold.fetch.debug": "500ms",
        "index.search.slowlog.threshold.fetch.trace": "200ms",
        "index.search.slowlog.level": "info"
    }
    
    

    使用不同的日志等级是为了方便更快的进行grep操作。

    对应的log4j2.properties配置为

    appender.index_search_slowlog_rolling.type = RollingFile
    appender.index_search_slowlog_rolling.name = index_search_slowlog_rolling
    appender.index_search_slowlog_rolling.fileName = ${sys:es.logs.base_path}${sys:file.separator}${sys:es.logs.cluster_name}_index_search_slowlog.log
    appender.index_search_slowlog_rolling.layout.type = PatternLayout
    appender.index_search_slowlog_rolling.layout.pattern = [%d{ISO8601}][%-5p][%-25c] [%node_name]%marker %.-10000m%n
    appender.index_search_slowlog_rolling.filePattern = ${sys:es.logs.base_path}${sys:file.separator}${sys:es.logs.cluster_name}_index_search_slowlog-%i.log.gz
    appender.index_search_slowlog_rolling.policies.type = Policies
    appender.index_search_slowlog_rolling.policies.size.type = SizeBasedTriggeringPolicy
    appender.index_search_slowlog_rolling.policies.size.size = 1GB
    appender.index_search_slowlog_rolling.strategy.type = DefaultRolloverStrategy
    appender.index_search_slowlog_rolling.strategy.max = 4
    
    logger.index_search_slowlog_rolling.name = index.search.slowlog
    logger.index_search_slowlog_rolling.level = trace
    logger.index_search_slowlog_rolling.appenderRef.index_search_slowlog_rolling.ref = index_search_slowlog_rolling
    logger.index_search_slowlog_rolling.additivity = false
    
    

    2. slow index

    PUT /twitter/_settings
    {
        "index.indexing.slowlog.threshold.index.warn": "10s",
        "index.indexing.slowlog.threshold.index.info": "5s",
        "index.indexing.slowlog.threshold.index.debug": "2s",
        "index.indexing.slowlog.threshold.index.trace": "500ms",
        "index.indexing.slowlog.level": "info",
        "index.indexing.slowlog.source": "1000"
    }
    
    

    log4j2.properties配置

    appender.index_indexing_slowlog_rolling.type = RollingFile
    appender.index_indexing_slowlog_rolling.name = index_indexing_slowlog_rolling
    appender.index_indexing_slowlog_rolling.fileName = ${sys:es.logs.base_path}${sys:file.separator}${sys:es.logs.cluster_name}_index_indexing_slowlog.log
    appender.index_indexing_slowlog_rolling.layout.type = PatternLayout
    appender.index_indexing_slowlog_rolling.layout.pattern = [%d{ISO8601}][%-5p][%-25c] [%node_name]%marker %.-10000m%n
    appender.index_indexing_slowlog_rolling.filePattern = ${sys:es.logs.base_path}${sys:file.separator}${sys:es.logs.cluster_name}_index_indexing_slowlog-%i.log.gz
    appender.index_indexing_slowlog_rolling.policies.type = Policies
    appender.index_indexing_slowlog_rolling.policies.size.type = SizeBasedTriggeringPolicy
    appender.index_indexing_slowlog_rolling.policies.size.size = 1GB
    appender.index_indexing_slowlog_rolling.strategy.type = DefaultRolloverStrategy
    appender.index_indexing_slowlog_rolling.strategy.max = 4
    
    logger.index_indexing_slowlog.name = index.indexing.slowlog.index
    logger.index_indexing_slowlog.level = trace
    logger.index_indexing_slowlog.appenderRef.index_indexing_slowlog_rolling.ref = index_indexing_slowlog_rolling
    logger.index_indexing_slowlog.additivity = false
    

    7. store 设置,设置shard data存储的文件系统的类型

    1. store的类型和设置

    这个设置主要是针对文件系统的一些设置,物理机的文件系统是各种各样的,默认情况下es会根据操作系统的实际情况选择最佳读写方式,你也可以对这个进行设置。

    这个设置是static的,而且这个也是一个专家级设置,有可能后面会移除这个设置

    这个设置可以直接在elasticsearch.yml中设置全局的

    index.store.type: niofs
    
    

    也可以针对单个的index设置

    
    PUT /my_index
    {
      "settings": {
        "index.store.type": "niofs"
      }
    }
    
    

    可以有以下设置:

    • fs: 默认文件系统实现。这将根据操作环境选择最佳的实现方式,当前的操作环境在所有受支持的系统上都是hybridfs,但可能会发生变化。

    • simplefs: Simple FS类型是使用随机访问文件直接实现文件系统存储(映射到Lucene SimpleFsDirectory)。此实现的并行性能较差(多个线程将成为瓶颈)。当您需要索引持久性时,通常最好使用niofs。

    • niofs: NIO FS类型使用NIO在文件系统上存储分片索引(映射到Lucene NIOFSDirectory)。它允许多个线程同时读取同一文件。由于SUN Java实现中存在bug,因此不建议在Windows上使用。

    • mmapfs: MMap FS类型通过将文件映射到内存(mmap)将碎片索引存储在文件系统上(映射到Lucene MMapDirectory)。内存映射会占用进程中虚拟内存地址空间的一部分,该空间等于要映射的文件的大小。在使用此类之前,请确保您已允许足够的虚拟地址空间。

    • hybridfs: hybridfs类型是niofs和mmapfs的混合类型,它根据读取访问模式为每种文件类型选择最佳的文件系统类型。当前,只有Lucene term 词典,norms 和doc values 文件才进行内存映射(mmap)。使用Lucene NIOFSDirectory打开所有其他文件。与mmapfs相似,请确保已允许大量虚拟地址空间。

    如果你没有权限使用大量的memory maps 你可以通过node.store.allow_mmap 来设置,这个是一个boolean值。默认是true,你可以设置为false。

    2. 预加载数据导文件系统的缓存中

    这个也是专家级设置,将来有可能修改。
    默认情况下,Elasticsearch完全依靠操作系统文件系统缓存来缓存I / O操作。可以通过设置index.store.preload,以告知操作系统在opening索引的时候将索引文件的内容加载到内存中。
    此设置接受以逗号分隔的文件扩展名列表:扩展名在列表中的所有文件将在打开时预加载。这对提高索引的搜索性能很有用,尤其是在重新启动主机操作系统时,因为这会导致文件系统缓存被破坏。
    但是请注意,这可能会减慢索引的打开速度,因为只有将数据加载到物理内存中后,索引才能变得可用。

    这个设置可以直接在elasticsearch.yml中设置全局的

    index.store.preload: ["nvd", "dvd"]
    
    

    也可以针对单个的index设置

    PUT /my_index
    {
      "settings": {
        "index.store.preload": ["nvd", "dvd"]
      }
    }
    
    

    里面的设置也支持wildcard的设置。

    8. tranlog , 控制transaction log和background flush 操作。

    这一部分就结合es的refresh,flush操作一起来理解好了。

    1. es shard和lucene的关系

    一个lucene 的shard(后面称es_shard)在lucene中对应了一个索引index(后面称lucene_index)
    lucene_index 的构成是由多个segment构成的。

    2. luncene_index满足事务特性,

    1. 当IndexReader.open打开一个索引的时候,相对于给当前索引进行了一次snapshot,此后的任何修改都不会被看到。
    2. 仅当IndexReader.open打开一个索引后,才有可能看到从上次打开后对索引的修改。
    3. 当IndexWriter没有调用Commit的时候,其修改的内容是不能够被看到的,哪怕IndexReader被重新打开。
    4. 欲使最新的修改被看到,一方面IndexWriter需要commit(产生新的segment),一方面IndexReader重新打开。

    lucene commit :lucene commit针对的是lucene_index不是某一个segment,会应用新的curd , merge 一些segment产生新的luncene_index 的segment,并持久化到磁盘。

    lucene reopen : 想要新的增改删可以应用到查询中,比如进行reopen才行。

    也就是所es想要新的内容可见的话理论上必须有一个commit+reopen的操作。实际上上这样做是比较耗时的,在这里可以简略的理解为es的一个可能实现。

    3. es如何应对增删改

    es为了追求更好的近实时性,引入了tranlog。每一个增删改请求进来后会生成两份,一份是记录到translog当中,一份是记录到in-memory buffer当中。
    当执行_refresh操作的时候(es默认每秒执行一次),in-memory-buffer 会被copy生成一个新的memory-segment,这个时候应该做了一些优化(实现了更快的类似commit+reopen)
    这个memory-segment随后就是searchable的了。但是这个时候memory-segment并没有被持久化。这个时候如果服务崩了就可以通过translog来进行数据回放重建。translog可以设置为对Index, Bulk, Delete, or Update 在响应前都进行持久化,也可以设置为异步持久化(有丢数据风险)。

    flush 对应的本质实际上是一个lucene的commit操作,他将memory-segment merge产生新的segment写到磁盘,同时创建新的translog文件(不会直接删除老的translog),这是一个相对昂贵的操作。
    es没有删除translog主要是为了在replica从primary复制的时候为了加快复制速度有时候直接通过传输translog文件来加快recovery的过程。

    4. translog的setting

    index.translog.durability: 这个设置的是translog的durability(持久化)方式,默认的配置是request,也就是意味着es对于index, delete, update, or bulk 请求,只有translog在primary和所有的replica上完成了持久化才会给client返回成功。他还可以被设置为 async,这样的话就会对translog进行一步的fsyncs,时间是 index.translog.sync_interval(默认to 5 seconds).

    index.translog.sync_interval: 默认是5s,不能小于100ms

    index.translog.flush_threshold_size: 进行flush操作的translog阈值,为了防止在shard recovery的时候通过大量的translog重建(相对较慢),会在translog达到一定的大小后进行lucene commit 操作,把translog中的内容应用到磁盘当中。

    index.translog.retention.size: 这个设置的translog所有文件总的最大大小,保持多一些tranlog文件能够在replica恢复的时候直接通过网络拷贝primary的translog加快数据同步的过程。如果translog的比较低效,还是会走通过segment的文件进行同步。默认的大小是512mb,超过了之后会删除旧的文件。

    index.translog.retention.age: tranlog文件最长保留时长,默认是12h.

    这篇文章将es的refresh,flush,translog之间的关系讲的比较清楚
    https://qbox.io/blog/refresh-flush-operations-elasticsearch-guide
    https://www.jianshu.com/p/15837be98ffd

    刘大佬的这篇文章可以作为一个注脚
    https://www.cnblogs.com/forfuture1978/archive/2010/06/08/1753642.html
    https://www.cnblogs.com/forfuture1978/archive/2010/06/27/1766162.html

    luncene 的事务特性
    https://www.cnblogs.com/forfuture1978/archive/2010/06/07/1752917.html

    9. index-sorting

    1. index-sorting简介

    这个的作用是在lucene创建segment的时候指定文档的排列顺序,默认情况下lucene是按照index的先后直接排列的,没有固定的规则。
    这个博客对index-sorting的特点介绍的很完整,
    这篇lucene 也很好

    index-sortring的功能主要就是在生成segment的时候使文档按照某个field排序后的值进行排列,这样的好处是doc_id的顺序和该field的顺序是一致的。在进行sort取topN的时候,只需要取每个segment的topN即可。

    使用,下面是一个使用了多个字段排序的segment

    PUT twitter
    {
        "settings" : {
            "index" : {
                "sort.field" : ["username", "date"], 
                "sort.order" : ["asc", "desc"] 
            }
        },
        "mappings": {
            "properties": {
                "username": {
                    "type": "keyword",
                    "doc_values": true
                },
                "date": {
                    "type": "date"
                }
            }
        }
    }
    
    

    2. 可以有以下属性

    index.sort.field: 是一个list,标识按照哪些fields进行排序
    index.sort.order: 对每个field的排序规则,asc, desc
    index.sort.mode: es可以使用multi-valued fields, 也就是说这个field的值有可能是一个array, 这个时候可以选择使用选择array中的哪一个参与排序,可以有min,max两个选项,分别标识使用最小值和最大值。
    index.sort.missing: 对于没有排序字段的doc如何处理,有两个选项_last, _first放在最后一位或者第一位

    index-sorting只能在index create的时候指定,不能再已经创建过的index上进行设置或者update.

    3. index-soring的主要功能

    可以提前结束查询过程,返回查询结果。

    PUT events
    {
        "settings" : {
            "index" : {
                "sort.field" : "timestamp",
                "sort.order" : "desc" 
            }
        },
        "mappings": {
            "properties": {
                "timestamp": {
                    "type": "date"
                }
            }
        }
    }
    
    

    默认情况下如果没有设置index-sorting ,es的一个request会遍历所有query命中的doc,根据doc id取出来sorted field对应的doc_value 然后排序,再取前N条。但是假如设置了index-soring,同时,查询使用的sort又是同样的field的话,这样的话可以只遍历前面N个doc即可。

    请求样例

    
    GET /events/_search
    {
        "size": 10,
        "sort": [
            { "timestamp": "desc" }
        ]
    }
    
    

    这个查询因为没有query,所以lucene会直接去取每个segment的前N条即可,剩下的会被收集用来计算total_number,假如不需要total_number的话可以在查询当中设置 "track_total_hits": false
    这样的话es在找到N个doc后就立即返回相对来说快了很多。
    如果query里面有agg操作的话,会忽略"track_total_hits": false的设置,还是会获取所有命中的doc。

    GET /events/_search
    {
        "size": 10,
        "sort": [ 
            { "timestamp": "desc" }
        ],
        "track_total_hits": false
    }
    
    {
      "_shards": ...
       "hits" : {  
          "max_score" : null,
          "hits" : []
      },
      "took": 20,
      "timed_out": false
    }
    

    这里顺便提一下lucene的查询机制,lucene是以segment作为查询单位的,每个segment也被称为sub-index。

    索引排序对于组织Lucene doc ID(不要和es中的_id弄混了)很有用,其方式是使AND 查询(a AND b AND…)更有效。为了高效,AND 查询依赖于以下事实:如果任何子查询不匹配,则整个查询都不匹配。通过使用索引排序,我们可以将不匹配的文档放到一起,这将有助于有效地跳过与连接符不匹配的大范围文档ID。

    此技巧仅适用于低基数字段(也就是说这个字段的值只有有限个数,但是doc的数量可以很大)。一条经验法则是,您应首先对基数都很低且经常用于过滤的字段进行排序。排序顺序(升序或降序)无所谓,因为我们只关心将与相同子句匹配的值彼此靠近。

    例如,如果您要索引要出售的汽车,则按燃料类型,车身类型,品牌,注册年份以及最终里程来分类可能会很有用。

    For instance if you were indexing cars for sale, it might be interesting to sort by fuel type, body type, make, year of registration and finally mileage.

    展开全文
  • print('Series的Index为:', series.index) #输出:Series的Index为:Index(['a', 'b', 'c', 'd', 'e'], dtype='object') print('Series的形状为:', series.shape) #输出:Series的形状为: (5,) print('Series...

    导读:pandas是一款开放源码的BSD许可的Python库。它基于NumPy创建,为Python编程语言提供了高性能的、易于使用的数据结构和数据分析工具。

    pandas应用领域广泛,包括金融、经济、统计、分析等学术和商业领域。本文将介绍pandas中Series、DataFrame、Index等常用类的基本用法。

    作者:李明江 张良均 周东平 张尚佳

    来源:大数据DT(ID:hzdashuju)

    pandas提供了众多类,可满足不同的使用需求,其中常用的类如下所示。

    • Series:基本数据结构,一维标签数组,能够保存任何数据类型

    • DataFrame:基本数据结构,一般为二维数组,是一组有序的列

    • Index:索引对象,负责管理轴标签和其他元数据(比如轴名称)

    • groupby:分组对象,通过传入需要分组的参数实现对数据分组

    • Timestamp:时间戳对象,表示时间轴上的一个时刻

    • Timedelta:时间差对象,用来计算两个时间点的差值

    在这6个类中,Series、DataFrame和Index是使用频率最高的类。

    01 Series

    Series由一组数据以及一组与之对应的数据标签(即索引)组成。Series对象可以视作一个NumPy的ndarray,因此许多NumPy库函数可以作用于Series。

    1. 创建Series

    创建Series对象的函数是Series,它的主要参数是data和index,其基本语法格式如下。

    class pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
    

    Series函数常用的参数及其说明如下所示。

    • data:接收array或dict。表示接收的数据。默认为None

    • index:接收array或list。表示索引,它必须与数据长度相同。默认为None

    • name:接收string或list。表示Series对象的名称。默认为None

    Series本质上是一个ndarray,通过ndarray创建Series对象,如代码清单6-1所示。

    • 代码清单6-1 通过ndarray创建Series

    import pandas as pd
    import numpy as np
    print('通过ndarray创建的Series为:\n',
          pd.Series(np.arange(5), index = ['a', 'b', 'c', 'd', 'e'], name = 'ndarray'))
    

    输出:

    通过ndarray创建的Series为:
    a    0
    b    1
    c    2
    d    3
    e    4
    Name: ndarray, dtype: int32
    

    若数据存放于一个dict中,则可以通过dict创建Series,此时dict的键名(key)作为Series的索引,其值会作为Series的值,因此无须传入index参数。通过dict创建Series对象,如代码清单6-2所示。

    • 代码清单6-2 通过dict创建Series

    dit = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}
    print('通过dict创建的Series为:\n', pd.Series(dit))
    

    输出:

    通过dict创建的Series为:
    a    0
    b    1
    c    2
    d    3
    e    4
    dtype: int64

    通过list创建Series,类似于通过ndarray创建Series,如代码清单6-3所示。

    • 代码清单6-3 通过list创建Series

    list1 = [0, 1, 2, 3, 4]
    print('通过list创建的Series为:\n', pd.Series(list1, index = ['a', 'b', 'c', 'd', 'e'], name = 'list'))
    

    输出:

    通过list创建的Series为:
    a    0
    b    1
    c    2
    d    3
    e    4
    Name: list, dtype: int64

    Series拥有8个常用属性,如下所示。

    • values:以ndarray的格式返回Series对象的所有元素

    • index:返回Series对象的索引

    • dtype:返回Series对象的数据类型

    • shape:返回Series对象的形状

    • nbytes:返回Series对象的字节数

    • ndim:返回Series对象的维度

    • size:返回Series对象的个数

    • T:返回Series对象的转置

    访问Series的属性,如代码清单6-4所示。

    • 代码清单6-4 访问Series的属性

    series = pd.Series(list1, index = ['a', 'b', 'c', 'd', 'e'], name = 'list')
    print('数组形式返回Series为:', series.values)
    
    #输出:数组形式返回Series为: [0 1 2 3 4]
    
    print('Series的Index为:', series.index)
    
    #输出:Series的Index为:Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
    
    print('Series的形状为:', series.shape)
    
    #输出:Series的形状为: (5,)
    
    print('Series的维度为:', series.ndim)
    
    #输出:Series的维度为:1
    

    2. 访问Series数据

    索引与切片是Series最常用操作之一。通过索引位置访问Series的数据与ndarray相同,如代码清单6-5所示。

    • 代码清单6-5 通过索引位置访问Series数据子集

    print('Series位于第1位置的数据为:', series[0])
    

    输出:

    Series位于第1位置的数据为: 0

    相比ndarray,通过索引名称(标签)也可以访问Series数据,如代码清单6-6所示。

    • 代码清单6-6 通过索引名称访问Series数据

    print('Series中Index为a的数据为:', series['a'])
    

    输出:

    Series中Index为a的数据为: 0

    此外,也可通过bool类型的Series、list或array访问Series数据,如代码清单6-7所示。

    • 代码清单6-7 通过bool数组访问Series数据

    bool = (series < 4)
    print('bool类型的Series为:\n', bool)
    

    输出:

    bool类型的Series为:
    a     True
    b     True
    c     True
    d     True
    e    False
    Name: list, dtype: bool
    
    print('通过bool数据访问Series结果为:\n', series[bool])
    

    输出:

    通过bool数据访问Series结果为:
    a    0
    b    1
    c    2
    d    3
    Name: list, dtype: int64
    

    3. 更新、插入和删除

    更新Series的方法十分简单,采用赋值的方式对指定索引标签(或位置)对应的数据进行修改即可,如代码清单6-8所示。

    • 代码清单6-8 更新Series

    # 更新元素
    series['a'] = 3
    print('更新后的Series为:\n', series)
    

    输出:

    更新后的Series为:
    a    3
    b    1
    c    2
    d    3
    e    4
    Name: list, dtype: int64

    类似list,通过append方法能够在原Series上插入(追加)新的Series。若只在原Series上插入单个值,则采用赋值方式即可,如代码清单6-9所示。

    • 代码清单6-9 追加Series和插入单个值

    series1 = pd.Series([4, 5], index = ['f', 'g'])
    # 追加Series
    print('在series插入series1后为:\n', series.append(series1))
    

    输出:

    在series插入series1后为:
    a    3
    b    1
    c    2
    d    3
    e    4
    f    4
    g    5
    dtype: int64
    # 新增单个数据
    series1['h'] = 7
    print('在series1插入单个数据后为:\n', series1)

    输出:

    在series1插入单个数据后为:
    f    4
    g    5
    h    7
    dtype: int64

    一般使用drop方法删除Series元素,它接收被删除元素对应的索引,inplace=True表示对原Series起作用,如代码清单6-10所示。

    • 代码清单6-10 删除Series元素

    # 删除数据
    series.drop('e', inplace = True)
    print('删除索引e对应数据后的series为:\n', series)
    

    输出:

    删除索引e对应数据后的series为:
    a    3
    b    1
    c    2
    d    3
    Name: list, dtype: int64
    

    02 DataFrame

    DataFrame是pandas基本数据结构,类似数据库中的表。DataFrame既有行索引,也有列索引,它可以看作Series组成的dict,每个Series看作DataFrame的一个列。

    1. 创建DataFrame

    DataFrame函数用于创建DataFrame对象,其基本语法格式如下。

    class pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
    

    DataFrame函数常用的参数及其说明如下所示。

    • data:接收ndarray,dict,list或DataFrame。表示输入数据。默认为None

    • index:接收Index,ndarray。表示索引。默认为None

    • columns:接收Index,ndarray。表示列标签(列名)。默认为None

    创建DataFrame的方法有很多,常见的一种是传入一个由等长list或ndarray组成的dict。若没有传入columns参数,则传入的dict的键会被当作列名,如代码清单6-11所示。

    • 代码清单6-11 通过dict创建DataFrame

    dict1 = {'col1': [0, 1, 2, 3, 4], 'col2': [5, 6, 7, 8, 9]}
    print('通过dict创建的DataFrame为:\n', pd.DataFrame(dict1, index = ['a', 'b', 'c', 'd', 'e']))
    

    输出:

    通过dict创建的DataFrame为:
        col1  col2
    a     0     5
    b     1     6
    c     2     7
    d     3     8
    e     4     9

    通过list或ndarray也可创建DataFrame,如代码清单6-12所示。

    • 代码清单6-12 通过list创建DataFrame

    list2 = [[0, 5], [1, 6], [2, 7], [3, 8], [4, 9]]
    print('通过list创建的DataFrame为:\n',
          pd.DataFrame(list2, index = ['a', 'b', 'c', 'd', 'e'], columns = ['col1', 'col2']))
    

    输出:

    通过list创建的DataFrame为:
        col1  col2
    a     0     5
    b     1     6
    c     2     7
    d     3     8
    e     4     9

    由于DataFrame是二维数据结构,包含列索引(列名),因此较Series有更多的属性。DataFrame常用的属性及其说明如下所示。

    • values:以ndarray的格式返回DataFrame对象的所有元素

    • index:返回DataFrame对象的Index

    • columns:返回DataFrame对象的列标签

    • dtypes:返回DataFrame对象的数据类型

    • axes:返回DataFrame对象的轴标签

    • ndim:返回DataFrame对象的轴尺寸数

    • size:返回DataFrame对象的个数

    • shape:返回DataFrame对象的形状

    访问创建的DataFrame的常用属性,如代码清单6-13所示。

    • 代码清单6-13 访问DataFrame的属性

    df = pd.DataFrame({'col1': [0, 1, 2, 3, 4], 'col2': [5, 6, 7, 8, 9]},
                       index = ['a', 'b', 'c', 'd', 'e'])
    print('DataFrame的Index为:', df.index)
    
    #输出:DataFrame的Index为:Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
    
    print('DataFrame的列标签为:', df.columns)
    
    #输出:DataFrame的列标签为:Index(['col1', 'col2'], dtype='object')
    
    print('DataFrame的轴标签为:', df.axes)
    
    #输出:DataFrame的轴标签为: [Index(['a', 'b', 'c', 'd', 'e'], dtype='object'), Index(['col1', 'col2'], dtype='object')]
    
    print('DataFrame的维度为:', df.ndim)
    
    #输出:DataFrame的维度为:2
    
    print('DataFrame的形状为:', df.shape)
    
    #输出:DataFrame的形状为: (5, 2)
    

    2. 访问DataFrame首尾数据

    head和tail方法用于访问DataFrame前n行和后n行数据,默认返回5行数据,如代码清单6-14所示。

    • 代码清单6-14 访问DataFrame前后n行数据

    print('默认返回前5行数据为:\n', df.head())    
    

    输出:

    默认返回前5行数据为:
        col1  col2
    a     0     5
    b     1     6
    c     2     7
    d     3     8
    e     4     9    
    
    print('返回后3行数据为:\n', df.tail(3))
    

    输出:

    返回后3行数据为:
        col1  col2
    c     2     7
    d     3     8
    e     4     9
    

    3. 更新、插入和删除

    类似Series,更新DataFrame列也采用赋值的方法,对指定列赋值即可,如代码清单6-15所示。

    • 代码清单6-15 更新DataFrame

    # 更新列
    df['col1'] = [10, 11, 12, 13, 14]
    print('更新列后的DataFrame为:\n', df)
    

    输出:

    更新列后的DataFrame为:
        col1  col2
    a    10     5
    b    11     6
    c    12     7
    d    13     8
    e    14     9

    插入列也可以采用赋值方法,如代码清单6-16所示。

    • 代码清单6-16 采用赋值的方法插入列

    # 插入列
    df['col3'] = [15, 16, 17, 18, 19]
    print('插入列后的DataFrame为:\n', df)
    

    输出:

    插入列后的DataFrame为:
        col1  col2  col3
    a    10     5    15
    b    11     6    16
    c    12     7    17
    d    13     8    18
    e    14     9    19

    删除列的方法有多种,如del、pop、drop等。常用的是drop方法,它可以删除行或者列,基本语法格式如下。

    DataFrame.drop(labels, axis=0, level=None, inplace=False, errors='raise')

    drop方法常用的参数及其说明如下所示。

    • labels:接收string或array。表示删除的行或列的标签。无默认值

    • axis:接收0或1。表示执行操作的轴向,其中0表示删除行,1表示删除列。默认为0

    • levels:接收int或者索引名。表示索引级别。默认为None

    • inplace:接收bool。表示操作是否对原数据生效。默认为False

    使用drop方法删除数据,如代码清单6-17所示。

    • 代码清单6-17 使用drop方法删除数据

    # 删除列
    df.drop(['col3'], axis = 1, inplace = True)
    print('删除col3列后的DataFrame为:\n', df)
    

    输出:

    删除col3列后的DataFrame为:
        col1  col2
    a    10     5
    b    11     6
    c    12     7
    d    13     8
    e    14     9
    
    # 删除行
    df.drop('a', axis = 0, inplace = True)
    print('删除a行后的DataFrame为:\n', df)
    

    输出:

    删除a行后的DataFrame为:
        col1  col2
    b    11     6
    c    12     7
    d    13     8
    e    14     9
    

    03 Index

    Index对象为其余pandas对象存储轴标签、管理轴标签和其他元数据(如轴名称)。创建Series或DataFrame等对象时,索引都会被转换为Index对象。主要Index对象及其说明如下所示。

    • Index:一般的Index对象

    • MultiIndex:层次化Index对象

    • DatetimeIndex:Timestamp索引对象

    • PeriodIndex:Period索引对象

    1. 创建Index

    Index对象可以通过pandas.Index()函数创建,也可以通过创建数据对象Series、DataFrame时接收index(或column)参数创建,前者属于显式创建,后者属于隐式创建。隐式创建中,通过访问index(或针对DataFrame的column)属性即得到Index。创建的Index对象不可修改,保证了Index对象在各个数据结构之间的安全共享。Series的索引是一个Index对象。访问Series索引,如代码清单6-18所示。

    • 代码清单6-18 访问Series索引

    print('series的Index为 :\n', series.index)
    

    输出:

    series的Index为 :
     Index(['a', 'b', 'c', 'd'], dtype='object')

    Index对象常用的属性及其说明如下所示。

    • is_monotonic:当各元素均大于前一个元素时,返回True

    • is_unique:当Index没有重复值时,返回True

    访问Index属性,如代码清单6-19所示。

    • 代码清单6-19 访问Index属性

    print('series中Index各元素是否大于前一个:', series.index.is_monotonic)
    
    #输出:series中Index各元素是否大于前一个:True
    
    print('series中Index各元素是否唯一:', series.index.is_unique)
    
    #输出:series中Index各元素是否唯一:True
    

    2. 常用方法

    Index对象的常用方法及其说明如下所示。

    • append:连接另一个Index对象,产生一个新的Index

    • difference:计算两个Index对象的差集,得到一个新的Index

    • interp:计算两个Index对象的交集

    • union:计算两个Index对象的并集

    • isin:计算一个Index是否在另一个Index,返回bool数组

    • delete:删除指定Index的元素,并得到新的Index

    • drop:删除传入的值,并得到新的Index

    • insert:将元素插入到指定Index处,并得到新的Index

    • unique:计算Index中唯一值的数组

    应用Index对象的常用方法如代码清单6-20所示。

    • 代码清单6-20 应用Index对象的常用方法

    index1 = series.index
    index2 = series1.index
    print('index1连接index2后结果为:\n', index1.append(index2))
    
    #输出:index1连接index2后结果为:
    # Index(['a', 'b', 'c', 'd', 'f', 'g', 'h'], dtype='object')
    
    print('index1与index2的差集为:', index1.difference(index2))
    
    #输出:index1与index2的差集为:Index(['a', 'b', 'c', 'd'], dtype='object')
    
    print('index1与index2的交集为:', index1.interp(index2))
    
    #输出:index1与index2的交集为:Index([], dtype='object')
    
    print('index1与index2的并集为:\n', index1.union(index2))
    
    #输出:index1与index2的并集为:
    # Index(['a', 'b', 'c', 'd', 'f', 'g', 'h'], dtype='object')
    
    print('index1中的元素是否在index2中:', index1.isin(index2))
    
    #输出:index1中的元素是否在index2中: [False False False False]
    

    关于作者:李明江,资深大数据专家,贵州省计算机学会常务理事,黔南州大数据专家委员会委员,黔南州计算机学会会长,黔南州教育信息化建设专家库专家,黔南民族师范学院计算机与信息学院院长,全国高校大数据教育联盟理事。

    张良均,资深大数据挖掘与分析专家、模式识别专家、AI技术专家。有10余年大数据挖掘与分析经验,擅长Python、R、Hadoop、Matlab等技术实现的数据挖掘与分析,对机器学习等AI技术驱动的数据分析也有深入研究。

    本文摘编自《Python3智能数据分析快速入门》。

    延伸阅读《Python3智能数据分析快速入门》

    点击上图了解及购买

    转载请联系微信:DoctorData

    推荐语:本书假设你有一定的数据分析基础,但是没有Python和AI基础,为了帮助你快速掌握智能数据分析需要的技术和方法,书中有针对性地讲解了Python和AI中必须要掌握的知识点,内容由浅入深,循序渐进。从环境配置、基本语法、基础函数到第三方库的安装与使用,对各个操作步骤、函数、工具、代码示例等的讲解非常详尽,确保所有满足条件的读者都能快速入门。

    更多精彩回顾

    书讯 |10月书讯(下)| 双节同庆,读书正当时

    书讯 |10月书讯(上)| 双节同庆,读书正当时

    上新 | 5G时代音视频开发王器:WebRTC
    书单 | 开学季——想打好数学基础?这些经典教材你最需要!

    干货 | 用户画像从0到100的构建思路

    收藏 | 逐行分析鸿蒙系统的 JavaScript 开发框架

    视频 | 大佬出镜推荐不可不读系列——Java建设者号主cxuan

    点击阅读全文购买

    展开全文
  • Elasticsearch最佳实践之Index与Shard设计

    万次阅读 多人点赞 2019-01-22 16:44:53
    作为专栏的第三篇,本文主要探讨实际应用中Index与Shard的设计方法。主要包括这样几方面:基于时间的Index设计、Mapping设计技巧、巧妙的Alias、Shard分配原则、整体思路。

      Index与Shard,这两个概念在《Elasticsearch最佳实践之核心概念与原理》一文有详细的介绍,分别对应了Elasticsearch的两种数据组织方式:逻辑组织和物理组织。逻辑层面上,Index与业务数据的结构、类型、使用方式等息息相关;而物理层面上,Shard关系到数据在不同机器上的分布情况。作为专栏的第三篇,本文主要探讨实际应用中Index与Shard的设计方法。所谓设计,即通过合理组合Elasticsearch的特性与功能来完成业务需求,尽可能实现业务的灵活性,保证系统的高性能与稳定性。当然,前提是得先知晓这些特性与功能以及何时使用。本文将从以下几个方面进行介绍,写作背景是Elasticsearch 5.5。(文中使用的一些示例和图片来自于笔者在2018年Elasticsearch南京Meetup中的幻灯片。)

    • 基于时间的Index设计
    • Mapping设计技巧
    • 巧妙的Alias
    • Shard分配原则
    • 整体思路

    1. 基于时间的Index设计

      Index设计时要考虑的第一件事,就是基于时间对Index进行分割,即每隔一段时间产生一个新的Index。为什么要这样做呢?因为现实世界的数据是随着时间的变化而不断产生的,切分管理可以获得足够的灵活性和更好的性能。

    • 如果数据都存储在一个Index中,很难进行扩展和调整,因为Elasticsearch中Index的某些设置在创建时就设定好了,是不能更改的,比如Primary Shard的个数。而根据时间来切分Index,则可以实现一定的灵活性,既可以在数据量过大时及时调整Shard个数,也可以及时响应新的业务需求。
    • 大多数业务场景下,客户对数据的请求都会命中在最近一段时间上,通过切分Index,可以尽可能的避免扫描不必要的数据,提高性能。

      当然,并不排除某些特定的业务场景下,不用对Index进行切分管理,比如一个固定的数据集或者一个增长非常缓慢的数据集。大多数情况下,笔者都建议按照时间进行分割。那么,要考虑的第二件事就是,按照什么规则来设定切分的间隔呢?根据上面的分析,自然是时间越短越能保持灵活性,但是这样做就会导致产生大量的Index,而每个Index都会消耗资源来维护其元信息的,因此需要在灵活性、资源和性能上做权衡。建议按照如下几点来思考:

    • 常见的间隔有小时、天、周和月。先考虑总共要存储多久的数据,然后选一个既不会产生大量Index又能够满足一定灵活性的间隔。比如,你需要存储6个月的数据,那么一开始选择“周”这个间隔就会比较合适。
    • 考虑业务增长速度。假如业务增长的特别快,比如上周产生了1亿数据,这周就增长到了10亿,那么就需要调低这个间隔来保证有足够的弹性能应对变化。
    • 结合业务特性和性能测试来决定要不要调整间隔。这点更多的是从业务角度来考虑的,举个例子,在笔者的一个项目中,一开始选择了“周”作为间隔,一周产生一个新的Index来存储实时的分钟级数据,但是每周会将历史数据合并成小时级数据来降低数据量、提高查询速度。在性能测试中发现,合并后的查询性能相比合并前提升特别大,因此我们将整体间隔调整到“天”来缩短合并的周期。(后面会另撰文章更详细的分享这个案例)

      接下来就是第三件事如何实现Index的分割?切分行为是由客户端(数据的写入端)发起的,根据时间间隔与数据产生时间将数据写入不同的Index中,为了易于区分,会在Index的名字中加上对应的时间标识。创建新Index这件事,可以是客户端主动发起一个创建的请求,带上具体的Settings、Mappings等信息,但是可能会有一个时间错位,即有新数据写入时新的Index还没有建好。Elasticsearch提供了更优雅的方式来实现这个动作,即Index Template。
      Index Template提供的功能是:先设置一个Template,定义好具体的Settings、Mappings等信息,当有数据需要写入新的Index时,就会根据Template内容自动创建Index。是否根据Template建立新的Index受三点因素制约:

    • 是否是新的Index;
    • Index的名字是否与template参数中定义的格式相匹配;
    • 如果有多个Template匹配上了,则根据order参数的大小来依次生效,即从小到大逐步更新相应的配置信息(相同的配置信息会被覆盖)。

      下面给出了一个具体的Index Template定义,来自于笔者项目中的真实定义(去掉了部分字段信息),该Template会匹配所有前缀为“ce-index-access-v1-”的Index,这个示例会被上下多个小节引用。

    {
        "facet_internet_access_minute": {
            "template": "ce-index-access-v1-*",
            "order": 0,
            "settings": {
                "number_of_shards": 5
            },
            "aliases": {
                "{index}-query": {}
            },
            "mappings": {
                "es_doc": {
                    "dynamic": "strict",
                    "_all": {
                        "enabled": false
                    },
                    "_source": {
                        "enabled": false
                    },
                    "properties": {
                        "CLF_Timestamp": {
                            "type": "long"
                        },
                        "CLF_CustomerID": {
                            "type": "keyword"
                        },
                        "CLF_ClientIP": {
                            "type": "ip",
                            "ignore_malformed": true
                        }
                    }
                }
            }
        }
    }
    

    2. Mapping设计技巧

      Index设计的第四件事,是结合业务需求来设定Mapping信息。如在专栏的第二篇中所述,Mapping定义了具体的数据结构与相关的元信息,合适的设置可以有效提高性能、节省磁盘空间。Mapping的设计,主要考虑两方面内容:

    • Schema设计。第一,尽管Elasticsearch支持半结构化数据,但是在实际使用中还是应该尽最大可能对数据结构加以控制。第二,因为Elasticsearch不支持JOIN操作,所以Schema应该尽量扁平化。第三,对于只需要做精确匹配的字段,应该设置为不做分词,5.5中通过type=keyword来设定。
    • 参数调整,即修改部分参数的默认值来适应自身业务。Elasticsearch中有很多参数可用,几乎可以满足大多数的业务需求,你很难记住所有的,不妨在有相关需求时先去文档查查看。

      这里将结合上述Index Template示例,阐述几个笔者用过的Mapping参数。

    _all参数

      假设在你的业务中,需要根据关键词来查找某条数据,但是并不明确知道要到哪个字段中去查,这时用_all参数就可以帮助你解决。_all=true时,Elasticsearch会在写入数据时将其所有字段值合并起来组合为一个新的值,对其建立索引,用来满足前面所述的搜索需求。也就是说,如果你的业务没有这种需求,那么将其设置为false,可以节省磁盘、提高性能。

    _source参数

      我们知道Elasticsearch中存储的每一条数据都是一个JSON结构,在写入数据时会对每个字段建立Inverted Index、doc values等,如果_source=true,Elasticsearch会将整个JSON数据也存储下来。如果你的业务中,不需要查询原始数据,只需要根据索引来过滤然后做聚合查询,那么可以将其设置为false,同样可以节省磁盘空间、提高性能。

    dynamic参数

      假如突然有一条数据里面包含了一个没有定义的字段,这时你期望Elasticsearch怎么做?dynanic参数便是用来处理此种情况的,有三种选择:strict表示不接受数据中包含没有定义的字段,发现了就报错;true表示允许没有定义的字段被插入进来;false表示忽略没有定义过的字段,继续写入数据的其他信息。具体怎么选,更多的取决于业务需求,但是要考虑清楚可能带来的后果。在笔者的项目中,就选择了strict,用来拒绝一切脏数据。

    ignore_malformed参数

      假设有一个字段CLF_ClientIP传过来的是字符串,我们期望将其转换为ip数据类型,方便做查询。理论上,将type设置为ip就可以解决了,但是有这么一种情况,客户端在某些情况下没有拿到对应的IP信息,用了一个“–”来表示,这样的数据到了Elasticsearch端是没法转换为ip数据类型的,但是这又是一条正常数据,该怎么处理呢?通过ignore_malformed=true,可以做到忽略CLF_ClientIP字段而保留数据的其他信息。

    3. 巧妙的Alias

      Alias,顾名思义,就是Index的别名。一个Alias可以指向多个Index,一个Index也可以关联多个Alias,具体可以通过Alias的REST API来设定。在查询数据时,Elasticsearch会自动检测请求的Path是否是Alias,是的话就会从其关联的Index中查询数据。Alias的巧妙之处在于,能帮助我们将查询请求无缝的从一个Index切换到另一个Index上面,这种切换对于客户端是透明的。
      举个例子来阐述,上面有提到,在笔者业务中,存在一种数据合并:将分钟粒度数据合并成小时粒度的数据,从而可以降低数据量、提高查询性能。下图中,左边表示分钟粒度数据的Index,右边表示小时粒度数据的Index。用户的查询会先命中到分钟粒度Index上,一天之后,当历史数据完成合并后,会将查询请求转到小时粒度Index上(分钟粒度的Index会被删除)。通过Alias,我们就可以实现这种没有downtime的切换,并且对客户端透明。客户端只要按照固定的Alias来查询即可,至于Elasticsearch这边从哪个Index来查,则是取决于不同时间这个Alias关联的Index。(在数据合并完成后,切换Alias关联的Index,在一个请求中完成卸载老的Index和关联新的Index。)

    4. Shard分配原则

      所谓Shard分配原则,就是如何设定Primary Shard的个数。看上去只是一个数字而已,也许在很多场景下,即使不设定也不会有问题(默认是5个Primary Shard)。但是如果不提前考虑,一旦出问题就可能导致系统性能下降、不可访问、甚至无法恢复。换句话说,即使使用默认值,也应该是通过足够的评估后作出的决定,而非拍脑袋定的。具体的分配方法,很难给出一个完美的套路适用于所有的业务需求,这里主要结合笔者的实践谈几点原则和调整方法,给大家提供一个思路。

    • 单个Shard的存储大小不超过30GB。首先,为什么是30GB?关于这个值,来自于笔者跟AWS和Elastic专家的沟通结果,大家普遍认为30GB是个合适的上限值。目前我们尚未对此做过测试验证,不过实践中确实遇到过因为单个Shard过大(超过30GB)导致系统不稳定的情况。其次,为什么不能超过30GB?主要是考虑Shard Relocate过程的负载。我们知道,如果Shard不均衡或者部分节点故障,Elasticsearch会做Shard Relocate,在这个过程中会搬移Shard,如果单个Shard过大,会导致CPU、IO负载过高进而影响系统性能与稳定性。
    • 单个Index的Primary Shard个数 = k * 数据节点个数。在保证第一点的前提下,单个Index的Primary Shard个数不宜过多,否则相关的元信息与缓存会消耗过多的系统资源。这里的k,为一个较小的整数值,建议取值为1,2等,整数倍的关系可以让Shard更好地均匀分布,可以充分的将请求分散到不同节点上。
    • 对于很小的Index,可以只分配1~2个Primary Shard的。有些情况下,Index很小,也许只有几十、几百MB左右,那么就不用按照第二点来分配了,只分配1~2个Primary Shard是可以,不用纠结。
    • 聊一个特殊的例子。曾经遇到过一个Index,里面存放的是关键事件的日志信息,数据量不大(400MB左右),所以只分配了2个Primary Shard。但是因为“最近的事件”是用户非常关注的,所以这个Index承载了整个集群50%以上的查询请求,为了提高查询性能,将请求分散到不同机器上,最后还是将Primary Shard设置为数据节点的个数。

    5. 整体思路

      Index与Shard的设计,并不是一下子就可以完成的,需要不断预估、测试、调整、再测试来达到最终模型。整个过程大致如下图时间轴所示,分为以下几个阶段,当然期间有很多阶段是需要迭代的。

    • 第一阶段,Index的设计,即完成本文第1~3小节提到的内容。这一阶段是完成业务需求的分解与设计,之后剩下的就是如何构建Elasticsearch集群来承载这样的需求了。
    • 第二阶段,预估数据量。预估单个Index的数据量,结合需要保留的数据周期可以得到整体的数据量。
    • 第三阶段,预估机型。根据业务的场景,来决定选择CPU增强型、内存增强型还是通用型机器(针对云服务)。
    • 第四阶段,预估机器个数。因为单机能挂载的磁盘大小是有限的,因此知道了数据量,也就知道了最少需要多少台机器。在预估磁盘空间时,还需要考虑另外两个因素:一个是Replica,即副本的个数,大多数情况下1个就够了(当然还是取决于业务);另一个是预留30%的磁盘空间,这部分空间既是预留给系统使用的,也是为磁盘告警的处理预留足够的时间。
    • 第五阶段,预估Primary Shard个数。即参考第4小节中的思路,预估Primary Shard的个数。
    • 第六阶段,部署、测试。根据性能测试和业务的特殊情况,做适当调整,调整可能包括Primary Shard个数、机型、机器个数等。

    (全文完,本文地址:https://blog.csdn.net/zwgdft/article/details/86416668
    (版权声明:本人拒绝不规范转载,所有转载需征得本人同意,并且不得更改文字与图片内容。大家相互尊重,谢谢!)

    Bruce
    2019/01/22 下午

    展开全文
  • Websites provide a lot of web pages with different URLs but there are some defacto pages that exist most of the web ... index.html is one of them. index.html is used as the main or entrance page fo...

    Websites provide a lot of web pages with different URLs but there are some defacto pages that exist most of the web sites. index.html is one of them. index.html is used as the main or entrance page for the whole web site or web application.

    网站提供了许多具有不同URL的网页,但是大多数网站上都存在一些事实上的页面。 index.html是其中之一。 index.html用作整个网站或Web应用程序的主页或入口。

    什么是index.html? (What Is index.html?)

    As its name suggests index.html consists of two words index and html. The index simply means shortlist for multiple items. In web terminology generally used to showcase the website pages, categories or parts on a single page. Html simply an extension for the index file which means the index file is an HTML file that contains HTML code or tags with some CSS and JavaScript code. index.html file generally resides in the root path of the web page and when the web site like http://www.poftut.com is requested by default index.html file is returned.

    顾名思义,index.html由两个单词indexhtml 。 该索引只是意味着多个项目的候选清单。 在网络术语中,通常用于在单个页面上展示网站页面,类别或部分。 HTML只是索引文件的扩展名,这意味着索引文件是一个HTML文件,其中包含HTML代码或带有一些CSS和JavaScript代码的标签。 index.html文件通常位于网页的根路径中,并且默认情况下,当请求http://www.poftut.com之类的网站时,将返回index.html文件。

    什么包含index.html? (What Contains index.html?)

    As stated previously index.html file contains mainly HTML code or tag with some CSS and JavaScript code. The client web browser will render and show the HTML, CSS and JavaScript code. For example, the following screenshot is the https://www.apachefriends.org/index.html. This is the main page of the apachefriends.org which contains content like text, header, video, menus, categories, links etc.

    如前所述,index.html文件主要包含HTML代码或带有一些CSS和JavaScript代码的标签。 客户端网络浏览器将呈现并显示HTML,CSS和JavaScript代码。 例如,以下屏幕截图是https://www.apachefriends.org/index.html 。 这是apachefriends.org主页,其中包含诸如文本,标题,视频,菜单,类别,链接等内容。

    What Contains index.html?
    What Contains index.html?
    什么包含index.html?

    index.html代码 (index.html Code)

    There is no standard about the index.html code but there are some regular code parts generally used in index.html. Below we can see that the JavaScript code is defined inside the head part of the web page. Also, the links and menu are defined as the first element of the index.html.

    关于index.html代码没有标准,但是index.html中通常使用一些常规代码部分。 在下面,我们可以看到JavaScript代码是在网页顶部定义的。 同样,链接和菜单被定义为index.html的第一个元素。

    LEARN MORE  CSS Rounded Corners for HTML Elements
    了解更多HTML元素CSS圆角
    index.html Code
    index.html Code
    index.html代码

    index.html基本结构(index.html Basic Structure)

    When we look at an index.html file we can see that there is some basic structure that is mostly used in most of the web site’s other pages.

    当我们查看index.html文件时,我们可以看到存在一些基本结构,该结构主要在大多数网站的其他页面中使用。

    • `Menu` will contain shortcuts to other pages of the sites.

      “菜单”将包含指向网站其他页面的快捷方式。
    • `Main Content` generally contains information about the web site and some latest or generic or definitive information about the web site.

      “主要内容”通常包含有关网站的信息以及有关该网站的一些最新或通用或权威性信息。
    • `Footer` may contain some social media link, contact information, copyright information, etc.

      “页脚”可能包含一些社交媒体链接,联系信息,版权信息等。

    index.html的位置 (Location Of The index.html)

    The index.html file is stored inside the web site root directory of the webserver. If the webserver is Apache2 the default path is /var/www and the web site folder name. If the webserver is IIS the path will be C:\inetpub\sites by default but change according to specific web site configuration.

    index.html文件存储在Web服务器的网站根目录中。 如果Web服务器是Apache2,则默认路径是/var/www并且网站文件夹名称。 如果Web服务器是IIS,则默认情况下路径为C:\inetpub\sites ,但根据特定的网站配置进行更改。

    index.html与index.htm (index.html vs index.htm)

    Well, we can see some minor changes in the usage of the index.html web page. index.htm is an alternative to the index.html file. index.htm is generally used in Windows servers but almost the same HTML, CSS and JavaScript code is used.

    好吧,我们可以看到index.html网页的用法有一些小的变化。 index.htm是index.html文件的替代方法。 index.htm通常在Windows服务器中使用,但是使用几乎相同HTML,CSS和JavaScript代码。

    index.html替代方法 (index.html Alternatives)

    index.html was popular a long time ago. Currently, most of the web sites prefer index.php or nothing where index.html is not used. But there are some alternatives that are mostly used with dynamic server-side applications or sites like PHP , Python, ASP.NET, etc.

    index.html很久以前就很流行。 当前,大多数网站更喜欢index.php或不使用index.html的网站。 但是,有些替代方案通常用于动态服务器端应用程序或站点,例如PHP,Python,ASP.NET等。

    • `index.asp` is used by ASP.NET web sites or web applications.

      ASP.NET网站或Web应用程序使用“ index.asp”。
    • `index.php` is used by PHP web applications.

      PHP Web应用程序使用`index.php`。
    • `default.html` or `home.html` are also alternatives to the index.html.

      default.html或home.html也是index.html的替代方案。

    翻译自: https://www.poftut.com/what-is-index-html-how-to-create-and-use-index-html/

    展开全文
  • Pandas的set_index和reset_index用法

    万次阅读 多人点赞 2018-11-01 18:38:20
    set_index(): 函数原型:DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)  参数解释: keys:列标签或列标签/数组列表,需要设置为索引的列 drop:默认为True,...
  • 新建的web项目为什么默认访问index.jsp

    万次阅读 多人点赞 2019-01-25 14:33:44
    新建的web项目为什么默认访问index.jsp
  • 生存模型的C-index(C指数)

    万次阅读 多人点赞 2018-11-30 23:34:18
    C-index,C指数即一致性指数(index of concordance),用来评价模型的预测能力。c指数是资料所有病人对子中预测结果与实际结果一致的对子所占的比例。它估计了预测结果与实际观察到的结果相一致的概率。c指数的计算...
  • 1.set_index DataFrame可以通过set_index方法,可以设置单索引和复合索引。 DataFrame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False) import pandas as pd import numpy as ...
  • js数组的findIndexindexOf对比

    万次阅读 2018-12-11 10:15:20
    findIndex() 方法返回传入一个测试条件(函数)符合条件的数组第一个元素位置。 findIndex() 方法为数组中的每个元素都调用一次函数执行: 当数组中的元素在测试条件时返回true时, findIndex() 返回符合条件的元素...
  • 小程序在wxml使用indexOf

    千次阅读 2019-07-12 11:37:55
    QQ技术交流群173683866 526474645 欢迎加入交流讨论,打广告的一律飞机票 demo场景: 有两个数组,页面渲染一个数组1,数组2中有数...index.wxml <wxs module="m1"> function fn(arr, arg) { var result...
  • Elasticsearch—Java API之index的使用

    千次阅读 2018-10-23 16:53:46
    索引(Index) 索引是具有某种相似特征的文档的集合。例如,客户数据索引,产品目录索引,以及订单数据索引。索引由名称(必须全部为小写)标识,此名称用于在对文档进行索引、搜索、更新和删除操作时使用。在单个...
  • Exception in thread "AWT-EventQueue-0" java.lang.IndexOutOfBoundsException: Index 1 out of bounds for length 1 at java.base/jdk.internal.util.Preconditions.outOfBounds(Preconditions.java:64) at ...
  • Python中的index()方法

    万次阅读 多人点赞 2020-02-13 21:21:25
      Python index() 方法检测字符串中是否包含子字符串 str ,如果指定 beg(开始) 和 end(结束) 范围,则检查是否包含在指定范围内,该方法与 python find()方法一样,只不过如果str不在 string中会报一个异常。...
  • 索引的配置项按是否可以更改分为static属性与动态配置,所谓...在ES层面可以通过es.index.max_number_of_shards属性设置索引最大的分片数,默认为1024,index.number_of_shards的默认值为Math.min(es.index.max_num...
  • 【pandas】reset_index函数详解

    千次阅读 2020-08-19 12:18:00
    参数 drop: 重新设置索引后是否将原索引作为新的一列并入DataFrame,默认为False inplace: 是否在原DataFrame上改动,默认为False level: 如果索引(index)有多个列,仅从索引中删除level指定的列,默认删除所有列 ...
  • 重命名DataFrame的index

    千次阅读 2020-08-08 23:45:57
    重命名DataFrame的index重命名DataFrame的index引入相关库DataFrame的index的重命名map的回顾 重命名DataFrame的index 引入相关库 import numpy as np import pandas as pd from pandas import Series,DataFrame ...
  • 21_Pandas.DataFrame,重置Series的索引index(reset_index) 如果使用reset_index()方法,则可以将pandas.DataFrame,pandas.Series的索引索引(行名称,行标签)重新分配为从0开始的序列号(行号)。 如果将行号...
  • 深入理解 CSS 属性 z-index

    万次阅读 多人点赞 2018-09-17 16:17:35
    最近在使用 CSS3 动画的时候遇到一个 DOM 层叠的问题,故此重新学习了一下 z-index,感觉这个 CSS 属性还是挺复杂的,希望本文可以帮助你重新认识 z-index 的魅力。 事情的经过是这样的(背景有点长),最近在写下面...
  • ES中index和type的区别

    万次阅读 2019-09-09 15:27:52
    对于 ES 的新用户来说,有一个常见的问题:要存储一批新数据时,应该在已有 index 里新建一个 type,还是给它新建一个 index?要想回答这个问题,我们必须先理解这两者是怎么实现的。 在过去,我们试图通过与关系...
  • # 实例2.1:加入索引left_index, right_index # join()将两个不同索引列组合 left = pd.DataFrame({'A': [ 'A1', 'A2'], 'B': [ 'B1', 'B2']}, index=['K1', 'K2']) right = pd.DataFrame({'C': [ 'C2', 'C3'], 'D...
  • nexus-maven-repository-index.zip

    千次下载 热门讨论 2013-02-12 22:16:39
    nexus-maven-repository-index.zip
  • 计算COX模型的cindex 以及 两个cox模型的假设检验 方法1:基于cox直接生成系数以及计算的C-index值 library("survminer") library("survival") ######### 生成COX模型 cox_model <- coxph() ####直接查看coxph ...
  • C#中List为什么要提供FindIndexIndexOf两个方法? 这两个方法对比有什么优劣? ``` // 定义 public int FindIndex(Predicate<T> match); public int FindIndex(int startIndex, Predicate<T> match); ...
  • java 中indexOf函数详解

    千次阅读 2020-10-07 15:28:53
    最近在解决android 中listview的查找问题,用到了indexOf 方法,仔细看了下源码,详解如下。 private static int indexOf(String source, String target, int fromIndex) { final int sourceLength = source....
  • 数据库中索引(index)介绍

    千次阅读 2019-01-16 10:14:15
    本文主要介绍数据库中索引(index)的相关知识。 1 概述 1.1 What 数据库中的索引(index),是数据库管理系统(DBMS)中的一个排序的数据结构,用于协助快速查询、更新数据库表中的数据。 除了实际需要使用的...
  • js indexOf()用法

    万次阅读 2018-10-22 12:01:10
    indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置。 语法 stringObject.indexOf(searchvalue,fromindex) 参数 描述 searchvalue 必需。规定需检索的字符串值。 fromindex 可选的...
  • MySQL的索引(Index)详解

    万次阅读 2019-02-16 01:01:49
    索引分类 (1)普通索引(Key Indexes) ...(4)组合索引(Composite Index) (5)前缀索引( Prefix Indexes) (6)全文索引(Full-Text Indexes) (7)哈希索引(Hash Indexes) (8)空间索引(Spatia...
  • Pandas index详解

    万次阅读 2017-06-09 09:43:11
    总括 pandas里对索引的操作主要有 1. DataFrame.rename 2. DataFrame.rename_axis 3. DataFrame.reindex ...5. DataFrame.reset_index 6. pandas.Index.reindex 7. pandas.Index.set_names 其中1和...
  • 承接上一遍“通过webpack构建vue项目”构建的项目文件,简单阐述一下当我们构建完成后,vue项目中的index.html、main.js、App.vue、index.js的运行加载过程,以及首界面是如何出现的,逐步了解vue项目,针对刚开始...
  • MySQL SHOW INDEX 的语法解析

    万次阅读 多人点赞 2018-11-10 17:52:15
    本文主要讲解一下mysql show index 的语法,以 show index from bbs_posts 为例,先看下执行效果如图 1、Table 表名 2、Non_unique 如果索引不能包括重复值则为0,如果可以则为1。也就是平时所说的唯一索引。 3...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,612,792
精华内容 1,845,116
关键字:

index