墨航_个人页_阿里云开发者社区

发表了文章 2018-08-10

file_fdw妙用无穷——从数据库读取系统信息

PostgreSQL是最先进的开源数据库，其中一个非常给力的特性就是FDW：外部数据包装器（Foreign Data Wrapper）。通过FDW，用户可以用统一的方式从Pg中访问各类外部数据源。file_fdw就是其中随数据库附赠的两个fdw之一。随着pg10的更新，file_fdw也添加了一颗赛艇的功能：从程序输出读取。小霸王妙用无穷，我们能通过file_fdw，轻松查看操作系统信息，拉取网络数据，把各种各样的数据源轻松喂进数据库里统一查看管理。安装与配置 file_fdw是Pg自带的组件，不需要奇怪的配置，在数据库中执行以下命令即可启用file_fdw： CREATE EXTENSION file_fdw; 启用FDW插件之后，需要创建一个实例，也是一行SQL搞定，创建一个名为fs的FDW Server实例。 CREATE SERVER fs FOREIGN DATA WRAPPER file_fdw; 创建外部表举个栗子，如果我想从数据库中读取操作系统中正在运行的进程信息，该怎么做呢？最典型，也是最常用的外部数据格式就是CSV啦。不过系统命令输出的结果并不是很规整： >>> ps ux USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND vonng 2658 0.0 0.2 148428 2620 ? S 11:51 0:00 sshd: vonng@pts/0,pts/2 vonng 2659 0.0 0.2 115648 2312 pts/0 Ss+ 11:51 0:00 -bash vonng 4854 0.0 0.2 115648 2272 pts/2 Ss 15:46 0:00 -bash vonng 5176 0.0 0.1 150940 1828 pts/2 R+ 16:06 0:00 ps -ux vonng 26460 0.0 1.2 271808 13060 ? S 10月26 0:22 /usr/local/pgsql/bin/postgres vonng 26462 0.0 0.2 271960 2640 ? Ss 10月26 0:00 postgres: checkpointer process vonng 26463 0.0 0.2 271808 2148 ? Ss 10月26 0:25 postgres: writer process vonng 26464 0.0 0.5 271808 5300 ? Ss 10月26 0:27 postgres: wal writer process vonng 26465 0.0 0.2 272216 2096 ? Ss 10月26 0:31 postgres: autovacuum launcher process vonng 26466 0.0 0.1 126896 1104 ? Ss 10月26 0:54 postgres: stats collector process vonng 26467 0.0 0.1 272100 1588 ? Ss 10月26 0:01 postgres: bgworker: logical replication launcher 可以通过awk，将ps的命令输出规整为分隔符为\x1F的csv格式。 ps aux | awk '{print $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,substr($0,index($0,$11))}' OFS='\037' 正戏来啦！通过以下DDL创建一张外表定义 CREATE FOREIGN TABLE process_status ( username TEXT, pid INTEGER, cpu NUMERIC, mem NUMERIC, vsz BIGINT, rss BIGINT, tty TEXT, stat TEXT, start TEXT, time TEXT, command TEXT ) SERVER fs OPTIONS ( PROGRAM $$ ps aux | awk '{print $1,$2,$3,$4,$5,$6,$7,$8,$9,$10,substr($0,index($0,$11))}' OFS='\037' $$ , FORMAT 'csv', DELIMITER E'\037', HEADER 'TRUE'); 这里，关键是通过CREATE FOREIGN TABLE OPTIONS (xxxx)中的OPTIONS提供相应的参数，在PROGRAM参数中填入上面的命令，pg就会在查询这张表的时候自动执行此命令，并读取其输出。FORMAT参数可以指定为CSV，DELIMITER参数指定为之前使用的\x1F，并通过HEADER 'TRUE'忽略CSV的第一行那么结果如何呢？有什么用最简单的场景，原本系统指标监控需要编写各种监测脚本，部署在奇奇怪怪的地方。然后定期执行拉取metric，再存进数据库。现在通过file_fdw的方式，可以将感兴趣的指标直接录入数据库表，一步到位，而且维护方便，部署简单，更加可靠。在外表上加上视图，定期拉取聚合，将原本一个监控系统完成的事情，在数据库中一条龙解决了。因为可以从程序输出读取结果，因此file_fdw可以与linux生态里各类强大的命令行工具配合使用，发挥出强大的威力。其他栗子诸如此类，实际上后来我发现Facebook貌似有一个类似的产品，叫OSQuery，也是干了差不多的事。通过SQL查询操作系统的指标。但明显PostgreSQL这种方法最简单粗暴高效啦，只要定义表结构，和命令数据源就能轻松对接指标数据，用不了一天就能做出一个功能差不多的东西来。用于读取系统用户列表的DDL： CREATE FOREIGN TABLE etc_password ( username TEXT, password TEXT, user_id INTEGER, group_id INTEGER, user_info TEXT, home_dir TEXT, shell TEXT ) SERVER fs OPTIONS ( PROGRAM $$ awk -F: 'NF && !/^[:space:]*#/ {print $1,$2,$3,$4,$5,$6,$7}' OFS='\037' /etc/passwd $$ , FORMAT 'csv', DELIMITER E'\037' ); 用于读取磁盘用量的DDL： CREATE FOREIGN TABLE disk_free ( file_system TEXT, blocks_1m BIGINT, used_1m BIGINT, avail_1m BIGINT, capacity TEXT, iused BIGINT, ifree BIGINT, iused_pct TEXT, mounted_on TEXT ) SERVER fs OPTIONS (PROGRAM $$ df -ml| awk '{print $1,$2,$3,$4,$5,$6,$7,$8,$9}' OFS='\037' $$ , FORMAT 'csv', HEADER 'TRUE', DELIMITER E'\037' ); 当然，用file_fdw只是一个很Naive的FDW，譬如这里就只能读，不能改。自己编写FDW实现增删改查逻辑也非常简单，例如Multicorn就是使用Python编写FDW的项目。 SQL over everything，让世界变的更简单~

发表了文章 2017-08-25

Go database/sql 教程

Go使用SQL与类SQL数据库的惯例是通过标准库database/sql。这是一个对关系型数据库的通用抽象，它提供了标准的、轻量的、面向行的接口。不过database/sql的包文档只讲它做了什么，却对如何使用只字未提。快速指南远比堆砌事实有用，本文讲述了database/sql的使用方法及其注意事项。 1. 顶层抽象在Go中访问数据库需要用到sql.DB接口：它可以创建语句(statement)和事务(transaction)，执行查询，获取结果。 sql.DB并不是数据库连接，也并未在概念上映射到特定的数据库(Database)或模式(schema)。它只是一个抽象的接口，不同的具体驱动有着不同的实现方式。通常而言，sql.DB会处理一些重要而麻烦的事情，例如操作具体的驱动打开/关闭实际底层数据库的连接，按需管理连接池。 sql.DB这一抽象让用户不必考虑如何管理并发访问底层数据库的问题。当一个连接在执行任务时会被标记为正在使用。用完之后会放回连接池中。不过用户如果用完连接后忘记释放，就会产生大量的连接，极可能导致资源耗尽（建立太多连接，打开太多文件，缺少可用网络端口）。 2. 导入驱动使用数据库时，除了database/sql包本身，还需要引入想使用的特定数据库驱动。尽管有时候一些数据库特有的功能必需通过驱动的Ad Hoc接口来实现，但通常只要有可能，还是应当尽量只用database/sql中定义的类型。这可以减小用户代码与驱动的耦合，使切换驱动时代码改动最小化，也尽可能地使用户遵循Go的惯用法。本文使用PostgreSQL为例，PostgreSQL的著名的驱动有： github.com/lib/pq github.com/go-pg/pg github.com/jackc/pgx。这里以pgx为例，它性能表现不俗，并对PostgreSQL诸多特性与类型有着良好的支持。既可使用Ad-Hoc API，也提供了标准数据库接口的实现：github.com/jackc/pgx/stdlib。 import ( "database/sql" _ "github.com/jackx/pgx/stdlib" ) 使用_别名来匿名导入驱动，驱动的导出名字不会出现在当前作用域中。导入时，驱动的初始化函数会调用sql.Register将自己注册在database/sql包的全局变量sql.drivers中，以便以后通过sql.Open访问。 3. 访问数据加载驱动包后，需要使用sql.Open()来创建sql.DB： func main() { db, err := sql.Open("pgx","postgres://localhost:5432/postgres") if err != nil { log.Fatal(err) } defer db.Close() } sql.Open有两个参数：第一个参数是驱动名称，字符串类型。为避免混淆，一般与包名相同，这里是pgx。第二个参数也是字符串，内容依赖于特定驱动的语法。通常是URL的形式，例如postgres://localhost:5432。绝大多数情况下都应当检查database/sql操作所返回的错误。一般而言，程序需要在退出时通过sql.DB的Close()方法释放数据库连接资源。如果其生命周期不超过函数的范围，则应当使用defer db.Close() 执行sql.Open()并未实际建立起到数据库的连接，也不会验证驱动参数。第一个实际的连接会惰性求值，延迟到第一次需要时建立。用户应该通过db.Ping()来检查数据库是否实际可用。 if err = db.Ping(); err != nil { // do something about db error } sql.DB对象是为了长连接而设计的，不要频繁Open()和Close()数据库。而应该为每个待访问的数据库创建一个sql.DB实例，并在用完前一直保留它。需要时可将其作为参数传递，或注册为全局对象。如果没有按照database/sql设计的意图，不把sql.DB当成长期对象来用而频繁开关启停，就可能遭遇各式各样的错误：无法复用和共享连接，耗尽网络资源，由于TCP连接保持在TIME_WAIT状态而间断性的失败等…… 4. 获取结果有了sql.DB实例之后就可以开始执行查询语句了。 Go将数据库操作分为两类：Query与Exec。两者的区别在于前者会返回结果，而后者不会。 Query表示查询，它会从数据库获取查询结果（一系列行，可能为空）。 Exec表示执行语句，它不会返回行。此外还有两种常见的数据库操作模式： QueryRow表示只返回一行的查询，作为Query的一个常见特例。 Prepare表示准备一个需要多次使用的语句，供后续执行用。 4.1 获取数据让我们看一个如何查询数据库并且处理结果的例子：利用数据库计算从1到10的自然数之和。 func example() { var sum, n int32 // invoke query rows, err := db.Query("SELECT generate_series(1,$1)", 10) // handle query error if err != nil { fmt.Println(err) } // defer close result set defer rows.Close() // Iter results for rows.Next() { if err = rows.Scan(&n); err != nil { fmt.Println(err) // Handle scan error } sum += n // Use result } // check iteration error if rows.Err() != nil { fmt.Println(err) } fmt.Println(sum) } 整体工作流程如下：使用db.Query()来发送查询到数据库，获取结果集Rows，并检查错误。使用rows.Next()作为循环条件，迭代读取结果集。使用rows.Scan从结果集中获取一行结果。使用rows.Err()在退出迭代后检查错误。使用rows.Close()关闭结果集，释放连接。一些需要详细说明的地方： db.Query会返回结果集*Rows和错误。每个驱动返回的错误都不一样，用错误字符串来判断错误类型并不是明智的做法，更好的方法是对抽象的错误做Type Assertion，利用驱动提供的更具体的信息来处理错误。当然类型断言也可能产生错误，这也是需要处理的。 if err.(pgx.PgError).Code == "0A000" { // Do something with that type or error } rows.Next()会指明是否还有未读取的数据记录，通常用于迭代结果集。迭代中的错误会导致rows.Next()返回false。 rows.Scan()用于在迭代中获取一行结果。数据库会使用wire protocal通过TCP/UnixSocket传输数据，对Pg而言，每一行实际上对应一条DataRow消息。Scan接受变量地址，解析DataRow消息并填入相应变量中。因为Go语言是强类型的，所以用户需要创建相应类型的变量并在rows.Scan中传入其指针，Scan函数会根据目标变量的类型执行相应转换。例如某查询返回一个单列string结果集，用户可以传入[]byte或string类型变量的地址，Go会将原始二进制数据或其字符串形式填入其中。但如果用户知道这一列始终存储着数字字面值，那么相比传入string地址后手动使用strconv.ParseInt()解析，更推荐的做法是直接传入一个整型变量的地址（如上面所示），Go会替用户完成解析工作。如果解析出错，Scan会返回相应的错误。 rows.Err()用于在退出迭代后检查错误。正常情况下迭代退出是因为内部产生的EOF错误，使得下一次rows.Next() == false，从而终止循环；在迭代结束后要检查错误，以确保迭代是因为数据读取完毕，而非其他“真正”错误而结束的。遍历结果集的过程实际上是网络IO的过程，可能出现各种错误。健壮的程序应当考虑这些可能，而不能总是假设一切正常。 rows.Close()用于关闭结果集。结果集引用了数据库连接，并会从中读取结果。读取完之后必须关闭它才能避免资源泄露。只要结果集仍然打开着，相应的底层连接就处于忙碌状态，不能被其他查询使用。因错误(包括EOF)导致的迭代退出会自动调用rows.Close()关闭结果集（和释放底层连接）。但如果程序自行意外地退出了循环，例如中途break & return，结果集就不会被关闭，产生资源泄露。rows.Close方法是幂等的，重复调用不会产生副作用，因此建议使用 defer rows.Close()来关闭结果集。以上就是在Go中使用数据库的标准方式。 4.2 单行查询如果一个查询每次最多返回一行，那么可以用快捷的单行查询来替代冗长的标准查询，例如上例可改写为： var sum int err := db.QueryRow("SELECT sum(n) FROM (SELECT generate_series(1,$1) as n) a;", 10).Scan(&sum) if err != nil { fmt.Println(err) } fmt.Println(sum) 不同于Query，如果查询发生错误，错误会延迟到调用Scan()时统一返回，减少了一次错误处理判断。同时QueryRow也避免了手动操作结果集的麻烦。需要注意的是，对于单行查询，Go将没有结果的情况视为错误。sql包中定义了一个特殊的错误常量ErrNoRows，当结果为空时，QueryRow().Scan()会返回它。 4.3 修改数据什么时候用Exec，什么时候用Query，这是一个问题。通常DDL和增删改使用Exec，返回结果集的查询使用Query。但这不是绝对的，这完全取决于用户是否希望想要获取返回结果。例如在PostgreSQL中：INSERT ... RETURNING *;虽然是一条插入语句，但它也有返回结果集，故应当使用Query而不是Exec。 Query和Exec返回的结果不同，两者的签名分别是： func (s *Stmt) Query(args ...interface{}) (*Rows, error) func (s *Stmt) Exec(args ...interface{}) (Result, error) Exec不需要返回数据集，返回的结果是Result，Result接口允许获取执行结果的元数据 type Result interface { // 用于返回自增ID，并不是所有的关系型数据库都有这个功能。 LastInsertId() (int64, error) // 返回受影响的行数。 RowsAffected() (int64, error) } Exec的用法如下所示： db.Exec(`CREATE TABLE test_users(id INTEGER PRIMARY KEY ,name TEXT);`) db.Exec(`TRUNCATE test_users;`) stmt, err := db.Prepare(`INSERT INTO test_users(id,name) VALUES ($1,$2) RETURNING id`) if err != nil { fmt.Println(err.Error()) } res, err := stmt.Exec(1, "Alice") if err != nil { fmt.Println(err) } else { fmt.Println(res.RowsAffected()) fmt.Println(res.LastInsertId()) } 相比之下Query则会返回结果集对象*Rows，使用方式见上节。其特例QueryRow使用方式如下： db.Exec(`CREATE TABLE test_users(id INTEGER PRIMARY KEY ,name TEXT);`) db.Exec(`TRUNCATE test_users;`) stmt, err := db.Prepare(`INSERT INTO test_users(id,name) VALUES ($1,$2) RETURNING id`) if err != nil { fmt.Println(err.Error()) } var returnID int err = stmt.QueryRow(4, "Alice").Scan(&returnID) if err != nil { fmt.Println(err) } else { fmt.Println(returnID) } 同样的语句使用Exec和Query执行有巨大的差别。如上文所述，Query会返回结果集Rows，而存在未读取数据的Rows其实会占用底层连接直到rows.Close()为止。因此，使用Query但不读取返回结果，会导致底层连接永远无法释放。database/sql期望用户能够用完就把连接还回来，所以这样的用法很快就会导致资源耗尽（连接过多）。所以，应该用Exec的语句绝不可用Query来执行。 4.4 准备查询在上一节的两个例子中，没有直接使用数据库的Query和Exec方法，而是首先执行了db.Prepare获取准备好的语句(prepared statement)。准备好的语句Stmt和sql.DB一样，都可以执行Query、Exec等方法。准备语句的优势在查询前进行准备是Go语言中的惯用法，多次使用的查询语句应当进行准备（Prepare）。准备查询的结果是一个准备好的语句（prepared statement），语句中可以包含执行时所需参数的占位符（即绑定值）。准备查询比拼字符串的方式好很多，它可以转义参数，避免SQL注入。同时，准备查询对于一些数据库也省去了解析和生成执行计划的开销，有利于性能。占位符 PostgreSQL使用$N作为占位符，N是一个从1开始递增的整数，代表参数的位置，方便参数的重复使用。MySQL使用?作为占位符，SQLite两种占位符都可以，而Oracle则使用:param1的形式。 MySQL PostgreSQL Oracle ===== ========== ====== WHERE col = ? WHERE col = $1 WHERE col = :col VALUES(?, ?, ?) VALUES($1, $2, $3) VALUES(:val1, :val2, :val3) 以PostgreSQL为例，在上面的例子中："SELECT generate_series(1,$1)" 就用到了$N的占位符形式，并在后面提供了与占位符数目匹配的参数个数。底层内幕准备语句有着各种优点：安全，高效，方便。但Go中实现它的方式可能和用户所设想的有轻微不同，尤其是关于和database/sql内部其他对象交互的部分。在数据库层面，准备语句Stmt是与单个数据库连接绑定的。通常的流程是：客户端向服务器发送带有占位符的查询语句用于准备，服务器返回一个语句ID，客户端在实际执行时，只需要传输语句ID和相应的参数即可。因此准备语句无法在连接之间共享，当使用新的数据库连接时，必须重新准备。 database/sql并没有直接暴露出数据库连接。用户是在DB或Tx上执行Prepare，而不是Conn。因此database/sql提供了一些便利处理，例如自动重试。这些机制隐藏在Driver中实现，而不会暴露在用户代码中。其工作原理是：当用户准备一条语句时，它在连接池中的一个连接上进行准备。Stmt对象会引用它实际使用的连接。当执行Stmt时，它会尝试会用引用的连接。如果那个连接忙碌或已经被关闭，它会获取一个新的连接，并在连接上重新准备，然后再执行。因为当原有连接忙时，Stmt会在其他连接上重新准备。因此当高并发地访问数据库时，大量的连接处于忙碌状态，这会导致Stmt不断获取新的连接并执行准备，最终导致资源泄露，甚至超出服务端允许的语句数目上限。所以通常应尽量采用扇入的方式减小数据库访问并发数。查询的微妙之处数据库连接其实是实现了Begin,Close,Prepare方法的接口。 type Conn interface { Prepare(query string) (Stmt, error) Close() error Begin() (Tx, error) } 所以连接接口上实际并没有Exec，Query方法，这些方法其实定义在Prepare返回的Stmt上。对于Go而言，这意味着db.Query()实际上执行了三个操作：首先对查询语句做了准备，然后执行查询语句，最后关闭准备好的语句。这对数据库而言，其实是3个来回。设计粗糙的程序与简陋实现驱动可能会让应用与数据库交互的次数增至3倍。好在绝大多数数据库驱动对于这种情况有优化，如果驱动实现sql.Queryer接口： type Queryer interface { Query(query string, args []Value) (Rows, error) } 那么database/sql就不会再进行Prepare-Execute-Close的查询模式，而是直接使用驱动实现的Query方法向数据库发送查询。对于查询都是即拼即用，也不担心安全问题的情况下，直接Query可以有效减少性能开销。 5. 使用事务事物是关系型数据库的核心特性。Go中事务（Tx）是一个持有数据库连接的对象，它允许用户在同一个连接上执行上面提到的各类操作。事务基本操作通过db.Begin()来开启一个事务，Begin方法会返回一个事务对象Tx。在结果变量Tx上调用Commit()或者Rollback()方法会提交或回滚变更，并关闭事务。在底层，Tx会从连接池中获得一个连接并在事务过程中保持对它的独占。事务对象Tx上的方法与数据库对象sql.DB的方法一一对应，例如Query,Exec等。事务对象也可以准备(prepare)查询，由事务创建的准备语句会显式绑定到创建它的事务。事务注意事项使用事务对象时，不应再执行事务相关的SQL语句，例如BEGIN,COMMIT等。这可能产生一些副作用： Tx对象一直保持打开状态，从而占用了连接。数据库状态不再与Go中相关变量的状态保持同步。事务提前终止会导致一些本应属于事务内的查询语句不再属于事务的一部分，这些被排除的语句有可能会由别的数据库连接而非原有的事务专属连接执行。当处于事务内部时，应当使用Tx对象的方法而非DB的方法，DB对象并不是事务的一部分，直接调用数据库对象的方法时，所执行的查询并不属于事务的一部分，有可能由其他连接执行。 Tx的其他应用场景如果需要修改连接的状态，也需要用到Tx对象，即使用户并不需要事务。例如：创建仅连接可见的临时表设置变量，例如SET @var := somevalue 修改连接选项，例如字符集，超时设置。在Tx上执行的方法都保证同一个底层连接执行，这使得对连接状态的修改对后续操作起效。这是Go中实现这种功能的标准方式。在事务中准备语句调用Tx.Prepare会创建一个与事务绑定的准备语句。在事务中使用准备语句，有一个特殊问题需要关注：一定要在事务结束前关闭准备语句。在事务中使用defer stmt.Close()是相当危险的。因为当事务结束后，它会释放自己持有的数据库连接，但事务创建的未关闭Stmt仍然保留着对事务连接的引用。在事务结束后执行stmt.Close()，如果原来释放的连接已经被其他查询获取并使用，就会产生竞争，极有可能破坏连接的状态。 6. 处理空值可空列（Nullable Column）非常的恼人，容易导致代码变得丑陋。如果可以，在设计时就应当尽量避免。因为： Go语言的每一个变量都有着默认零值，当数据的零值没有意义时，可以用零值来表示空值。但很多情况下，数据的零值和空值实际上有着不同的语义。单独的原子类型无法表示这种情况。标准库只提供了有限的四种Nullable type：：NullInt64, NullFloat64, NullString, NullBool。并没有诸如NullUint64，NullYourFavoriteType，用户需要自己实现。空值有很多麻烦的地方。例如用户认为某一列不会出现空值而采用基本类型接收时却遇到了空值，程序就会崩溃。这种错误非常稀少，难以捕捉、侦测、处理，甚至意识到。空值的解决办法使用额外的标记字段 database\sql提供了四种基本可空数据类型：使用基本类型和一个布尔标记的复合结构体表示可空值。例如： type NullInt64 struct { Int64 int64 Valid bool // Valid is true if Int64 is not NULL } 可空类型的使用方法与基本类型一致： for rows.Next() { var s sql.NullString err := rows.Scan(&s) // check err if s.Valid { // use s.String } else { // handle NULL case } } 使用指针在Java中通过装箱（boxing）处理可空类型，即把基本类型包装成一个类，并通过指针引用。于是，空值语义可以通过指针为空来表示。Go当然也可以采用这种办法，不过标准库中并没有提供这种实现方式。pgx提供了这种形式的可空类型支持。使用零值表示空值如果数据本身从语义上就不会出现零值，或者根本不区分零值和空值，那么最简便的方法就是使用零值来表示空值。驱动go-pg提供了这种形式的支持。自定义处理逻辑任何实现了Scanner接口的类型，都可以作为Scan传入的地址参数类型。这就允许用户自己定制复杂的解析逻辑，实现更丰富的类型支持。 type Scanner interface { // Scan 从数据库驱动中扫描出一个值，当不能无损地转换时，应当返回错误 // src可能是int64, float64, bool, []byte, string, time.Time，也可能是nil，表示空值。 Scan(src interface{}) error } 在数据库层面解决通过对列添加NOT NULL约束，可以确保任何结果都不会为空。或者，通过在SQL中使用COALESCE来为NULL设定默认值。 7. 处理动态列 Scan()函数要求传递给它的目标变量的数目，与结果集中的列数正好匹配，否则就会出错。但总有一些情况，用户事先并不知道返回的结果到底有多少列，例如调用一个返回表的存储过程时。在这种情况下，使用rows.Columns()来获取列名列表。在不知道列类型情况下，应当使用sql.RawBytes作为接受变量的类型。获取结果后自行解析。 cols, err := rows.Columns() if err != nil { // handle this.... } // 目标列是一个动态生成的数组 dest := []interface{}{ new(string), new(uint32), new(sql.RawBytes), } // 将数组作为可变参数传入Scan中。 err = rows.Scan(dest...) // ... 8. 连接池 database/sql包里实现了一个通用的连接池，它只提供了非常简单的接口，除了限制连接数、设置生命周期基本没有什么定制选项。但了解它的一些特性也是很有帮助的。连接池意味着：同一个数据库上的连续两条查询可能会打开两个连接，在各自的连接上执行。这可能导致一些让人困惑的错误，例如程序员希望锁表插入时连续执行了两条命令：LOCK TABLE和INSERT，结果却会阻塞。因为执行插入时，连接池创建了一个新的连接，而这条连接并没有持有表锁。在需要时，而且连接池中没有可用的连接时，连接才被创建。默认情况下连接数量没有限制，想创建多少就有多少。但服务器允许的连接数往往是有限的。用db.SetMaxIdleConns(N)来限制连接池中空闲连接的数量，但是这并不会限制连接池的大小。连接回收(recycle)的很快，通过设置一个较大的N，可以在连接池中保留一些空闲连接，供快速复用(reuse)。但保持连接空闲时间过久可能会引发其他问题，比如超时。设置N=0则可以避免连接空闲太久。用db.SetMaxOpenConns(N)来限制连接池中打开的连接数量。用db.SetConnMaxLifetime(d time.Duration)来限制连接的生命周期。连接超时后，会在需要时惰性回收复用。 9. 微妙行为 database/sql并不复杂，但某些情况下它的微妙表现仍然会出人意料。 9.1 资源耗尽不谨慎地使用database/sql会给自己挖许多坑，最常见的问题就是资源枯竭（resource exhaustion）：打开和关闭数据库（sql.DB）可能会导致资源枯竭；结果集没有读取完毕，或者调用rows.Close()失败，结果集会一直占用池里的连接；使用Query()执行一些不返回结果集的语句，返回的未读取结果集会一直占用池里的连接；不了解准备语句（Prepared Statement）的工作原理会产生许多额外的数据库访问。 9.2 Uint64 Go底层使用int64来表示整型，使用uint64时应当极其小心。使用超出int64表示范围的整数作为参数，会产生一个溢出错误： // Error: constant 18446744073709551615 overflows int _, err := db.Exec("INSERT INTO users(id) VALUES", math.MaxUint64) 这种类型的错误非常不容易发现，它可能一开始表现的很正常，但是溢出之后问题就来了。 9.3 不合预期的连接状态连接的状态，例如是否处于事务中，所连接的数据库，设置的变量等，应该通过Go的相关类型来处理，而不是通过SQL语句。用户不应当对自己的查询在哪条连接上执行作任何假设，如果需要在同一条连接上执行，需要使用Tx。举个例子，通过USE DATABASE改变连接的数据库对于不少人是习以为常的操作，执行这条语句，只影响当前连接的状态，其他连接仍然访问的是原来的数据库。如果没有使用事务Tx，后续的查询并不能保证仍然由当前的连接执行，所以这些查询很可能并不像用户预期的那样工作。更糟糕的是，如果用户改变了连接的状态，用完之后它成为空连接又回到了连接池，这会污染其他代码的状态。尤其是直接在SQL中执行诸如BEGIN或COMMIT这样的语句。 9.4 驱动的特殊语法尽管database/sql是一个通用的抽象，但不同的数据库，不同的驱动仍然会有不同的语法和行为。参数占位符就是一个例子。 9.5 批量操作出乎意料的是，标准库没有提供对批量操作的支持。即INSERT INTO xxx VALUES (1),(2),...;这种一条语句插入多条数据的形式。目前实现这个功能还需要自己手动拼SQL。 9.6 执行多条语句 database/sql并没有对在一次查询中执行多条SQL语句的显式支持，具体的行为以驱动的实现为准。所以对于 _, err := db.Exec("DELETE FROM tbl1; DELETE FROM tbl2") // Error/unpredictable result 这样的查询，怎样执行完全由驱动说了算，用户并无法确定驱动到底执行了什么，又返回了什么。 9.7 事务中的多条语句因为事务保证在它上面执行的查询都由同一个连接来执行，因此事务中的语句必需按顺序一条一条执行。对于返回结果集的查询，结果集必须Close()之后才能进行下一次查询。用户如果尝试在前一条语句的结果还没读完前就执行新的查询，连接就会失去同步。这意味着事务中返回结果集的语句都会占用一次单独的网络往返。 10. 其他本文主体基于[[Go database/sql tutorial]]([Go database/sql tutorial])，由我翻译并进行一些增删改，修正过时错误的内容。转载保留出处。

