clean算法

① 保存失败 Value at 0 is null. 什么意思

‍

作者 | 聂晓龙（率鸽）

01 前言

前天回家路上，有辆车强行插到前面的空位，司机大哥暴躁地拍着方向盘吐槽道“加塞最可恶了”，我问“还有更可恶的吗”，司机大哥淡定说道“不让自己加塞的”。似乎和我们很类似，我们程序员届也有这 2 件相辅相成的事：最讨厌别人不写注释，更讨厌让自己写注释。

一段糟糕的代码，往往大家最低的预期是把注释写清楚，最合理的做法通常应该对代码做优化。如果我们将代码真正做到了优秀，我们是否还需要注释？

02 注释的意义

; **************************************************************************
; * RAMinit Release 2.0 *
; * Copyright (c) 1989-1994 by Yellow Rose Software Co. *
; * Written by Mr. Leijun *
; * Press HotKey to remove all TSR program after this program *
; **************************************************************************
; Removed Softwares by RI:
; SPDOS v6.0F, WPS v3.0F
; Game Busters III, IV
; NETX ( Novell 3.11 )
; PC-CACHE
; Norton Cache
; Microsoft SmartDrv
; SideKick 1.56A
; MOUSE Driver
; Crazy (Monochrome simulate CGA program)
; RAMBIOS v2.0
; 386MAX Version 6.01

注释是对代码的解释和说明，本质目的是为了增强程序的可读性与可解释性。注释会随着源代码，在进入预处理器或编译器处理后会被移除。这是雷布斯 1994 年写的一段 MASM 汇编代码，注释与代码整体结构都非常清晰。如果说代码是为了让机器读懂我们的指令，那注释完全就是为了让我们了解我们自己到底发出了哪些指令。

03 争议与分歧

注释的起源非常早，我们甚至已经查阅不到注释的由来，但现在任何一种语言，甚至几乎任何一种文本格式都支持各式各样的注释形式。

但如何使用注释，其实一直是一个备受争论的话题。当我们接手一段‘祖传代码’时，没有注释的感觉简直让人抓狂，我们总是希望别人能提供更多的注释。但软件届也有一段神话传说，叫做‘我的代码像诗一样优雅’。有注释的代码都存在着一些瑕疵，认为足够完美的代码是不需要注释的。

04 坏代码的救命稻草

The proper use of comments is to compensate for our failure to express ourself in code. -- Robert C. Martin 《Clean Code》 译：注释的恰当用法是弥补我们在用代码表达意图时遭遇的失败

Clean Code 的作者 Robert C. Martin 可以说是注释的极力否定者了，他认为注释是一种失败，当我们无法找到不用注释就能表达自我的方法时，才会使用注释，任何一次注释的使用，我们都应该意识到是自己表达能力上的失败。

PH&V 的系统架构师和负责人 Peter Vogel，同样也是一名坚定的注释否定着，他发表了一篇文章 why commenting code is still bad 来表述为代码添加注释在某种程度上可能是必要的，但确实没有价值。

事实上，我们也确实经历着非常多无价值的注释，以及完全应由代码来承担解释工作的“职能错位”的注释。

01 零注释

糟糕的代码加上完全不存在的注释，我喜欢称呼它们为‘我和上帝之间的秘密’，当然过 2 个月后也可以称之为‘上帝一个人的秘密’。

压垮程序员最后一根稻草的，往往都是零注释。可以没有文档，可以没有设计，但如果没有注释，我们每一次阅读都是灾难性的。当我们抱怨它一行注释都没有时，其实我们是在抱怨我们很难理解代码想要表达的含义，注释是直接原因，但根本原因是代码。

零注释往往和坏代码一起生活，“没有注释”的吐槽，其实本质上直击的是那堆歪七扭八的英文字母，到底它们想表达什么！

02 无用注释

/**
* returns the last day of the month
* @return the last day of the month
*/
public Date getLastDayOfMonth(Date date) {
Calendar calendar = new GregorianCalendar();
calendar.setTime(date);
calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
return calendar.getTime();
}

这是典型的废话注释，读代码时代码本身就能很好的表达具体的含义，我们完全不需要看注释，并且注释也不会给我们提供更多有效的信息。无用注释或许是零注释的另一个极端，我们担心自己写的代码被人所吐槽，于是尽可能去补全注释，当你为 getLastDayOfMonth() 补一段 get last day of month 的注释时，恭喜你，你得到了双倍的代码。

03 代码优于注释

"Comments Do Not Make Up for Bad Code" -- Robert C.Martin 《Clean Code》 译：注释不能美化糟糕的代码

当需要为一段代码加上注释时，说明代码已经不能很好的表达意图，于是大家开始为这段代码添加注释。Robert C.Martin 在 Clean Code 中提出一个观点：注释不能美化糟糕的代码。能用代码表达的直接用代码表达，不能用代码表达的，你再想想，如何能用代码表达。

复杂的代码最直接的表现就是不够直观、难以理解，加上注释后往往会清晰很多，但你是愿意看这段代码：

