summaryrefslogtreecommitdiffhomepage
path: root/zh-cn
diff options
context:
space:
mode:
Diffstat (limited to 'zh-cn')
-rw-r--r--zh-cn/asciidoc-cn.html.md135
-rw-r--r--zh-cn/bash-cn.html.markdown2
-rw-r--r--zh-cn/c-cn.html.markdown4
-rw-r--r--zh-cn/cmake-cn.html.markdown168
-rw-r--r--zh-cn/go-cn.html.markdown2
-rw-r--r--zh-cn/haskell-cn.html.markdown2
-rw-r--r--zh-cn/java-cn.html.markdown4
-rw-r--r--zh-cn/make-cn.html.markdown8
-rw-r--r--zh-cn/mips-cn.html.markdown334
-rw-r--r--zh-cn/opencv-cn.html.markdown145
-rw-r--r--zh-cn/perl-cn.html.markdown12
-rw-r--r--zh-cn/python-cn.html.markdown6
-rw-r--r--zh-cn/pythonlegacy-cn.html.markdown2
-rw-r--r--zh-cn/qt-cn.html.markdown160
-rw-r--r--zh-cn/ruby-cn.html.markdown2
-rw-r--r--zh-cn/set-theory-cn.html.markdown138
-rw-r--r--zh-cn/solidity-cn.html.markdown2
-rw-r--r--zh-cn/swift-cn.html.markdown2
-rw-r--r--zh-cn/wolfram-cn.html.markdown140
-rw-r--r--zh-cn/yaml-cn.html.markdown55
20 files changed, 1272 insertions, 51 deletions
diff --git a/zh-cn/asciidoc-cn.html.md b/zh-cn/asciidoc-cn.html.md
new file mode 100644
index 00000000..74eed445
--- /dev/null
+++ b/zh-cn/asciidoc-cn.html.md
@@ -0,0 +1,135 @@
+---
+language: asciidoc
+filename: asciidoc-cn.md
+contributors:
+ - ["Ryan Mavilia", "http://unoriginality.rocks/"]
+ - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
+translators:
+ - ["Liu Yihua", "https://github.com/yihuajack"]
+lang: zh-cn
+---
+
+AsciiDoc 是一种类似于 Markdown 的标记语言，它可以用来写从书到博客的任何东西。它由 Stuart Rackham 在 2002 年发明，它的语言很简单，但同时也可以有丰富的定制。
+
+文档标题
+
+标题是可选的，且不可以包含空行。它必须离正文空出至少一个空行。
+
+仅标题
+
+```
+= 文档标题
+
+文档的第一句话。
+```
+
+标题和作者
+
+```
+= 文档标题
+张三 <san.zhang@learnxinyminutes.com>
+
+文档开始。
+```
+
+多名作者的情形
+
+```
+= 文档标题
+李四 <si@go.com>; 王五 <wu@yo.com>; 赵六 <xzhao@pirate.com>
+
+有多名作者的文档开始。
+```
+
+版本行（需要作者行）
+
+```
+= 文档标题（第一版）
+土豆人 <chip@crunchy.com>
+v1.0, 2016-01-13
+
+这篇关于炸薯条的文章会很有趣。
+```
+
+段落
+
+```
+段落不需要什么特别操作。
+
+在两段之间用一个空行隔开。
+
+当你需要换行时，添加一个 +
+你就会得到一个换行符！
+```
+
+文本格式化
+
+```
+_用下划线创建斜体_
+*用星号加粗*
+*_组合起来用更有趣_*
+`用重音符显示等宽字体`
+`*加粗等宽字体*`
+```
+
+节标题
+
+```
+= 第 0 级 （一般只用于文档标题）
+
+== 第 1 级 <h2>
+
+=== 第 2 级 <h3>
+
+==== 第 3 级 <h4>
+
+===== 第 4 级 <h5>
+
+```
+
+列表
+
+用星号创建无序列表。
+
+```
+* 甲
+* 乙
+* 丙
+```
+
+用句点创建有序列表。
+
+```
+. 项目 1
+. 项目 2
+. 项目 3
+```
+
+你可以用额外的星号或句点来嵌套最多五次列表。
+
+```
+* 甲 1
+** 甲 2
+*** 甲 3
+**** 甲 4
+***** 甲 5
+
+. 甲 1
+.. 甲 2
+... 甲 3
+.... 甲 4
+..... 甲 5
+```
+
+## 补充材料
+
+处理 AsciiDoc 文档有两种工具：
+
+1. [AsciiDoc](http://asciidoc.org/): 原版的 Python 实现，在主流 Linux 发行版中已附带，目前处于稳定版本维护模式。
+2. [Asciidoctor](http://asciidoctor.org/): 使用 Ruby 的另一种实现，也可以从 Java 和 JavaScript 中使用。它处于积极的开发中，目标是用新特性和输出格式扩展 AsciiDoc 的语法。
+
+以下是 `Asciidoctor` 实现的相关链接：
+
+* [Markdown - AsciiDoc 语法比较](http://asciidoctor.org/docs/user-manual/#comparison-by-example)：并列比较一般 Markdown 和 AsciiDoc 的元素。
+* [入门](http://asciidoctor.org/docs/#get-started-with-asciidoctor)：安装和快速启动指南，帮助构建简单的文档。
+* [Asciidoctor 用户手册](http://asciidoctor.org/docs/user-manual/): 完整的单文档指南，包含语法参考、示例、渲染工具等。
diff --git a/zh-cn/bash-cn.html.markdown b/zh-cn/bash-cn.html.markdown
index d85e5b8f..225df06b 100644
--- a/zh-cn/bash-cn.html.markdown
+++ b/zh-cn/bash-cn.html.markdown
@@ -18,7 +18,7 @@ filename: LearnBash-cn.sh
lang: zh-cn
---
-Bash 是一个为 GNU 计划编写的 Unix shell，是 Linux 和 Mac OS X 下的默认 shell。
+Bash 是一个为 GNU 计划编写的 Unix shell，是 Linux 和 macOS 下的默认 shell。
以下大多数例子可以作为脚本的一部分运行，也可直接在 shell 下交互执行。
[更多信息](http://www.gnu.org/software/bash/manual/bashref.html)
diff --git a/zh-cn/c-cn.html.markdown b/zh-cn/c-cn.html.markdown
index 8eecc56e..dbad5030 100644
--- a/zh-cn/c-cn.html.markdown
+++ b/zh-cn/c-cn.html.markdown
@@ -128,7 +128,7 @@ printf("Enter the array size: "); // 询问用户数组长度
char buf[0x100];
fgets(buf, sizeof buf, stdin);
-// stroul 将字符串解析为无符号整数
+// strtoul 将字符串解析为无符号整数
size_t size = strtoul(buf, NULL, 10);
int var_length_array[size]; // 声明VLA
printf("sizeof array = %zu\n", sizeof var_length_array);
@@ -616,7 +616,7 @@ typedef void (*my_fnp_type)(char *);
如果你有问题，请阅读[compl.lang.c Frequently Asked Questions](http://c-faq.com/)。
-使用合适的空格、缩进，保持一致的代码风格非常重要。可读性强的代码比聪明的代码、高速的代码更重要。可以参考下[Linux内核编码风格](https://www.kernel.org/doc/Documentation/CodingStyle)
+使用合适的空格、缩进，保持一致的代码风格非常重要。可读性强的代码比聪明的代码、高速的代码更重要。可以参考下[Linux内核编码风格](https://www.kernel.org/doc/Documentation/process/coding-style.rst)
。
除了这些，多多Google吧
diff --git a/zh-cn/cmake-cn.html.markdown b/zh-cn/cmake-cn.html.markdown
new file mode 100644
index 00000000..dd9961ca
--- /dev/null
+++ b/zh-cn/cmake-cn.html.markdown
@@ -0,0 +1,168 @@
+---
+category: tool
+tool: cmake
+contributors:
+ - ["Bruno Alano", "https://github.com/brunoalano"]
+translators:
+ - ["tx23", "https://github.com/tx23"]
+filename: CMake-cn
+lang: zh-cn
+---
+
+CMake 是一个跨平台且开源的自动化构建系统工具。通过该工具你可以对你的源代码进行测试、编译或创建安装包。
+
+CMake 试图去解决Makefile 跨平台的自动配置问题(不同的make解释器有不同的命令)，以及链接第三方库时的易用性问题。
+
+CMake是一个可扩展的开源系统，它以操作系统和与编译器无关的方式管理构建过程。与其他许多跨平台系统不同的是，
+CMake被设计为与本机的构建环境结合使用。它通过被放置于每个源文件目录下的简单配置文件（名为 CMakeLists.txt 的文件）
+来生成常规使用的标准构建文件（比如：Unix 下的 makefiles 文件或 Windows MSVC 中的 projects/workspaces）。
+
+```cmake
+# 在 CMake 中, 这是一条命令
+
+# 要运行我们的代码，请执行以下命令：
+# - mkdir build && cd build
+# - cmake ..
+# - make
+#
+# 通过上述命令，我们将遵循最佳实践在子目录中进行编译
+# 在第二行命令中我们请求Cmake 生成新的依赖于系统的Makefile文件。
+# 最后，我们运行本地的make 命令。
+
+#------------------------------------------------------------------------------
+# 基础部分
+#------------------------------------------------------------------------------
+#
+# Cmake文件必须被命令为 “CMakeLists.txt” 。
+
+# 设置生成Makefile的CMake所需最低版本要求
+cmake_minimum_required (VERSION 2.8)
+
+# 当版本小于2.8时，需要加入关键字 FATAL_ERROR。
+cmake_minimum_required (VERSION 2.8 FATAL_ERROR)
+
+# 在这里定义了项目的名称，同时会影响Cmake 生成的目录命名约定。
+# 我们可以将代码的语言作为第二个参数传入。
+project (learncmake C)
+
+# 设置项目的源目录（仅仅是由于惯例）
+set( LEARN_CMAKE_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} )
+set( LEARN_CMAKE_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR} )
+
+# 在构建系统中用“semver”风格为我们代码设置当前版本是很有用的。
+set (LEARN_CMAKE_VERSION_MAJOR 1)
+set (LEARN_CMAKE_VERSION_MINOR 0)
+set (LEARN_CMAKE_VERSION_PATCH 0)
+
+# 将变量（版本号）发送到源代码头
+configure_file (
+ "${PROJECT_SOURCE_DIR}/TutorialConfig.h.in"
+ "${PROJECT_BINARY_DIR}/TutorialConfig.h"
+)
+
+# 包含目录
+# 在 GCC中, 该语句等同于 "-I" 命令
+include_directories( include )
+
+# 在哪里安装其他库？注意：在此处提供includes路径，后续检查将解决所有其他问题
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# 条件
+if ( CONDITION )
+ # 输出！
+
+ # 附带信息
+ message(STATUS "My message")
+
+ # CMake 警告，继续处理
+ message(WARNING "My message")
+
+ # CMake 警告 (dev)，继续处理
+ message(AUTHOR_WARNING "My message")
+
+ # CMake 错误，继续处理但是会跳过生成
+ message(SEND_ERROR "My message")
+
+ # CMake 错误，停止处理和生成
+ message(FATAL_ERROR "My message")
+endif()
+
+if( CONDITION )
+
+elseif( CONDITION )
+
+else( CONDITION )
+
+endif( CONDITION )
+
+# 循环
+foreach(loop_var arg1 arg2 ...)
+ COMMAND1(ARGS ...)
+ COMMAND2(ARGS ...)
+ ...
+endforeach(loop_var)
+
+foreach(loop_var RANGE total)
+foreach(loop_var RANGE start stop [step])
+
+foreach(loop_var IN [LISTS [list1 [...]]]
+ [ITEMS [item1 [...]]])
+
+while(condition)
+ COMMAND1(ARGS ...)
+ COMMAND2(ARGS ...)
+ ...
+endwhile(condition)
+
+
+# 逻辑运算
+if(FALSE AND (FALSE OR TRUE))
+ message("Don't display!")
+endif()
+
+# 将常规，缓存或环境变量设置为给定值。
+# 如果指定了PARENT_SCOPE选项，则将在当前作用域上的作用域中设置变量
+# `set(<variable> <value>... [PARENT_SCOPE])`
+
+# 如何在带引号和不带引号的参数中引用变量？How to reference variables inside quoted and unquoted arguments?
+# 如果未设置变量，变量引用由变量值或空字符串替换。
+${variable_name}
+
+# 清单
+# 设置源文件列表
+set( LEARN_CMAKE_SOURCES
+ src/main.c
+ src/imagem.c
+ src/pather.c
+)
+
+# 调用编译器
+#
+# ${PROJECT_NAME} 即 Learn_CMake
+add_executable( ${PROJECT_NAME} ${LEARN_CMAKE_SOURCES} )
+
+# 链接库
+target_link_libraries( ${PROJECT_NAME} ${LIBS} m )
+
+# 在哪里安装其他库？注意：在此处提供includes路径，后续检查将解决所有其他问题
+set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/CMake/modules/" )
+
+# 编译条件 (gcc ; g++)
+if ( "${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" )
+ message( STATUS "Setting the flags for ${CMAKE_C_COMPILER_ID} compiler" )
+ add_definitions( --std=c99 )
+endif()
+
+# 检查 OS
+if( UNIX )
+ set( LEARN_CMAKE_DEFINITIONS
+ "${LEARN_CMAKE_DEFINITIONS} -Wall -Wextra -Werror -Wno-deprecated-declarations -Wno-unused-parameter -Wno-comment" )
+endif()
+```
+
+### 资源
+
++ [CMake tutorial](https://cmake.org/cmake-tutorial/)
++ [CMake documentation](https://cmake.org/documentation/)
++ [Mastering CMake](http://amzn.com/1930934319/)
++ [An Introduction to Modern CMake](https://cliutils.gitlab.io/modern-cmake/)
diff --git a/zh-cn/go-cn.html.markdown b/zh-cn/go-cn.html.markdown
index 37b4b137..2953acf3 100644
--- a/zh-cn/go-cn.html.markdown
+++ b/zh-cn/go-cn.html.markdown
@@ -40,7 +40,7 @@ import (
func main() {
// 往标准输出打印一行。
// 用包名fmt限制打印函数。
- fmt.Println("天坑欢迎你!")
+ fmt.Println("你好世界")
// 调用当前包的另一个函数。
beyondHello()
diff --git a/zh-cn/haskell-cn.html.markdown b/zh-cn/haskell-cn.html.markdown
index c854169e..d653c58c 100644
--- a/zh-cn/haskell-cn.html.markdown
+++ b/zh-cn/haskell-cn.html.markdown
@@ -128,7 +128,7 @@ snd ("haskell", 1) -- 1
-- 一个接受两个变量的简单函数
add a b = a + b
--- 注意，如果你使用 ghci (Hakell 解释器)，你需要使用 `let`，也就是
+-- 注意，如果你使用 ghci (Haskell 解释器)，你需要使用 `let`，也就是
-- let add a b = a + b
-- 调用函数
diff --git a/zh-cn/java-cn.html.markdown b/zh-cn/java-cn.html.markdown
index 27003f3e..1de7f3e6 100644
--- a/zh-cn/java-cn.html.markdown
+++ b/zh-cn/java-cn.html.markdown
@@ -297,8 +297,8 @@ class Bicycle {
// Bicycle 类的成员变量和方法
public int cadence; // Public: 任意位置均可访问
private int speed; // Private: 只在同类中可以访问
- protected int gear; // Protected: 可以在同类与子类中可以访问
- String name; // default: 可以在包内中可以访问
+ protected int gear; // Protected: 可以在同类与子类中访问
+ String name; // default: 可以在包内访问
// 构造函数是初始化一个对象的方式
// 以下是一个默认构造函数
diff --git a/zh-cn/make-cn.html.markdown b/zh-cn/make-cn.html.markdown
index 76dde941..641714ef 100644
--- a/zh-cn/make-cn.html.markdown
+++ b/zh-cn/make-cn.html.markdown
@@ -23,7 +23,7 @@ Makefile 用于定义如何创建目标文件, 比如如何从源码到可执行
```make
# 这行表示注释
-# 文件名一定要交 Makefile, 大小写区分, 使用 `make <target>` 生成 target
+# 文件名一定要叫 Makefile, 大小写区分, 使用 `make <target>` 生成 target
# 如果想要取别的名字, 可以用 `make -f "filename" <target>`.
# 重要的事情 - 只认识 TAB, 空格是不认的, 但是在 GNU Make 3.82 之后, 可以通过
@@ -87,7 +87,7 @@ ex0.txt ex1.txt: maker
maker:
touch ex0.txt ex1.txt
-# 如果定义的 phony target 与文件名重名, 可以用 .PHONY 显示的指明哪些 targets 是 phony
+# 如果定义的 phony target 与文件名重名, 可以用 .PHONY 显式地指明哪些 targets 是 phony
.PHONY: all maker process
# This is a special target. There are several others.
@@ -116,7 +116,7 @@ process: ex1.txt file0.txt
# 模式匹配
#-----------------------------------------------------------------------
-# 可以让 make 知道如何转换某些文件到别格式
+# 可以让 make 知道如何转换某些文件到其他格式
# 比如 从 svg 到 png
%.png: %.svg
inkscape --export-png $^
@@ -149,7 +149,7 @@ echo:
@echo $(name)
@echo ${name2}
@echo $name # 这个会被蠢蠢的解析成 $(n)ame.
- @echo \"$(name3)\" # 为声明的变量或扩展成空字符串.
+ @echo \"$(name3)\" # 未声明的变量会被处理成空字符串.
@echo $(name4)
@echo $(name5)
# 你可以通过4种方式设置变量.
diff --git a/zh-cn/mips-cn.html.markdown b/zh-cn/mips-cn.html.markdown
new file mode 100644
index 00000000..83888338
--- /dev/null
+++ b/zh-cn/mips-cn.html.markdown
@@ -0,0 +1,334 @@
+---
+language: "MIPS Assembly"
+filename: MIPS-cn.asm
+contributors:
+ - ["Stanley Lim", "https://github.com/Spiderpig86"]
+translators:
+ - ["Liu Yihua", "https://github.com/yihuajack"]
+lang: zh-cn
+---
+
+MIPS（Microprocessor without Interlocked Pipeline Stages）汇编语言是为了配合约翰·雷洛伊·亨尼西于1981年设计的 MIPS 微处理器范式而设计的，这些 RISC 处理器用于嵌入式系统，例如网关和路由器。
+
+[阅读更多](https://en.wikipedia.org/wiki/MIPS_architecture)
+
+```asm
+# 注释用一个 '#' 表示
+
+# 一行中 '#' 之后的所有文本都会被汇编器的词法分析器忽略
+
+# 程序通常包含 .data 和 .text 部分
+
+.data # 数据存储在内存中（在RAM中分配）
+ # 类似于高级语言中的变量
+
+ # 声明遵循（ 标签: .类型 值 ）的声明形式
+ hello_world: .asciiz "Hello World\n" # 声明一个 null 结束的字符串
+ num1: .word 42 # 整数被视为字
+ # （32位值）
+
+ arr1: .word 1, 2, 3, 4, 5 # 字数组
+ arr2: .byte 'a', 'b' # 字符数组（每个1字节）
+ buffer: .space 60 # 在 RAM 中分配空间
+ # （不清除为0）
+
+ # 数据类型的大小
+ _byte: .byte 'a' # 1字节
+ _halfword: .half 53 # 2字节
+ _word: .word 3 # 4字节
+ _float: .float 3.14 # 4字节
+ _double: .double 7.0 # 8字节
+
+ .align 2 # 数据的内存对齐
+ # 其中数字（应是2的幂）表示几字节对齐
+ # .align 2 表示字对齐（因为 2^2 = 4 字节）
+
+.text # 这部分包括指令和程序逻辑
+.globl _main # 声明一个全局指令标签
+ # 其他文件都可以访问
+
+ _main: # MIPS 程序按顺序执行指令
+ # 这条标签下的代码将首先执行
+
+ # 打印 "hello world"
+ la $a0, hello_world # 加载存储在内存中的字符串地址
+ li $v0, 4 # 加载 syscall 的值
+ # （数字代表要执行哪个 syscall）
+ syscall # 使用给定的参数（$a0）执行指定的 syscall
+
+ # 寄存器（用于在程序执行期间保存数据）
+ # $t0 - $t9 # 临时寄存器，用于过程内部的中间计算
+ # （过程调用时不保存）
+
+ # $s0 - $s7 # 保留寄存器（被保留的寄存器，过程调用时保存）
+ # 通常保存在栈中
+
+ # $a0 - $a3 # 参数寄存器，用于传递过程的参数
+ # $v0 - $v1 # 返回寄存器，用于向调用过程返回值
+
+ # 存取指令
+ la $t0, label # 将内存中由 label 指定的值的地址复制到寄存器 $t0 中
+ lw $t0, label # 从内存中复制一个字
+ lw $t1, 4($s0) # 从寄存器中存储的地址复制一个字
+ # 偏移量为4字节（地址 + 4）
+ lb $t2, label # 把一个字节复制到寄存器 $t2 的低阶部分
+ lb $t2, 0($s0) # 从 $s0 的源地址复制一个字节
+ # 偏移量为0
+ # 同理也适用于 'lh' （取半字）
+
+ sw $t0, label # 将字存储到由 label 映射的内存地址中
+ sw $t0, 8($s0) # 将字存储到 $s0 指定的地址中
+ # 偏移量为8字节
+ # 同理也适用于 'sb' （存字）和 'sh' （存半字）。'sa'不存在
+
+### 数学 ###
+ _math:
+ # 记住要将值加载到寄存器中
+ lw $t0, num # 从数据部分
+ li $t0, 5 # 或者从一个立即数（常数）
+ li $t1, 6
+ add $t2, $t0, $t1 # $t2 = $t0 + $t1
+ sub $t2, $t0, $t1 # $t2 = $t0 - $t1
+ mul $t2, $t0, $t1 # $t2 = $t0 * $t1
+ div $t2, $t0, $t1 # $t2 = $t0 / $t1
+ # （MARS 的某些版本可能不支持）
+ div $t0, $t1 # 执行 $t0 / $t1。
+ # 用 'mflo' 得商，用 'mfhi' 得余数
+
+ # 移位
+ sll $t0, $t0, 2 # 按位左移立即数（常数值）2
+ sllv $t0, $t1, $t2 # 根据一个寄存器中的变量值左移相应位
+ srl $t0, $t0, 5 # 按位右移
+ # （不保留符号，用0符号扩展）
+ srlv $t0, $t1, $t2 # 根据一个寄存器中的变量值右移相应位
+ sra $t0, $t0, 7 # 按算术位右移（保留符号）
+ srav $t0, $t1, $t2 # 根据一个寄存器中的变量值右移相应算数位
+
+ # 按位运算符
+ and $t0, $t1, $t2 # 按位与
+ andi $t0, $t1, 0xFFF # 用立即数按位与
+ or $t0, $t1, $t2 # 按位或
+ ori $t0, $t1, 0xFFF # 用立即数按位或
+ xor $t0, $t1, $t2 # 按位异或
+ xori $t0, $t1, 0xFFF # 用立即数按位异或
+ nor $t0, $t1, $t2 # 按位或非
+
+## 分支 ##
+ _branching:
+ # 分支指令的基本格式通常遵循 <指令> <寄存器1> <寄存器2> <标签>
+ # 如果给定的条件求值为真，则跳转到标签
+ # 有时向后编写条件逻辑更容易，如下面的简单的 if 语句示例所示
+
+ beq $t0, $t1, reg_eq # 如果 $t0 == $t1，则跳转到 reg_eq
+ # 否则执行下一行
+ bne $t0, $t1, reg_neq # 当 $t0 != $t1 时跳转
+ b branch_target # 非条件分支，总会执行
+ beqz $t0, req_eq_zero # 当 $t0 == 0 时跳转
+ bnez $t0, req_neq_zero # 当 $t0 != 0 时跳转
+ bgt $t0, $t1, t0_gt_t1 # 当 $t0 > $t1 时跳转
+ bge $t0, $t1, t0_gte_t1 # 当 $t0 >= $t1 时跳转
+ bgtz $t0, t0_gt0 # 当 $t0 > 0 时跳转
+ blt $t0, $t1, t0_gt_t1 # 当 $t0 < $t1 时跳转
+ ble $t0, $t1, t0_gte_t1 # 当 $t0 <= $t1 时跳转
+ bltz $t0, t0_lt0 # 当 $t0 < 0 时跳转
+ slt $s0, $t0, $t1 # 当 $t0 < $t1 时结果为 $s0 （1为真）
+
+ # 简单的 if 语句
+ # if (i == j)
+ # f = g + h;
+ # f = f - i;
+
+ # 让 $s0 = f, $s1 = g, $s2 = h, $s3 = i, $s4 = j
+ bne $s3, $s4, L1 # if (i !=j)
+ add $s0, $s1, $s2 # f = g + h
+
+ L1:
+ sub $s0, $s0, $s3 # f = f - i
+
+ # 下面是一个求3个数的最大值的例子
+ # 从 Java 到 MIPS 逻辑的直接翻译：
+ # if (a > b)
+ # if (a > c)
+ # max = a;
+ # else
+ # max = c;
+ # else
+ # max = b;
+ # else
+ # max = c;
+
+ # 让 $s0 = a, $s1 = b, $s2 = c, $v0 = 返回寄存器
+ ble $s0, $s1, a_LTE_b # 如果 (a <= b) 跳转到 (a_LTE_b)
+ ble $s0, $s2, max_C # 如果 (a > b && a <= c) 跳转到 (max_C)
+ move $v0, $s1 # 否则 [a > b && a > c] max = a
+ j done # 跳转到程序结束
+
+ a_LTE_b: # 当 a <= b 时的标签
+ ble $s1, $s2, max_C # 如果 (a <= b && b <= c) 跳转到 (max_C)
+ move $v0, $s1 # 如果 (a <= b && b > c) max = b
+ j done # 跳转到 done
+
+ max_C:
+ move $v0, $s2 # max = c
+
+ done: # 程序结束
+
+## 循环 ##
+ _loops:
+ # 循环的基本结构是一个退出条件和一个继续执行的跳转指令
+ li $t0, 0
+ while:
+ bgt $t0, 10, end_while # 当 $t0 小于 10，不停迭代
+ addi $t0, $t0, 1 # 累加值
+ j while # 跳转回循环开始
+ end_while:
+
+ # 二维矩阵遍历
+ # 假设 $a0 存储整数 3 × 3 矩阵的地址
+ li $t0, 0 # 计数器 i
+ li $t1, 0 # 计数器 j
+ matrix_row:
+ bgt $t0, 3, matrix_row_end
+
+ matrix_col:
+ bgt $t1, 3, matrix_col_end
+
+ # 执行一些东西
+
+ addi $t1, $t1, 1 # 累加列计数器
+ matrix_col_end:
+
+ # 执行一些东西
+
+ addi $t0, $t0, 1
+ matrix_row_end:
+
+## 函数 ##
+ _functions:
+ # 函数是可调用的过程，可以接受参数并返回所有用标签表示的值，如前所示
+
+ main: # 程序以 main 函数开始
+ jal return_1 # jal 会把当前程序计数器（PC）存储在 $ra
+ # 并跳转到 return_1
+
+ # 如果我们想传入参数呢？
+ # 首先，我们必须将形参传递给参数寄存器
+ li $a0, 1
+ li $a1, 2
+ jal sum # 现在我们可以调用函数了
+
+ # 递归怎么样？
+ # 这需要更多的工作
+ # 由于 jal 会自动覆盖每次调用，我们需要确保在 $ra 中保存并恢复之前的程序计数器
+ li $a0, 3
+ jal fact
+
+ li $v0, 10
+ syscall
+
+ # 这个函数返回1
+ return_1:
+ li $v0, 1 # 将值取到返回寄存器 $v0 中
+ jr $ra # 跳转回原先的程序计数器继续执行
+
+
+ # 有2个参数的函数
+ sum:
+ add $v0, $a0, $a1
+ jr $ra # 返回
+
+ # 求阶乘的递归函数
+ fact:
+ addi $sp, $sp, -8 # 在栈中分配空间
+ sw $s0, ($sp) # 存储保存当前数字的寄存器
+ sw $ra, 4($sp) # 存储先前的程序计数器
+
+ li $v0, 1 # 初始化返回值
+ beq $a0, 0, fact_done # 如果参数为0则完成
+
+ # 否则继续递归
+ move $s0, $a0 # 复制 $a0 到 $s0
+ sub $a0, $a0, 1
+ jal fact
+
+ mul $v0, $s0, $v0 # 做乘法
+
+ fact_done:
+ lw $s0, ($sp)
+ lw $ra, ($sp) # 恢复程序计数器
+ addi $sp, $sp, 8
+
+ jr $ra
+
+## 宏 ##
+ _macros:
+ # 宏可以实现用单个标签替换重复的代码块，这可以增强程序的可读性
+ # 它们绝不是函数的替代品
+ # 它们必须在使用之前声明
+
+ # 用于打印换行符的宏（这可以被多次重用）
+ .macro println()
+ la $a0, newline # 存储在这里的新行字符串
+ li $v0, 4
+ syscall
+ .end_macro
+
+ println() # 汇编器会在运行前复制此代码块
+
+ # 参数可以通过宏传入。
+ # 它们由 '%' 符号表示，可以选择起任意名字
+ .macro print_int(%num)
+ li $v0, 1
+ lw $a0, %num
+ syscall
+ .end_macro
+
+ li $t0, 1
+ print_int($t0)
+
+ # 我们也可以给宏传递立即数
+ .macro immediates(%a, %b)
+ add $t0, %a, %b
+ .end_macro
+
+ immediates(3, 5)
+
+ # 以及标签
+ .macro print(%string)
+ la $a0, %string
+ li $v0, 4
+ syscall
+ .end_macro
+
+ print(hello_world)
+
+## 数组 ##
+.data
+ list: .word 3, 0, 1, 2, 6 # 这是一个字数组
+ char_arr: .asciiz "hello" # 这是一个字符数组
+ buffer: .space 128 # 在内存中分配块，不会自动清除
+ # 这些内存块彼此对齐
+
+.text
+ la $s0, list # 取 list 的地址
+ li $t0, 0 # 计数器
+ li $t1, 5 # list 的长度
+
+ loop:
+ bgt $t0, $t1, end_loop
+
+ lw $a0, ($s0)
+ li $v0, 1
+ syscall # 打印数字
+
+ addi $s0, $s0, 4 # 字的大小为4字节
+ addi $t0, $t0, 1 # 累加
+ j loop
+ end_loop:
+
+## INCLUDE ##
+# 使用 include 语句可以将外部文件导入到程序中
+# （它只是将文件中的代码放入 include 语句的位置）
+.include "somefile.asm"
+
+```
diff --git a/zh-cn/opencv-cn.html.markdown b/zh-cn/opencv-cn.html.markdown
new file mode 100644
index 00000000..06b997d5
--- /dev/null
+++ b/zh-cn/opencv-cn.html.markdown
@@ -0,0 +1,145 @@
+---
+category: tool
+tool: OpenCV
+filename: learnopencv.py
+contributors:
+ - ["Yogesh Ojha", "http://github.com/yogeshojha"]
+translators:
+ - ["GengchenXU", "https://github.com/GengchenXU"]
+lang: zh-cn
+---
+### Opencv
+
+Opencv（开源计算机视觉）是一个编程功能库，主要面向实时计算机视觉。最初由英特尔开发，后来由Willow Garage，然后Itseez（后来被英特尔收购）支持。Opencv 目前支持多种语言，如C++、Python、Java 等
+
+#### 安装
+有关在计算机上安装 OpenCV，请参阅这些文章。
+
+* Windows 安装说明： [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_setup/py_setup_in_windows/py_setup_in_windows.html#install-opencv-python-in-windows]()
+* Mac 安装说明 (High Sierra): [https://medium.com/@nuwanprabhath/installing-opencv-in-macos-high-sierra-for-python-3-89c79f0a246a]()
+* Linux 安装说明 （Ubuntu 18.04): [https://www.pyimagesearch.com/2018/05/28/ubuntu-18-04-how-to-install-opencv]()
+
+### 在这里，我们将专注于 OpenCV 的 python 实现
+
+```python
+# OpenCV读取图片
+import cv2
+img = cv2.imread('cat.jpg')
+
+# 显示图片
+# imshow() 函数被用来显示图片
+cv2.imshow('Image',img)
+# 第一个参数是窗口的标题，第二个参数是image
+# 如果你得到错误，对象类型为None，你的图像路径可能是错误的。请重新检查图像包
+cv2.waitKey(0)
+# waitKey() 是一个键盘绑定函数，参数以毫秒为单位。对于GUI事件，必须使用waitKey()函数。
+
+# 保存图片
+cv2.imwrite('catgray.png',img)
+# 第一个参数是文件名，第二个参数是图像
+
+# 转换图像灰度
+gray_image = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+# 从摄像头捕捉视频
+cap = cv2.VideoCapture(0)
+#0 是你的相机，如果你有多台相机，你需要输入他们的id
+while(True):
+ # 一帧一帧地获取
+ _, frame = cap.read()
+ cv2.imshow('Frame',frame)
+ # 当用户按下q ->退出
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+# 相机必须释放
+cap.release()
+
+# 在文件中播放视频
+cap = cv2.VideoCapture('movie.mp4')
+while(cap.isOpened()):
+ _, frame = cap.read()
+ # 灰度播放视频
+ gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+ cv2.imshow('frame',gray)
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+cap.release()
+
+# 在OpenCV中画线
+# cv2.line(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness)(注 color颜色rgb参数 thickness粗细)
+cv2.line(img,(0,0),(511,511),(255,0,0),5)
+
+# 画矩形
+# cv2.rectangle(img,(x,y),(x1,y1),(color->r,g,b->0 to 255),thickness)
+# 粗细= -1用于填充矩形
+cv2.rectangle(img,(384,0),(510,128),(0,255,0),3)
+
+# 画圆
+cv2.circle(img,(xCenter,yCenter), radius, (color->r,g,b->0 to 255), thickness)
+cv2.circle(img,(200,90), 100, (0,0,255), -1)
+
+# 画椭圆
+cv2.ellipse(img,(256,256),(100,50),0,0,180,255,-1)
+
+# 在图像上增加文字
+cv2.putText(img,"Hello World!!!", (x,y), cv2.FONT_HERSHEY_SIMPLEX, 2, 255)
+
+# 合成图像
+img1 = cv2.imread('cat.png')
+img2 = cv2.imread('openCV.jpg')
+dst = cv2.addWeighted(img1,0.5,img2,0.5,0)
+
+# 阈值图像
+# 二进制阈值
+_,thresImg = cv2.threshold(img,127,255,cv2.THRESH_BINARY)
+# Adaptive Thresholding
+adapThres = cv2.adaptiveThreshold(img,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY,11,2)
+
+# 模糊的形象
+# 高斯模糊
+blur = cv2.GaussianBlur(img,(5,5),0)
+# 模糊中值
+medianBlur = cv2.medianBlur(img,5)
+
+# Canny 边缘检测
+img = cv2.imread('cat.jpg',0)
+edges = cv2.Canny(img,100,200)
+
+# 用Haar Cascades进行人脸检测
+# 下载 Haar Cascades 在 https://github.com/opencv/opencv/blob/master/data/haarcascades/
+import cv2
+import numpy as np
+face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
+eye_cascade = cv2.CascadeClassifier('haarcascade_eye.xml')
+
+img = cv2.imread('human.jpg')
+gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+
+aces = face_cascade.detectMultiScale(gray, 1.3, 5)
+for (x,y,w,h) in faces:
+ cv2.rectangle(img,(x,y),(x+w,y+h),(255,0,0),2)
+ roi_gray = gray[y:y+h, x:x+w]
+ roi_color = img[y:y+h, x:x+w]
+ eyes = eye_cascade.detectMultiScale(roi_gray)
+ for (ex,ey,ew,eh) in eyes:
+ cv2.rectangle(roi_color,(ex,ey),(ex+ew,ey+eh),(0,255,0),2)
+
+cv2.imshow('img',img)
+cv2.waitKey(0)
+
+cv2.destroyAllWindows()
+# destroyAllWindows() destroys all windows.
+# 如果您希望销毁特定窗口，请传递您创建的窗口的确切名称。
+```
+
+### 进一步阅读：
+
+* Download Cascade from [https://github.com/opencv/opencv/blob/master/data/haarcascades]()
+* OpenCV 绘图函数 [https://docs.opencv.org/2.4/modules/core/doc/drawing_functions.html]()
+* 最新的语言参考 [https://opencv.org]()
+* 更多的资源 [https://en.wikipedia.org/wiki/OpenCV]()
+* 优秀的的 OpenCV 教程
+ * [https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_tutorials.html]()
+ * [https://realpython.com/python-opencv-color-spaces]()
+ * [https://pyimagesearch.com]()
+ * [https://www.learnopencv.com]()
diff --git a/zh-cn/perl-cn.html.markdown b/zh-cn/perl-cn.html.markdown
index 5b0d6179..46c54618 100644
--- a/zh-cn/perl-cn.html.markdown
+++ b/zh-cn/perl-cn.html.markdown
@@ -10,9 +10,9 @@ translators:
lang: zh-cn
---
-Perl 5是一个功能强大、特性齐全的编程语言，有25年的历史。
+Perl 是一个功能强大、特性齐全的编程语言，有25年的历史。
-Perl 5可以在包括便携式设备和大型机的超过100个平台上运行，既适用于快速原型构建，也适用于大型项目开发。
+Perl 可以在包括便携式设备和大型机的超过100个平台上运行，既适用于快速原型构建，也适用于大型项目开发。
```perl
# 单行注释以#号开头
@@ -146,7 +146,7 @@ perlfaq有很多常见问题和相应回答，也经常有对优秀CPAN模块的
#### 深入阅读
- - [perl-tutorial](http://perl-tutorial.org/)
- - [www.perl.com的learn站点](http://www.perl.org/learn.html)
- - [perldoc](http://perldoc.perl.org/)
- - 以及 perl 内置的： `perldoc perlintro`
+- [perl-tutorial](http://perl-tutorial.org/)
+- [www.perl.com的learn站点](http://www.perl.org/learn.html)
+- [perldoc](http://perldoc.perl.org/)
+- 以及 perl 内置的： `perldoc perlintro`
diff --git a/zh-cn/python-cn.html.markdown b/zh-cn/python-cn.html.markdown
index da13275b..6c5556fc 100644
--- a/zh-cn/python-cn.html.markdown
+++ b/zh-cn/python-cn.html.markdown
@@ -436,9 +436,9 @@ all_the_args(1, 2, a=3, b=4) prints:
# 调用可变参数函数时可以做跟上面相反的，用*展开序列，用**展开字典。
args = (1, 2, 3, 4)
kwargs = {"a": 3, "b": 4}
-all_the_args(*args) # 相当于 foo(1, 2, 3, 4)
-all_the_args(**kwargs) # 相当于 foo(a=3, b=4)
-all_the_args(*args, **kwargs) # 相当于 foo(1, 2, 3, 4, a=3, b=4)
+all_the_args(*args) # 相当于 all_the_args(1, 2, 3, 4)
+all_the_args(**kwargs) # 相当于 all_the_args(a=3, b=4)
+all_the_args(*args, **kwargs) # 相当于 all_the_args(1, 2, 3, 4, a=3, b=4)
# 函数作用域
diff --git a/zh-cn/pythonlegacy-cn.html.markdown b/zh-cn/pythonlegacy-cn.html.markdown
index 756081d6..f8aa2332 100644
--- a/zh-cn/pythonlegacy-cn.html.markdown
+++ b/zh-cn/pythonlegacy-cn.html.markdown
@@ -163,7 +163,7 @@ li[:3] # => [1, 2, 4]
del li[2] # li 现在是 [1, 2, 3]
# 合并列表
-li + other_li # => [1, 2, 3, 4, 5, 6] - 并不会不改变这两个列表
+li + other_li # => [1, 2, 3, 4, 5, 6] - 并不会改变这两个列表
# 通过拼接来合并列表
li.extend(other_li) # li 是 [1, 2, 3, 4, 5, 6]
diff --git a/zh-cn/qt-cn.html.markdown b/zh-cn/qt-cn.html.markdown
new file mode 100644
index 00000000..8681c85b
--- /dev/null
+++ b/zh-cn/qt-cn.html.markdown
@@ -0,0 +1,160 @@
+---
+category: tool
+tool: Qt Framework
+language: c++
+filename: learnqt-cn.cpp
+contributors:
+ - ["Aleksey Kholovchuk", "https://github.com/vortexxx192"]
+translators:
+ - ["GengchenXU", "https://github.com/GengchenXU"]
+lang: zh-cn
+
+---
+
+**Qt** Qt是一个广为人知的框架，用于开发跨平台软件，该软件可以在各种软件和硬件平台上运行，代码几乎没有变化，同时具有本机应用程序的能力和速度。虽然**Qt**最初是用*C*++，但也有其他语言的端口: *[PyQt](https://learnxinyminutes.com/docs/pyqt/)*, *QtRuby*, *PHP-Qt*, 等等.
+
+**Qt** 非常适合使用图形用户界面 （GUI） 创建应用程序。本教程是关于如何用*C++*去实现。
+
+```c++
+/*
+ * 让我们从最经典的开始
+ */
+
+// Qt框架的所有标头均以大写字母'Q'开头
+#include <QApplication>
+#include <QLineEdit>
+
+int main(int argc, char *argv[]) {
+ // 创建一个对象来管理应用程序范围内的资源
+ QApplication app(argc, argv);
+
+ // 创建行编辑widgets并在屏幕上显示
+ QLineEdit lineEdit("Hello world!");
+ lineEdit.show();
+
+ // 启动应用程序的事件循环
+ return app.exec();
+}
+```
+
+**Qt**与 GUI 相关的部分与*widgets*及其之间的*connection*有关。
+
+[阅读更多有关widgets的信息](http://doc.qt.io/qt-5/qtwidgets-index.html)
+
+```c++
+/*
+ * 让我们创建一个标签和一个按钮。
+ * 按下按钮时应显示一个标签。
+ * Qt代码本身就可以说明问题。
+ */
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QLabel>
+
+int main(int argc, char *argv[]) {
+ QApplication app(argc, argv);
+
+ QDialog dialogWindow;
+ dialogWindow.show();
+
+ // 添加垂直布局
+ QVBoxLayout layout;
+ dialogWindow.setLayout(&layout);
+
+ QLabel textLabel("Thanks for pressing that button");
+ layout.addWidget(&textLabel);
+ textLabel.hide();
+
+ QPushButton button("Press me");
+ layout.addWidget(&button);
+
+ // 按下按钮时显示隐藏标签
+ QObject::connect(&button, &QPushButton::pressed,
+ &textLabel, &QLabel::show);
+
+ return app.exec();
+}
+```
+
+注意，*QObject :: connect*部分。 此方法用于将一个对象的*SIGNAL*连接到另一个对象的*SLOTS*。
+
+**Signals** 会被发出当对象发生某些事情时，例如当用户按下QPushButton对象时会发出*push*的信号。
+
+**Slots** 是可以响应于接收到的信号而执行的*action*。
+
+[阅读有关SLOTS和SIGNALS的更多信息](http://doc.qt.io/qt-5/signalsandslots.html)
+
+
+接下来，让我们了解到我们不仅可以使用标准的wigets，而且可以通过继承扩展其行为。 让我们创建一个按钮并计算其被按下的次数。 为此，我们定义了自己的类* CounterLabel *。 由于特定的Qt体系结构，必须在单独的文件中声明它。
+
+```c++
+// counterlabel.hpp
+
+#ifndef COUNTERLABEL
+#define COUNTERLABEL
+
+#include <QLabel>
+
+class CounterLabel : public QLabel {
+ Q_OBJECT // 在每个自定义wiget中必须存在的Qt定义的宏
+
+public:
+ CounterLabel() : counter(0) {
+ setText("Counter has not been increased yet"); // QLabel方法
+ }
+
+public slots:
+ // 将响应按钮按下而调用的操作
+ void increaseCounter() {
+ setText(QString("Counter value: %1").arg(QString::number(++counter)));
+ }
+
+private:
+ int counter;
+};
+
+#endif // COUNTERLABEL
+```
+
+```c++
+// main.cpp
+// 与前面的示例几乎相同
+
+#include <QApplication>
+#include <QDialog>
+#include <QVBoxLayout>
+#include <QPushButton>
+#include <QString>
+#include "counterlabel.hpp"
+
+int main(int argc, char *argv[]) {
+ QApplication app(argc, argv);
+
+ QDialog dialogWindow;
+ dialogWindow.show();
+
+ QVBoxLayout layout;
+ dialogWindow.setLayout(&layout);
+
+ CounterLabel counterLabel;
+ layout.addWidget(&counterLabel);
+
+ QPushButton button("Push me once more");
+ layout.addWidget(&button);
+ QObject::connect(&button, &QPushButton::pressed,
+ &counterLabel, &CounterLabel::increaseCounter);
+
+ return app.exec();
+}
+```
+
+当然，Qt框架比本教程介绍的部分要复杂得多，因此请仔细阅读和练习。
+
+## 进一步阅读
+- [Qt 4.8 tutorials](http://doc.qt.io/qt-4.8/tutorials.html)
+- [Qt 5 tutorials](http://doc.qt.io/qt-5/qtexamplesandtutorials.html)
+
+祝你好运，生活愉快!
diff --git a/zh-cn/ruby-cn.html.markdown b/zh-cn/ruby-cn.html.markdown
index 9918c022..63adab64 100644
--- a/zh-cn/ruby-cn.html.markdown
+++ b/zh-cn/ruby-cn.html.markdown
@@ -657,4 +657,4 @@ Something.new.qux # => 'qux'
- [Ruby from other languages](https://www.ruby-lang.org/en/documentation/ruby-from-other-languages/)
- [Programming Ruby](http://www.amazon.com/Programming-Ruby-1-9-2-0-Programmers/dp/1937785491/) - An older [free edition](http://ruby-doc.com/docs/ProgrammingRuby/) is available online.
- [Ruby Style Guide](https://github.com/bbatsov/ruby-style-guide) - A community-driven Ruby coding style guide.
-- [Try Ruby](http://tryruby.org) - Learn the basic of Ruby programming language, interactive in the browser.
+- [Try Ruby](https://try.ruby-lang.org/) - Learn the basic of Ruby programming language, interactive in the browser.
diff --git a/zh-cn/set-theory-cn.html.markdown b/zh-cn/set-theory-cn.html.markdown
new file mode 100644
index 00000000..13ba2c80
--- /dev/null
+++ b/zh-cn/set-theory-cn.html.markdown
@@ -0,0 +1,138 @@
+---
+category: Algorithms & Data Structures
+name: Set theory
+contributors:
+translators:
+ - ["Tianchen Xu", "https://github.com/lo0b0o"]
+lang: zh-cn
+---
+集合论是数学的一个分支，研究集合、它们的运算和它们的性质。
+
+* 集合由不重复的项组成。
+
+## 基本符号
+
+### 运算符
+* 并运算符，`∪`，表示“或”；
+* 交运算符，`∩`，表示“且”；
+* 差运算符，`\`，表示“不包括”；
+* 补运算符，`'`，表示补集;
+* 叉积运算符，`×`，表示笛卡尔积。
+
+### 限定词
+* 冒号限定词，`:`，表示“使得”；
+* 从属限定词，`∈`，表示“属于”；
+* 子集限定词，`⊆`，表示“是……的子集”;
+* 真子集限定词，`⊂`，表示“是……的真子集”。
+
+### 重要的集合
+* `∅`，空集，即不包含任何元素的集合；
+* `ℕ`，自然数集；
+* `ℤ`，整数集；
+* `ℚ`，有理数集；
+* `ℝ`，实数集。
+
+关于以上集合，有如下几点需要注意：
+1. 空集是其本身的子集（并且也是任何其他集合的子集），即便空集不包含任何项；
+2. 数学家们对于零是否为自然数的看法通常并不统一，教科书一般会明确说明作者是否认为零是自然数。
+
+### 基数
+
+集合的基数，或者说大小，由该集合中的项目数量决定。基数运算符为 `|...|`。
+
+例如，若 `S = { 1, 2, 4 }`，则 `|S| = 3`。
+
+### 空集
+
+* 可以在集合符号中使用不成立的条件来构造空集，例如，`∅ = { x : x ≠ x }`，或 `∅ = { x : x ∈ N, x < 0 }`；
+* 空集总是唯一的（即，有且只有一个空集）；
+* 空集是所有集合的子集；
+* 空集的基数为 0，即 `|∅| = 0`。
+
+## 集合的表示
+
+### 集合的逐项构造
+
+集合可以通过包含其全部项的列表逐项生成。例如，`S = { a, b, c, d }`。
+
+只要构成集合的项清楚，长列表可以用省略号缩短。例如，`E = { 2, 4, 6, 8, ... }` 显然为所有偶数构成的集合，它包含无穷多项，虽然我们只显式写出了其中四项。
+
+### 集合构造器
+
+集合构造器符号是构造集合的一种更具描述性的方式。它依赖于一个主语和一个谓词，使得 `S = { 主语 : 谓词 }`。 例如，
+
+```
+A = { x : x 是元音字母 } = { a, e, i, o, u, y}
+B = { x : x ∈ N, x < 10 } = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
+C = { x : x = 2k, k ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+有时，谓词可能会 "漏 "到主语中，例如，
+
+```
+D = { 2x : x ∈ N } = { 0, 2, 4, 6, 8, ... }
+```
+
+## 关系
+
+### 从属关系
+
+* 如果值 `a` 包含在集合 `A` 中，那么我们说 `a` 属于 `A`，并用符号表示为 `a ∈ A`。
+* 如果值 `a` 不包含于集合 `A` 中，那么我们说 `a` 不属于 `A`，并用符号表示为 `a ∉ A`。
+
+### 相等关系
+
+* 如果两个集合包括相同的项，那么我们说这两个集合相等，例如，`A = B`。
+* 集合的相等关系于顺序无关，例如 `{ 1, 2, 3, 4 } = { 2, 3, 1, 4 }`。
+* 集合中的元素不能重复，例如 `{ 1, 2, 2, 3, 4, 3, 4, 2 } = { 1, 2, 3, 4 }`。
+* 集合 `A` 与 `B` 相等当且仅当 `A ⊆ B` 且 `B ⊆ A`。
+
+## 特殊集合
+
+### 幂集
+
+* 令 `A` 为任意集合。幂集指的是包括了 `A` 的所有子集的集合，记作 `P(A)`。如果集合 `A` 由 `2n` 个元素组成，那么 `P(A)` 中有 `2^n` 个元素。
+
+```
+P(A) = { x : x ⊆ A }
+```
+
+## 两个集合的运算
+### 并
+
+给定集合 `A` 和 `B`，两个集合的并由出现在 `A` 或 `B` 中的项构成，记作 `A ∪ B`。
+
+```
+A ∪ B = { x : x ∈ A ∪ x ∈ B }
+```
+
+### 交
+
+给定集合 `A` 和 `B`，两个集合的交由出现在 `A` 和 `B` 中的项构成，记作 `A ∩ B`。
+
+```
+A ∩ B = { x : x ∈ A, x ∈ B }
+```
+
+### 差
+给定集合 `A` 和 `B`，`A` 对于 `B` 的集合差指的是属于 `A` 但不属于 `B` 的每一项。
+
+```
+A \ B = { x : x ∈ A, x ∉ B }
+```
+
+### 对称差
+给定集合 `A` 和 `B`，对称差指的是属于 `A` 或 `B` 但不属于它们交集的所有项。
+
+```
+A △ B = { x : ((x ∈ A) ∩ (x ∉ B)) ∪ ((x ∈ B) ∩ (x ∉ A)) }
+
+A △ B = (A \ B) ∪ (B \ A)
+```
+
+### 笛卡尔积
+给定集合 `A` 和 `B`，`A` 和 `B` 的笛卡尔积由 `A` 和 `B` 的项的所有组合构成。
+
+```
+A × B = { (x, y) | x ∈ A, y ∈ B }
+```
diff --git a/zh-cn/solidity-cn.html.markdown b/zh-cn/solidity-cn.html.markdown
index ec684997..12a532bc 100644
--- a/zh-cn/solidity-cn.html.markdown
+++ b/zh-cn/solidity-cn.html.markdown
@@ -213,7 +213,7 @@ names.length; // 获得数组长度
names.length = 1; // 可以设定长度（仅针对 storage 中的动态数组）
// 多维数组
-uint x[][5]; // 5个动态数组元素的数组(和多数语言的顺序相反)
+uint[][5] x; // 5个动态数组元素的数组(和多数语言的顺序相反)
// 字典类型 (任一类型到其他类型的映射)
mapping (string => uint) public balances;
diff --git a/zh-cn/swift-cn.html.markdown b/zh-cn/swift-cn.html.markdown
index 18bc52ed..c56a0d33 100644
--- a/zh-cn/swift-cn.html.markdown
+++ b/zh-cn/swift-cn.html.markdown
@@ -10,7 +10,7 @@ translators:
lang: zh-cn
---
-Swift 是 Apple 开发的用于 iOS 和 OS X 开发的编程语言。Swift 于2014年 Apple WWDC （全球开发者大会）中被引入，用以与 Objective-C 共存，同时对错误代码更具弹性。Swift 由 Xcode 6 beta 中包含的 LLVM 编译器编译。
+Swift 是 Apple 开发的用于 iOS 和 macOS 开发的编程语言。Swift 于2014年 Apple WWDC （全球开发者大会）中被引入，用以与 Objective-C 共存，同时对错误代码更具弹性。Swift 由 Xcode 6 beta 中包含的 LLVM 编译器编译。
Swift 的官方语言教程 [Swift Programming Language](https://itunes.apple.com/us/book/swift-programming-language/id881256329) 可以从 iBooks 免费下载.
diff --git a/zh-cn/wolfram-cn.html.markdown b/zh-cn/wolfram-cn.html.markdown
new file mode 100644
index 00000000..9d6ef54f
--- /dev/null
+++ b/zh-cn/wolfram-cn.html.markdown
@@ -0,0 +1,140 @@
+---
+language: wolfram
+contributors:
+ - ["hyphz", "http://github.com/hyphz/"]
+translators:
+ - ["wuyudi", "http://github.com/wuyudi/"]
+filename: learnwolfram-cn.nb
+lang: zh-cn
+---
+
+Wolfram 语言是最初在 Mathematica 中使用的底层语言，但现在可用于多种场合。
+
+Wolfram 语言有几个界面。
+
+- Raspberry Pi 上的命令行内核界面（就叫 _The Wolfram Language_），它是交互式运行的，不能产生图形输入。
+- _Mathematica_ 是一个丰富的文本/数学编辑器，内置交互式的 Wolfram: 在 "代码单元 "上按 shift+Return 键可以创建一个输出单元，输出结果，这不是动态的。
+- _Wolfram Workbench_，这是 Eclipse 与 Wolfram 语言后端的界面。
+
+本例中的代码可以在任何界面中输入，并使用 Wolfram Workbench 进行编辑。直接加载到 Mathematica 中可能会很不方便，因为该文件不包含单元格格式化信息（这将使该文件作为文本阅读时变得一团糟）--它可以被查看/编辑，但可能需要一些设置。
+
+```mma
+(* 这是一个注释 *)
+
+(* 在Mathematica中，您可以创建一个文本单元格，用排版好的文本和图像来注释您的代码，而不是使用这些注释 *)
+
+(* 输入一个表达式返回结果 *)
+2*2 (* 4 *)
+5+8 (* 13 *)
+
+(* 调用函数 *)
+(* 注意，函数名（和其他所有东西）是区分大小写的 *)
+Sin[Pi/2] (* 1 *)
+
+(* 带有一个参数的函数调用的替代语法 *)
+Sin@(Pi/2) (* 1 *)
+(Pi/2) // Sin (* 1 *)
+
+(* WL 中的每一种语法都有一些等价的函数调用，即万物皆函数 *)
+Times[2, 2] (* 4 *)
+Plus[5, 8] (* 13 *)
+
+(* 第一次使用一个变量定义它，并使其成为全局变量 *)
+x = 5 (* 5 *)
+x == 5 (* 返回真，C-style 的赋值和相等测试 *)
+x (* 5 *)
+x = x + 5 (* 10 *)
+x (* 10 *)
+Set[x, 20] (* 当我说万物皆函数时 我是认真的 *)
+x (* 20 *)
+
+(* 因为WL是基于计算机代数系统的, *)
+(* 可以使用未定义的变量，它们只是阻碍了计算 *)
+cow + 5 (* 5 + cow, cow 是未定义的，所以无法进一步计算 *)
+cow + 5 + 10 (* 15 + cow, 它将尽力计算 *)
+% (* 15 + cow, % 获取最后一次返回的内容 *)
+% - cow (* 15, 未定义的变量cow被消去 *)
+moo = cow + 5 (* 小心，moo 现在是一个表达式，不是一个数字! *)
+
+(* 定义一个函数 *)
+Double[x_] := x * 2 (* 注意 := 防止对RHS进行即时计算。
+ 而 x 后面的 _ 表示没有模式匹配的约束条件*)
+Double[10] (* 20 *)
+Double[Sin[Pi/2]] (* 2 *)
+Double @ Sin @ (Pi/2) (* 2, @-syntax 避免了闭括号的队列 *)
+(Pi/2) // Sin // Double(* 2, //-syntax 按执行顺序列举了函数 *)
+
+(* 对于命令式编程，使用 ; 来分隔语句。 *)
+(* 丢弃 LHS 的任何输出并运行 RHS *)
+MyFirst[] := (Print@"Hello"; Print@"World") (* 请注意，外侧的小括号是关键
+ ;的优先级低于:= *)
+MyFirst[] (* 你好，世界 *)
+
+(* C-Style 的 For 循环，注：在 Mathematica 中使用 For 循环是低效的 *)
+PrintTo[x_] := For[y=0, y<x, y++, (Print[y])] (* 开始，测试，自增，循环体 *)
+PrintTo[5] (* 0 1 2 3 4 *)
+
+(* While 循环 *)
+x = 0; While[x < 2, (Print@x; x++)] (* 带测试和程序体的 while 循环 *)
+
+(* If 和 条件 *)
+x = 8; If[x==8, Print@"Yes", Print@"No"] (* Condition, true case, else case *)
+Switch[x, 2, Print@"Two", 8, Print@"Yes"] (* 值匹配风格切换 *)
+Which[x==2, Print@"No", x==8, Print@"Yes"] (* Elif风格切换 *)
+
+(* 除参数外的变量默认为全局变量，即使在函数内部也是如此 *)
+y = 10 (* 10, 全局变量 y *)
+PrintTo[5] (* 0 1 2 3 4 *)
+y (* 5, 全局的 y 被 PrintTo 内的循环计数器所占用 *)
+x = 20 (* 20, 全局变量 x *)
+PrintTo[5] (* 0 1 2 3 4 *)
+x (* 20, PrintTo 中的 x 是一个参数，并自动局部化 *)
+
+(* 局部变量使用 Module 元函数声明 *)
+(* 带本地变量的版本 *)
+BetterPrintTo[x_] := Module[{y}, (For[y=0, y<x, y++, (Print@y)])]
+y = 20 (* 全局变量 y *)
+BetterPrintTo[5] (* 0 1 2 3 4 *)
+y (* 20, 那更好 *)
+
+(* 实际上，模块允许我们声明任何我们喜欢的作用域 *)
+Module[{count}, count=0; (* 声明这个变量count的作用域 *)
+ (IncCount[] := ++count); (* 这些函数都在该作用域内 *)
+ (DecCount[] := --count)]
+count (* count - 全局变量 count 未定义 *)
+IncCount[] (* 1, 使用作用域内的counter变量 *)
+IncCount[] (* 2, incCount 升级了它 *)
+DecCount[] (* 1, decCount 也是 *)
+count (* count - 这个名字依旧不是全局变量 *)
+
+(* Lists *)
+myList = {1, 2, 3, 4} (* {1, 2, 3, 4} *)
+myList[[1]] (* 1 - 注意列表索引从 1 开始，而不是从 0 开始。 *)
+Map[Double, myList] (* {2, 4, 6, 8} - 函数式列表的 map 函数 *)
+Double /@ myList (* {2, 4, 6, 8} - 以上的缩略语法 *)
+Scan[Print, myList] (* 1 2 3 4 - 命令式循环 *)
+Fold[Plus, 0, myList] (* 10 (0+1+2+3+4) *)
+FoldList[Plus, 0, myList] (* {0, 1, 3, 6, 10} - 存值的 Fold *)
+Append[myList, 5] (* {1, 2, 3, 4, 5} - 注意 myList 没有更新 *)
+Prepend[myList, 5] (* {5, 1, 2, 3, 4} - 如果想让 myList 更新，就加上 "myList = " *)
+Join[myList, {3, 4}] (* {1, 2, 3, 4, 3, 4} *)
+myList[[2]] = 5 (* {1, 5, 3, 4} - 这确实更新了myList *)
+
+(* 关联，又称字典/哈希值 *)
+myHash = <|"Green" -> 2, "Red" -> 1|> (* 创建一个关联 *)
+myHash[["Green"]] (* 2, 使用 *)
+myHash[["Green"]] := 5 (* 5, 更新 *)
+myHash[["Puce"]] := 3.5 (* 3.5, 扩展 *)
+KeyDropFrom[myHash, "Green"] (* 抹去绿色的键 *)
+Keys[myHash] (* {Red, Puce} *)
+Values[myHash] (* {1, 3.5} *)
+
+(* 做 Wolfram 的演示时 你不能不展示这个 *)
+Manipulate[y^2, {y, 0, 20}] (* 返回一个反应式的用户界面，显示y^2
+ 并允许通过滑块在 0-20 之间调整y。
+ 只适用于图形前端 *)
+```
+
+## 想多来点?
+
+- [Wolfram Language Documentation Center](http://reference.wolfram.com/language/)
diff --git a/zh-cn/yaml-cn.html.markdown b/zh-cn/yaml-cn.html.markdown
index 7b6ff305..cfa22dfb 100644
--- a/zh-cn/yaml-cn.html.markdown
+++ b/zh-cn/yaml-cn.html.markdown
@@ -5,27 +5,27 @@ contributors:
translators:
- ["Zach Zhang", "https://github.com/checkcheckzz"]
- ["Jiang Haiyun", "https://github.com/haiiiiiyun"]
+ - ["Wen Sun", "https://github.com/HermitSun"]
filename: learnyaml-cn.yaml
lang: zh-cn
---
-YAML 是一个数据序列化语言，被设计成人类直接可写可读的。
+YAML 是一种数据序列化语言，旨在让人类直接可写可读。
-它是 JSON 的严格超集，增加了语法显著换行符和缩进，就像 Python。但和 Python 不一样，
-YAML 根本不容许文字制表符。
+它是 JSON 的严格超集，增加了*在语法上有意义的*（syntactically significant）换行符和缩进，就像 Python 一样。但和 Python 的不同之处在于，YAML 不允许使用*文字制表符*（literal tab characters）来表示缩进。
```yaml
--- # 文档开头
-# YAML 中的注解看起来像这样。
+# YAML 中的注释看起来像这样。
################
# 标量类型 #
################
-# 我们的根对象 (它们在整个文件里延续) 将会是一个映射，
-# 它等价于在别的语言里的一个字典，哈希表或对象。
+# 我们的根对象 (贯穿整个文档的始终) 是一个映射（map），
+# 它等价于其它语言中的一个字典（dictionary），哈希表（hash）或对象（object）。
key: value
another_key: Another value goes here.
a_number_value: 100
@@ -35,16 +35,16 @@ scientific_notation: 1e+12
boolean: true
null_value: null
key with spaces: value
-# 注意，字符串不必被括在引号中，但也可以被括起来。
+# 注意，字符串可以不括在引号里。当然，也可以括在引号里。
however: 'A string, enclosed in quotes.'
'Keys can be quoted too.': "Useful if you want to put a ':' in your key."
single quotes: 'have ''one'' escape pattern'
double quotes: "have many: \", \0, \t, \u263A, \x0d\x0a == \r\n, and more."
-# UTF-8/16/32 字符需要被转义(encoded)
+# UTF-8/16/32字符需要指明编码（通过\u）。
Superscript two: \u00B2
-# 多行字符串既可以写成像一个'文字块'(使用 |)，
-# 或像一个'折叠块'(使用 '>')。
+# 多行字符串既可以写成一个'字面量块'(使用 '|')，
+# 也可以写成一个'折叠块'(使用 '>')。
literal_block: |
This entire block of text will be the value of the 'literal_block' key,
with line breaks being preserved.
@@ -67,7 +67,7 @@ folded_style: >
# 集合类型 #
####################
-# 嵌套是通过缩进完成的。推荐使用 2 个空格的缩进（但非必须）
+# 嵌套是通过缩进完成的。推荐使用 2 个空格的缩进（但非必须）。
a_nested_map:
key: value
another_key: Another Value
@@ -77,22 +77,22 @@ a_nested_map:
# 映射的键不必是字符串。
0.25: a float key
-# 键也可以是复合型的，比如多行对象
-# 我们用 ? 后跟一个空格来表示一个复合键的开始。
+# 键也可以是复合（complex）的，比如多行对象
+# 我们用 '?' 后跟一个空格来表示一个复合键的开始。
? |
This is a key
that has multiple lines
: and this is its value
# YAML 也允许使用复杂键语法表示序列间的映射关系。
-# 但有些语言的解析器可能会不支持。
+# 但有些解析器可能会不支持。
# 一个例子：
? - Manchester United
- Real Madrid
: [ 2001-01-01, 2002-02-02 ]
-# 序列 (等价于列表或数组) 看起来像这样：
-# 注意 '-' 算作缩进
+# 序列 (sequences，等价于列表 list 或数组 array ) 看起来像这样：
+# 注意 '-' 也算缩进：
a_sequence:
- Item 1
- Item 2
@@ -115,7 +115,7 @@ and quotes are optional: {key: [3, 2, 1, takeoff]}
# 其余的 YAML 特性 #
#######################
-# YAML 还有一个方便的特性叫 '锚'，它能让你很容易在文档中进行文本复用。
+# YAML 还有一个方便的特性叫“锚”（anchors）。你可以使用它在文档中轻松地完成文本复用。
# 如下两个键会有相同的值：
anchored_content: &anchor_name This string will appear as the value of two keys.
other_anchor: *anchor_name
@@ -124,8 +124,8 @@ other_anchor: *anchor_name
base: &base
name: Everyone has same name
-# The regexp << is called Merge Key Language-Independent Type.
-# 它表明指定映射的所有键值会插入到当前的映射中。
+# '<<'称为语言无关的合并键类型（Merge Key Language-Independent Type）.
+# 它表明一个或多个指定映射中的所有键值会插入到当前的映射中。
foo: &foo
<<: *base
@@ -137,22 +137,22 @@ bar: &bar
# foo 和 bar 将都含有 name: Everyone has same name
-# YAML 还有标签，你可以用它显式地声明类型。
+# YAML 还有标签（tags），你可以用它显式地声明类型。
explicit_string: !!str 0.5
-# 一些解析器实现特定语言的标签，就像这个针对 Python 的复数类型。
+# 一些解析器实现了特定语言的标签，就像这个针对Python的复数类型的标签。
python_complex_number: !!python/complex 1+2j
-# 我们也可以在 YAML 的复合键中使用特定语言的标签
+# 我们也可以在 YAML 的复合键中使用特定语言的标签：
? !!python/tuple [5, 7]
: Fifty Seven
-# 将会是 Python 中的 {(5, 7): 'Fifty Seven'}
+# 将会是 Python 中的 {(5, 7): 'Fifty Seven'}
####################
# 其余的 YAML 类型 #
####################
-# 除了字符串和数字，YAML 还能理解其它标量。
-# ISO 格式的日期和日期时间文本也可以被解析。
+# 除了字符串和数字，YAML 还支持其它标量。
+# ISO 格式的日期和时间字面量也可以被解析。
datetime: 2001-12-15T02:59:43.1Z
datetime_with_spaces: 2001-12-14 21:59:43.10 -5
date: 2002-12-14
@@ -165,14 +165,14 @@ gif_file: !!binary |
+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
-# YAML 还有一个集合类型，它看起来像这样：
+# YAML 还有一个集合（set）类型，它看起来像这样：
set:
? item1
? item2
? item3
or: {item1, item2, item3}
-# 集合只是值为 null 的映射；上面的集合等价于：
+# 集合只是值均为 null 的映射；上面的集合等价于：
set2:
item1: null
item2: null
@@ -184,4 +184,5 @@ set2:
### 更多资源
+ [YAML official website](http://yaml.org/)
++ [Online YAML Converter](http://yamlonline.com)
+ [Online YAML Validator](http://codebeautify.org/yaml-validator)