发表了文章 2017-08-10

深入Go语言文本类型

Go的作者Ken Thompson是UTF-8的发明人（也是C,Unix,Plan9等的创始人），因此在关于字符编码上，Go有着独到而周全的设计。本文介绍了Go语言中的三种内置文本类型：string, byte,rune的内部表示与相互转换。 1. 概览 Go中，字符串string是内置类型，与文本处理相关的内置类型还有符文rune和字节byte。 UTF-8编码在Go语言中有着特殊的位置，无论是源代码的文本编码，还是字符串的内部编码都是UTF-8。Go绕开前辈语言们踩过的坑，使用了UTF8作为默认编码是一个非常明智的选择。相比之下，Java，Javascript都使用 UCS-2/UTF16作为内部编码，早期还有随机访问的优势，可当Unicode增长超出BMP之后，这一优势也荡然无存了。相比之下，字节序，Surrogate , 空间冗余带来的麻烦却仍让人头大无比。标准库与C语言类似，大多数关于字符串处理的函数都放在标准库里。Go将大部分字符串处理的函数放在了strings,bytes这两个包里。因为在字符串和整型间没有隐式类型转换，字符串和其他基本类型的转换的功能主要在标准库strconv中提供。unicode相关功能在unicode包中提供。encoding包提供了一系列其他的编码支持。摘要 Go语言源代码总是采用UTF-8编码字符串string可以包含任意字节序列，通常是UTF-8编码的。字符串字面值，在不带有字节转义的情况下一定是UTF-8编码的。 Go使用rune代表Unicode码位。一个字符可能由一个或多个码位组成（复合字符） Go string是建立在字节数组的基础上的，因此对string使用[]索引会得到字节byte而不是字符rune。 Go语言的字符串不是正规化(normalized)的，因此同一个字符可能由不同的字节序列表示。使用unicode/norm解决此类问题。基础数据结构数组与切片要讨论[]byte和[]rune，就必需先解释Go语言中的数组(Array)与切片(Slice)，数组很好理解，和C语言中的数组概念一致，切片则是对数组的引用。数组Array是固定长度的数据结构，不存放任何额外的信息。很少直接使用，往往用作切片的底层存储。切片Slice描述了数组中一个连续的片段，Go语言的切片操作与Python较为类似。在底层实现中，切片可以看成一个由三个word组成的结构体，这里word是CPU的字长。这三个字分别是ptr,len,cap，分别代表数组首元素地址，切片的长度，当前切片头位置到底层数组尾部的距离。因此，在函数参数中传递十个元素的数组，那么就会在栈上复制这十个元素。而传递一个切片，则实际上传递的是这个3Word结构体。传递切片本身就是传递引用。字节byte 字节byte实际上是uint8的别名，只是为了和其他8bit类型相区别才单独起了别名。通常出现的更多的是字节切片[]byte与字节数组[...]byte。字面值字节可以用单引号扩起的单个字符表示，不过这种字面值和rune的字面值很容易搞混。赋予字节变量一个超出范围的值，如果在编译期能检查出来就会报overflows byte编译错误。底层结构对于字节数组[]byte，实质上可以看做[]uint8，即一个整形切片，所以字节数组的本体结构定义如下： type SliceHeader struct { Data uintptr Len int Cap int } 字符串string 字符串通常是UTF8编码的文本，由一系列8bit字节组成。raw string literal和不含转义符号的string literal一定是UTF-8编码的，但string其实可以含有任意的字节序列。字符串是不可变对象，可以空(s="")，但不会是nil。底层结构 string在Go中的实现与Slice类似，但因为字符串是不可变类型，因此底层数组的长度就是字符串的长度，所以相比切片，string结构的本体少了一个Cap字段。只有一个指针和一个长度值，由两个Word组成。64位机器上占用16个字节。 type StringHeader struct { Data uintptr Len int } 虽然字符串是不可变类型，但通过指针和强制转换，还是可以进行一些危险但高效的操作的。不过要注意，编译器作为常量确定的string会写入只读段，是不可以修改的。相比之下,fmt.Sprintf生成的字符串分配在堆上，就可以通过黑魔法进行修改。关于string，有这么几点需要注意。 string常量会在编译期分配到只读段，对应数据地址不可写入。相同的string常量不会重复存储，但动态生成的字符串即使内容一样，数据也是在不同的空间。常量空字符串有数据地址，动态生成的字符串没有设置数据地址，只有动态生成的string可以unsafe魔改。 Golang string和[]byte转换，会将数据复制到堆上，返回数据指向复制的数据。所以string(bytes)存在开销 string和[]byte通过复制转换，性能损失接近4倍符文rune 符文rune其实是int32的别名，表示一个Unicode的码位。注意一个字符(Character)可以由一个或多个码位(Code Point)构成。例如带音调的e，即é,既可以由\u00e9单个码位表示，也可以由e和口音符号\u0301复合而成。这涉及到normalization的问题。但通常情况下一个字符就是一个码位。 >>> print u'\u00e9', u'e\u0301',u'e\u0301\u0301\u0301' é é é́́ 符文的字面值是用单引号括起的一个或多个字符，例如a,啊,\a,\141,\x61,\u0061,\U00000061，都是合法的rune literal。其格式定义如下： rune_lit = "'" ( unicode_value | byte_value ) "'" . unicode_value = unicode_char | little_u_value | big_u_value | escaped_char . byte_value = octal_byte_value | hex_byte_value . octal_byte_value = `\` octal_digit octal_digit octal_digit . hex_byte_value = `\` "x" hex_digit hex_digit . little_u_value = `\` "u" hex_digit hex_digit hex_digit hex_digit . big_u_value = `\` "U" hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit hex_digit . escaped_char = `\` ( "a" | "b" | "f" | "n" | "r" | "t" | "v" | `\` | "'" | `"` ) . 其中，八进制的数字范围是0~255，Unicode转义字符通常要排除0x10FFFF以上的字符和surrogate字符。看上去这样用单引号括起来的字面值像是一个字符串，但当源代码转换为内部表示时，它其实就是一个int32。所以var b byte = '蛤'，其实就是为uint8赋了一个int32的值，会导致溢出。相应的，一个rune也可以在不产生溢出的条件下赋值给byte。文本类型转换三种基本文本类型之间可以相互转换，当然，有常规的做法，也有指针黑魔法。 string与[]byte的转换 string和bytes的转换是最常见的，因为通常通过IO得到的都是[]byte，例如io.Reader接口的方法签名为：Read(p []byte) (n int, err error)。但日常字符串操作使用的都是string，这就需要在两者之间进行转换。常规做法通常[]byte和string可以直接通过类型名强制转化，但实质上执行了一次堆复制。理论上stringHeader只是比sliceHeader少一个cap字段，但因为string需要满足不可变的约束，而[]byte是可变的，因此在执行[]byte到string的操作时会进行一次复制，在堆上新分配一次内存。 // byte to string s := string(b) // string index -> byte s[i] = b // []byte to string s := string(bytes) // string to []byte bytes := []byte(s) 黑魔法利用unsafe.Pointer和reflect包可以实现很多禁忌的黑魔法，但这些操作对GC并不友好。最好不要尝试。 type Bytes []byte // 将string转换为[]byte，'可以修改'，很危险，因为[]byte结构要多一个cap字段。 func StringBytes(s string) Bytes { return *(*Bytes)(unsafe.Pointer(&s)) } // 不拷贝地将[]byte转换为string func BytesString(b []byte) String { // 因为[]byte的Header只比string的Header多一个Cap字段。可以直接强制成`*String` return *(*String)(unsafe.Pointer(&b)) } // 获取&s[0]，即存储字符串的字节数组的地址指针，Go里不允许这种操作。 func StringPointer(s string) unsafe.Pointer { p := (*reflect.StringHeader)(unsafe.Pointer(&s)) return unsafe.Pointer(p.Data) } // r获取&b[0]，即[]byte底层数组的地址指针，Go里不允许这种操作 func BytesPointer(b []byte) unsafe.Pointer { p := (*reflect.SliceHeader)(unsafe.Pointer(&b)) return unsafe.Pointer(p.Data) } string与rune的转换 string是UTF8编码的字符串，因此对于非含有ASCII字符的字符串，是没法简单的直接索引的。例如 fmt.Printf("%x","hello"[0])，会取出第一个字节h的相应字节表示uint8，值为：0x68。然而 fmt.Printf("%s","你好"[0])，也是同理，在UTF-8编码中，汉字"你"被编码为0xeE4BDA0由三个字节组成，因此使用下标0去索引字符串，并不会取出第一个汉字字符的int32码位值0x4f60来，而是这三个字节中的第一个0xE4。没有办法随机访问一个中文汉字是一件很蛋疼的事情。曾经Java和Javascript之类的语言就出于性能考虑使用UCS2/UTF-16来平衡时间和空间开销。但现在Unicode字符远远超过65535个了，这点优势已经荡然无存，想要准确的索引一个字符（尤其是带Emoji的），也需要用特制的API从头解码啦，啪啪啪打脸苍天饶过谁……。常规方式 string和rune之间也可以通过类型名直接转换，不过string不能直接转换成单个的rune。 // rune to string str := string(r) // range string -> rune for i,r := range str // string to []rune runes := []rune(str) // []rune to string str := string(runes) 特殊支持 Go对于UTF-8有特殊的支持和处理（因为UTF-8和Go都是Ken发明的……。），这体现在对于string的range迭代上。 const nihongo = "日本語" for index, runeValue := range nihongo { fmt.Printf("%#U starts at byte position %d\n", runeValue, index) } U+65E5 '日' starts at byte position 0 U+672C '本' starts at byte position 3 U+8A9E '語' starts at byte position 6 直接索引string会得到字节序号和相应字节。而对string进行range迭代，获得的就是字符rune的索引与相应的rune。 byte与rune的转换 byte其实是uint8，而rune实际就是int32，所以uint8和int32两者之间的转换就是整数的转换。但是[]uint8和[]int32是两个不同类型的整形数组，它们之间是没有直接强制转换的方法的，好在通过string来曲线救国：runes := []rune(string(bytes))