// 判断是否活跃用户
if((customer.getLastLoginTime().after(dateUtils.minusDays(new Date(),15)) && customer.getCommentsLast30Days() > 5)
|| orderService.countRecentDaysByCustomer(customer,30) > 1)

还是这段代码？

if(customer.isActive())

糟糕代码的存在，通常是我们写注释的常见动机之一。这种试图粉饰可读性差的代码的注释称之为‘拐杖式注释’，即使大名鼎鼎的 JDK，也存在这样的拐杖式注释。

public synchronized void setFormatter(Formatter newFormatter) {
checkPermission();
// Check for a null pointer
newFormatter.getClass();
formatter = newFormatter;
}

这是取自 JDK java.util.logging.Handler 类的 setFormatter 方法，作者为了不让空指针异常下传，提前做一次空指针检查。没有这段注释我们完全不知道游离的这句 newFormatter.getClass() 到底要做什么，这段注释也充分表达了作者自己也知道这句代码难以理解，所以他加上了注释进行说明。但我们完全可以用 Objects.requireNonNull() 来进行替代。同样的代码作用，但可读性可理解性大不一样，JDK 里的这段代码，确实让人遗憾。

04 注释否定论

"If our programming languages were expressive enough, or if we had the talent to subtly wield those languages to express our intent, we would not need comments very much—perhaps not at all." -- Robert C.Martin 《Clean Code》 译：若编程语言足够有表达力，或者我们长于用这些语言来表达意图，就不那么需要注释--也许根本不需要

通过代码进行阐述，是注释否定论的核心思想。当你花功夫来想如何写注释，让这段代码更好的表达含义时，我们更应该重构它，通过代码来解释我们的意图。每一次注释的编写，都是对我们代码表达能力上的差评，提升我们的归纳、表达、解释能力，更优于通过注释来解决问题。当代码足够优秀时，注释则是非必须的。并且需求在不断调整，代码一定会随之变动，但注释可能慢慢被人遗忘，当代码与注释不匹配时，将是更大的灾难。

05 软件设计的乌托邦

01 好吧你很优秀

曾经我的确对优秀的代码不断钻研，对代码本身所蕴含的能量无比坚信。如同当科学代替鬼神论走上历史舞台时，即使存在有科学解释不了，我们依然坚信只是科学还需要发展。当代码别人无法理解时，我会认为是我表述不够精准，抽象不够合理，然后去重构去完善。

有一次给老板 review 代码，当时老板提出，“你的代码缺缺少注释”，我说不需要注释，代码就能自解释。于是老板现场读了一段代码，“query-customer-list 查询客户”、“transfer-customer-to-sales 分发客户到销售”、“check-sales-capacity 检查销售库容”，每一个类每一个函数，一个单词一个单词往外蹦时，你会发现好像确实都能读懂，于是老板回了一个“好吧”。

02 美丽的乌托邦

"'good code is self-documenting' is a delicious myth" -- John Ousterhout《A Philosophy of Software Design》 译：‘好的代码自解释’是一个美丽的谎言

在软件设计中，总有一些软件工程师所坚信的诗和远方，有的是大洋彼岸的美好国度，有的或许是虚无缥缈的理想乌托邦。John Ousterhout 教授在 A Philosophy of Software Design 中提到一个观念，‘好的代码自解释’是一个美丽的谎言。

我们可以通过选择更好的变量名，更准确的类与方法，更合理的继承与派生来减少注释，但尽快如此，我们还是有非常多的信息无法直接通过代码来表达。这里的信息，或许不单单只是业务逻辑与技术设计，可能还包括了我们的观感，我们的体验，我们的接纳程度以及第一印象带来的首因效应。

06 好代码的最佳僚机

You might think the purpose of commenting is to 'explain what the code does', but that is just a small part of it.The purpose of commenting is to help the reader know as much as the writer did. -- Dustin Boswell《The Art of Readable Code》 译：你可能以为注释的目的是“解释代码做了什么”，但这只是其中很小一部分，注释的目的是尽量帮助读者了解得和作者一样多

如同 John Ousterhout 教授一样，The Art of Readable Code 的作者 Dustin Boswell，也是一个坚定的注释支持者。与 Robert C.Martin 类似，Dustin Boswell 同样认为我们不应该为那些从代码本身就能快速推断的事实写注释，并且他也反对拐杖式注释，注释不能美化代码。

但 Dustin Boswell 认为注释的目的不仅解释了代码在做什么，甚至这只是一小部分，注释最重要的目的是帮助读者了解得和作者一样多 。编写注释时，我们需要站在读者的角度，去想想他们知道什么，这是注释的核心。这里有非常多的空间是代码很难阐述或无法阐述的，配上注释的代码并非就是糟糕的代码，相反有些时候，注释还是好代码最棒的僚机。

01 更精准表述

There are only two hard things in Computer Science: cache invalidation and naming things. -- Phil Karlton 译：计算机科学中只有两个难题：缓存失效和命名