发表了文章 2017-08-07

使用PostgreSQL_Notify实现多实例缓存同步

Parallel与Hierarchy是架构设计的两大法宝，缓存是Hierarchy在IO领域的体现。单线程场景下缓存机制的实现可以简单到不可思议，但很难想象成熟的应用会只有一个实例。在使用缓存的同时引入并发，就不得不考虑一个问题：如何保证每个实例的缓存与底层数据副本的数据一致性。分布式系统受到CAP定理的约束，分区一致性P是一般来说是不允许牺牲的，不可能让两个实例对同样的请求却给出不同的结果。用缓存是为了更好的性能，所以如果还要追求可用性A，就一定会牺牲C。我们能做的，就是通过巧妙设计让AP系统的一致性损失最小化。传统方法最简单粗暴的办法就是定时重新拉取，例如每个整点，所有应用一起去数据库拉取一次最新版本的数据。很多应用都是这么做的。当然问题也很多：拉的间隔长了，变更不能及时应用，用户体验差；拉的频繁了，IO压力大。而且实例数目和数据大小一旦膨胀起来，对于宝贵的IO资源是很大的浪费。异步通知是一种更好的办法，尤其是在读请求远多于写请求的情况下。接受到写请求的实例，通过发送广播的方式通知其他实例。Redis的PubSub就可以很好地实现这个功能。如果原本下层存储就是Redis自然是再方便不过，但如果下层存储是关系型数据库的话，为这样一个功能引入一个新的组件似乎有些得不偿失。况且考虑到后台管理程序或者其他应用如果在修改了数据库后也要去redis发布通知，实在太麻烦了。一种可行的办法是通过数据库中间件来监听RDS变动并广播通知，淘宝不少东西就是这么做的。但如果DB本身就能搞定的事情，为什么要加一个中间件呢？通过PostgreSQL的Notfiy-Listen机制，可以方便地实现这种功能。目标无论从任何渠道产生的数据库记录变更（增删改）都能被所有相关应用实时感知，用于维护自身缓存与数据库内容的一致性。原理 PostgreSQL行级触发器 + Notify机制 + 自定义协议 + Smart Client 行级触发器：通过为我们感兴趣的表建立一个行级别的写触发器，对数据表中的每一行记录的Update,Delete,Insert都会出发自定义函数的执行。 Notify：通过PostgreSQL内建的异步通知机制向指定的Channel发送通知自定义协议：协商消息格式，传递操作的类型与变更记录的标识 Smart Client：客户端监听消息变更，根据消息对缓存执行相应的操作。实际上这样一套东西就是一个超简易的WAL（Write After Log）实现，从而使应用内部的缓存状态能与数据库保持实时一致（compare to poll）。实现 DDL 这里以一个最简单的表作为示例，一张以主键标识的users表。 -- 用户表 CREATE TABLE users ( id TEXT, name TEXT, PRIMARY KEY (id) ); 触发器 -- 通知触发器 CREATE OR REPLACE FUNCTION notify_change() RETURNS TRIGGER AS $$ BEGIN IF (TG_OP = 'INSERT') THEN PERFORM pg_notify(TG_RELNAME || '_chan', 'I' || NEW.id); RETURN NEW; ELSIF (TG_OP = 'UPDATE') THEN PERFORM pg_notify(TG_RELNAME || '_chan', 'U' || NEW.id); RETURN NEW; ELSIF (TG_OP = 'DELETE') THEN PERFORM pg_notify(TG_RELNAME || '_chan', 'D' || OLD.id); RETURN OLD; END IF; END; $$ LANGUAGE plpgsql SECURITY DEFINER; 这里创建了一个触发器函数，通过内置变量TG_OP获取操作的名称，TG_RELNAME获取表名。每当触发器执行时，它会向名为<table_name>_chan的通道发送指定格式的消息：[I|U|D]<id> 题外话：通过行级触发器，还可以实现一些很实用的功能，例如In-DB Audit，自动更新字段值，统计信息，自定义备份策略与回滚逻辑等。 -- 为用户表创建行级触发器，监听INSERT UPDATE DELETE 操作。 CREATE TRIGGER t_user_notify AFTER INSERT OR UPDATE OR DELETE ON users FOR EACH ROW EXECUTE PROCEDURE notify_change(); 创建触发器也很简单，表级触发器对每次表变更执行一次，而行级触发器对每条记录都会执行一次。这样，数据库的里的工作就算全部完成了。消息格式通知需要传达出两个信息：变更的操作类型，变更的实体标记。变更的操作类型就是增删改：INSERT,DELETE,UPDATE。通过一个打头的字符'[I|U|D]'就可以标识。变更的对象可以通过实体主键来标识。如果不是字符串类型，还需要确定一种无歧义的序列化方式。这里为了省事直接使用字符串类型作为ID，那么插入一条id=1的记录，对应的消息就是I1，更新一条id=5的记录消息就是U5，删除id=3的记录消息就是D3。完全可以通过更复杂的消息协议实现更强大的功能。 SmartClient 数据库的机制需要客户端的配合才能生效，客户端需要监听数据库的变更通知，才能将变更实时应用到自己的缓存副本中。对于插入和更新，客户端需要根据ID重新拉取相应实体，对于删除，客户端需要删除自己缓存副本的相应实体。以Go语言为例，编写了一个简单的客户端模块。本例中使用一个以User.ID作为键，User对象作为值的并发安全字典Users sync.Map作为缓存。作为演示，启动了另一个goroutine对数据库写入了一些变更。 package main import "sync" import "strings" import "github.com/go-pg/pg" import . "github.com/Vonng/gopher/db/pg" import log "github.com/Sirupsen/logrus" type User struct { ID string `sql:",pk"` Name string } // Users 内部数据缓存 var Users sync.Map // 辅助函数：加载全部用户，初始化时使用 func LoadAllUser() { var users []User Pg.Query(&users, `SELECT ID,name FROM users;`) for _, user := range users { Users.Store(user.ID, user) } } // 辅助函数：根据ID重载单个用户，当插入和更新时执行 func LoadUser(id string) { user := User{ID: id} Pg.Select(&user) Users.Store(user.ID, user) } // 打印缓存内部的Key列表 func PrintUsers() string { var buf []string Users.Range(func(key, value interface{}) bool { buf = append(buf, key.(string)); return true }) return strings.Join(buf, ",") } // ListenUserChange 会监听PostgreSQL users数据表中的变动通知，并维护缓存状态 func ListenUserChange() { go func(c <-chan *pg.Notification) { for notify := range c { action, id := notify.Payload[0], notify.Payload[1:] switch action { case 'I': fallthrough case 'U': LoadUser(id); case 'D': Users.Delete(id) } log.Infof("[NOTIFY] Action:%c ID:%s Users: %s", action, id, PrintUsers()) } }(Pg.Listen("users_chan").Channel()) } // MakeSomeChange 会向数据库写入一些变更 func MakeSomeChange() { Pg.Exec(`TRUNCATE TABLE users;`) Pg.Insert(&User{"001", "张三"}) Pg.Insert(&User{"002", "李四"}) Pg.Insert(&User{"003", "王五"}) // 插入 Pg.Update(&User{"003", "王麻子"}) // 改名 Pg.Delete(&User{ID: "002"}) // 删除 } func main() { LoadAllUser() ListenUserChange() go MakeSomeChange() <-make(chan struct{}) } 运行结果如下： [NOTIFY] Action:I ID:001 Users: 001 [NOTIFY] Action:I ID:002 Users: 001,002 [NOTIFY] Action:I ID:003 Users: 002,003,001 [NOTIFY] Action:U ID:003 Users: 001,002,003 [NOTIFY] Action:D ID:002 Users: 001,003 可以看出，缓存确是与数据库保持了同样的状态。应用场景读远大于写的场景。

发表了文章 2017-07-05

Golang调用Python

Python是时髦的机器学习御用开发语言，Golang是大红大紫的新时代后端开发语言。Python很适合让搞算法的写写模型，而Golang很适合提供API服务，两位同志都红的发紫，这里就介绍一下正确搅基的办法。原理 Python提供了丰富的C-API。而C和Go又可以通过cgo无缝集成。所以，直接通过Golang调用libpython，就可以实现Go调Python的功能了。确实没啥神奇，只要会用C调Python，马上就知道怎么用了。但问题是，如果有的选择，这个年代还有多少人愿意去裸写C和C++呢？诚心默念Golang大法好。准备工作 Python ：确保Python正确安装，所谓正确安装，就是在系统中能找到libpython.so(dylib)，找到Python.h。一般linux直接安装python-devel，mac直接用homebrew安装就可以。 Golang安装：Golang不需要什么特殊的处理，能找到go即可。安装libpython-go-binding 虽然直接用cgo调用libpython也不是不可以，但是有native-binding用起来肯定要爽的多。Github上有一个现成的Binding库go-python。 go get github.com/sbinet/go-python 如果Python安装正确，这里会自动编译并显示提示，事就这样成了。 Have a try 首先写一个测试Python脚本 import numpy import sklearn a = 10 def b(xixi): return xixi + "haha" 然后写一个Go脚本： package main import ( "github.com/sbinet/go-python" "fmt" ) func init() { err := python.Initialize() if err != nil { panic(err.Error()) } } var PyStr = python.PyString_FromString var GoStr = python.PyString_AS_STRING func main() { // import hello InsertBeforeSysPath("/Users/vonng/anaconda2/lib/python2.7/site-packages") hello := ImportModule("/Users/vonng/Dev/go/src/gitlab.alibaba-inc.com/cplus", "hello") fmt.Printf("[MODULE] repr(hello) = %s\n", GoStr(hello.Repr())) // print(hello.a) a := hello.GetAttrString("a") fmt.Printf("[VARS] a = %#v\n", python.PyInt_AsLong(a)) // print(hello.b) b := hello.GetAttrString("b") fmt.Printf("[FUNC] b = %#v\n", b) // args = tuple("xixi",) bArgs := python.PyTuple_New(1) python.PyTuple_SetItem(bArgs, 0, PyStr("xixi")) // b(*args) res := b.Call(bArgs, python.Py_None) fmt.Printf("[CALL] b('xixi') = %s\n", GoStr(res)) // sklearn sklearn := hello.GetAttrString("sklearn") skVersion := sklearn.GetAttrString("__version__") fmt.Printf("[IMPORT] sklearn = %s\n", GoStr(sklearn.Repr())) fmt.Printf("[IMPORT] sklearn version = %s\n", GoStr(skVersion.Repr())) } // InsertBeforeSysPath will add given dir to python import path func InsertBeforeSysPath(p string) string { sysModule := python.PyImport_ImportModule("sys") path := sysModule.GetAttrString("path") python.PyList_Insert(path, 0, PyStr(p)) return GoStr(path.Repr()) } // ImportModule will import python module from given directory func ImportModule(dir, name string) *python.PyObject { sysModule := python.PyImport_ImportModule("sys") // import sys path := sysModule.GetAttrString("path") // path = sys.path python.PyList_Insert(path, 0, PyStr(dir)) // path.insert(0, dir) return python.PyImport_ImportModule(name) // return __import__(name) } 打印输出为： repr(hello) = <module 'hello' from '/Users/vonng/Dev/go/src/gitlab.alibaba-inc.com/cplus/hello.pyc'> a = 10 b = &python.PyObject{ptr:(*python._Ctype_struct__object)(0xe90b1b8)} b('xixi') = xixihaha sklearn = <module 'sklearn' from '/Users/vonng/anaconda2/lib/python2.7/site-packages/sklearn/__init__.pyc'> sklearn version = '0.18.1' 这里简单解释一下。首先将这个脚本的路径添加到sys.path中。然后调用PyImport_ImportModule导入包使用GetAttrString可以根据属性名获取对象的属性，相当于python中的.操作。调用Python函数可以采用Object.Call方法，，列表参数使用Tuple来构建。返回值用PyString_AS_STRING从Python字符串转换为C或Go的字符串。更多用法可以参考Python-C API文档。但是只要有这几个API，就足够 Make python module rock & roll。充分利用Golang和Python各自的特性，构建灵活而强大的应用了。

发表了文章 2017-05-16

神经网络基础知识笔记

神经网络表示神经元模型神经网络从大脑的工作原理得到启发，可用于解决通用的学习问题。神经网络的基本组成单元是神经元(neuron)。每个神经元具有一个轴突和多个树突。每个连接到本神经元的树突都是一个输入，当所有输入树突的兴奋水平之和超过某一阈值，神经元就会被激活。激活的神经元会沿着其轴突发射信号，轴突分出数以万计的树突连接至其他神经元，并将本神经元的输出并作为其他神经元的输入。数学上，神经元可以用感知机的模型表示。一个神经元的数学模型主要包括以下内容：名称符号说明输入 (input) $x$ 列向量权值 (weight) $w$ 行向量，维度等于输入个数偏置 (bias) $b$ 标量值，是阈值的相反数带权输入 (weighted input) $z$ $z=w · x + b$ ，激活函数的输入值激活函数 (activation function) $σ$ 接受带权输入，给出激活值。激活值 (activation) $a$ 标量值，$a = σ(vec{w}·vec{x}+b)$ 激活函数表达式 $$ a = \sigma( \left[ \begin{matrix} w_{1} & ⋯ & w_{n} \\ \end{matrix}\right] · \left[ \begin{array}{x} x_1 \\ ⋮ \\ ⋮ \\ x_n \end{array}\right] + b ) $$ 激活函数通常使用S型函数，又称为sigmoid或者logsig，因为该函数具有良好的特性：光滑可微，形状接近感知机所使用的硬极限传输函数，函数值与导数值计算方便。 $$ σ(z) = \frac 1 {1+e^{-z}} $$ $$ σ'(z) = σ(z)(1-σ(z)) $$ 也有一些其他的激活函数，例如：硬极限传输函数(hardlim)，对称硬极限函数(hardlims)，线性函数(purelin) ，对称饱和线性函数(satlins) ，对数-s形函数(logsig) ，正线性函数(poslin)，双曲正切S形函数(tansig)，竞争函数(compet)，有时候为了学习速度或者其他原因也会使用，表过不提。单层神经网络模型可以并行操作的神经元组成的集合，称为神经网络的一层。现在考虑一个具有$n$个输入，$s$个神经元(输出)的单层神经网络，则原来单个神经元的数学模型可扩展如下：名称符号说明输入 $x$ 同层所有神经元共用输入，故输入保持不变，仍为$(n×1)$列向量权值 $W$ 由$1 × n$行向量，变为$s × n$矩阵，每一行表示一个神经元的权值信息偏置 $b$ 由$1 × 1$标量变为$s × 1$列向量带权输入 $z$ 由$1 × 1$标量变为$s × 1$列向量激活值 $a$ 由$1 × 1$标量变为$s × 1$列向量激活函数向量表达式 $$ \left[ \begin{array}{a} a_1 \\ ⋮ \\ a_s \end{array}\right] = \sigma( \left[ \begin{matrix} w_{1,1} & ⋯ & w_{1,n} \\ ⋮ & ⋱ & ⋮ \\ w_{s,1} & ⋯ & w_{s,n} \\ \end{matrix}\right] · \left[ \begin{array}{x} x_1 \\ ⋮ \\ ⋮ \\ x_n \end{array}\right] + \left[ \begin{array}{b} b_1 \\ ⋮ \\ b_s \end{array}\right] ) $$ 单层神经网络能力有限，通常都会将多个单层神经网络的输出和输入相连，组成多层神经网络。多层神经网络模型多层神经网络的层数从1开始计数，第一层为输入层，第$L$层为输出层，其它的层称为隐含层。每一层神经网络都有自己的参数$W,b,z,a,⋯$，为了区别，使用上标区分：$W^2,W^3,⋯$。整个多层网络的输入，即为输入层的激活值$x=a^1$，整个网络的输出，即为输出层的激活值：$y'=a^L$。因为输入层没有神经元，所以该层所有参数中只有激活值$a^1$作为网络输入值而存在，没有$W^1,b^1,z^1$等。现在考虑一个$L$层的神经网络，其各层神经元个数依次为：$d_1,d_2,⋯,d_L$。则该网络的数学模型可扩展如下：名称符号说明输入 $x$ 输入仍然保持不变，为$(d_1×1)$列向量权值 $W$ 由$s × n$矩阵扩展为$L-1$个矩阵组成的列表：$W^2_{d_2 × d_1},⋯,W^L_{d_L × d_{L-1}}$ 偏置 $b$ 由$s × 1$列向量扩展为$L-1$个列向量组成的列表：$b^2_{d_2},⋯,b^L_{d_L}$ 带权输入 $z$ 由$s × 1$列向量扩展为$L-1$个列向量组成的列表：$z^2_{d_2},⋯,z^L_{d_L}$ 激活值 $a$ 由$s × 1$列向量扩展为$L$个列向量组成的列表：$a^1_{d_1},a^2_{d_2},⋯,a^L_{d_L}$ 激活函数矩阵表达式 $$ \left[ \begin{array}{a} a^l_1 \\ ⋮ \\ a^l_{d_l} \end{array}\right] = \sigma( \left[ \begin{matrix} w^l_{1,1} & ⋯ & w^l_{1,d_{l-1}} \\ ⋮ & ⋱ & ⋮ \\ w^l_{d_l,1} & ⋯ & w^l_{d_l,d_{l-1}} \\ \end{matrix}\right] · \left[ \begin{array}{x} a^{l-1}_1 \\ ⋮ \\ ⋮ \\ a^{l-1}_{d_{l-1}} \end{array}\right] + \left[ \begin{array}{b} b^l_1 \\ ⋮ \\ b^l_{d_l} \end{array}\right]) $$ 权值矩阵的涵义多层神经网络的权值由一系列权值矩阵表示第$l$层网络的权值矩阵可记作$W^l$，表示前一层（$l-1$）到本层（$l$ ）的连接权重 $W^l$的第$j$行可记作$W^l_{j*}$ ，表示从$l-1$层所有$d_{l-1}$个神经元出发，到达$l$ 层$j$号神经元的连接权重 $W^l$的第$k$列可记作$W^l_{*k}$ ，表示从$l-1$层第$k$号神经元出发，到达$l$ 层所有$d_l$个神经元的连接权重 $W^l$的$j$行$k$列可记作$W^l_{jk}$，表示从$l-1$层$k$号神经元出发，到达$l$ 层$j$神经元的连接权重如图，$w^3_{24}$表示从2层4号神经元到3层2号神经元的连接权值：只要记住，权值矩阵$W$的行标表示本层神经元的标号，列标表示上层神经元的标号即可。神经网络推断前馈（feed forward）是指神经网络接受输入，产生输出的一次计算过程。又称为一次推断（inference）。计算过程如下： $$ \begin{align} a^1 &= x \\ a^2 &= σ(W^2a^1 + b^2) \\ a^3 &= σ(W^3a^2 + b^3) \\ ⋯ \\ a^L &= σ(W^La^{L-1} + b^L) \\ y &= a^L \\ \end{align} $$ 推断实际上就是一系列矩阵乘法与向量运算，一个训练好的神经网络可以高效地使用各种语言实现。神经网络的功能是通过推断而体现的。推断实现起来很简单，但如何训练神经网络才是真正的难点。神经网络训练神经网络的训练，是调整网络中的权值参数与偏置参数，从而提高网络工作效果的过程。通常使用梯度下降(Gradient Descent)的方法来调整神经网络的参数，首先要定义一个代价函数(cost function)用以衡量神经网络的误差，然后通过梯度下降方法计算合适的参数修正量，从而最小化网络误差。代价函数代价函数是用于衡量神经网络工作效果的函数，是定义在一个或多个样本上的实值函数，通常应满足以下条件：误差是非负的，神经网络效果越好，误差越小代价可以写成神经网络输出的函数总体代价等于个体样本代价的均值：$C=\frac{1}{n} \sum_x C_x$ 最常用的一个简单的代价函数是：二次代价函数，又称为均方误差(MeanSquareError) $$ C(w,b) = \frac{1}{2n} \sum_x{{\|y(x)-a\|}^2} $$ 前面的系数$\frac 1 2$是为了求导后简洁的形式而添加的，$n$是使用样本的数量，这里$y$和$x$都是已知的样本数据。理论上任何可以反映网络工作效果的指标都可以作为代价函数。但之所以使用MSE，而不是诸如“正确分类图像个数”的指标，是因为只有一个光滑可导的代价函数才可以使用梯度下降(Gradient Descent)调整参数。样本的使用代价函数的计算需要一个或多个训练样本。当训练样本非常多时，如果每轮训练都要重新计算网络整个训练集上所有样本的误差函数，开销非常大，速度难以接受。若只使用总体的一小部分，计算就能快很多。不过这样做依赖一个假设：随机样本的代价，近似等于总体的代价。按照使用样本的方式，梯度下降又分为：批量梯度下降法(Batch GD)：最原始的形式，更新每一参数都使用所有样本。可以得到全局最优解，易于并行实现，但当样本数量很多时，训练速度极慢。随机梯度下降法(Stochastic GD)：解决BGD训练慢的问题，每次随机使用一个样本。训练速度快，但准确度下降，且并不是全局最优，也不易于并行实现。小批量梯度下降法(MiniBatch GD)：在每次更新参数时使用b个样本（例如每次10个样本），在BGD与SGD中取得折中。每次只使用一个样本时，又称为在线学习或递增学习。当训练集的所有样本都被使用过一轮，称为完成一轮迭代。梯度下降算法若希望通过调整神经网络中的某个参数来减小整体代价，则可以考虑微分的方法。因为每层的激活函数，以及最终的代价函数都是光滑可导的。所以最终的代价函数$C$对于某个我们感兴趣的参数$w,b$也是光滑可导的。轻微拨动某个参数的值，最终的误差值也会发生连续的轻微的变化。不断地沿着参数的梯度方向，轻微调整每个参数的值，使得总误差值向下降的方向前进，最终达到极值点。就是梯度下降法的核心思想。梯度下降的逻辑现在假设代价函数$C$为两个变量$v_1,v_2$的可微函数，梯度下降实际上就是选择合适的$Δv$，使得$ΔC$为负。由微积分可知： $$ ΔC ≈ \frac{∂C}{∂v_1} Δv_1 + \frac{∂C}{∂v_2} Δv_2 $$ 这里$Δv$是向量：$Δv = left[ begin{array}{v} Δv_1 \ Δv_2 end{array}right]$，$ΔC$是梯度向量$left[ begin{array}{C} frac{∂C}{∂v_1} \ frac{∂C}{∂v_2} end{array} right]$，于是上式可重写为 $$ ΔC ≈ ∇C \cdot Δv $$ 怎样的$Δv$才能令代价函数的变化量为负呢？一种简单办法是令即$Δv$取一个与梯度$∇C$共线反向的小向量，此时$Δv = -η∇C$ ，则损失函数变化量$ΔC ≈ -η{∇C}^2$，可以确保为负值。按照这种方法，通过不断调整$v$：$v → v' = v -η∇C$，使得$C$最终达到极小值点。这即梯度下降的涵义所在：所有参数都会沿着自己的梯度(导数)方向不断进行轻微下降，使得总误差到达极值点。对于神经网络，学习的参数实际上是权重$w$与偏置量$b$。原理是一样的，不过这里的$w,b$数目非常巨大 $$ w →w' = w-η\frac{∂C}{∂w} \\ b → b' = b-η\frac{∂C}{∂b} $$ 真正棘手的问题在于梯度$∇C_w,∇C_b$的计算方式。如果使用微分的方法，通过$frac {C(p+ε)-C} {ε}$来求参数的梯度，那么网络中的每一个参数都需要进行一次前馈和一次$C(p+ε)$的计算，在神经网络汪洋大海般的参数面前，这样的办法是行不通的。反向传播(Back propagation)算法可以解决这一问题。通过巧妙的简化，可以在一次前馈与一次反传中，高效地计算整个网络中所有参数梯度。反向传播反向传播算法接受一个打标样本$(x,y)$作为输入，给出网络中所有参数$(W,b)$的梯度。反向传播误差δ 反向传播算法需要引入一个新的概念：误差$δ$。误差的定义源于这样一种朴素的思想：如果轻微修改某个神经元的带权输入$z$，而最终代价$C$已不再变化，则可认为$z$已经到达极值点，调整的很好了。于是损失函数$C$对某神经元带权输入$z$的偏导$frac {∂C}{∂z}$可以作为该神经元上误差$δ$的度量。故定义第$l$层的第$j^{th}$个神经元上的误差$δ^l_j$为： $$ δ^l_j ≡ \frac{∂C}{∂z^l_j} $$ 与激活值$a$，带权输入$z$一样，误差也可以写作向量。第$l$层的误差向量记作$δ^l$。虽然看上去差不多，但之所以使用带权输入$z$而不是激活值输出$a$来定义本层的误差，有着形式上巧妙的设计。引入反向传播误差的概念，是为了通过误差向量来计算梯度$∇C_w,∇C_b$。反向传播算法一言蔽之：计算出输出层误差，通过递推方程逐层回算出每一层的误差，再由每一层的误差算出本层的权值梯度与偏置梯度。这需要解决四个问题：递推首项：如何计算输出层的误差：$δ^L$ 递推方程：如何根据后一层的误差$δ^{l+1}$计算前一层误差$δ^l$ 权值梯度：如何根据本层误差$δ^l$计算本层权值梯度$∇W^l$ 偏置梯度：如何根据本层误差$δ^l$计算本层偏置梯度$∇b^l$ 这四个问题，可以通过四个反向传播方程得到解决。反向传播方程方程说明编号 $δ^L = ∇C_a ⊙ σ'(z^L)$ 输出层误差计算公式 BP1 $δ^l = (W^{l+1})^T δ^{l+1} ⊙ σ'(z^l)$ 误差传递公式 BP2 $∇C_{W^l} = δ^l × {(a^{l-1})}^T $ 权值梯度计算公式 BP3 $∇C_b = δ^l$ 偏置梯度计算公式 BP4 当误差函数取MSE：$C = \frac 1 2 \|\vec{y} -\vec{a}\|^2= \frac 1 2 [(y_1 - a_1)^2 + \cdots + (y_{d_L} - a_{d_L})^2]$，激活函数取sigmoid时：计算方程说明编号 $δ^L = (a^L - y) ⊙(1-a^L)⊙ a^L$ 输出层误差需要$a^L$和$y$ BP1 $δ^l = (W^{l+1})^T δ^{l+1} ⊙(1-a^l)⊙ a^l $ 本层误差需要：后层权值$W^{l+1}$，后层误差$δ^{l+1}$，本层输出$a^l$ BP2 $∇C_{W^l} = δ^l × {(a^{l-1})}^T $ 权值梯度需要：本层误差$δ^l$，前层输出$a^{l-1}$ BP3 $∇C_b = δ^l$ 偏置梯度需要：本层误差$δ^l$ BP4 反向传播方程的证明 BP1：输出层误差方程输出层误差方程给出了根据网络输出$a^L$与标记结果$y$计算输出层误差$δ$的方法： $$ δ^L = (a^L - y) ⊙(1-a^L)⊙ a^L $$ 证明因为$a^L = σ(z^L)$，本方程可以直接从反向传播误差的定义，通过$a^L$作为中间变量链式求导推导得出： $$ \frac{∂C}{∂z^L} = \frac{∂C}{∂a^L} \frac{∂a^L}{∂z^L} = ∇C_a σ'(z^L) $$ 而因为误差函数$C = frac 1 2 |vec{y} -vec{a}|^2= frac 1 2 [(y_1 - a_1)^2 + ⋯ + (y_{d_L} - a_{d_L})^2]$，方程两侧对某个$a_j$取偏导则有： $$ \frac {∂C}{∂a^L_j} = (a^L_j-y_j) $$ 因为误差函数中，其他神经元的输出不会影响到误差函数对神经元$j$输出的偏导，系数也正好平掉了。写作向量形式即为：$ (a^L - y) $。另一方面，易证$σ'(z^L) = (1-a^L)⊙ a^L$。 QED BP2：误差传递方程误差传递方程给出了根据后一层误差计算前一层误差的方法： $$ δ^l = (W^{l+1})^T δ^{l+1} ⊙ σ'(z^l) $$ 证明本方程可以直接从反向传播误差的定义，以后一层所有神经元的带权输入$z^{l+1}$作为中间变量进行链式求导推导出： $$ δ^l_j = \frac {∂C}{∂z^l_j} = \sum_{k=1}^{d_{l+1}} \frac{∂C}{∂z^{l+1}_k} \frac{∂z^{l+1}_k}{∂z^{l}_j} = \sum_{k=1}^{d_{l+1}} (δ^{l+1}_k \frac{∂z^{l+1}_k}{∂z^{l}_j}) $$ 通过链式求导，引入后一层带权输入作为中间变量，从而在方程右侧引入后一层误差的表达形式。现在要解决的就是$frac{∂z^{l+1}_k}{∂z^{l}_j}$ 是什么的问题。由带权输入的定义$z = wx + b$可知： $$ z^{l+1}_k = W^{l+1}_{k,*} ·a^l + b^{l+1}_k = W^{l+1}_{k,*} · σ(z^l) + b^{l+1}_k = \sum_{j=1}^{d_{l}}(w_{kj}^{l+1} σ(z^l_j)) + b^{l+1}_k $$ 两边同时对$z^{l}_j$求导可以得到： $$ \frac{∂z^{l+1}_k}{∂z^{l}_j} = w^{l+1}_{kj} σ'(z^l) $$ 回代则有： $$ \begin{align} δ^l_j & = \sum_{k=1}^{d_{l+1}} (δ^{l+1}_k \frac{∂z^{l+1}_k}{∂z^{l}_j}) \\ & = σ'(z^l) \sum_{k=1}^{d_{l+1}} (δ^{l+1}_k w^{l+1}_{kj}) \\ & = σ'(z^l) ⊙ [(δ^{l+1}) · W^{l+1}_{*.j}] \\ & = σ'(z^l) ⊙ [(W^{l+1})^T_{j,*} · (δ^{l+1}) ]\\ \end{align} $$ 这里，对后一层所有神经元的误差权值之积求和，可以改写为两个向量的点积：后一层$k$个神经元的误差向量后一层权值矩阵的第$j$列，即所有从本层$j$神经元出发前往下一层所有$k$个神经元的权值。又因为向量点积可以改写为矩阵乘法：以行向量乘以列向量的方式进行，所以将权值矩阵转置，原来拿的是列，现在则拿出了行向量。这时候再改写回向量形式为： $$ δ^l = σ'(z^l) ⊙ (W^{l+1})^Tδ^{l+1} $$ QED BP3：权值梯度方程每一层的权值梯度$∇C_{W^l}$可以根据本层的误差向量（列向量），与上层的输出向量（行向量）的外积得出。 $$ ∇C_{W^l} = δ^l × {(a^{l-1})}^T $$ 证明由误差的定义，以$w^l_{jk}$作为中间变量求偏导可得： $$ \begin{align} δ^l_j & = \frac{∂C}{∂z^l_j} = \frac{∂C}{∂w^l_{jk}} \frac{∂ w_{jk}}{∂ z^l_j} = ∇C_{w^l_{jk}} \frac{∂w_{jk}}{∂ z^l_j} \end{align} $$ 由定义可得，第$l$层第$j$个神经元的带权输入$z^l_j$： $$ z^l_j = \sum_k w^l_{jk} a^{l-1}_k + b^l_j $$ 两侧对$w_{jk}^l$求导得到： $$ \frac{\partial z_j}{\partial w^l_{jk}} = a^{l-1}_k $$ 代回则有： $$ ∇C_{w^l_{jk}} = δ^l_j \frac{∂ z^l_j}{∂w_{jk}} = δ^l_j a^{l-1}_k $$ 观察可知，向量形式是一个外积： $$ ∇C_{W^l} = δ^l × {(a^{l-1})}^T $$ 本层误差行向量：$δ^l$，维度为（$d_l \times 1$) 上层激活列向量：$(a^{l-1})^T$，维度为（$1 times d_{l-1}$） QED BP4：偏置梯度方程 $$ ∇C_b = δ^l $$ 证明由定义可知： $$ δ^l_j = \frac{∂C}{∂z^l_j} = \frac{∂C}{∂b^l_j} \frac{∂b_j}{∂z^l_j} = ∇C_{b^l_{j}} \frac{∂b_j}{∂z^l_j} $$ 因为$z^l_j = W^l_{*,j} \cdot a^{l-1} + b^l_j$，两侧对$z_j^l$求导得到$1=frac{∂b_j}{∂z^l_j}$。于是回代得到：$∇C_{b^l_{j}} =δ^l_j $ ， QED 至此，四个方程均已证毕。只要将其转换为代码即可工作。神经网络的实现作为概念验证，这里给出了MNIST手写数字分类神经网络的Python实现。 # coding: utf-8 # author: vonng(fengruohang@outlook.com) # ctime: 2017-05-10 import random import numpy as np class Network(object): def __init__(self, sizes): self.sizes = sizes self.L = len(sizes) self.layers = range(0, self.L - 1) self.w = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])] self.b = [np.random.randn(x, 1) for x in sizes[1:]] def feed_forward(self, a): for l in self.layers: a = 1.0 / (1.0 + np.exp(-np.dot(self.w[l], a) - self.b[l])) return a def gradient_descent(self, train, test, epoches=30, m=10, eta=3.0): for round in range(epoches): # generate mini batch random.shuffle(train) for batch in [train_data[k:k + m] for k in xrange(0, len(train), m)]: x = np.array([item[0].reshape(784) for item in batch]).transpose() y = np.array([item[1].reshape(10) for item in batch]).transpose() n, r, a = len(batch), eta / len(batch), [x] # forward & save activations for l in self.layers: a.append(1.0 / (np.exp(-np.dot(self.w[l], a[-1]) - self.b[l]) + 1)) # back propagation d = (a[-1] - y) * a[-1] * (1 - a[-1]) #BP1 for l in range(1, self.L): # l is reverse index since last layer if l > 1: #BP2 d = np.dot(self.w[-l + 1].transpose(), d) * a[-l] * (1 - a[-l]) self.w[-l] -= r * np.dot(d, a[-l - 1].transpose()) #BP3 self.b[-l] -= r * np.sum(d, axis=1, keepdims=True) #BP4 # evaluate acc_cnt = sum([np.argmax(self.feed_forward(x)) == y for x, y in test]) print "Round {%d}: {%s}/{%d}" % (round, acc_cnt, len(test_data)) if __name__ == '__main__': import mnist_loader train_data, valid_data, test_data = mnist_loader.load_data_wrapper() net = Network([784, 100, 10]) net.gradient_descent(train_data, test_data, epoches=100, m=10, eta=2.0) 数据加载脚本：mnist_loader.py 。输入数据为二元组列表：(input(784,1), output(10,1)) $ python net.py Round {0}: {9136}/{10000} Round {1}: {9265}/{10000} Round {2}: {9327}/{10000} Round {3}: {9387}/{10000} Round {4}: {9418}/{10000} Round {5}: {9470}/{10000} Round {6}: {9469}/{10000} Round {7}: {9484}/{10000} Round {8}: {9509}/{10000} Round {9}: {9539}/{10000} Round {10}: {9526}/{10000} 一轮迭代后，网络在测试集上的分类准确率就达到90%，最终收敛至96%左右。对于五十行代码，这个效果是值得惊叹的。然而96%的准确率在实际生产中恐怕仍然是无法接受的。想要达到更好的效果，就需要对神经网络进行优化。神经网络优化神经网络的基础知识也就这么多，但改善其表现却是一个无尽的挑战。每一种优化的手段，都可以当做一个进阶的Topic深入研究。优化手段也是八仙过海，有数学，有科学，有工程学，也有哲学，还有玄学…… 改进神经网络的学习效果有几种主要的方法：选取更好的代价函数：例如交叉熵（cross-entropy）规范化（regularization）：L2规范化、弃权、L1规范化采用其他的激活神经元：线性修正神经元（ReLU），双曲正切神经元（tansig）修改神经网络的输出层：柔性最大值(softmax) 修改神经网络输入的组织方式：递归神经网络（Recurrent NN），卷积神经网络（Convolutional NN）。添加层数：深度神经网络（Deep NN）通过尝试，选择合适的超参数（hyper-parameters），按照迭代轮数或评估效果动态调整超参数。采用其他的梯度下降方法：基于动量的梯度下降使用更好的初始化权重人为扩展已有训练数据集这里介绍两种方法，交叉熵代价函数与L2规范化。因为它们：实现简单，修改一行代码即可实现，还减小了计算开销。效果立竿见影，将分类错误率从4%降低到2%以下。代价函数：交叉熵 MSE是一个不错的代价函数，然而它存在一个很尴尬的问题：学习速度。 MSE输出层误差的计算公式为： $$ δ^L = (a^L - y)σ'(z^L) $$ sigmoid又称为逻辑斯蒂曲线，其导数$σ'$是一个钟形曲线。所以当带权输入$z$从大到小或从小到大时，梯度的变化会经历一个“小，大，小”的过程。学习的速度也会被导数项拖累，存在一个“慢，快，慢”的过程。 MSE Cross Entropy 若采用交叉熵（cross entropy）误差函数： $$ C = - \frac 1 n \sum_x [ y ln(a) + (1-y)ln(1-a)] $$ 对于单个样本，即 $$ C = - [ y ln(a) + (1-y)ln(1-a)] $$ 虽然看起来很复杂，但输出层的误差公式变得异常简单，变为：$δ^L = a^L - y$ 比起MSE少掉了导数因子，所以误差直接和（预测值-实际值）成正比，不会遇到学习速度被激活函数的导数拖慢的问题，而且计算起来更简单了！证明 $C$对网络输出值$a$求导，则有： $$ ∇C_a = \frac {∂C} {∂a^L} = - [ \frac y a - \frac {(1-y)} {1-a}] = \frac {a - y} {a (1-a)} $$ 反向传播的四个基本方程里，与误差函数$C$相关的只有BP1：即输出层误差的计算方式。 $$ δ^L = ∇C_a ⊙ σ'(z^L) $$ 现在$C$换了计算方式，将新的误差函数$C$对输出值$a^L$的梯度$frac {∂C} {∂a^L}$带回BP1，即有： $$ δ^L = \frac {a - y} {a (1-a)}× a(1-a) = a-y $$ 规范化拥有大量的自由参数的模型能够描述特别神奇的现象。费米说："With four parameters I can fit an elephant, and with five I can make him wiggle his trunk"。神经网络这种动辄百万的参数的模型能拟合出什么奇妙的东西是难以想象的。一个模型能够很好的拟合已有的数据，可能只是因为模型中足够的自由度，使得它可以描述几乎所有给定大小的数据集，而不是真正洞察数据集背后的本质。发生这种情形时，模型对已有的数据表现的很好，但是对新的数据很难泛化。这种情况称为过拟合（overfitting）。例如用3阶多项式拟合一个带随机噪声的正弦函数，看上去就还不错；而10阶多项式，虽然完美拟合了数据集中的所有点，但实际预测能力就很离谱了。它拟合的更多地是数据集中的噪声，而非数据集背后的潜在规律。 x, xs = np.linspace(0, 2 * np.pi, 10), np.arange(0, 2 * np.pi, 0.001) y = np.sin(x) + np.random.randn(10) * 0.4 p1,p2 = np.polyfit(x, y, 10), np.polyfit(x, y, 3) plt.plot(xs, np.polyval(p1, xs));plt.plot(x, y, 'ro');plt.plot(xs, np.sin(xs), 'r--') plt.plot(xs, np.polyval(p2, xs));plt.plot(x, y, 'ro');plt.plot(xs, np.sin(xs), 'r--') 3阶多项式 10阶多项式一个模型真正的测验标准，是它对没有见过的场景的预测能力，称为泛化能力（generalize）。如何避免过拟合？按照奥卡姆剃刀原理：两个效果相同的解释，选择简单的那一个。当然这个原理只是我们抱有的一种信念，并不是真正的定理铁律：这些数据点真的由拟合出的十阶多项式产生，也不能否认这种可能… 总之，如果出现非常大的权重参数，通常就意味着过拟合。例如拟合所得十阶多项式系数就非常畸形： -0.001278386964370502 0.02826407452052734 -0.20310716176300195 0.049178327509096835 7.376259706365357 -46.295365250182925 135.58265224859255 -211.767050023543 167.26204130954324 -50.95259728945658 0.4211227089756039 通过添加权重衰减项，可以有效遏制过拟合。例如$L2$规范化为损失函数添加了一个$frac λ 2 w^2$的惩罚项： $$ C = -\frac{1}{n} \sum_{xj} \left[ y_j \ln a^L_j+(1-y_j) \ln (1-a^L_j)\right] + \frac{\lambda}{2n} \sum_w w^2 $$ 所以，权重越大，损失值越大，这就避免神经网络了向拟合出畸形参数的方向发展。这里使用的是交叉熵损失函数。但无论哪种损失函数，都可以写成： $$ C = C_0 + \frac {λ}{2n} \sum_w {w^2} $$ 其中原始的代价函数为$C_0$。那么，原来损失函数对权值的偏导，就可以写成： $$ \frac{∂C}{∂w} = \frac{ ∂C_0}{∂w}+\frac{λ}{n} w $$ 因此，引入$L2$规范化惩罚项在计算上的唯一变化，就是在处理权值梯度时首先要乘一个衰减系数： $$ w → w' = w\left(1 - \frac{ηλ}{n} \right)- η\frac{∂C_0}{∂ w} $$ 注意这里的$n$是所有的训练样本数，而不是一个小批次使用的训练样本数。改进实现 # coding: utf-8 # author: vonng(fengruohang@outlook.com) # ctime: 2017-05-10 import random import numpy as np class Network(object): def __init__(self, sizes): self.sizes = sizes self.L = len(sizes) self.layers = range(0, self.L - 1) self.w = [np.random.randn(y, x) / np.sqrt(x) for x, y in zip(sizes[:-1], sizes[1:])] self.b = [np.random.randn(x, 1) for x in sizes[1:]] def feed_forward(self, a): for l in self.layers: a = 1.0 / (1.0 + np.exp(-np.dot(self.w[l], a) - self.b[l])) return a def gradient_descent(self, train, test, epoches=30, m=10, eta=0.1, lmd=5.0): n = len(train) for round in range(epoches): random.shuffle(train) for batch in [train_data[k:k + m] for k in xrange(0, len(train), m)]: x = np.array([item[0].reshape(784) for item in batch]).transpose() y = np.array([item[1].reshape(10) for item in batch]).transpose() r = eta / len(batch) w = 1 - eta * lmd / n a = [x] for l in self.layers: a.append(1.0 / (np.exp(-np.dot(self.w[l], a[-1]) - self.b[l]) + 1)) d = (a[-1] - y) # cross-entropy BP1 for l in range(1, self.L): if l > 1: # BP2 d = np.dot(self.w[-l + 1].transpose(), d) * a[-l] * (1 - a[-l]) self.w[-l] *= w # weight decay self.w[-l] -= r * np.dot(d, a[-l - 1].transpose()) # BP3 self.b[-l] -= r * np.sum(d, axis=1, keepdims=True) # BP4 acc_cnt = sum([np.argmax(self.feed_forward(x)) == y for x, y in test]) print "Round {%d}: {%s}/{%d}" % (round, acc_cnt, len(test_data)) if __name__ == '__main__': import mnist_loader train_data, valid_data, test_data = mnist_loader.load_data_wrapper() net = Network([784, 100, 10]) net.gradient_descent(train_data, test_data, epoches=50, m=10, eta=0.1, lmd=5.0) Round {0}: {9348}/{10000} Round {1}: {9538}/{10000} Round {2}: {9589}/{10000} Round {3}: {9667}/{10000} Round {4}: {9651}/{10000} Round {5}: {9676}/{10000} ... Round {25}: {9801}/{10000} Round {26}: {9799}/{10000} Round {27}: {9806}/{10000} Round {28}: {9804}/{10000} Round {29}: {9804}/{10000} Round {30}: {9802}/{10000} 可见只是简单的变更，就使准确率有了显著提高，最终收敛至98%。修改Size为[784,128,64,10]添加一层隐藏层，可以进一步提升测试集准确率至98.33%，验证集至98.24%。对于MNIST数字分类任务，目前最好的准确率为99.79%，那些识别错误的case，恐怕人类想要正确识别也很困难。神经网络的分类效果最新进展可以参看这里：classification_datasets_results。本文是tensorflow官方推荐教程：Neural Networks and Deep Learning的笔记整理，原文Github Page。

发表了文章 2017-04-19

Pure PostgreSQL实现推荐系统

Pure PostgreSQL实现推荐系统推荐系统大家都熟悉哈，猜你喜欢，淘宝个性化什么的，前年双十一搞了个大新闻，拿了CEO特别贡献奖。今天就来说说怎么用PostgreSQL 3分钟实现一个最简单ItemCF推荐系统，以推荐系统最喜闻乐见的movielens数据集为例。原理 Item CF，全称Item Collaboration Filter，即基于物品的协同过滤，是目前业界应用最多的推荐算法。ItemCF不需要物品与用户的标签、属性，只要有用户对Item的行为日志就可以了，同时具有很好的可解释性。所以无论是亚马逊，Hulu，YouTube，balabala，用的都是该算法。 ItemCF算法的核心思想是：给用户推荐那些和他们之前喜欢的物品相似的物品。这里有两个Point：用户喜欢物品怎么表示？物品之间的相似度怎样表示？用户评分表用户评分表有三个核心字段：user_id, movie_id, rating，分别是用户ID，物品ID，用户对物品的评分。这个表怎么来呢？如果本来就是个评论打分网站，直接有用户对电影，音乐，小说的评分记录，那是最好不过。对于其他的场景，比如电商，社交网络，则可以通过行为日志生成这张评分表。例如，浏览，点击，收藏，购买，点击“我不喜欢”按钮，可以分别设一个喜好权重：0.1, 0.2, 0.3, 0.4, -100。然后最终计算出每个用户对每个物品的评分来。事就成了一半了。物品相似度还需要解决的一个问题是物品相似度的计算与表示。假设一共有N个物品，则物品相似度数据可以表示为一个NxN的矩阵，第i行j列的值表示物品i与物品j之间的相似度。这样相似度表示的问题就解决了。然后就是物品相似度矩阵的计算了，在此之前必须要做的一件事，就是定义什么是相似度？两个物品之间的相似度有很多种定义与计算方式，如果我们知道物品的各种属性的话，就可以方便的根据各种“距离”来定义相似度。但ItemCF有一种更简单的定义方法，令N(i)为喜欢物品i的用户集合： $$ w_{ij} = \frac{|N(i) \cap N(j)|}{ \sqrt{ |N(i)| * |N(j)|}} $$ 即：同时喜欢物品i和物品j的人数，除以喜爱物品i人数和喜爱物品j人数的几何平均数。可以简单的认为，只要用户给电影打分超过某一阈值，就是喜爱该电影。推荐物品现在有一个用户u，他对物品$i_1,i_2,…,i_n$的评分分别为$w_1,w_2,…,w_n$，则按照该评分权重累积所有物品的相似度，就可以得到用户对所有物品的评分了。 $$ \displaystyle p_{uj} = \sum_{i \in N(u) \cap S(i, K)} w_{ji}r_{ui} $$ 排序取TopN，就得到了推荐物品列表实践说了这么多废话，赶紧燥起来。第一步：准备数据下载数据集，开发测试的话选小规模的(100k)就可以。对于ItemCF来说，有用的数据其实就是用户行为表，即ratings.csv -- movielens 用户评分数据集 CREATE TABLE mls_ratings ( user_id INTEGER, movie_id INTEGER, rating TEXT, timestamp INTEGER, PRIMARY KEY (user_id, movie_id) ); -- 从CSV导入数据，并将评分乘以2变为2~10的整数便于处理，将Unix时间戳转换为日期类型 COPY mls_ratings FROM '/Users/vonng/Dev/recsys/ml-latest-small/ratings.csv' DELIMITER ',' CSV HEADER; ALTER TABLE mls_ratings ALTER COLUMN rating SET DATA TYPE INTEGER USING (rating :: DECIMAL * 2) :: INTEGER; ALTER TABLE mls_ratings ALTER COLUMN timestamp SET DATA TYPE TIMESTAMPTZ USING to_timestamp(timestamp :: DOUBLE PRECISION); 数据大概长这样，第一列用户ID列表，第二列电影ID列表，第三列是评分，最后是时间戳。一共100k条 movielens=# select * from mls_ratings limit 10; user_id | movie_id | rating | timestamp ---------+----------+--------+------------------------ 1 | 31 | 5 | 2009-12-14 10:52:24+08 1 | 1029 | 6 | 2009-12-14 10:52:59+08 1 | 1061 | 6 | 2009-12-14 10:53:02+08 1 | 1129 | 4 | 2009-12-14 10:53:05+08 1 | 1172 | 8 | 2009-12-14 10:53:25+08 1 | 1263 | 4 | 2009-12-14 10:52:31+08 1 | 1287 | 4 | 2009-12-14 10:53:07+08 1 | 1293 | 4 | 2009-12-14 10:52:28+08 1 | 1339 | 7 | 2009-12-14 10:52:05+08 1 | 1343 | 4 | 2009-12-14 10:52:11+08 第二步：计算物品相似度中间结果表：计算物品相似度，要计算两个中间数据：每个物品被用户喜欢的次数：N(i) 每对物品共同被同一个用户喜欢的次数 N(i)∩N(j) 如果是用编程语言，那可以一次性解决两个问题，不过SQL就要稍微麻烦点了，先创建两张中间临时表。 -- 中间表1：每个电影被用户看过的次数：N(i) CREATE TABLE mls_occur ( movie_id INTEGER PRIMARY KEY, n INTEGER ); -- 这个好算的很，按照movie_id聚合一下就知道每个电影被多少用户看过了:47ms INSERT INTO mls_occur SELECT movie_id, count(*) AS n FROM mls_ratings GROUP BY movie_id; -- 中间表2：同时看过电影i和j的人数： N(i)∩N(j) CREATE TABLE mls_common ( i INTEGER, j INTEGER, n INTEGER, PRIMARY KEY (i, j) ); -- 计算物品共现矩阵，这个比较慢。大表自己Join自己比较省事：2m 23s INSERT INTO mls_common SELECT a.movie_id AS i, b.movie_id AS j, count(*) AS n FROM mls_ratings a INNER JOIN mls_ratings b ON a.user_id = b.user_id GROUP BY i, j; 物品相似度表有了中间结果，就可以应用距离公式，计算最终的物品相似度啦 -- 物品相似度表，这是把矩阵用<i,j,M_ij>的方式在数据库中表示。 CREATE TABLE mls_similarity ( i INTEGER, j INTEGER, p FLOAT, PRIMARY KEY (i, j) ); -- 计算物品相似度矩阵：1m 24s INSERT INTO mls_similarity SELECT i, j, n / sqrt(n1 * n2) AS p FROM mls_common c, LATERAL (SELECT n AS n1 FROM mls_occur WHERE movie_id = i) n1, LATERAL (SELECT n AS n2 FROM mls_occur WHERE movie_id = j) n2; 物品相似度表大概长这样，实际上还可以修剪修剪，比如非常小的相似度干脆可以直接删掉。也可以用整个表中相似度的最大值作为单位1，进行归一化。不过这里都不弄了。第三步：进行推荐！现在假设我们为ID为10的用户推荐10部他没看过的电影，该怎么做呢？ SELECT j AS movie_id, sum(rating * p) AS score FROM (SELECT movie_id, rating FROM mls_ratings WHERE user_id = 10 ) seed LEFT OUTER JOIN mls_similarity b ON seed.movie_id = b.i WHERE i != j GROUP BY j ORDER BY score DESC LIMIT 100; 首先取用户评过分的电影作为种子集合，Join物品相似度表。按权重算出所有出现物品的预测评分并依此排序取TOP10，就得到推荐结果啦！大概长这样 movie_id | score ----------+------------------ 1270 | 121.487735902517 1196 | 118.399962228869 1198 | 117.518394778743 1036 | 116.841317175111 1240 | 116.432450924524 1214 | 116.146138947698 1580 | 116.015331936539 2797 | 115.144083402858 1265 | 114.959033115913 1291 | 114.934944010088 包装一下，把它变成一个存储过程 CREATE OR REPLACE FUNCTION get_recommendation(userid INTEGER) RETURNS JSONB AS $$ BEGIN RETURN (SELECT jsonb_agg(movie_id) FROM ( SELECT j AS movie_id, sum(rating * p) AS score FROM (SELECT movie_id, rating FROM mls_ratings WHERE user_id = userid) seed LEFT OUTER JOIN mls_similarity b ON seed.movie_id = b.i WHERE i != j GROUP BY j ORDER BY score DESC LIMIT 100) res); END $$ LANGUAGE plpgsql STABLE; SELECT get_recommendation(11); 用起来更方便啦 movielens=# SELECT get_recommendation(11) as res; res ----------------------------------------------------------------------- [80489, 96079, 79132, 59315, 91529, 69122, 58559, 59369, 1682, 71535] 是的，就是这么简单……。还能再给力点吗就算这样，还是有些蛋疼，比如说计算相似度矩阵的时候，竟然花了一两分钟，才100k条记录就这样，不太给力呀。而且这么多SQL写起来也烦，有没有更快更省事的方法？这儿还有个基于PostgreSQL源码魔改的推荐数据库：RecDB，直接用C实现了推荐系统相关的功能扩展，性能杠杠地。同时还包装了SQL语法糖，一行SQL建立推荐系统！再一行SQL开始使用~。 -- 计算推荐所需的信息 CREATE RECOMMENDER MovieRec ON ml_ratings USERS FROM userid ITEMS FROM itemid EVENTS FROM ratingval USING ItemCosCF -- 进行推荐！ SELECT * FROM ml_ratings R RECOMMEND R.itemid TO R.userid ON R.ratingval USING ItemCosCF WHERE R.userid = 1 ORDER BY R.ratingval LIMIT 10

发表了文章 2016-11-28

Mac&Win功能键魔改：让CapsLock焕发第二春

Capslock Make CapsLock Great Again! 显著提高APM！！功能强大：基于⇪CapsLock的新功能键Hyper可以与任何按键组合，提供强大的定制性。精心设计：在作者两年使用实践中不断雕琢，将最常使用的操作预置于核心键区，显著提高操作效率。轻量跨平台：分别基于Karabiner() 与AutoHotKey(⊞)以脚本方式实现。部署方便：放在随身装机U盘中，还是托管在Github上，简单几步即可复刻环境。 CapsLock() : 使用姿势参考 CapsLock(⊞) 前言 ⇪CapsLock，即大写锁定键，其起源可追溯至打字机时代。打字机是纯机械的设备，当按下Shift时，整套设备会与墨条纸带发生位移，使小写字母“上档”为大写字母。此等操作对小拇指是不小的负担，以致连续输入两到三个大写字母都比较吃力。于是在今天键盘上⇪Capslock的位置上出现了其原型Shiftlock功能键：可以在大小写状态之间切换与保持。这样的设计解决了一指禅选手的困境，更减轻了打字员的负担。然而随着科技的进步，这样的问题已经不存在了。除了一指禅选手，Shift能够毫不费力的满足人们的需求。而⇪Capslock这个'多余'的按键，则因为历史惯性保留在了绝大多数键盘的黄金位置。历史上有很多人注意到了这一点，不少人都琢磨着让这个占据宝地的按键发挥出更大的作用。一些键盘直接去掉了⇪Capslock键，而另一些则直接把它作为⌃Ctrl使用。在一些Unix Like（e.g ）环境中，⇪Capslock还被用作语言切换的按键。有些人将⇪Capslock改为复合功能键：单独键入时是⎋ESC，而按住不放时是⌃Ctrl。不过为什么要浪费这样一个绝佳的机会呢？我们所能做的远比这更多：譬如创造一个类似⇧ Shift、⌃ Ctrl、⌥ Option、⊞ Win、⎇ Alt 、 ⌘ Command等修饰键的全新功能键： Hyper 功能说明以Mac为例：右手核心区基本映射按住⇪CapsLock，映射为 Hyper 按下⇪CapsLock，映射为⌥␢ 输入法切换（二选一，默认）按下⇪CapsLock，映射为⎋ ESC （二选一）导航键映射按下 Hyper启用光标移动，按下⌘时启用光标选择 H ↦ ← (VI导航键：H映射为左) J ↦ ↓ (VI导航键：J映射为左) K ↦ ↑ (VI导航键：K映射为左) L ↦ → (VI导航键：L映射为右) U ↦ ⇞ (U映射为PageUp) I ↦ ↖ (I映射为Home) O ↦ ↘ (O映射为End) P ↦ ⇟ (P映射为Pagedown) 删除键 N ↦ ⌥⌫ (删除光标左侧一个单词) M ↦ ⌫ (删除光标左侧一个字符) , ↦ ⌦ (删除光标右侧一个字符) . ↦ ⌥⌦ (删除光标右侧一个单词) 左手核心区窗口操作 ⇥ ↦ ⌃⇥ (Tab 映射为正向切换标签页) ⌘⇥↦ ⌃⇧⇥ (⌘Tab 映射为反向切换标签页) Q ↦ ⌘Q (关闭窗口) W ↦ ⌘W (关闭标签页) A ↦ ⌃⌥⇧⌘A (Moom-Meta键，※一个窗口操作软件) ⌘A ↦ F11 (回到桌面) S ↦ ⌃⇥ (切换标签页) ⌘S ↦ ⌃⇧⇥ (反向切换标签页 ) Bash控制 Z ↦ ⌃Z (作业停止信号：SIGTSTP)) X ↦ ⌃B (Tmux-Prefix，※一个终端复用软件) C ↦ ⌃C (作业中断信号：SIGINT) V ↦ , (Vim-Leader键) D ↦ ⌃D (发送EOF) 应用快捷方式 E ↦ Google Chrome ⌘E ↦ Finder R ↦ iTerm ⌘R ↦ ^R (IDE-Run) T ↦ Sublime Text ⌘T ↦ Typora F ↦ Dash ⌘F ↦ Dictionary G ↦ IntelliJ IDEA G ↦ CLion 键盘第一行：功能键功能键映射 F1 ↦ BrightnessDown F2 ↦ BrightnessUp F3 ↦ ExposeAll F4 ↦ LaunchPad F5 ↦ KeyboardLightDown F6 ↦ KeyboardLightUp F7 ↦ MusicPrev F8 ↦ MusicPlay F9 ↦ MusicNext F10 ↦ Mute F11 ↦ VolumeDown F12 ↦ VolumeUp 键盘第二行：数字键上档键映射 [12...-=] ↦ ⇧[12...-=] (将数字键、减号、等于号上档为对应符号) [] ↦ ⇧90 '()' (将方括号映射为圆括号) ' ↦ ⇧- '_' (将单引号映射为下划线) 主键区其他按键主键区其他杂项 ⎋ ↦ ⇪ (Escape 将Hyper转义回⇪CapsLock) ␢ ↦ ⎋ (空格映射为⎋ESC) \ ↦ ⌃/ (斜杠映射为注释/解注释) ` ↦ ⌃⇧⌘4(反引号映射为选取截图区域并存储) ⌘ ↦ ⌃⇧4` (⌘反引号映射为选取截图区域至剪贴板) ' ↦ = (单引号映射为等于号) 特殊键区 PC键盘特殊按键映射 Ins ↦ ⇧⌥F1 (Insert 微调提升屏幕亮度) Del ↦ ⇧⌥F2 (Delete 微调降低屏幕亮度) ↘ ↦ ⇧⌥F5 (Home 微调提升键盘背光亮度) ↖ ↦ ⇧⌥F6 (End 微调降低键盘背光亮度) ⇟ ↦ ⇧⌥F11 (PgUp 微调提升音量) ⇞ ↦ ⇧⌥F12 (PgDn 微调降低音量) PrintScreen ↦ ⌃⇧⌘3 (保存全屏截图至剪贴板) PrintScreen ↦ ⌃⇧⌘3 (保存全屏截图至桌面文件) ScrollLock ↦ VolumeMute (ScrollLock静音) Pause ↦ MusicPlay (Pause映射为音乐播放) 光标键映射 ↑ ↦ MouseUp ↓ ↦ MouseDown ← ↦ MouseLeft → ↦ MouseRight ↩ ↦ MouseLButton \ ↦ MouseRButton 符号参考表 Modifiers: Mac Sym Key Hyper ⌃ Control ⌥ Option ⇧ Shift ⌘ Command Modifiers: ⊞Windows Sym Key Hyper ⌃ Control ⊞ Windows ⇧ Shift ⎇ Alter Normal Keys GLYPH NAME  Apple ⌘ Command, Cmd, Clover, (formerly) Apple ⌃ Control, Ctl, Ctrl ⌥ Option, Opt, (Windows) Alt ⎇ Alt ⇧ Shift ⇪ Caps lock ⏏ Eject ↩, ↵, ⏎ Return, Carriage Return ⌤ Enter ⌫ Delete, Backspace ⌦ Forward Delete ⎋ Escape, Esc → Right arrow ← Left arrow ↑ Up arrow ↓ Down arrow ⇞ Page Up, PgUp ⇟ Page Down, PgDn ↖ Home ↘ End ⌧ Clear ⇥ Tab, Tab Right, Horizontal Tab ⇤ Shift Tab, Tab Left, Back-tab ␢ Space, Blank ␣ Space, Blank ⃝ Power ⇭ Num lock ?⃝ Help  Context menu Mac版本脚本 CapsLock() 更新中 <?xml version="1.0"?> <root>  <item> <name style="important">CapsLock Enhancement</name> <appendix></appendix> <appendix>Make CapsLock Great Again!</appendix> <appendix></appendix> <appendix>※Author: Vonng (fengruohang@outlook.com)</appendix> <appendix>※Document: https://github.com/Vonng/Capslock/tree/master/osx</appendix> <appendix>※Environment: Mac OS X darwin64 via Karabiner</appendix> <appendix>※License: WTFPL</appendix> <appendix>※Prequisite: Maps ⇪CapsLock to F19(KeyCode:80) first. (via Seil)</appendix> </item>  <modifierdef>HYPER</modifierdef> <item> <name style="important">CapsLock setup</name> <appendix>Hold CapsLock to Hyper</appendix> <appendix>⇪[Hold] ↦ </appendix> <appendix></appendix> <appendix>Press CapsLock to ?</appendix> <appendix><![CDATA[* ⎋ ESC ]]></appendix> <appendix><![CDATA[* ⌥␢ Language-Switcher]]></appendix> </item>  <item> <name>Press CapsLock to Language-Switcher</name> <appendix>⇪[Press] ↦ ⌥␢</appendix> <identifier>private.capslock-langswitcher</identifier> <autogen> --KeyOverlaidModifier-- KeyCode::F19, KeyCode::VK_MODIFIER_HYPER, KeyCode::SPACE, ModifierFlag::CONTROL_L </autogen> </item>  <item> <name>Press CapsLock to Escape</name> <appendix>⇪[Press] ↦ ⎋</appendix> <identifier>private.capslock-escape</identifier> <autogen> --KeyOverlaidModifier-- KeyCode::F19, KeyCode::VK_MODIFIER_HYPER, KeyCode::ESCAPE </autogen> </item>  <item> <name>Hyper Navigator</name> <appendix><![CDATA[H ↦ ← (CursorLeft)]]></appendix> <appendix><![CDATA[J ↦ ↓ (CursorDown)]]></appendix> <appendix><![CDATA[K ↦ ↑ (CursorUp)]]></appendix> <appendix><![CDATA[L ↦ → (CursorRight)]]></appendix> <appendix><![CDATA[U ↦ ⇞ (PageUp)]]></appendix> <appendix><![CDATA[I ↦ ↖ (Home)]]></appendix> <appendix><![CDATA[O ↦ ↘ (End)]]></appendix> <appendix><![CDATA[P ↦ ⇟ (Pagedown)]]></appendix> <appendix></appendix> <appendix>※Hint: Hold additional ⌘(Left) key for selection</appendix> <identifier>private.hyper-navigator</identifier>  <autogen> --KeyToKey-- KeyCode::H, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::CURSOR_LEFT | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::H, ModifierFlag::HYPER, KeyCode::CURSOR_LEFT </autogen>  <autogen> --KeyToKey-- KeyCode::J, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::CURSOR_DOWN | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::J,ModifierFlag::HYPER, KeyCode::CURSOR_DOWN </autogen>  <autogen> --KeyToKey-- KeyCode::K, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::CURSOR_UP | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::K,ModifierFlag::HYPER, KeyCode::CURSOR_UP </autogen>  <autogen> --KeyToKey-- KeyCode::L, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::CURSOR_RIGHT | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::L,ModifierFlag::HYPER, KeyCode::CURSOR_RIGHT </autogen>  <autogen> --KeyToKey-- KeyCode::U, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::PAGEUP | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::U,ModifierFlag::HYPER, KeyCode::PAGEUP </autogen>  <autogen> --KeyToKey-- KeyCode::I, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::HOME | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::I,ModifierFlag::HYPER, KeyCode::HOME </autogen>  <autogen> --KeyToKey-- KeyCode::O, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::END | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::O,ModifierFlag::HYPER, KeyCode::END </autogen>  <autogen> --KeyToKey-- KeyCode::P, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::PAGEDOWN | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::P,ModifierFlag::HYPER, KeyCode::PAGEDOWN </autogen> </item>  <item> <name>Hyper Deletion</name> <appendix><![CDATA[N ↦ ⌥⌫ (Delete a word ahead)]]></appendix> <appendix><![CDATA[M ↦ ⌫ (Delete a char ahead)]]></appendix> <appendix><![CDATA[, ↦ ⌦ (Forward Delete a char)]]></appendix> <appendix><![CDATA[. ↦ ⌥⌦ (Forward Delete a word)]]></appendix> <identifier>private.hyper-deletion</identifier> <autogen> --KeyToKey-- KeyCode::N, ModifierFlag::HYPER, KeyCode::DELETE, ModifierFlag::OPTION_L, </autogen> <autogen> --KeyToKey-- KeyCode::M,ModifierFlag::HYPER, KeyCode::DELETE </autogen> <autogen> --KeyToKey-- KeyCode::COMMA,ModifierFlag::HYPER, KeyCode::FORWARD_DELETE </autogen> <autogen> --KeyToKey-- KeyCode::DOT,ModifierFlag::HYPER, KeyCode::FORWARD_DELETE, ModifierFlag::OPTION_L </autogen> </item>  <item> <name>Hyper Window-Manipulation</name> <appendix><![CDATA[Q ↦ ⌘Q (Close Window)]]></appendix> <appendix><![CDATA[W ↦ ⌘W (Close Tab)]]></appendix> <appendix><![CDATA[A ↦ ⌃⌥⇧⌘A (Moom Prefix)]]></appendix> <appendix><![CDATA[⌘A ↦ F11 (Desktop)]]></appendix> <appendix><![CDATA[S ↦ ⌃⇥ (Tab Switch)]]></appendix> <appendix><![CDATA[⌘S ↦ ⌃⇧⇥ (Reverse Tab Switch)]]></appendix> <identifier>private.hyper-window-manipulation</identifier>  <autogen> --KeyToKey-- KeyCode::TAB, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::TAB,ModifierFlag::CONTROL_L | ModifierFlag::SHIFT_L </autogen>  <autogen> --KeyToKey-- KeyCode::TAB, ModifierFlag::HYPER, KeyCode::TAB,ModifierFlag::CONTROL_L </autogen>  <autogen> --KeyToKey-- KeyCode::Q, ModifierFlag::HYPER, KeyCode::Q, ModifierFlag::COMMAND_L </autogen>  <autogen> --KeyToKey-- KeyCode::W, ModifierFlag::HYPER , KeyCode::W, ModifierFlag::COMMAND_L </autogen>  <autogen> --KeyToKey-- KeyCode::A,ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::F11 </autogen> <autogen> --KeyToKey-- KeyCode::A,ModifierFlag::HYPER , KeyCode::A,ModifierFlag::COMMAND_L | ModifierFlag::OPTION_L | ModifierFlag::CONTROL_L | ModifierFlag::SHIFT_L </autogen>  <autogen> --KeyToKey-- KeyCode::S,ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::TAB,ModifierFlag::CONTROL_L | ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::S,ModifierFlag::HYPER, KeyCode::TAB,ModifierFlag::CONTROL_L </autogen> </item>  <item> <name>Hyper Bash-Control</name> <appendix><![CDATA[Z ↦ ⌃Z (SIGTSTP)]]></appendix> <appendix><![CDATA[X ↦ ⌃B (Tmux-Prefix)]]></appendix> <appendix><![CDATA[C ↦ ⌃C (SIGINT)]]></appendix> <appendix><![CDATA[V ↦ , (VIM Leader)]]></appendix> <appendix><![CDATA[D ↦ ⌃D (EOF)]]></appendix> <identifier>private.hyper-bash-control</identifier>  <autogen> --KeyToKey-- KeyCode::Z, ModifierFlag::HYPER , KeyCode::Z, ModifierFlag::CONTROL_L </autogen>  <autogen> --KeyToKey-- KeyCode::X, ModifierFlag::HYPER , KeyCode::B, ModifierFlag::CONTROL_L </autogen>  <autogen> --KeyToKey-- KeyCode::C, ModifierFlag::HYPER, KeyCode::C, ModifierFlag::CONTROL_L </autogen>  <autogen> --KeyToKey-- KeyCode::V, ModifierFlag::HYPER , KeyCode::COMMA </autogen>  <autogen> --KeyToKey-- KeyCode::D, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::D, ModifierFlag::CONTROL_L </autogen> <autogen> --KeyToKey-- KeyCode::D, ModifierFlag::HYPER , KeyCode::D, ModifierFlag::CONTROL_L </autogen> </item>  <item> <name>Hyper Application</name> <appendix></appendix> <appendix>E: Explore</appendix> <appendix><![CDATA[E ↦ Google Chrome]]></appendix> <appendix><![CDATA[⌘E ↦ Finder]]></appendix> <appendix></appendix> <appendix>R: Run</appendix> <appendix><![CDATA[R ↦ iTerm]]></appendix> <appendix><![CDATA[⌘R ↦ ^R (IDE-Run)]]></appendix> <appendix></appendix> <appendix>T: Text</appendix> <appendix><![CDATA[T ↦ Sublime Text]]></appendix> <appendix><![CDATA[⌘T ↦ Typora]]></appendix> <appendix></appendix> <appendix>F: Find</appendix> <appendix><![CDATA[F ↦ Dash]]></appendix> <appendix><![CDATA[⌘F ↦ Dictionary]]></appendix> <appendix></appendix> <appendix>G: Grand</appendix> <appendix><![CDATA[G ↦ Intellij IDEA]]></appendix> <appendix><![CDATA[G ↦ CLion]]></appendix> <identifier>private.hyper-application</identifier>  <vkopenurldef> <name>KeyCode::VK_OPEN_URL_APP_Google_Chrome</name> <url type="file">/Applications/Google Chrome.app</url> </vkopenurldef> <vkopenurldef> <name>KeyCode::VK_OPEN_URL_APP_iTerm</name> <url type="file">/Applications/iTerm.app</url> </vkopenurldef> <vkopenurldef> <name>KeyCode::VK_OPEN_URL_APP_Sublime_Text</name> <url type="file">/Applications/Sublime Text.app</url> </vkopenurldef> <vkopenurldef> <name>KeyCode::VK_OPEN_URL_APP_INTELLIJ_IDEA</name> <url type="file">/Applications/IntelliJ IDEA.app/</url> </vkopenurldef> <vkopenurldef> <name>KeyCode::VK_OPEN_URL_APP_CLion</name> <url type="file">/Applications/CLion.app/</url> </vkopenurldef> <vkopenurldef> <name>KeyCode::VK_OPEN_URL_APP_Dash</name> <url type="file">/Applications/Dash.app/</url> </vkopenurldef> <vkopenurldef> <name>KeyCode::VK_OPEN_URL_APP_Typora</name> <url type="file">/Applications/Typora.app</url> </vkopenurldef> <autogen> --KeyToKey-- KeyCode::E, ModifierFlag::HYPER | ModifierFlag::COMMAND_L , KeyCode::VK_OPEN_URL_APP_Finder </autogen> <autogen> --KeyToKey-- KeyCode::E, ModifierFlag::HYPER, KeyCode::VK_OPEN_URL_APP_Google_Chrome </autogen> <autogen> --KeyToKey-- KeyCode::R, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::R, ModifierFlag::CONTROL_L </autogen> <autogen> --KeyToKey-- KeyCode::R, ModifierFlag::HYPER, KeyCode::VK_OPEN_URL_APP_iTerm </autogen> <autogen> --KeyToKey-- KeyCode::T, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::VK_OPEN_URL_APP_Typora </autogen> <autogen> --KeyToKey-- KeyCode::T, ModifierFlag::HYPER, KeyCode::VK_OPEN_URL_APP_Sublime_Text </autogen> <autogen> --KeyToKey-- KeyCode::F, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::VK_OPEN_URL_APP_Dictionary </autogen> <autogen> --KeyToKey-- KeyCode::F, ModifierFlag::HYPER, KeyCode::VK_OPEN_URL_APP_Dash </autogen> <autogen> --KeyToKey-- KeyCode::G, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::VK_OPEN_URL_APP_CLion </autogen> <autogen> --KeyToKey-- KeyCode::G, ModifierFlag::HYPER, KeyCode::VK_OPEN_URL_APP_INTELLIJ_IDEA </autogen> </item>  <item> <name>Hyper Functional</name> <appendix>Maps F[N] to corresponding functionality</appendix> <appendix><![CDATA[F1 ↦ BrightnessDown]]></appendix> <appendix><![CDATA[F2 ↦ BrightnessUp]]></appendix> <appendix><![CDATA[F3 ↦ ExposeAll]]></appendix> <appendix><![CDATA[F4 ↦ LaunchPad]]></appendix> <appendix><![CDATA[F5 ↦ KeyboardLightDown]]></appendix> <appendix><![CDATA[F6 ↦ KeyboardLightUp]]></appendix> <appendix><![CDATA[F7 ↦ MusicPrev]]></appendix> <appendix><![CDATA[F8 ↦ MusicPlay]]></appendix> <appendix><![CDATA[F9 ↦ MusicNext]]></appendix> <appendix><![CDATA[F10 ↦ Mute]]></appendix> <appendix><![CDATA[F11 ↦ VolumeDown]]></appendix> <appendix><![CDATA[F12 ↦ VolumeUp]]></appendix> <appendix></appendix> <appendix>※Hint: Enable system settings: preference -> keyboard -> 'Use F1,F2,etc.. as standard function key' </appendix> <identifier>private.hyper-function</identifier>  <autogen> __KeyToKey__ KeyCode::F1, ModifierFlag::HYPER, ConsumerKeyCode::BRIGHTNESS_DOWN ,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen>  <autogen> __KeyToKey__ KeyCode::F2, ModifierFlag::HYPER, ConsumerKeyCode::BRIGHTNESS_UP ,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen>  <autogen>__KeyToKey__ KeyCode::F3, ModifierFlag::HYPER, KeyCode::EXPOSE_ALL</autogen>  <autogen>__KeyToKey__ KeyCode::F4, ModifierFlag::HYPER, KeyCode::LAUNCHPAD</autogen>  <autogen> __KeyToKey__ KeyCode::F5, ModifierFlag::HYPER, ConsumerKeyCode::KEYBOARDLIGHT_LOW ,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen>  <autogen> __KeyToKey__ KeyCode::F6, ModifierFlag::HYPER, ConsumerKeyCode::KEYBOARDLIGHT_HIGH ,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen>  <autogen> __KeyToKey__ KeyCode::F7, ModifierFlag::HYPER, ConsumerKeyCode::MUSIC_PREV </autogen>  <autogen> __KeyToKey__ KeyCode::F8, ModifierFlag::HYPER, ConsumerKeyCode::MUSIC_PLAY </autogen>  <autogen> __KeyToKey__ KeyCode::F9, ModifierFlag::HYPER, ConsumerKeyCode::MUSIC_NEXT </autogen>  <autogen> __KeyToKey__ KeyCode::F10, ModifierFlag::HYPER, ConsumerKeyCode::VOLUME_MUTE </autogen>  <autogen> __KeyToKey__ KeyCode::F11, ModifierFlag::HYPER, ConsumerKeyCode::VOLUME_DOWN,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen>  <autogen> __KeyToKey__ KeyCode::F12, ModifierFlag::HYPER, ConsumerKeyCode::VOLUME_UP,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen> </item>  <item> <name>Hyper Shifter</name> <appendix>Maps hyper numkeys, minus, equal to corresponding punctuation.</appendix> <appendix>[12...-=] ↦ ⇧[12...-=] '!@..._+'</appendix> <appendix></appendix> <appendix>Maps square bracket to round breacket.</appendix> <appendix>[ ↦ ⇧9 '('</appendix> <appendix>] ↦ ⇧0 ')'</appendix> <appendix></appendix> <appendix>Maps Hyper semicolon to low dash</appendix> <appendix>; ↦ ⇧- '_'</appendix> <identifier>private.hyper-shifter</identifier> <autogen> --KeyToKey-- KeyCode::1, ModifierFlag::HYPER, KeyCode::1, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::2, ModifierFlag::HYPER, KeyCode::2, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::3, ModifierFlag::HYPER, KeyCode::3, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::4, ModifierFlag::HYPER, KeyCode::4, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::5, ModifierFlag::HYPER, KeyCode::5, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::6, ModifierFlag::HYPER, KeyCode::6, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::7, ModifierFlag::HYPER, KeyCode::7, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::8, ModifierFlag::HYPER, KeyCode::8, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::9, ModifierFlag::HYPER, KeyCode::9, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::0, ModifierFlag::HYPER, KeyCode::0, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::MINUS, ModifierFlag::HYPER, KeyCode::MINUS, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::EQUAL, ModifierFlag::HYPER, KeyCode::EQUAL, ModifierFlag::SHIFT_L </autogen> <autogen> --KeyToKey-- KeyCode::BRACKET_LEFT, ModifierFlag::HYPER, KeyCode::9 , ModifierFlag::SHIFT_R, </autogen> <autogen> --KeyToKey-- KeyCode::BRACKET_RIGHT, ModifierFlag::HYPER, KeyCode::0 , ModifierFlag::SHIFT_R, </autogen>  <autogen> --KeyToKey-- KeyCode::SEMICOLON, ModifierFlag::HYPER, KeyCode::MINUS , ModifierFlag::SHIFT_R, </autogen> </item>  <item> <name>Hyper Other</name> <appendix>Escape Hyper back to CapsLock</appendix> <appendix><![CDATA[⎋ ↦ ⇪ (CapsLock)]]></appendix> <appendix></appendix> <appendix>Hyper Space to Escape</appendix> <appendix><![CDATA[␢ ↦ ⎋ (Escape)]]></appendix> <appendix></appendix> <appendix><![CDATA[\ ↦ ⌃/ (Comment/Uncomment)]]></appendix> <appendix><![CDATA[` ↦ ⌃⇧⌘4 (ScreenShot by area)]]></appendix> <appendix><![CDATA[⌘` ↦ ⌃⇧4 (ScreenShot by area to file)]]></appendix> <appendix><![CDATA[' ↦ = (Quote to equal)]]></appendix> <identifier>private.hyper-other</identifier>  <autogen>__KeyToKey__ KeyCode::ESCAPE, ModifierFlag::HYPER, KeyCode::CAPSLOCK</autogen>  <autogen> --KeyToKey-- KeyCode::SPACE, ModifierFlag::HYPER, KeyCode::ESCAPE </autogen>  <autogen> --KeyToKey-- KeyCode::SLASH, ModifierFlag::HYPER, KeyCode::SLASH, ModifierFlag::COMMAND_L </autogen>  <autogen> --KeyToKey-- KeyCode::BACKQUOTE, ModifierFlag::HYPER, KeyCode::4, ModifierFlag::CONTROL_L | ModifierFlag::SHIFT_L | ModifierFlag::COMMAND_L </autogen>  <autogen> --KeyToKey-- KeyCode::BACKQUOTE, ModifierFlag::HYPER | ModifierFlag::COMMAND_L, KeyCode::4, ModifierFlag::SHIFT_L | ModifierFlag::COMMAND_L </autogen>  <autogen> --KeyToKey-- KeyCode::QUOTE, ModifierFlag::HYPER, KeyCode::EQUAL </autogen> </item>  <item> <name>Hyper Special to fine grained functional keys</name> <appendix><![CDATA[Ins ↦ ⇧⌥F1 (Fine grained brightness down)]]></appendix> <appendix><![CDATA[Del ↦ ⇧⌥F2 (Fine grained brightness up)]]></appendix> <appendix><![CDATA[↘ ↦ ⇧⌥F5 (Fine grained keyboard light down)]]></appendix> <appendix><![CDATA[↖ ↦ ⇧⌥F6 (Fine grained keyboard light up)]]></appendix> <appendix><![CDATA[⇟ ↦ ⇧⌥F11 (Fine grained volume down)]]></appendix> <appendix><![CDATA[ ↦ ⇧⌥F12 (Fine grained volume up)]]></appendix> <appendix></appendix> <appendix><![CDATA[PrintScreen ↦ ⌃⇧⌘3 (Save full screen to clipboard)]]></appendix> <appendix><![CDATA[PrintScreen ↦ ⌃⇧3 (Save full screen to file)]]></appendix> <appendix><![CDATA[ScrollLock ↦ VolumeMute (Save full screen to clipboard)]]></appendix> <appendix><![CDATA[Pause ↦ MusicPlay (Save full screen to clipboard)]]></appendix> <identifier>private.hyper-special</identifier>  <autogen> __KeyToKey__ KeyCode::PC_INSERT, ModifierFlag::HYPER, ConsumerKeyCode::BRIGHTNESS_UP,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen> <autogen> __KeyToKey__ KeyCode::PC_DEL, ModifierFlag::HYPER, ConsumerKeyCode::BRIGHTNESS_DOWN,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen>  <autogen> __KeyToKey__ KeyCode::HOME, ModifierFlag::HYPER, ConsumerKeyCode::KEYBOARDLIGHT_LOW,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen> <autogen> __KeyToKey__ KeyCode::END, ModifierFlag::HYPER, ConsumerKeyCode::KEYBOARDLIGHT_HIGH,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen>  <autogen> __KeyToKey__ KeyCode::PAGEUP, ModifierFlag::HYPER, ConsumerKeyCode::VOLUME_UP,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen> <autogen> __KeyToKey__ KeyCode::PAGEDOWN, ModifierFlag::HYPER, ConsumerKeyCode::VOLUME_DOWN,ModifierFlag::SHIFT_L | ModifierFlag::OPTION_L </autogen>  <autogen> __KeyToKey__ KeyCode::PC_PRINTSCREEN, KeyCode::3, ModifierFlag::CONTROL_L | ModifierFlag::SHIFT_L | ModifierFlag::COMMAND_L </autogen> <autogen> __KeyToKey__ KeyCode::PC_PRINTSCREEN, ModifierFlag::HYPER, KeyCode::3, ModifierFlag::CONTROL_L | ModifierFlag::SHIFT_L </autogen>  <autogen> __KeyToKey__ KeyCode::PC_SCROLLLOCK, ModifierFlag::HYPER, ConsumerKeyCode::VOLUME_MUTE </autogen>  <autogen> __KeyToKey__ KeyCode::PC_PAUSE, ModifierFlag::HYPER, ConsumerKeyCode::MUSIC_PLAY </autogen> </item>  <item> <name>Hyper MouseKey</name> <appendix><![CDATA[↑ ↦ MouseUp]]></appendix> <appendix><![CDATA[↓ ↦ MouseDown]]></appendix> <appendix><![CDATA[← ↦ MouseLeft]]></appendix> <appendix><![CDATA[→ ↦ MouseRight]]></appendix> <appendix><![CDATA[↩ ↦ MouseLButton]]></appendix> <appendix><![CDATA[\ ↦ MouseRButton]]></appendix> <identifier>private.hyper-mousekey</identifier> <autogen> --KeyToKey-- KeyCode::CURSOR_UP, ModifierFlag::HYPER, KeyCode::VK_MOUSEKEY_UP </autogen> <autogen> --KeyToKey-- KeyCode::CURSOR_DOWN, ModifierFlag::HYPER, KeyCode::VK_MOUSEKEY_DOWN </autogen> <autogen> --KeyToKey-- KeyCode::CURSOR_LEFT, ModifierFlag::HYPER, KeyCode::VK_MOUSEKEY_LEFT </autogen> <autogen> --KeyToKey-- KeyCode::CURSOR_RIGHT, ModifierFlag::HYPER, KeyCode::VK_MOUSEKEY_RIGHT </autogen> <autogen> --KeyToKey-- KeyCode::RETURN, ModifierFlag::HYPER, KeyCode::VK_MOUSEKEY_BUTTON_LEFT </autogen> <autogen> --KeyToKey-- KeyCode::BACKSLASH, ModifierFlag::HYPER, KeyCode::VK_MOUSEKEY_BUTTON_RIGHT </autogen> </item> </root> Win版本脚本 CapsLock(⊞) 这个是两年前写的，不过功能大体上是差不多的。 ;=====================================================================o ; Feng Ruohang's AHK Script | ; CapsLock Enhancement | ;---------------------------------------------------------------------o ;Description: | ; This Script is wrote by Feng Ruohang via AutoHotKey Script. It | ; Provieds an enhancement towards the "Useless Key" CapsLock, and | ; turns CapsLock into an useful function Key just like Ctrl and Alt | ; by combining CapsLock with almost all other keys in the keyboard. | ; | ;Summary: | ;o----------------------o---------------------------------------------o ;|CapsLock; | {ESC} Especially Convient for vim user | ;|CaspLock + ` | {CapsLock}CapsLock Switcher as a Substituent| ;|CapsLock + hjklwb | Vim-Style Cursor Mover | ;|CaspLock + uiop | Convient Home/End PageUp/PageDn | ;|CaspLock + nm,. | Convient Delete Controller | ;|CapsLock + zxcvay | Windows-Style Editor | ;|CapsLock + Direction | Mouse Move | ;|CapsLock + Enter | Mouse Click | ;|CaspLock + {F1}~{F6} | Media Volume Controller | ;|CapsLock + qs | Windows & Tags Control | ;|CapsLock + ;'[] | Convient Key Mapping | ;|CaspLock + dfert | Frequently Used Programs (Self Defined) | ;|CaspLock + 123456 | Dev-Hotkey for Visual Studio (Self Defined) | ;|CapsLock + 67890-= | Shifter as Shift | ;-----------------------o---------------------------------------------o ;|Use it whatever and wherever you like. Hope it help | ;=====================================================================o ;=====================================================================o ; CapsLock Initializer ;| ;---------------------------------------------------------------------o SetCapsLockState, AlwaysOff ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Switcher: ;| ;---------------------------------o-----------------------------------o ; CapsLock + ` | {CapsLock} ;| ;---------------------------------o-----------------------------------o CapsLock & `:: ;| GetKeyState, CapsLockState, CapsLock, T ;| if CapsLockState = D ;| SetCapsLockState, AlwaysOff ;| else ;| SetCapsLockState, AlwaysOn ;| KeyWait, `` ;| return ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Escaper: ;| ;----------------------------------o----------------------------------o ; CapsLock | {ESC} ;| ;----------------------------------o----------------------------------o CapsLock::Send, {ESC} ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Direction Navigator ;| ;-----------------------------------o---------------------------------o ; CapsLock + h | Left ;| ; CapsLock + j | Down ;| ; CapsLock + k | Up ;| ; CapsLock + l | Right ;| ; Ctrl, Alt Compatible ;| ;-----------------------------------o---------------------------------o CapsLock & h:: ;| if GetKeyState("control") = 0 ;| { ;| if GetKeyState("alt") = 0 ;| Send, {Left} ;| else ;| Send, +{Left} ;| return ;| } ;| else { ;| if GetKeyState("alt") = 0 ;| Send, ^{Left} ;| else ;| Send, +^{Left} ;| return ;| } ;| return ;| ;-----------------------------------o ;| CapsLock & j:: ;| if GetKeyState("control") = 0 ;| { ;| if GetKeyState("alt") = 0 ;| Send, {Down} ;| else ;| Send, +{Down} ;| return ;| } ;| else { ;| if GetKeyState("alt") = 0 ;| Send, ^{Down} ;| else ;| Send, +^{Down} ;| return ;| } ;| return ;| ;-----------------------------------o ;| CapsLock & k:: ;| if GetKeyState("control") = 0 ;| { ;| if GetKeyState("alt") = 0 ;| Send, {Up} ;| else ;| Send, +{Up} ;| return ;| } ;| else { ;| if GetKeyState("alt") = 0 ;| Send, ^{Up} ;| else ;| Send, +^{Up} ;| return ;| } ;| return ;| ;-----------------------------------o ;| CapsLock & l:: ;| if GetKeyState("control") = 0 ;| { ;| if GetKeyState("alt") = 0 ;| Send, {Right} ;| else ;| Send, +{Right} ;| return ;| } ;| else { ;| if GetKeyState("alt") = 0 ;| Send, ^{Right} ;| else ;| Send, +^{Right} ;| return ;| } ;| return ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Home/End Navigator ;| ;-----------------------------------o---------------------------------o ; CapsLock + i | Home ;| ; CapsLock + o | End ;| ; Ctrl, Alt Compatible ;| ;-----------------------------------o---------------------------------o CapsLock & i:: ;| if GetKeyState("control") = 0 ;| { ;| if GetKeyState("alt") = 0 ;| Send, {Home} ;| else ;| Send, +{Home} ;| return ;| } ;| else { ;| if GetKeyState("alt") = 0 ;| Send, ^{Home} ;| else ;| Send, +^{Home} ;| return ;| } ;| return ;| ;-----------------------------------o ;| CapsLock & o:: ;| if GetKeyState("control") = 0 ;| { ;| if GetKeyState("alt") = 0 ;| Send, {End} ;| else ;| Send, +{End} ;| return ;| } ;| else { ;| if GetKeyState("alt") = 0 ;| Send, ^{End} ;| else ;| Send, +^{End} ;| return ;| } ;| return ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Page Navigator ;| ;-----------------------------------o---------------------------------o ; CapsLock + u | PageUp ;| ; CapsLock + p | PageDown ;| ; Ctrl, Alt Compatible ;| ;-----------------------------------o---------------------------------o CapsLock & u:: ;| if GetKeyState("control") = 0 ;| { ;| if GetKeyState("alt") = 0 ;| Send, {PgUp} ;| else ;| Send, +{PgUp} ;| return ;| } ;| else { ;| if GetKeyState("alt") = 0 ;| Send, ^{PgUp} ;| else ;| Send, +^{PgUp} ;| return ;| } ;| return ;| ;-----------------------------------o ;| CapsLock & p:: ;| if GetKeyState("control") = 0 ;| { ;| if GetKeyState("alt") = 0 ;| Send, {PgDn} ;| else ;| Send, +{PgDn} ;| return ;| } ;| else { ;| if GetKeyState("alt") = 0 ;| Send, ^{PgDn} ;| else ;| Send, +^{PgDn} ;| return ;| } ;| return ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Mouse Controller ;| ;-----------------------------------o---------------------------------o ; CapsLock + Up | Mouse Up ;| ; CapsLock + Down | Mouse Down ;| ; CapsLock + Left | Mouse Left ;| ; CapsLock + Right | Mouse Right ;| ; CapsLock + Enter(Push Release) | Mouse Left Push(Release) ;| ;-----------------------------------o---------------------------------o CapsLock & Up:: MouseMove, 0, -10, 0, R ;| CapsLock & Down:: MouseMove, 0, 10, 0, R ;| CapsLock & Left:: MouseMove, -10, 0, 0, R ;| CapsLock & Right:: MouseMove, 10, 0, 0, R ;| ;-----------------------------------o ;| CapsLock & Enter:: ;| SendEvent {Blind}{LButton down} ;| KeyWait Enter ;| SendEvent {Blind}{LButton up} ;| return ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Deletor ;| ;-----------------------------------o---------------------------------o ; CapsLock + n | Ctrl + Delete (Delete a Word) ;| ; CapsLock + m | Delete ;| ; CapsLock + , | BackSpace ;| ; CapsLock + . | Ctrl + BackSpace ;| ;-----------------------------------o---------------------------------o CapsLock & ,:: Send, {Del} ;| CapsLock & .:: Send, ^{Del} ;| CapsLock & m:: Send, {BS} ;| CapsLock & n:: Send, ^{BS} ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Editor ;| ;-----------------------------------o---------------------------------o ; CapsLock + z | Ctrl + z (Cancel) ;| ; CapsLock + x | Ctrl + x (Cut) ;| ; CapsLock + c | Ctrl + c (Copy) ;| ; CapsLock + v | Ctrl + z (Paste) ;| ; CapsLock + a | Ctrl + a (Select All) ;| ; CapsLock + y | Ctrl + z (Yeild) ;| ; CapsLock + w | Ctrl + Right(Move as [vim: w]);| ; CapsLock + b | Ctrl + Left (Move as [vim: b]);| ;-----------------------------------o---------------------------------o CapsLock & z:: Send, ^z ;| CapsLock & x:: Send, ^x ;| CapsLock & c:: Send, ^c ;| CapsLock & v:: Send, ^v ;| CapsLock & a:: Send, ^a ;| CapsLock & y:: Send, ^y ;| CapsLock & w:: Send, ^{Right} ;| CapsLock & b:: Send, ^{Left} ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Media Controller ;| ;-----------------------------------o---------------------------------o ; CapsLock + F1 | Volume_Mute ;| ; CapsLock + F2 | Volume_Down ;| ; CapsLock + F3 | Volume_Up ;| ; CapsLock + F3 | Media_Play_Pause ;| ; CapsLock + F5 | Media_Next ;| ; CapsLock + F6 | Media_Stop ;| ;-----------------------------------o---------------------------------o CapsLock & F1:: Send, {Volume_Mute} ;| CapsLock & F2:: Send, {Volume_Down} ;| CapsLock & F3:: Send, {Volume_Up} ;| CapsLock & F4:: Send, {Media_Play_Pause} ;| CapsLock & F5:: Send, {Media_Next} ;| CapsLock & F6:: Send, {Media_Stop} ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Window Controller ;| ;-----------------------------------o---------------------------------o ; CapsLock + s | Ctrl + Tab (Swith Tag) ;| ; CapsLock + q | Ctrl + W (Close Tag) ;| ; (Disabled) Alt + CapsLock + s | AltTab (Switch Windows) ;| ; Alt + CapsLock + q | Ctrl + Tab (Close Windows) ;| ; CapsLock + g | AppsKey (Menu Key) ;| ;-----------------------------------o---------------------------------o CapsLock & s::Send, ^{Tab} ;| ;-----------------------------------o ;| CapsLock & q:: ;| if GetKeyState("alt") = 0 ;| { ;| Send, ^w ;| } ;| else { ;| Send, !{F4} ;| return ;| } ;| return ;| ;-----------------------------------o ;| CapsLock & g:: Send, {AppsKey} ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Self Defined Area ;| ;-----------------------------------o---------------------------------o ; CapsLock + d | Alt + d(Dictionary) ;| ; CapsLock + f | Alt + f(Search via Everything);| ; CapsLock + e | Open Search Engine ;| ; CapsLock + r | Open Shell ;| ; CapsLock + t | Open Text Editor ;| ;-----------------------------------o---------------------------------o CapsLock & d:: Send, !d ;| CapsLock & f:: Send, !f ;| CapsLock & e:: Run http://cn.bing.com/ ;| CapsLock & r:: Run Powershell ;| CapsLock & t:: Run C:\Program Files (x86)\Notepad++\notepad++.exe ;| ;---------------------------------------------------------------------o ;=====================================================================o ; CapsLock Char Mapping ;| ;-----------------------------------o---------------------------------o ; CapsLock + ; | Enter (Cancel) ;| ; CapsLock + ' | = ;| ; CapsLock + [ | Back (Visual Studio) ;| ; CapsLock + ] | Goto Define (Visual Studio) ;| ; CapsLock + / | Comment (Visual Studio) ;| ; CapsLock + \ | Uncomment (Visual Studio) ;| ; CapsLock + 1 | Build and Run(Visual Studio) ;| ; CapsLock + 2 | Debuging (Visual Studio) ;| ; CapsLock + 3 | Step Over (Visual Studio) ;| ; CapsLock + 4 | Step In (Visual Studio) ;| ; CapsLock + 5 | Stop Debuging(Visual Studio) ;| ; CapsLock + 6 | Shift + 6 ^ ;| ; CapsLock + 7 | Shift + 7 & ;| ; CapsLock + 8 | Shift + 8 * ;| ; CapsLock + 9 | Shift + 9 ( ;| ; CapsLock + 0 | Shift + 0 ) ;| ;-----------------------------------o---------------------------------o CapsLock & `;:: Send, {Enter} ;| CapsLock & ':: Send, = ;| CapsLock & [:: Send, ^- ;| CapsLock & ]:: Send, {F12} ;| ;-----------------------------------o ;| CapsLock & /:: ;| Send, ^e ;| Send, c ;| return ;| ;-----------------------------------o ;| CapsLock & \:: ;| Send, ^e ;| Send, u ;| return ;| ;-----------------------------------o ;| CapsLock & 1:: Send,^{F5} ;| CapsLock & 2:: Send,{F5} ;| CapsLock & 3:: Send,{F10} ;| CapsLock & 4:: Send,{F11} ;| CapsLock & 5:: Send,+{F5} ;| ;-----------------------------------o ;| CapsLock & 6:: Send,+6 ;| CapsLock & 7:: Send,+7 ;| CapsLock & 8:: Send,+8 ;| CapsLock & 9:: Send,+9 ;| CapsLock & 0:: Send,+0 ;| ;---------------------------------------------------------------------o Contact GitHub API Training Shop Blog About FAQ Q： Why using as symbol of hyper key？ A：Cause asterisk have the ascii code 42, which is the answer to life, the universe, and everything! while itself has meaning 'star'. (Heavy-Asterisk) is a pretty version of *(Asterisk). Actually I would choose