Martin Fowler 在他的 TwoHardThings 文章中引用了 Phil Karlton 的一段话，命名一直都是一件非常难的事情，因为我们需要将所有含义浓缩到几个单词中表达。很早之前学 Java，接触到很长的类名是 。可能有人认为只要能将含义准确地表达出来，名字长一些无所谓。那如果我们需要有一段处理有关“一带一路”的内容，那我们的代码可能是这样的：

public class {

他非常准确的表达了含义，但很明显这不是我们期望的代码。但如果我们辅以简单的注释，代码会非常清晰，说明了简称，也说明了全意，表述更精准。

/**
* 一带一路
* 丝绸之路经济带和21世纪海上丝绸之路
*/
public class OneBeltOneRoad {

02 代码层次切割

函数抽取是我们经常使用且成本最低的重构方法之一，但并非银弹。函数并非抽得越细越好，如同分布式系统中，并非无限的堆机器让每台机器处理的数据越少，整体就会越快。过深的嵌套封装，会加大我们的代码阅读成本，有时我们只需要有一定的层次与结构帮助我们理解就够了，盲目的抽取封装是无意义的。

/**
* 客户列表查询
*/
public List queryCustomerList(){
// 查询参数准备
UserInfo userInfo = context.getLoginContext().getUserInfo();
if(userInfo == null || StringUtils.isBlank(userInfo.getUserId())){
return Collections.emptyList();
}
LoginDTO loginDTO = userInfoConvertor.convertUserInfo2LoginDTO(userInfo);
// 查询客户信息
List customerSearchList = customerRemoteQueryService.query(loginDTO);
Iterable it = customerSearchList.iterator();
// 排除不合规客户
while(it.hasNext()){
CustomerSearchVO customerSearchVO = it.next();
if(isInBlackList(customerSearchVO) || isLowQuality(customerSearchVO)){
it.remove();
}
}
// 补充客户其他属性信息
batchFillCustomerPositionInfo(customerSearchList);
batchFillCustomerAddressInfo(customerSearchList);
}

其实细看每一处代码，都很容易让人理解。但如果是一版没有注释的代码，可能我们会有点头疼。缺少结构缺少分层，是让我们大脑第一感观觉得它很复杂，需要一次性消化多个内容。通过注释将代码层次进行切割，是一次抽象层次的划分。同时也不建议大家不断去抽象私有方法，这样代码会变得非常割裂，并且上下文的背景逻辑、参数的传递等等，都会带来额外的麻烦。

03 母语的力量

其实上述例子，我们更易阅读，还有一个重要的原因，那就是母语的力量。我们天然所经历的环境与我们每天所接触到的事物，让我们对中文与英文有完全不一样的感受。我们代码的编写本质上是一个将我们沟通中的“中文问题”，翻译成“英文代码”来实现的过程。而阅读代码的人在做得，是一件将“英文代码”翻译成“中文表述”的事情。而这之中经过的环节越多，意思变味越严重。

TaskDispatch taskDispatch = TaskDispatchBuilder.newBuilder().withExceptionIgnore().build();
taskDispatch
// 外贸信息
.join(new FillForeignTradeInfoTask(targetCustomer, sourceInfo))
// 国民经济行业、电商平台、注册资本
.join(new FillCustOutterInfoTask(targetCustomer, sourceInfo))
// 客户信息
.join(new (targetCustomer, sourceInfo))
// 客户扩展信息
.join(new FillCustExtInfoTask(targetCustomer, sourceInfo))
// 收藏屏蔽信息
.join(new FillCollectStatusInfoTask(targetCustomer, sourceInfo, loginDTO()))
// 详情页跳转需要的标签信息
.join(new FillTagInstanceTask(targetCustomer, sourceInfo, loginDTO()))
// 客户信息完整度分数
.join(new FillCustomerScoreTask(targetCustomer, sourceInfo))
// 潜客分层完整度
.join(new FillCustomerSegmentationTask(targetCustomer, sourceInfo))
// 填充操作信息
.join(new FillOperationStatusTask(targetCustomer, sourceInfo, loginDTO))
// 认证状态
.join(new FillAvStatusTask(targetCustomer, loginDTO))
// 客户地址和组织
.join(new FillCompanyAddressTask(targetCustomer, loginDTO))
// 违规信息
.join(new FillPunishInfoTask(targetCustomer, sourceInfo))
// 填充客户黑名单信息
.join(new FillCustomerBlackStatusTask(targetCustomer, sourceInfo))
// 填充客户意愿度
.join(new FillCustIntentionLevelTask(targetCustomer, sourceInfo));
// 执行
.execute();

这是一段补齐客户全数据信息的代码，虽然每一个英文我们都看得懂，但我们永远只会第一眼去看注释，就因为它是中文。并且也因为有这些注释，这里非常复杂的业务逻辑，我们同样可以非常清晰的了解到它做了哪些，分哪几步，如果要优化应该如何处理。这里也建议大家写中文注释，注释是一种说明，越直观越好，中文的亲和力是英文无法比拟的。当然，这条建议并不适合美国程序员。

07 注释的真正归属

01 复杂的业务逻辑

// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if ((beanName)) {
throw new (beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
return parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}

这是 Spring 中的一段获取 bean 的代码，spring 作为容器管理，获取 bean 的逻辑也非常复杂。对于复杂的业务场景，配上必要的注释说明，可以更好的理解相应的业务场景与实现逻辑。

截取自：

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean

02 晦涩的算法公式

/**
* Returns the value obtained by reversing the order of the bits in the
* two's complement binary representation of the specified {@code long}
* value.
*/
public static long reverse(long i) {
// HD, Figure 7-1
i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L;
i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L;
i = (i & 0x0f0f0f0f0f0f0f0fL) << 4 | (i >>> 4) & 0x0f0f0f0f0f0f0f0fL;
i = (i & 0x00ff00ff00ff00ffL) << 8 | (i >>> 8) & 0x00ff00ff00ff00ffL;
i = (i << 48) | ((i & 0xffff0000L) << 16) |
((i >>> 16) & 0xffff0000L) | (i >>> 48);
return i;
}

这是 JDK 中 Long 类中的一个方法，为 reverse 方法添加了足够多的注释。对于几乎没有改动且使用频繁的底层代码，性能的优先级会高于可读性。在保证高效的同时，注释帮助我们弥补了可读性的短板。

截取自：java.lang.Long#reverse

03 不明所以的常量

/**
* The bin count threshold for using a tree rather than list for a
* bin. Bins are converted to trees when adding an element to a
* bin with at least this many nodes. The value must be greater
* than 2 and should be at least 8 to mesh with assumptions in
* tree removal about conversion back to plain bins upon
* shrinkage.
*/
static final int TREEIFY_THRESHOLD = 8;

这是 JDK 中 HashMap 的一个常量因子，记录由链表转向红黑树的链表长度阈值，超过该长度则链表转为红黑树。这里记录了一个 8，不仅记录了该常量的用途，也记录了为什么我们定义这个值。经常我们会发现我们代码中存在一个常量等于 3、等于 4，有时我们不知道这些 3 和 4 是干什么的，有时我们不知道为什么是 3 和 4。

截取自：java.util.HashMap#TREEIFY_THRESHOLD

04 意料之外的行为

for (int i = 0; i < 3; i++) {
// if task running, invoke only check result ready or not
Result result = bigDataQueryService.queryBysql(sql, token);
if (SUCCESS.equals(result.getStatus())) {
return result.getValue();
}
Thread.sleep(5000);
}

代码及注释所示为每 5 秒 check 一下是否有结果返回，远程服务将触发与获取放在了一个接口。没有注释我们可能认为这段代码有问题，代码表现的含义更像是每 5 秒调用一次，而非每 5 秒 check 一次。为意料之外的行为添加注释，可以减少对代码的误解读，并向读者说明必要的背景及逻辑信息。

05 接口对外 API

Checks if a CharSequence is empty (""), null or whitespace only.

Whitespace is defined by {@link Character#isWhitespace(char)}.

* StringUtils.isBlank(null) = true
* StringUtils.isBlank("") = true
* StringUtils.isBlank(" ") = true
* StringUtils.isBlank("bob") = false
* StringUtils.isBlank(" bob ") = false
* @param cs the CharSequence to check, may be null
* @return {@code true} if the CharSequence is null, empty or whitespace only
public static boolean isBlank(final CharSequence cs) {
final int strLen = length(cs);
if (strLen == 0) {
return true;
for (int i = 0; i < strLen; i++) {
if (!Character.isWhitespace(cs.charAt(i))) {
return false;

return true;

我们经常使用的 StringUtils 工具类中的 isBlank 方法，写了非常详情的注释，不仅包括方法的逻辑，入参的含义，甚至还包括具体示例。我们平常定义的二方库中的 HSF、HTTP 接口定义，同样需要有清晰详尽的注释，这里的注释甚至经常会多过你的代码。

截取自：org.apache.commons.lang3.StringUtils#isBlank

06 法律文件信息

/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding right ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

与法律相关的注释，在开源软件库中较经常遇到。涉及到一些版权及着作声明时，我们需要在源文件顶部放置法律相关注释。当然，我们不需要将所有法律信息写到注释中，如例子中的跳链，引用一份标准的外部文档，会是一个更好的选择。

08 写在最后

注释并不会妨碍你写出优雅简洁的代码，它只是程序固有的一部分而已。我们不用过分在意我们的代码是否可以脱离注释，也不需要强调因为我们的代码符合什么原则，满足什么约定，所以代码是优秀的注释是冗余的。代码是一门艺术，并不会因为满足三规九条它就一定完美，因为艺术，是不可衡量的。

参阅书籍

《A Philosophy of Software Design》

《Clean Code》

《The Art of Readable Code》

技 术 好 文

企 业 案 例

② 宏基因组分析笔记之binning

一、宏基因组简介：

reads→（根据overlap组装）→ contig重叠群 → （构建454 paired-end库或illumina meta-paired库，组装）→ scaffold → （binning）→ chromosome基因组草图

Contig N50：Reads拼接后会获得一些不同长度的Contigs.将所有的Contig长度相加,能获得一个Contig总长度.然后将所有的Contigs按照从长到短进行排序,如获得Contig 1,Contig 2,contig 3...………Contig 25.将Contig按照这个顺序依次相加,当相加的长度达到Contig总长度的一半时,最后一个加上的Contig长度即为Contig N50.举例：Contig 1+Contig 2+ Contig 3 +Contig 4=Contig总长度*1/2时,Contig 4的长度即为Contig N50.ContigN50可以作为基因组拼接的结果好坏的一个判断标准.

Scaffold N50：Scaffold N50与Contig N50的定义类似.Contigs拼接组装获得一些不同长度的Scaffolds.将所有的Scaffold长度相加,能获得一个Scaffold总长度.然后将所有的Scaffolds按照从长到短进行排序,如获得Scaffold 1,Scaffold 2,Scaffold 3...………Scaffold 25.将Scaffold按照这个顺序依次相加,当相加的长度达到Scaffold总长度的一半时,最后一个加上的Scaffold长度即为Scaffold N50.举例：Scaffold 1+Scaffold 2+ Scaffold3 +Scaffold 4 +Scaffold 5=Scaffold总长度*1/2时,Scaffold 5的长度即为Scaffold N50.Scaffold N50可以作为基因组拼接的结果好坏的一个判断标准.

二、binning简介：

宏基因组分箱（Binning）是将宏基因组测序得到的混合了不同生物的序列或序列组装得到的contigs按物种分开归类的过程。宏基因组分箱技术有助于获得不可培养微生物的全基因组序列，获得新物种的基因组序列和功能，预测未知物种的培养方法等等。

1，统计contig深度

第一列：contigName

第二列：contigLen

第三列：totalAvgDepth

第四列：library1.sorted.bam

第五列：library1.sorted.bam-var

第六列：library2.sorted.bam

第七列：library2.sorted.bam-var

2，用metabat软件binning

3，CheckM软件做基因组的质量评估

基因组组装或者宏基因组binning获得的基因组草图，首先需要评估其质量，包括基因组完整度、污染度、序列分布等信息。

https://mp.weixin.qq.com/s/2cggAwQbRRWG9WfjEj0t9Q

三、binning原理

1、binning的依据：

（1）根据核酸组成信息来进行binning：k-mer frequencies（来自同一菌株的序列，其核酸组成是相似的）：如根 据核酸使用频率 （oligonucleotide frequency variations），通常是四核苷酸频率（tetranucleotide frequency）， GC含量 和 必需的单拷贝基因 等

（2）根据丰度信息来进行binning：来自同一个菌株的基因在不同的样品中 ( 不同时间或不同病理程度 ) 的丰度分布模式是相似的。如，某一细菌中有两个基因，A和B，它们在该细菌基因组中的拷贝数比例为 A:B = 2:1，则不管在哪个样品中这种细菌的数量有多少，这两个基因的丰度比例总是为 2:1。但这种方式需要较大样本量，一般至少要50个样本以上，且至少要有2个组能呈现丰度变化 ( 即不同的处理、不同的时间、疾病和健康、或者不同的采样地点等 ) ，每个组内的生物学重复也要尽量的多。

（3）同时依据核酸组成和丰度变化信息：利用核酸组成信息和丰度差异综合计算距离矩阵，既能保证binning效果，也能相对节约计算资源，现在比较主流的binning软件大多是NCA算法。

（4）根据基因组甲基化模式：不同的细菌，其基因组甲基化模式不同，平均一种细菌有3种特意的甲基化 motif。MGEs (mobile genetic elements) 中含有 MTase 基因，其基因水平转移是细菌甲基化组多样性的驱动因素。虽然 MGEs 在不同个体的拷贝数不同，但是都存在，因此具有相同 MGEs 的细菌个体，其总遗传物质（包括染色体和 MGEs ）都会受到相同的MTase的作用而得到相同的甲基化模式。

2、binning

原始的clean reads，还是从组装成的contig，还是从预测到的gene，都可以binning，暂且分为reads binning， contig binning和 genes binning。应用最广泛的就是基于genes binning 和 contig binning

四、binning后续分析

关联分析

即通过binning得到的bins（暂且简称为bins，更确切的说是strain-level clusters 或strain-level taxonomic units）可以进行宏基因组关联分析以及多组学联合分析，将特定功能代谢产物与特定物种、特定基因进行关联研究，推动其因果机制的探究，为疾病监控、环境监测提供了菌株水平的生物靶标。

单菌组装

通过对binning得到的bins进行后续组装，可以得到很多不能在实验室里培养的细菌、古菌、病毒的基因组草图，然后根据单菌组装结果进行菌株水平的基因和功能注释、比较基因组分析、进化分析等，使我们得以洞察这些无法在实验室培养获得的菌株的生态适应机制，营养互作机制和新陈代谢功能等，可以研究在生态环境和复杂疾病中起重要作用的菌种以及致病菌和宿主的互作机制及其微进化机制。

参考：

https://www.jianshu.com/p/66ab14988a74

https://www.jianshu.com/p/f010020a2859

https://mp.weixin.qq.com/s/2cggAwQbRRWG9WfjEj0t9Q

http://www.pinlue.com/article/2018/09/1804/497268180444.html

https://www.jianshu.com/p/117441ac6eb8

③ 如何对混合型数据做聚类分析

如何对混合型数据做聚类分析
利用聚类分析，我们可以很容易地看清数据集中样本的分布情况。以往介绍聚类分析的文章中通常只介绍如何处理连续型变量，这些文字并没有过多地介绍如何处理混合型数据（如同时包含连续型变量、名义型变量和顺序型变量的数据）。本文将利用 Gower 距离、PAM（partitioning around medoids）算法和轮廓系数来介绍如何对混合型数据做聚类分析。
R语言
本文主要分为三个部分：
距离计算
聚类算法的选择
聚类个数的选择
为了介绍方便，本文直接使用 ISLR 包中的 College 数据集。该数据集包含了自 1995 年以来美国大学的 777 条数据，其中主要有以下几个变量：
连续型变量
录取率
学费
新生数量
分类型变量
公立或私立院校
是否为高水平院校，即所有新生中毕业于排名前 10% 高中的新生数量占比是否大于 50%
本文中涉及到的R包有：
In [3]:
set.seed(1680) # 设置随机种子，使得本文结果具有可重现性
library(dplyr)
library(ISLR)
library(cluster)
library(Rtsne)
library(ggplot2)

Attaching package: ‘dplyr’

The following objects are masked from ‘package:stats’:

filter, lag

The following objects are masked from ‘package:base’:

intersect, setdiff, setequal, union

构建聚类模型之前，我们需要做一些数据清洗工作：
录取率等于录取人数除以总申请人数
判断某个学校是否为高水平院校，需要根据该学校的所有新生中毕业于排名前 10% 高中的新生数量占比是否大于 50% 来决定

In [5]:

college_clean <- College %>%
mutate(name = row.names(.),
accept_rate = Accept/Apps,
isElite = cut(Top10perc,
breaks = c(0, 50, 100),
labels = c("Not Elite", "Elite"),
include.lowest = TRUE)) %>%
mutate(isElite = factor(isElite)) %>%
select(name, accept_rate, Outstate, Enroll,
Grad.Rate, Private, isElite)

glimpse(college_clean)

Observations: 777
Variables: 7
$ name (chr) "Abilene Christian University", "Adelphi University", "...
$ accept_rate (dbl) 0.7421687, 0.8801464, 0.7682073, 0.8369305, 0.7564767, ...
$ Outstate (dbl) 7440, 12280, 11250, 12960, 7560, 13500, 13290, 13868, 1...
$ Enroll (dbl) 721, 512, 336, 137, 55, 158, 103, 489, 227, 172, 472, 4...
$ Grad.Rate (dbl) 60, 56, 54, 59, 15, 55, 63, 73, 80, 52, 73, 76, 74, 68,...
$ Private (fctr) Yes, Yes, Yes, Yes, Yes, Yes, Yes, Yes, Yes, Yes, Yes,...
$ isElite (fctr) Not Elite, Not Elite, Not Elite, Elite, Not Elite, Not...
距离计算
聚类分析的第一步是定义样本之间距离的度量方法，最常用的距离度量方法是欧式距离。然而欧氏距离只适用于连续型变量，所以本文将采用另外一种距离度量方法—— Gower 距离。
Gower 距离
Gower 距离的定义非常简单。首先每个类型的变量都有特殊的距离度量方法，而且该方法会将变量标准化到[0,1]之间。接下来，利用加权线性组合的方法来计算最终的距离矩阵。不同类型变量的计算方法如下所示：
连续型变量：利用归一化的曼哈顿距离
顺序型变量：首先将变量按顺序排列，然后利用经过特殊调整的曼哈顿距离
名义型变量：首先将包含 k 个类别的变量转换成 k 个 0-1 变量，然后利用 Dice 系数做进一步的计算
优点：通俗易懂且计算方便
缺点：非常容易受无标准化的连续型变量异常值影响，所以数据转换过程必不可少；该方法需要耗费较大的内存
利用 daisy 函数，我们只需要一行代码就可以计算出 Gower 距离。需要注意的是，由于新生入学人数是右偏变量，我们需要对其做对数转换。daisy 函数内置了对数转换的功能，你可以调用帮助文档来获取更多的参数说明。

In [6]:

# Remove college name before clustering

gower_dist <- daisy(college_clean[, -1],
metric = "gower",
type = list(logratio = 3))

# Check attributes to ensure the correct methods are being used
# (I = interval, N = nominal)
# Note that despite logratio being called,
# the type remains coded as "I"

summary(gower_dist)

Out[6]:

301476 dissimilarities, summarized :
Min. 1st Qu. Median Mean 3rd Qu. Max.
0.0018601 0.1034400 0.2358700 0.2314500 0.3271400 0.7773500
Metric : mixed ; Types = I, I, I, I, N, N
Number of objects : 777

此外，我们可以通过观察最相似和最不相似的样本来判断该度量方法的合理性。本案例中，圣托马斯大学和约翰卡罗尔大学最相似，而俄克拉荷马科技和艺术大学和哈佛大学差异最大。

In [7]:

gower_mat <- as.matrix(gower_dist)

# Output most similar pair

college_clean[
which(gower_mat == min(gower_mat[gower_mat != min(gower_mat)]),
arr.ind = TRUE)[1, ], ]

Out[7]:

In [8]:

# Output most dissimilar pair

college_clean[
which(gower_mat == max(gower_mat[gower_mat != max(gower_mat)]),
arr.ind = TRUE)[1, ], ]

Out[8]:

聚类算法的选择

现在我们已经计算好样本间的距离矩阵，接下来需要选择一个合适的聚类算法，本文采用 PAM（partioniong around medoids）算法来构建模型：

PAM 算法的主要步骤：

随机选择 k 个数据点，并将其设为簇中心点
遍历所有样本点，并将样本点归入最近的簇中
对每个簇而言，找出与簇内其他点距离之和最小的点，并将其设为新的簇中心点
重复第2步，直到收敛

该算法和 K-means 算法非常相似。事实上，除了中心点的计算方法不同外，其他步骤都完全一致 。

优点：简单易懂且不易受异常值所影响
缺点：算法时间复杂度为 O(n2)O(n2)

聚类个数的选择

我们将利用轮廓系数来确定最佳的聚类个数，轮廓系数是一个用于衡量聚类离散度的内部指标，该指标的取值范围是[-1,1]，其数值越大越好。通过比较不同聚类个数下轮廓系数的大小，我们可以看出当聚类个数为 3 时，聚类效果最好。

In [9]:

# Calculate silhouette width for many k using PAM

sil_width <- c(NA)

for(i in 2:10){

pam_fit <- pam(gower_dist,
diss = TRUE,
k = i)

sil_width[i] <- pam_fit$silinfo$avg.width

}

# Plot sihouette width (higher is better)

plot(1:10, sil_width,
xlab = "Number of clusters",
ylab = "Silhouette Width")
lines(1:10, sil_width)

聚类结果解释
描述统计量

聚类完毕后，我们可以调用 summary 函数来查看每个簇的汇总信息。从这些汇总信息中我们可以看出：簇1主要是中等学费且学生规模较小的私立非顶尖院校，簇2主要是高收费、低录取率且高毕业率的私立顶尖院校，而簇3则是低学费、低毕业率且学生规模较大的公立非顶尖院校。

In [18]:

pam_fit <- pam(gower_dist, diss = TRUE, k = 3)

pam_results <- college_clean %>%
dplyr::select(-name) %>%
mutate(cluster = pam_fit$clustering) %>%
group_by(cluster) %>%
do(the_summary = summary(.))

print(pam_results$the_summary)

[[1]]
accept_rate Outstate Enroll Grad.Rate Private
Min. :0.3283 Min. : 2340 Min. : 35.0 Min. : 15.00 No : 0
1st Qu.:0.7225 1st Qu.: 8842 1st Qu.: 194.8 1st Qu.: 56.00 Yes:500
Median :0.8004 Median :10905 Median : 308.0 Median : 67.50
Mean :0.7820 Mean :11200 Mean : 418.6 Mean : 66.97
3rd Qu.:0.8581 3rd Qu.:13240 3rd Qu.: 484.8 3rd Qu.: 78.25
Max. :1.0000 Max. :21700 Max. :4615.0 Max. :118.00
isElite cluster
Not Elite:500 Min. :1
Elite : 0 1st Qu.:1
Median :1
Mean :1
3rd Qu.:1
Max. :1

[[2]]
accept_rate Outstate Enroll Grad.Rate Private
Min. :0.1545 Min. : 5224 Min. : 137.0 Min. : 54.00 No : 4
1st Qu.:0.4135 1st Qu.:13850 1st Qu.: 391.0 1st Qu.: 77.00 Yes:65
Median :0.5329 Median :17238 Median : 601.0 Median : 89.00
Mean :0.5392 Mean :16225 Mean : 882.5 Mean : 84.78
3rd Qu.:0.6988 3rd Qu.:18590 3rd Qu.:1191.0 3rd Qu.: 94.00
Max. :0.9605 Max. :20100 Max. :4893.0 Max. :100.00
isElite cluster
Not Elite: 0 Min. :2
Elite :69 1st Qu.:2
Median :2
Mean :2
3rd Qu.:2
Max. :2

[[3]]
accept_rate Outstate Enroll Grad.Rate Private
Min. :0.3746 Min. : 2580 Min. : 153 Min. : 10.00 No :208
1st Qu.:0.6423 1st Qu.: 5295 1st Qu.: 694 1st Qu.: 46.00 Yes: 0
Median :0.7458 Median : 6598 Median :1302 Median : 54.50
Mean :0.7315 Mean : 6698 Mean :1615 Mean : 55.42
3rd Qu.:0.8368 3rd Qu.: 7748 3rd Qu.:2184 3rd Qu.: 65.00
Max. :1.0000 Max. :15516 Max. :6392 Max. :100.00
isElite cluster
Not Elite:199 Min. :3
Elite : 9 1st Qu.:3
Median :3
Mean :3
3rd Qu.:3
Max. :3

PAM 算法的另一个优点是各个簇的中心点是实际的样本点。从聚类结果中我们可以看出，圣弗朗西斯大学是簇1 的中心点，巴朗德学院是簇2 的中心点，而密歇根州州立大学河谷大学是簇3 的中心点。

In [19]:

college_clean[pam_fit$medoids, ]

Out[19]:

可视化方法

t-SNE 是一种降维方法，它可以在保留聚类结构的前提下，将多维信息压缩到二维或三维空间中。借助t-SNE我们可以将 PAM 算法的聚类结果绘制出来，有趣的是私立顶尖院校和公立非顶尖院校这两个簇中间存在一个小聚类簇。

In [22]:

tsne_obj <- Rtsne(gower_dist, is_distance = TRUE)

tsne_data <- tsne_obj$Y %>%
data.frame() %>%
setNames(c("X", "Y")) %>%
mutate(cluster = factor(pam_fit$clustering),
name = college_clean$name)

ggplot(aes(x = X, y = Y), data = tsne_data) +
geom_point(aes(color = cluster))

进一步探究可以发现，这一小簇主要包含一些竞争力较强的公立院校，比如弗吉尼亚大学和加州大学伯克利分校。虽然无法通过轮廓系数指标来证明多分一类是合理的，但是这 13 所院校的确显着不同于其他三个簇的院校。

In [25]:

tsne_data %>%
filter(X > 15 & X < 25,
Y > -15 & Y < -10) %>%
left_join(college_clean, by = "name") %>%
collect %>%
.[["name"]]

Out[25]:

‘Kansas State University’
‘North Carolina State University at Raleigh’
‘Pennsylvania State Univ. Main Campus’
‘SUNY at Buffalo’
‘Texas A&M Univ. at College Station’
‘University of Georgia’
‘University of Kansas’
‘University of Maryland at College Park’
‘University of Minnesota Twin Cities’
‘University of Missouri at Columbia’
‘University of Tennessee at Knoxville’
‘University of Texas at Austin’

④ 数字图像处理clean算法的MATLAB代码

图像去噪是数字图像处理中的重要环节和步骤。去噪效果的好坏直接影响到后续的图像处理工作如图像分割、边缘检测等。图像信号在产生、传输过程中都可能会受到噪声的污染，一般数字图像系统中的常见噪声主要有：高斯噪声（主要由阻性元器件内部产生）、椒盐噪声（主要是图像切割引起的黑图像上的白点噪声或光电转换过程中产生的泊松噪声）等； 
目前比较经典的图像去噪算法主要有以下三种： 
均值滤波算法：也称线性滤波，主要思想为邻域平均法，即用几个像素灰度的平均值来代替每个像素的灰度。有效抑制加性噪声，但容易引起图像模糊，可以对其进行改进，主要避开对景物边缘的平滑处理。 
中值滤波：基于排序统计理论的一种能有效抑制噪声的非线性平滑滤波信号处理技术。中值滤波的特点即是首先确定一个以某个像素为中心点的邻域，一般为方形邻域，也可以为圆形、十字形等等，然后将邻域中各像素的灰度值排序，取其中间值作为中心像素灰度的新值，这里领域被称为窗口，当窗口移动时，利用中值滤波可以对图像进行平滑处理。其算法简单，时间复杂度低，但其对点、线和尖顶多的图像不宜采用中值滤波。很容易自适应化。 Wiener维纳滤波：使原始图像和其恢复图像之间的均方误差最小的复原方法，是一种自适应滤波器，根据局部方差来调整滤波器效果。对于去除高斯噪声效果明显。 
实验一：均值滤波对高斯噪声的效果 
I=imread('C:\Documents and Settings\Administrator\桌面\1.gif');%读取图像

⑤ JVM的垃圾算法有哪几种

一、垃圾收集器概述

如上图所示，垃圾回收算法一共有7个，3个属于年轻代、三个属于年老代，G1属于横跨年轻代和年老代的算法。

JVM会从年轻代和年老代各选出一个算法进行组合，连线表示哪些算法可以组合使用

二、各个垃圾收集器说明

1、Serial(年轻代）

• 年轻代收集器，可以和Serial Old、CMS组合使用

• 采用复制算法

• 使用单线程进行垃圾回收，回收时会导致Stop The World，用户进程停止

• client模式年轻代默认算法

• GC日志关键字：DefNew(Default New Generation)

• 图示（Serial+Serial Old)
  

  7、G1

• G1收集器由于没有使用过，所以从网上找了一些教程供大家了解

• 并行与并发

• 分代收集

• 空间整合

• 可预测的停顿