发表了文章 2016-11-16

从/0开始：聊聊异常

是的，没有打错，标题中是/0而不是0。那么问题就来了：除以0会发生什么？限定条件是必须的：在CS领域，*nix | win操作系统下任意编程语言中，整数除法运算中除数为零的情况。答案并不是固定的，在不同的操作系统，不同的编程语言，甚至不同的编译器下，答案都可能是不同的。除0异常譬如, 在OS X下，使用C语言，Clang编译，引发除零并不会报错，会返回一个垃圾值。 $ echo 'void main(){printf("%d",1/0);}' > a.c && gcc a.c 2> /dev/null && ./a.out 1512003000 同样的代码在Linux下，使用C语言，GCC编译，就会引发Float point exception。 $ echo 'void main(){printf("%d",1/0);}' > a.c && gcc a.c 2> /dev/null && ./a.out Floating point exception C++在两种环境中与C表现是一致的。至于Windows，手头没有Windows机器且VS只支持C++，但没记错的话/Od下Windows是会通过SEH抛Exception的，而/O2则会返回垃圾值。But who cares windows here…. 相比之下Python与Java在不同的系统中表现是一致的： $ python -c 'print(1/0)' Traceback (most recent call last): File "<string>", line 1, in <module> ZeroDivisionError: integer division or modulo by zero $ echo "class DZ{public static void main(String[] args){System.out.println(2/0);}}" > DZ.java && javac DZ.java && java DZ Exception in thread "main" java.lang.ArithmeticException: / by zero at DZ.main(DZ.java:1) Js这种只有浮点数的奇葩‘巧妙’地用Inf绕开了这个问题，就不讨论了。备注：浮点数除数为0是合法的。硬件级异常那么在除0的时候，究竟发生了什么呢？查阅Intel芯片手册可以发现，在x86机器上DIV或IDIV指令除数为0时，会引发0号中断，编号#DE(Divide Error)，即所谓除零异常。如果做过王爽《汇编语言》里面的小实验：编写零号中断处理程序，就能知道在硬件机器码与汇编编程的洪荒年代里，异常是怎样处理的：程序员需要自己写一段代码，作为硬件中断的处理程序。当然，在没有操作系统的环境里，所谓“异常”，其实就是硬件级异常，翻来覆去也就哪几种：除零、溢出、越界、非法指令等等。异常的种类虽然不多，但想找出异常的原因，或者编写合适的处理函数确实是相当让人抓狂的工作。许多我们耳熟能详的概念，例如进程与文件，都是伴随操作系统的发明而引入的。在拥有文件概念的现代操作系统中，数据被存放在文件里，有独立的从零开始的寻址空间，程序员只需要通过文件路径就能拿到这坨数据；如果文件不存在，可以通过open的返回值-1和全局的errno来判断究竟是什么原因导致了错误。想一想这是多么幸福的事啊！在洪荒年代，整个计算机就那么一两个寻址空间，对应着内存或者硬盘，数据就放在固定的偏移量，没什么所谓的文件（其实在固定偏移量维护一点元数据，这就是所谓的文件系统了）。如果读取不出有意义的数据那就只能报错挂掉呗，根本没有所谓的“FileNotExistException”。除了文件，进程也是一样。在没有操作系统的世界里，连栈的概念都不存在。控制流的玩弄可以称得上随心所欲，只要不越界，不跳到非代码段，整个世界真是天高任鸟飞，随你怎么跳。在洪荒年代里，异常处理就是处理硬件异常。硬件异常的种类只手可数，不除零，不越界，不干蠢事，几乎可以说是百无禁忌。当然这并不一定是好事，人们往往声称向往自由；但在真正的自由面前，很少的人才能把握方向，其他人只能在无穷的选择面前感到焦虑迷茫。程序员们呼唤着新秩序的到来，于是就有了操作系统。操作系统级异常时代在发展，C语言和操作系统出现了，程序员们从洪荒年代进入了远古时代。终于告别了直接和硬件异常打交道的苦日子。但从C语言的错误处理方式中，我们还是能看到那个时代的缩影。操作系统引入诸多新颖抽象，随之而来的则是各种新颖的异常：文件打开失败，进程fork失败。这些异常，不同于硬件级异常，属于操作系统的异常。POSIX标准中很多系统调用使用返回-1的方式告知调用者出现异常，通过设置全局errno的方式传递异常的具体原因。于是我们经常能看见这样的代码： if (somecall() == -1) { printf("somecall() failed\n"); if (errno == ...) { ... } } 但还有一个问题：原来的硬件异常怎么办？譬如喜闻乐见的野指针越界：Segmentation fault： $ echo 'void main(){int* p;printf("%d",*p);}' > a.c && gcc a.c 2> /dev/null && ./a.out Segmentation fault 虽然printf并不是系统调用，只是一个库函数。即便如此，发生硬件异常时，库函数并没有如同发生普通的操作系统异常一样返回-1 ，而是直接CoreDump给程序员一个Surprise~，Tada~。因为这种异常并不是操作系统产生的，操作系统面对硬件异常也要挠头。怎么办？显然，让程序员自己编写0号中断处理程序是不现实的，操作系统能做的就是把接受这个硬件中断包装成一个操作系统的中断，即“信号”的概念，然后发送给进程。这几个异常信号进程要是不处理，默认的行为就是挂掉。但是到了操作系统的时代，编写除零、越界信号的处理程序往往是没有太大意义的……，因为程序员在此类异常发生后往往无能为力。不然怎么着，越界读写是准备重试？还是不读了跳过？除零错误是准备加个小的抖动偏移量除出一个天文数字？还是准备拿着垃圾值凑数？如果有这个闲工夫写这种Handler，为啥不在错误语句事前加上条件判断呢……。程序能做到的最好程度，无非是handle SIG之后打好日志，保留现场然后老老实实的挂掉……。所以，在操作系统级(C,C++)，我们还是可以清晰地看到硬件异常与操作系统异常处理方式的差异，前者通过信号(Linux)，后者通过返回值和错误码。在Linux下C语言处理硬件异常的方式： #include <signal.h> #include <stdio.h> void handler(int a) { printf("SIGNAL: %d",a); } int main() { signal(SIGFPE, handler); int a = 1/0; } $ gcc a.c 2> /dev/null && ./a.out SIGNAL: 8 高级语言中的异常 C和C++是所谓的“中级”语言，由于标准库的功能非常有限，在不同操作系统中，程序员还是需要与不少Ad-Hoc的细节打交道。Java的出现可以说解决了（Well, at least part of）这一问题。我们可以看到Java中整数除0发生的是java.lang.ArithmeticException，看上去和其他异常并没有什么不同。只是所属的uncheked RuntimeException好像又隐隐地告诉着我们这个异常和其他异常有点不太一样。虽然说JVM提供了中间字节码的解释器，但最终JVM还是使用C或汇编将字节码映射为系统调用与机器指令。那么操作系统异常与硬件异常仍然是不可避免的。但是JVM会帮程序员打理好这一切：当发生硬件级异常，比如除零错误时，Java捕获SIGFPE,SIGSEGV等异常信号(Linux下)，并将其转化为语言内部的异常抛出；相比之下，诸如文件没找着这种系统调用失效，也都会被Java包装相应的异常；在Java的语言概念中，至少在处理方式上并没有对这些异常(硬件异常，操作系统异常，应用逻辑异常)进行区分，程序员想捕获都能用同一种方式来捕捉处理。世界大同了吗？Java这一类高级语言虽然在形式上消弭了硬件异常、操作系统异常、应用异常的区分，但从语义设计、编程规范、工程实践的方式，却制定了另一种分类方式：另一种异常划分的方式先来看一下Java异常与错误的继承关系。这个继承树中有三大类叶子节点： Error，RuntimeException，Blahblah...Exception。 BlahblahException就是程序或者库定义的普通异常，需要显式在代码中处理。 Error是JVM运行时产生的致命错误，不允许去处理。不过实际上去catch throwable也是可以的……。 RuntimeException，又称为unchecked Exception。是不推荐程序员去捕获的异常。事实上我们可以还原出这样对异常分类的设计初衷，如下表所示：原因能否处理程序员能处理的(checked) 程序员处理不了的（unchecked）设计缺陷假命题 RuntimeException 操作失效普通Exception，需要显式处理 Error 老朋友除零异常换了身马甲:java.lang.ArithmeticException藏在了RuntimeException中。程序员能处理的设计缺陷，本身就是一个矛盾的陈述。程序员能处理的操作失效，就是Java中普通的异常。这类异常设计的初衷就是提供一种Fancy的控制流，程序员在调用链条中玩起抛绣球游戏，让错误处理变得方便一些。程序员处理不了的设计缺陷，属于所谓的RuntimeException。这一点需要解释一下：大家都知道防止NPE是程序员的基本修养。除非文档显式指明，拿到参数或者返回值，首先要做的就是检查是否为空。同理，程序员也有义务在逻辑上保证除法的除数不为0。如果程序员没有这么做，那么这就是一个设计缺陷。任何硬件异常，或者可能导致硬件异常的条件(譬如：除0，数组越界、野指针、栈溢出)，都应当在运行时抛出RuntimeException。程序员处理不了的操作失效：另一方面，JVM本身也是一个程序。人固有一死，程序固有一挂。无论是因为JVM自己的BUG也好，还是环境条件不符合预期，当JVM陷入严重错误时，程序员对此是毫无办法的（自己去改Jvm不算！），这类异常是所谓的程序员处理不了的操作失效，即Error。对于程序员处理不了的异常，Java处理为unchecked Exception，也就是无需在函数签名后显式列出此类异常。这很好理解，如果这类异常需要指明，那每个使用到指针和除法的地方都可能会抛异常，也就是说几乎每个函数都要在签名后面加上throws RuntimeException，蛋疼无比。所以uncheck是RuntimeException所必须的性质。这就引出另一个问题了，Error也是非检查的异常。Error就是一种特殊的RuntimeException，它只是运行时异常的一个细分子类。其实在程序员看来，只有两种异常：我能处理的，我不能处理的。无论是JVM挂了还是程序员设计缺陷，这些异常都不是程序员能处理的，也不是程序员该处理的。进行细分实在没有必要，无故将事情复杂化。这一点上我觉得Java设计还是蛮恶心的。另外Java的RuntimeException真的是个垃圾筐，什么垃圾异常都往里装。比较合理的设计应当参考C# Runtime Exception 。运行时只会抛出几种异常，都可以与硬件异常对应上，其他的异常都是普通异常。总结从程序员的视角，异常分为两种：能处理的应用异常，处理不了的运行时异常应用异常是程序员或库作者所使用的错误处理方式。这种异常设计就是为了被捕获处理。运行时异常属于系统异常，产生原因应当包括两个：应用设计缺陷导致的硬件异常。环境条件导致的JVM或者CRT严重操作失效。不管怎样，这种异常设计就是为了让程序赶紧当掉避免造成更大损失的。从异常的原因来说，异常分为：设计缺陷与操作失效设计缺陷是因为程序员或者库作者的考虑不周导致的，应当立即挂掉暴露出错误来。操作失效是因为环境条件不满足导致的异常，不太严重的操作失效是可以抢救一下的，例如IO Timeout可以等一段时间重试几次，不行再挂掉，或者可选步骤出错可以直接跳过。严重的操作失效，比如JVM自己尿了，那就没办法了，早死早超生吧。最后，回到最初的问题除零会发生什么呢？在Intel x86_64 Linux下： CPU执行div指令，遇到操作数为0，产生0号中断(#DE) Linux内核捕获0号中断，给相应进程产生一个SIGFPE (8) 进程接受到信号不处理：产生CoreDump 程序自行处理：例如C中注册SIGFPE信号的handler，实现异常捕获。运行时压制：比如一些C运行时就偷偷忽略或者压制了这个异常，提着垃圾高高兴兴回家了。（C++标准中，整数除以0是未定义行为，读者可以自行实验。）运行时包装并抛出：Java和Python的运行时接受到信号后，转换为相应的语言内异常抛出。runtimeException一般不捕获，所以一般来说程序就挂了。

发表了文章 2016-11-14

如何抓取无线网络数据包

结论：Mac: airport, tcpdumpWindows: OmnipeekLinux: tcpdump, airmon-ng 以太网里抓包很简单，各种软件一大把，什么Wireshark，Ethereal，Sniffer Pro 一抓一大把。不过如果是无线数据包，就要稍微麻烦一点了。网上找了一堆罗里吧嗦的文章，绕来绕去的,其实抓无线包一条命令就好了。 Windows下因为无线网卡驱动会拒绝进入混杂模式，所以比较蛋疼，一般是用Omnipeek去弄，不细说了。 Linux和Mac就很方便了。只要用tcpdump就可以，一般系统都自带了。最后-i选项的参数填想抓的网络设备名就行。Mac默认的WiFi网卡是en0。tcpdump -Ine -i en0 主要就是指定-I参数，进入监控模式。-I :Put the interface in "monitor mode"; this is supported only on IEEE 802.11 Wi-Fi interfaces, and supported only on some operating systems.进入监控模式之后计算机用于监控的无线网卡就上不了网了，所以可以考虑买个外置无线网卡来抓包，上网抓包两不误。抓了包能干很多坏事，比如WEP网络抓几个IV包就可以用aircrack破密码，WPA网络抓到一个握手包就能跑字典破无线密码了。如果在同一个网络内，还可以看到各种未加密的流量……什么小黄图啊，隐私照啊之类的……。假如我已经知道某个手机的MAC地址，那么只要tcpdump -Ine -i en0 | grep $MAC_ADDRESS 就过滤出该手机相关的WiFi流量。具体帧的类型详情参看802.11协议，《802.11无线网络权威指南》等。顺便解释以下混杂模式与监控模式的区别：混杂(promiscuous)模式是指：接收同一个网络中的所有数据包，无论是不是发给自己的。监控(monitor)模式是指：接收某个物理信道中所有传输着的数据包。 RFMONRFMON is short for radio frequency monitoring mode and is sometimes also described as monitor mode or raw monitoring mode. In this mode an 802.11 wireless card is in listening mode (“sniffer” mode). The wireless card does not have to associate to an access point or ad-hoc network but can passively listen to all traffic on the channel it is monitoring. Also, the wireless card does not require the frames to pass CRC checks and forwards all frames (corrupted or not with 802.11 headers) to upper level protocols for processing. This can come in handy when troubleshooting protocol issues and bad hardware. RFMON/Monitor Mode vs. Promiscuous ModePromiscuous mode in wired and wireless networks instructs a wired or wireless card to process any traffic regardless of the destination mac address. In wireless networks promiscuous mode requires that the wireless card be associated to an access point or ad-hoc network. While in promiscuous mode a wireless card can transmit and receive but will only captures traffic for the network (SSID) to which it is associated. RFMON mode is only possible for wireless cards and does not require the wireless card to be associated to a wireless network. While in monitor mode the wireless card can passively monitor traffic of all networks and devices within listening range (SSIDs, stations, access points). In most cases the wireless card is not able to transmit and does not follow the typical 802.11 protocol when receiving traffic (i.e. transmit an 802.11 ACK for received packet). Both modes have to be supported by the driver of the wired or wireless card. 另外在研究抓包工具时，发现了Mac下有一个很好用的命令行工具airport，可以用来抓包，以及摆弄Macbook的WiFi。位置在/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport 可以创建一个符号链接方便使用：sudo ln -s /System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport /usr/sbin/airport 常用的命令有：显示当前网络信息：airport -I扫描周围无线网络：airport -s断开当前无线网络：airport -z强制指定无线信道：airport -c=$CHANNEL 抓无线包，可以指定信道：airport en0 sniff [$CHANNEL]抓到的包放在/tmp/airportSniffXXXXX.cap，可以用tcpdump, tshark, wireshark等软件来读。最实用的功能还是扫描周围无线网络。

墨航_个人页

个人介绍

擅长的技术

file_fdw妙用无穷——从数据库读取系统信息

Go database/sql 教程

深入Go语言文本类型

使用PostgreSQL_Notify实现多实例缓存同步

Golang调用Python

神经网络基础知识笔记

Pure PostgreSQL实现推荐系统

Mac&Win功能键魔改：让CapsLock焕发第二春

从/0开始：聊聊异常

如何抓取无线网络数据包

OpenAPI (Kong) Benchmark

如何从开发环境直连线上(IPTables)

JSON

[转]Go环境配置

Java基础概念

Happybase的基本使用

使用pgpool-ii建立PostgreSQL链接池

MySQL的编译安装、部署与配置

论如何设计博客分类标签系统

为Tornado配置Nginx反向代理

为Tornado配置Nginx反向代理

PostgreSQL安装手册

理解Python的协程机制-Yield

KONG基础使用

Node.js, Go, Python, OpenResty Benchmark

字符编码掠影：现代编码模型

file_fdw妙用无穷——从数据库读取系统信息

Go database/sql 教程

深入Go语言文本类型

使用PostgreSQL_Notify实现多实例缓存同步

Golang调用Python

神经网络基础知识笔记

Pure PostgreSQL实现推荐系统

Mac&Win功能键魔改：让CapsLock焕发第二春

从/0开始：聊聊异常

如何抓取无线网络数据包

OpenAPI (Kong) Benchmark

如何从开发环境直连线上(IPTables)

JSON

[转]Go环境配置

Java基础概念

Happybase的基本使用

使用pgpool-ii建立PostgreSQL链接池

MySQL的编译安装、部署与配置

论如何设计博客分类标签系统

为Tornado配置Nginx反向代理

通过DBlink或者fdw可以调用外部资料库的function吗？