summaryrefslogtreecommitdiffhomepage
path: root/zh-cn
diff options
context:
space:
mode:
Diffstat (limited to 'zh-cn')
-rw-r--r--zh-cn/c-cn.html.markdown2
-rw-r--r--zh-cn/julia-cn.html.markdown917
-rw-r--r--zh-cn/matlab-cn.html.markdown47
-rw-r--r--zh-cn/python3-cn.html.markdown48
-rw-r--r--zh-cn/swift-cn.html.markdown18
5 files changed, 590 insertions, 442 deletions
diff --git a/zh-cn/c-cn.html.markdown b/zh-cn/c-cn.html.markdown
index 02ec7f7b..8566e811 100644
--- a/zh-cn/c-cn.html.markdown
+++ b/zh-cn/c-cn.html.markdown
@@ -41,7 +41,7 @@ enum days {SUN = 1, MON, TUE, WED, THU, FRI, SAT};
void function_1(char c);
void function_2(void);
-// 如果函数调用在main()之后，那么必须在main()之前
+// 如果函数调用在main()之后，那么必须声明在main()之前
// 先声明一个函数原型
int add_two_ints(int x1, int x2); // 函数原型
diff --git a/zh-cn/julia-cn.html.markdown b/zh-cn/julia-cn.html.markdown
index 1f91d52c..b350b6dc 100644
--- a/zh-cn/julia-cn.html.markdown
+++ b/zh-cn/julia-cn.html.markdown
@@ -2,16 +2,24 @@
language: Julia
filename: learn-julia-zh.jl
contributors:
- - ["Jichao Ouyang", "http://oyanglul.us"]
+ - ["Leah Hanson", "http://leahhanson.us"]
+ - ["Pranit Bauva", "https://github.com/pranitbauva1997"]
+ - ["Daniel YC Lin", "https://github.com/dlintw"]
translators:
- ["Jichao Ouyang", "http://oyanglul.us"]
+ - ["woclass", "https://github.com/inkydragon"]
lang: zh-cn
---
-```ruby
-# 单行注释只需要一个井号
+Julia 是一种新的同像函数式编程语言(homoiconic functional language)，它专注于科学计算领域。
+虽然拥有同像宏(homoiconic macros)、一级函数(first-class functions)和底层控制等全部功能，但 Julia 依旧和 Python 一样易于学习和使用。
+
+示例代码基于 Julia 1.0.0
+
+```julia
+# 单行注释只需要一个井号「#」
#= 多行注释
- 只需要以 '#=' 开始 '=#' 结束
+ 只需要以「#=」开始「=#」结束
还可以嵌套.
=#
@@ -19,41 +27,41 @@ lang: zh-cn
## 1. 原始类型与操作符
####################################################
-# Julia 中一切皆是表达式。
-
-# 这是一些基本数字类型.
-3 # => 3 (Int64)
-3.2 # => 3.2 (Float64)
-2 + 1im # => 2 + 1im (Complex{Int64})
-2//3 # => 2//3 (Rational{Int64})
-
-# 支持所有的普通中缀操作符。
-1 + 1 # => 2
-8 - 1 # => 7
-10 * 2 # => 20
-35 / 5 # => 7.0
-5 / 2 # => 2.5 # 用 Int 除 Int 永远返回 Float
-div(5, 2) # => 2 # 使用 div 截断小数点
-5 \ 35 # => 7.0
-2 ^ 2 # => 4 # 次方, 不是二进制 xor
-12 % 10 # => 2
+# Julia 中一切皆为表达式
+
+# 这是一些基本数字类型
+typeof(3) # => Int64
+typeof(3.2) # => Float64
+typeof(2 + 1im) # => Complex{Int64}
+typeof(2 // 3) # => Rational{Int64}
+
+# 支持所有的普通中缀操作符
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7.0
+10 / 2 # => 5.0 # 整数除法总是返回浮点数
+div(5, 2) # => 2 # 使用 div 可以获得整除的结果
+5 \ 35 # => 7.0
+2^2 # => 4 # 幂运算，不是异或 (xor)
+12 % 10 # => 2
# 用括号提高优先级
(1 + 3) * 2 # => 8
-# 二进制操作符
-~2 # => -3 # 非
-3 & 5 # => 1 # 与
-2 | 4 # => 6 # 或
-2 $ 4 # => 6 # 异或
-2 >>> 1 # => 1 # 逻辑右移
-2 >> 1 # => 1 # 算术右移
-2 << 1 # => 4 # 逻辑/算术 右移
-
-# 可以用函数 bits 查看二进制数。
-bits(12345)
+# 位操作符
+~2 # => -3 # 按位非 (not)
+3 & 5 # => 1 # 按位与 (and)
+2 | 4 # => 6 # 按位或 (or)
+xor(2, 4) # => 6 # 按位异或 (xor)
+2 >>> 1 # => 1 # 逻辑右移
+2 >> 1 # => 1 # 算术右移
+2 << 1 # => 4 # 逻辑/算术左移
+
+# 可以用函数 bitstring 查看二进制数。
+bitstring(12345)
# => "0000000000000000000000000000000000000000000000000011000000111001"
-bits(12345.0)
+bitstring(12345.0)
# => "0100000011001000000111001000000000000000000000000000000000000000"
# 布尔值是原始类型
@@ -61,40 +69,50 @@ true
false
# 布尔操作符
-!true # => false
-!false # => true
-1 == 1 # => true
-2 == 1 # => false
-1 != 1 # => false
-2 != 1 # => true
-1 < 10 # => true
-1 > 10 # => false
-2 <= 2 # => true
-2 >= 2 # => true
-# 比较可以串联
+!true # => false
+!false # => true
+1 == 1 # => true
+2 == 1 # => false
+1 != 1 # => false
+2 != 1 # => true
+1 < 10 # => true
+1 > 10 # => false
+2 <= 2 # => true
+2 >= 2 # => true
+
+# 链式比较
1 < 2 < 3 # => true
2 < 3 < 2 # => false
-# 字符串可以由 " 创建
+# 字符串可以由「"」创建
"This is a string."
-# 字符字面量可用 ' 创建
+# 字符字面量可用「'」创建
'a'
+# 字符串使用 UTF-8 编码
# 可以像取数组取值一样用 index 取出对应字符
-"This is a string"[1] # => 'T' # Julia 的 index 从 1 开始 :(
-# 但是对 UTF-8 无效,
-# 因此建议使用遍历器 (map, for loops, 等).
+ascii("This is a string")[1]
+# => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
+# Julia 的 index 从 1 开始 :(
+# 但只有在字符串仅由 ASCII 字符构成时，字符串才能够被安全的引索
+# 因此建议使用遍历器 (map, for loops, 等)
# $ 可用于字符插值:
"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
# 可以将任何 Julia 表达式放入括号。
-# 另一种格式化字符串的方式是 printf 宏.
-@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000
+# 另一种输出格式化字符串的方法是使用标准库 Printf 中的 Printf 宏
+using Printf
+@printf "%d is less than %f\n" 4.5 5.3 # => 5 is less than 5.300000
# 打印字符串很容易
-println("I'm Julia. Nice to meet you!")
+println("I'm Julia. Nice to meet you!") # => I'm Julia. Nice to meet you!
+
+# 字符串可以按字典序进行比较
+"good" > "bye" # => true
+"good" == "good" # => true
+"1 + 2 = 3" == "1 + 2 = $(1 + 2)" # => true
####################################################
## 2. 变量与集合
@@ -106,12 +124,12 @@ some_var # => 5
# 访问未声明变量会抛出异常
try
- some_other_var # => ERROR: some_other_var not defined
+ some_other_var # => ERROR: UndefVarError: some_other_var not defined
catch e
println(e)
end
-# 变量名需要以字母开头.
+# 变量名必须以下划线或字母开头
# 之后任何字母，数字，下划线，叹号都是合法的。
SomeOtherVar123! = 6 # => 6
@@ -122,66 +140,93 @@ SomeOtherVar123! = 6 # => 6
# 注意 Julia 的命名规约:
#
-# * 变量名为小写，单词之间以下划线连接('\_')。
+# * 名称可以用下划线「_」分割。
+# 不过一般不推荐使用下划线，除非不用变量名就会变得难于理解
#
-# * 类型名以大写字母开头，单词以 CamelCase 方式连接。
+# * 类型名以大写字母开头，单词以 CamelCase 方式连接，无下划线。
#
# * 函数与宏的名字小写，无下划线。
#
-# * 会改变输入的函数名末位为 !。
+# * 会改变输入的函数名末位为「!」。
# 这类函数有时被称为 mutating functions 或 in-place functions.
-# 数组存储一列值，index 从 1 开始。
-a = Int64[] # => 0-element Int64 Array
+# 数组存储一列值，index 从 1 开始
+a = Int64[] # => 0-element Array{Int64,1}
+
+# 一维数组可以以逗号分隔值的方式声明
+b = [4, 5, 6] # => 3-element Array{Int64,1}: [4, 5, 6]
+b = [4; 5; 6] # => 3-element Array{Int64,1}: [4, 5, 6]
+b[1] # => 4
+b[end] # => 6
-# 一维数组可以以逗号分隔值的方式声明。
-b = [4, 5, 6] # => 包含 3 个 Int64 类型元素的数组: [4, 5, 6]
-b[1] # => 4
-b[end] # => 6
+# 二维数组以分号分隔维度
+matrix = [1 2; 3 4] # => 2×2 Array{Int64,2}: [1 2; 3 4]
-# 二维数组以分号分隔维度。
-matrix = [1 2; 3 4] # => 2x2 Int64 数组: [1 2; 3 4]
+# 指定数组的类型
+b = Int8[4, 5, 6] # => 3-element Array{Int8,1}: [4, 5, 6]
# 使用 push! 和 append! 往数组末尾添加元素
-push!(a,1) # => [1]
-push!(a,2) # => [1,2]
-push!(a,4) # => [1,2,4]
-push!(a,3) # => [1,2,4,3]
-append!(a,b) # => [1,2,4,3,4,5,6]
+push!(a, 1) # => [1]
+push!(a, 2) # => [1,2]
+push!(a, 4) # => [1,2,4]
+push!(a, 3) # => [1,2,4,3]
+append!(a, b) # => [1,2,4,3,4,5,6]
-# 用 pop 弹出末尾元素
-pop!(b) # => 6 and b is now [4,5]
+# 用 pop 弹出尾部的元素
+pop!(b) # => 6
+b # => [4,5]
-# 可以再放回去
-push!(b,6) # b 又变成了 [4,5,6].
+# 再放回去
+push!(b, 6) # => [4,5,6]
+b # => [4,5,6]
-a[1] # => 1 # 永远记住 Julia 的 index 从 1 开始!
+a[1] # => 1 # 永远记住 Julia 的引索从 1 开始！而不是 0！
-# 用 end 可以直接取到最后索引. 可用作任何索引表达式
+# 用 end 可以直接取到最后索引。它可以用在任何索引表达式中
a[end] # => 6
-# 还支持 shift 和 unshift
-shift!(a) # => 返回 1，而 a 现在时 [2,4,3,4,5,6]
-unshift!(a,7) # => [7,2,4,3,4,5,6]
+# 数组还支持 popfirst! 和 pushfirst!
+popfirst!(a) # => 1
+a # => [2,4,3,4,5,6]
+pushfirst!(a, 7) # => [7,2,4,3,4,5,6]
+a # => [7,2,4,3,4,5,6]
# 以叹号结尾的函数名表示它会改变参数的值
-arr = [5,4,6] # => 包含三个 Int64 元素的数组: [5,4,6]
-sort(arr) # => [4,5,6]; arr 还是 [5,4,6]
-sort!(arr) # => [4,5,6]; arr 现在是 [4,5,6]
+arr = [5,4,6] # => 3-element Array{Int64,1}: [5,4,6]
+sort(arr) # => [4,5,6]
+arr # => [5,4,6]
+sort!(arr) # => [4,5,6]
+arr # => [4,5,6]
-# 越界会抛出 BoundsError 异常
+# 数组越界会抛出 BoundsError
try
- a[0] # => ERROR: BoundsError() in getindex at array.jl:270
- a[end+1] # => ERROR: BoundsError() in getindex at array.jl:270
+ a[0]
+ # => ERROR: BoundsError: attempt to access 7-element Array{Int64,1} at
+ # index [0]
+ # => Stacktrace:
+ # => [1] getindex(::Array{Int64,1}, ::Int64) at .\array.jl:731
+ # => [2] top-level scope at none:0
+ # => [3] ...
+ # => in expression starting at ...\LearnJulia.jl:203
+ a[end + 1]
+ # => ERROR: BoundsError: attempt to access 7-element Array{Int64,1} at
+ # index [8]
+ # => Stacktrace:
+ # => [1] getindex(::Array{Int64,1}, ::Int64) at .\array.jl:731
+ # => [2] top-level scope at none:0
+ # => [3] ...
+ # => in expression starting at ...\LearnJulia.jl:211
catch e
println(e)
end
-# 错误会指出发生的行号，包括标准库
-# 如果你有 Julia 源代码，你可以找到这些地方
+# 报错时错误会指出出错的文件位置以及行号，标准库也一样
+# 你可以在 Julia 安装目录下的 share/julia 文件夹里找到这些标准库
# 可以用 range 初始化数组
-a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
+a = [1:5;] # => 5-element Array{Int64,1}: [1,2,3,4,5]
+# 注意！分号不可省略
+a2 = [1:5] # => 1-element Array{UnitRange{Int64},1}: [1:5]
# 可以切割数组
a[1:3] # => [1, 2, 3]
@@ -189,11 +234,13 @@ a[2:end] # => [2, 3, 4, 5]
# 用 splice! 切割原数组
arr = [3,4,5]
-splice!(arr,2) # => 4 ; arr 变成了 [3,5]
+splice!(arr, 2) # => 4
+arr # => [3,5]
# 用 append! 连接数组
b = [1,2,3]
-append!(a,b) # a 变成了 [1, 2, 3, 4, 5, 1, 2, 3]
+append!(a, b) # => [1, 2, 3, 4, 5, 1, 2, 3]
+a # => [1, 2, 3, 4, 5, 1, 2, 3]
# 检查元素是否在数组中
in(1, a) # => true
@@ -201,240 +248,258 @@ in(1, a) # => true
# 用 length 获得数组长度
length(a) # => 8
-# Tuples 是 immutable 的
-tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple.
+# 元组(Tuples)是不可变的
+tup = (1, 2, 3) # => (1,2,3)
+typeof(tup) # => Tuple{Int64,Int64,Int64}
tup[1] # => 1
-try:
- tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+try
+ tup[1] = 3
+ # => ERROR: MethodError: no method matching
+ # setindex!(::Tuple{Int64,Int64,Int64}, ::Int64, ::Int64)
catch e
println(e)
end
-# 大多数组的函数同样支持 tuples
+# 大多数组的函数同样支持元组
length(tup) # => 3
-tup[1:2] # => (1,2)
-in(2, tup) # => true
+tup[1:2] # => (1,2)
+in(2, tup) # => true
-# 可以将 tuples 元素分别赋给变量
-a, b, c = (1, 2, 3) # => (1,2,3) # a is now 1, b is now 2 and c is now 3
+# 可以将元组的元素解包赋给变量
+a, b, c = (1, 2, 3) # => (1,2,3)
+a # => 1
+b # => 2
+c # => 3
# 不用括号也可以
-d, e, f = 4, 5, 6 # => (4,5,6)
+d, e, f = 4, 5, 6 # => (4,5,6)
+d # => 4
+e # => 5
+f # => 6
# 单元素 tuple 不等于其元素值
(1,) == 1 # => false
-(1) == 1 # => true
+(1) == 1 # => true
# 交换值
-e, d = d, e # => (5,4) # d is now 5 and e is now 4
+e, d = d, e # => (5,4)
+d # => 5
+e # => 4
-# 字典Dictionaries store mappings
-empty_dict = Dict() # => Dict{Any,Any}()
+# 字典用于储存映射(mappings)（键值对）
+empty_dict = Dict() # => Dict{Any,Any} with 0 entries
# 也可以用字面量创建字典
-filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
-# => Dict{ASCIIString,Int64}
+filled_dict = Dict("one" => 1, "two" => 2, "three" => 3)
+# => Dict{String,Int64} with 3 entries:
+# => "two" => 2, "one" => 1, "three" => 3
# 用 [] 获得键值
filled_dict["one"] # => 1
# 获得所有键
keys(filled_dict)
-# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# => Base.KeySet for a Dict{String,Int64} with 3 entries. Keys:
+# => "two", "one", "three"
# 注意，键的顺序不是插入时的顺序
# 获得所有值
values(filled_dict)
-# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# => Base.ValueIterator for a Dict{String,Int64} with 3 entries. Values:
+# => 2, 1, 3
# 注意，值的顺序也一样
# 用 in 检查键值是否已存在，用 haskey 检查键是否存在
-in(("one", 1), filled_dict) # => true
-in(("two", 3), filled_dict) # => false
-haskey(filled_dict, "one") # => true
-haskey(filled_dict, 1) # => false
+in(("one" => 1), filled_dict) # => true
+in(("two" => 3), filled_dict) # => false
+haskey(filled_dict, "one") # => true
+haskey(filled_dict, 1) # => false
# 获取不存在的键的值会抛出异常
try
- filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+ filled_dict["four"] # => ERROR: KeyError: key "four" not found
catch e
println(e)
end
# 使用 get 可以提供默认值来避免异常
# get(dictionary,key,default_value)
-get(filled_dict,"one",4) # => 1
-get(filled_dict,"four",4) # => 4
+get(filled_dict, "one", 4) # => 1
+get(filled_dict, "four", 4) # => 4
-# 用 Sets 表示无序不可重复的值的集合
-empty_set = Set() # => Set{Any}()
-# 初始化一个 Set 并定义其值
-filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+# Set 表示无序不可重复的值的集合
+empty_set = Set() # => Set(Any[])
+# 初始化一个带初值的 Set
+filled_set = Set([1, 2, 2, 3, 4]) # => Set([4, 2, 3, 1])
-# 添加值
-push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+# 新增值
+push!(filled_set, 5) # => Set([4, 2, 3, 5, 1])
-# 检查是否存在某值
-in(2, filled_set) # => true
-in(10, filled_set) # => false
+# 检查 Set 中是否存在某值
+in(2, filled_set) # => true
+in(10, filled_set) # => false
# 交集，并集，差集
-other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
-intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
-union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
-setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
-
+other_set = Set([3, 4, 5, 6]) # => Set([4, 3, 5, 6])
+intersect(filled_set, other_set) # => Set([4, 3, 5])
+union(filled_set, other_set) # => Set([4, 2, 3, 5, 6, 1])
+setdiff(Set([1,2,3,4]), Set([2,3,5])) # => Set([4, 1])
####################################################
-## 3. 控制流
+## 3. 控制语句
####################################################
# 声明一个变量
some_var = 5
-# 这是一个 if 语句，缩进不是必要的
+# 这是一个 if 语句块，其中的缩进不是必须的
if some_var > 10
println("some_var is totally bigger than 10.")
-elseif some_var < 10 # elseif 是可选的.
+elseif some_var < 10 # elseif 是可选的
println("some_var is smaller than 10.")
-else # else 也是可选的.
+else # else 也是可选的
println("some_var is indeed 10.")
end
-# => prints "some var is smaller than 10"
+# => some_var is smaller than 10.
# For 循环遍历
-# Iterable 类型包括 Range, Array, Set, Dict, 以及 String.
-for animal=["dog", "cat", "mouse"]
+# 可迭代的类型包括：Range, Array, Set, Dict 和 AbstractString
+for animal = ["dog", "cat", "mouse"]
println("$animal is a mammal")
- # 可用 $ 将 variables 或 expression 转换为字符串into strings
+ # 你可以用 $ 将变量或表达式插入字符串中
end
-# prints:
-# dog is a mammal
-# cat is a mammal
-# mouse is a mammal
+# => dog is a mammal
+# => cat is a mammal
+# => mouse is a mammal
-# You can use 'in' instead of '='.
+# 你也可以不用「=」而使用「in」
for animal in ["dog", "cat", "mouse"]
println("$animal is a mammal")
end
-# prints:
-# dog is a mammal
-# cat is a mammal
-# mouse is a mammal
+# => dog is a mammal
+# => cat is a mammal
+# => mouse is a mammal
-for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
- println("$(a[1]) is a $(a[2])")
+for pair in Dict("dog" => "mammal", "cat" => "mammal", "mouse" => "mammal")
+ from, to = pair
+ println("$from is a $to")
end
-# prints:
-# dog is a mammal
-# cat is a mammal
-# mouse is a mammal
+# => mouse is a mammal
+# => cat is a mammal
+# => dog is a mammal
+# 注意！这里的输出顺序和上面的不同
-for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+for (k, v) in Dict("dog" => "mammal", "cat" => "mammal", "mouse" => "mammal")
println("$k is a $v")
end
-# prints:
-# dog is a mammal
-# cat is a mammal
-# mouse is a mammal
+# => mouse is a mammal
+# => cat is a mammal
+# => dog is a mammal
# While 循环
-x = 0
-while x < 4
- println(x)
- x += 1 # x = x + 1
+let x = 0
+ while x < 4
+ println(x)
+ x += 1 # x = x + 1 的缩写
+ end
end
-# prints:
-# 0
-# 1
-# 2
-# 3
+# => 0
+# => 1
+# => 2
+# => 3
# 用 try/catch 处理异常
try
- error("help")
+ error("help")
catch e
- println("caught it $e")
+ println("caught it $e")
end
# => caught it ErrorException("help")
-
####################################################
## 4. 函数
####################################################
-# 用关键字 'function' 可创建一个新函数
-#function name(arglist)
-# body...
-#end
+# 关键字 function 用于定义函数
+# function name(arglist)
+# body...
+# end
function add(x, y)
println("x is $x and y is $y")
- # 最后一行语句的值为返回
+ # 函数会返回最后一行的值
x + y
end
-add(5, 6) # => 在 "x is 5 and y is 6" 后会打印 11
+add(5, 6)
+# => x is 5 and y is 6
+# => 11
+
+# 更紧凑的定义函数
+f_add(x, y) = x + y # => f_add (generic function with 1 method)
+f_add(3, 4) # => 7
+
+# 函数可以将多个值作为元组返回
+fn(x, y) = x + y, x - y # => fn (generic function with 1 method)
+fn(3, 4) # => (7, -1)
# 还可以定义接收可变长参数的函数
function varargs(args...)
return args
- # 关键字 return 可在函数内部任何地方返回
+ # 使用 return 可以在函数内的任何地方返回
end
# => varargs (generic function with 1 method)
varargs(1,2,3) # => (1,2,3)
-# 省略号 ... 被称为 splat.
+# 省略号「...」称为 splat
# 刚刚用在了函数定义中
-# 还可以用在函数的调用
-# Array 或者 Tuple 的内容会变成参数列表
-Set([1,2,3]) # => Set{Array{Int64,1}}([1,2,3]) # 获得一个 Array 的 Set
-Set([1,2,3]...) # => Set{Int64}(1,2,3) # 相当于 Set(1,2,3)
+# 在调用函数时也可以使用它，此时它会把数组或元组解包为参数列表
+add([5,6]...) # 等价于 add(5,6)
-x = (1,2,3) # => (1,2,3)
-Set(x) # => Set{(Int64,Int64,Int64)}((1,2,3)) # 一个 Tuple 的 Set
-Set(x...) # => Set{Int64}(2,3,1)
+x = (5, 6) # => (5,6)
+add(x...) # 等价于 add(5,6)
-
-# 可定义可选参数的函数
-function defaults(a,b,x=5,y=6)
+# 可定义带可选参数的函数
+function defaults(a, b, x=5, y=6)
return "$a $b and $x $y"
end
+# => defaults (generic function with 3 methods)
-defaults('h','g') # => "h g and 5 6"
-defaults('h','g','j') # => "h g and j 6"
-defaults('h','g','j','k') # => "h g and j k"
+defaults('h', 'g') # => "h g and 5 6"
+defaults('h', 'g', 'j') # => "h g and j 6"
+defaults('h', 'g', 'j', 'k') # => "h g and j k"
try
- defaults('h') # => ERROR: no method defaults(Char,)
- defaults() # => ERROR: no methods defaults()
+ defaults('h') # => ERROR: MethodError: no method matching defaults(::Char)
+ defaults() # => ERROR: MethodError: no method matching defaults()
catch e
println(e)
end
-# 还可以定义键值对的参数
-function keyword_args(;k1=4,name2="hello") # note the ;
- return ["k1"=>k1,"name2"=>name2]
+# 还可以定义带关键字参数的函数
+function keyword_args(;k1=4, name2="hello") # 注意分号 ';'
+ return Dict("k1" => k1, "name2" => name2)
end
+# => keyword_args (generic function with 1 method)
-keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
-keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
-keyword_args() # => ["name2"=>"hello","k1"=>4]
+keyword_args(name2="ness") # => ["name2"=>"ness", "k1"=>4]
+keyword_args(k1="mine") # => ["name2"=>"hello", "k1"=>"mine"]
+keyword_args() # => ["name2"=>"hello", "k1"=>4]
-# 可以组合各种类型的参数在同一个函数的参数列表中
+# 可以在一个函数中组合各种类型的参数
function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
println("normal arg: $normal_arg")
println("optional arg: $optional_positional_arg")
println("keyword arg: $keyword_arg")
end
+# => all_the_args (generic function with 2 methods)
all_the_args(1, 3, keyword_arg=4)
-# prints:
-# normal arg: 1
-# optional arg: 3
-# keyword arg: 4
+# => normal arg: 1
+# => optional arg: 3
+# => keyword arg: 4
# Julia 有一等函数
function create_adder(x)
@@ -443,14 +508,16 @@ function create_adder(x)
end
return adder
end
+# => create_adder (generic function with 1 method)
# 这是用 "stabby lambda syntax" 创建的匿名函数
(x -> x > 2)(3) # => true
-# 这个函数和上面的 create_adder 一模一样
+# 这个函数和上面的 create_adder 是等价的
function create_adder(x)
y -> x + y
end
+# => create_adder (generic function with 1 method)
# 你也可以给内部函数起个名字
function create_adder(x)
@@ -459,18 +526,19 @@ function create_adder(x)
end
adder
end
+# => create_adder (generic function with 1 method)
-add_10 = create_adder(10)
-add_10(3) # => 13
-
+add_10 = create_adder(10) # => (::getfield(Main, Symbol("#adder#11")){Int64})
+ # (generic function with 1 method)
+add_10(3) # => 13
# 内置的高阶函数有
-map(add_10, [1,2,3]) # => [11, 12, 13]
-filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+map(add_10, [1,2,3]) # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
-# 还可以使用 list comprehensions 替代 map
-[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
-[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+# 还可以使用 list comprehensions 让 map 更美观
+[add_10(i) for i = [1, 2, 3]] # => [11, 12, 13]
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
####################################################
## 5. 类型
@@ -482,248 +550,315 @@ filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
typeof(5) # => Int64
# 类型是一等值
-typeof(Int64) # => DataType
-typeof(DataType) # => DataType
+typeof(Int64) # => DataType
+typeof(DataType) # => DataType
# DataType 是代表类型的类型，也代表他自己的类型
-# 类型可用作文档化，优化，以及调度
-# 并不是静态检查类型
+# 类型可用于文档化代码、执行优化以及多重派分(dispatch)
+# Julia 并不只是静态的检查类型
# 用户还可以自定义类型
-# 跟其他语言的 records 或 structs 一样
-# 用 `type` 关键字定义新的类型
+# 就跟其它语言的 record 或 struct 一样
+# 用 `struct` 关键字定义新的类型
-# type Name
+# struct Name
# field::OptionalType
# ...
# end
-type Tiger
- taillength::Float64
- coatcolor # 不附带类型标注的相当于 `::Any`
+struct Tiger
+ taillength::Float64
+ coatcolor # 不带类型标注相当于 `::Any`
end
-# 构造函数参数是类型的属性
-tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+# 默认构造函数的参数是类型的属性，按类型定义中的顺序排列
+tigger = Tiger(3.5, "orange") # => Tiger(3.5, "orange")
# 用新类型作为构造函数还会创建一个类型
-sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+sherekhan = typeof(tigger)(5.6, "fire") # => Tiger(5.6, "fire")
-# struct 类似的类型被称为具体类型
-# 他们可被实例化但不能有子类型
+# 类似 struct 的类型被称为具体类型
+# 它们可被实例化，但不能有子类型
# 另一种类型是抽象类型
-# abstract Name
-abstract Cat # just a name and point in the type hierarchy
+# 抽象类型名
+abstract type Cat end # 仅仅是指向类型结构层次的一个名称
-# 抽象类型不能被实例化，但是可以有子类型
+# 抽象类型不能被实例化，但可以有子类型
# 例如，Number 就是抽象类型
-subtypes(Number) # => 6-element Array{Any,1}:
- # Complex{Float16}
- # Complex{Float32}
- # Complex{Float64}
- # Complex{T<:Real}
- # ImaginaryUnit
- # Real
-subtypes(Cat) # => 0-element Array{Any,1}
-
-# 所有的类型都有父类型; 可以用函数 `super` 得到父类型.
+subtypes(Number) # => 2-element Array{Any,1}:
+ # => Complex
+ # => Real
+subtypes(Cat) # => 0-element Array{Any,1}
+
+# AbstractString，类如其名，也是一个抽象类型
+subtypes(AbstractString) # => 4-element Array{Any,1}:
+ # => String
+ # => SubString
+ # => SubstitutionString
+ # => Test.GenericString
+
+# 所有的类型都有父类型。可以用函数 `supertype` 得到父类型
typeof(5) # => Int64
-super(Int64) # => Signed
-super(Signed) # => Real
-super(Real) # => Number
-super(Number) # => Any
-super(super(Signed)) # => Number
-super(Any) # => Any
-# 所有这些类型，除了 Int64, 都是抽象类型.
-
-# <: 是类型集成操作符
-type Lion <: Cat # Lion 是 Cat 的子类型
- mane_color
- roar::String
+supertype(Int64) # => Signed
+supertype(Signed) # => Integer
+supertype(Integer) # => Real
+supertype(Real) # => Number
+supertype(Number) # => Any
+supertype(supertype(Signed)) # => Real
+supertype(Any) # => Any
+# 除了 Int64 外，其余的类型都是抽象类型
+typeof("fire") # => String
+supertype(String) # => AbstractString
+supertype(AbstractString) # => Any
+supertype(SubString) # => AbstractString
+
+# <: 是子类型化操作符
+struct Lion <: Cat # Lion 是 Cat 的子类型
+ mane_color
+ roar::AbstractString
end
# 可以继续为你的类型定义构造函数
-# 只需要定义一个同名的函数
-# 并调用已有的构造函数设置一个固定参数
-Lion(roar::String) = Lion("green",roar)
-# 这是一个外部构造函数，因为他再类型定义之外
-
-type Panther <: Cat # Panther 也是 Cat 的子类型
- eye_color
- Panther() = new("green")
- # Panthers 只有这个构造函数，没有默认构造函数
+# 只需要定义一个与类型同名的函数，并调用已有的构造函数得到正确的类型
+Lion(roar::AbstractString) = Lion("green", roar) # => Lion
+# 这是一个外部构造函数，因为它在类型定义之外
+
+struct Panther <: Cat # Panther 也是 Cat 的子类型
+ eye_color
+ Panther() = new("green")
+ # Panthers 只有这个构造函数，没有默认构造函数
end
-# 使用内置构造函数，如 Panther，可以让你控制
-# 如何构造类型的值
-# 应该尽可能使用外部构造函数而不是内部构造函数
+# 像 Panther 一样使用内置构造函数，让你可以控制如何构建类型的值
+# 应该尽量使用外部构造函数，而不是内部构造函数
####################################################
## 6. 多分派
####################################################
-# 在Julia中, 所有的具名函数都是类属函数
-# 这意味着他们都是有很大小方法组成的
-# 每个 Lion 的构造函数都是类属函数 Lion 的方法
+# Julia 中所有的函数都是通用函数，或者叫做泛型函数(generic functions)
+# 也就是说这些函数都是由许多小方法组合而成的
+# Lion 的每一种构造函数都是通用函数 Lion 的一个方法
# 我们来看一个非构造函数的例子
+# 首先，让我们定义一个函数 meow
-# Lion, Panther, Tiger 的 meow 定义为
+# Lion, Panther, Tiger 的 meow 定义分别为
function meow(animal::Lion)
- animal.roar # 使用点符号访问属性
+ animal.roar # 使用点记号「.」访问属性
end
+# => meow (generic function with 1 method)
function meow(animal::Panther)
- "grrr"
+ "grrr"
end
+# => meow (generic function with 2 methods)
function meow(animal::Tiger)
- "rawwwr"
+ "rawwwr"
end
+# => meow (generic function with 3 methods)
# 试试 meow 函数
-meow(tigger) # => "rawwr"
-meow(Lion("brown","ROAAR")) # => "ROAAR"
+meow(tigger) # => "rawwwr"
+meow(Lion("brown", "ROAAR")) # => "ROAAR"
meow(Panther()) # => "grrr"
-# 再看看层次结构
-issubtype(Tiger,Cat) # => false
-issubtype(Lion,Cat) # => true
-issubtype(Panther,Cat) # => true
+# 回顾类型的层次结构
+Tiger <: Cat # => false
+Lion <: Cat # => true
+Panther <: Cat # => true
-# 定义一个接收 Cats 的函数
+# 定义一个接收 Cat 类型的函数
function pet_cat(cat::Cat)
- println("The cat says $(meow(cat))")
+ println("The cat says $(meow(cat))")
end
+# => pet_cat (generic function with 1 method)
-pet_cat(Lion("42")) # => prints "The cat says 42"
+pet_cat(Lion("42")) # => The cat says 42
try
- pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+ pet_cat(tigger) # => ERROR: MethodError: no method matching pet_cat(::Tiger)
catch e
println(e)
end
# 在面向对象语言中，通常都是单分派
-# 这意味着分派方法是通过第一个参数的类型决定的
-# 在Julia中, 所有参数类型都会被考虑到
+# 这意味着使用的方法取决于第一个参数的类型
+# 而 Julia 中选择方法时会考虑到所有参数的类型
-# 让我们定义有多个参数的函数，好看看区别
-function fight(t::Tiger,c::Cat)
- println("The $(t.coatcolor) tiger wins!")
+# 让我们定义一个有更多参数的函数，这样我们就能看出区别
+function fight(t::Tiger, c::Cat)
+ println("The $(t.coatcolor) tiger wins!")
end
# => fight (generic function with 1 method)
-fight(tigger,Panther()) # => prints The orange tiger wins!
-fight(tigger,Lion("ROAR")) # => prints The orange tiger wins!
+fight(tigger, Panther()) # => The orange tiger wins!
+fight(tigger, Lion("ROAR")) # => fight(tigger, Lion("ROAR"))
-# 让我们修改一下传入具体为 Lion 类型时的行为
-fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+# 让我们修改一下传入 Lion 类型时的行为
+fight(t::Tiger, l::Lion) = println("The $(l.mane_color)-maned lion wins!")
# => fight (generic function with 2 methods)
-fight(tigger,Panther()) # => prints The orange tiger wins!
-fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins!
+fight(tigger, Panther()) # => The orange tiger wins!
+fight(tigger, Lion("ROAR")) # => The green-maned lion wins!
-# 把 Tiger 去掉
-fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+# 我们不需要一只老虎参与战斗
+fight(l::Lion, c::Cat) = println("The victorious cat says $(meow(c))")
# => fight (generic function with 3 methods)
-fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr
+fight(Lion("balooga!"), Panther()) # => The victorious cat says grrr
try
- fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
-catch
+ fight(Panther(), Lion("RAWR"))
+ # => ERROR: MethodError: no method matching fight(::Panther, ::Lion)
+ # => Closest candidates are:
+ # => fight(::Tiger, ::Lion) at ...
+ # => fight(::Tiger, ::Cat) at ...
+ # => fight(::Lion, ::Cat) at ...
+ # => ...
+catch e
+ println(e)
end
-# 在试试让 Cat 在前面
-fight(c::Cat,l::Lion) = println("The cat beats the Lion")
-# => Warning: New definition
-# fight(Cat,Lion) at none:1
-# is ambiguous with
-# fight(Lion,Cat) at none:2.
-# Make sure
-# fight(Lion,Lion)
-# is defined first.
-#fight (generic function with 4 methods)
-
-# 警告说明了无法判断使用哪个 fight 方法
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
-# 结果在老版本 Julia 中可能会不一样
-
-fight(l::Lion,l2::Lion) = println("The lions come to a tie")
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie
-
-
-# Under the hood
-# 你还可以看看 llvm 以及生成的汇编代码
-
-square_area(l) = l * l # square_area (generic function with 1 method)
-
-square_area(5) #25
-
-# 给 square_area 一个整形时发生什么
-code_native(square_area, (Int32,))
- # .section __TEXT,__text,regular,pure_instructions
- # Filename: none
- # Source line: 1 # Prologue
- # push RBP
- # mov RBP, RSP
- # Source line: 1
- # movsxd RAX, EDI # Fetch l from memory?
- # imul RAX, RAX # Square l and store the result in RAX
- # pop RBP # Restore old base pointer
- # ret # Result will still be in RAX
-
-code_native(square_area, (Float32,))
- # .section __TEXT,__text,regular,pure_instructions
- # Filename: none
- # Source line: 1
- # push RBP
- # mov RBP, RSP
- # Source line: 1
- # vmulss XMM0, XMM0, XMM0 # Scalar single precision multiply (AVX)
- # pop RBP
- # ret
-
-code_native(square_area, (Float64,))
- # .section __TEXT,__text,regular,pure_instructions
- # Filename: none
- # Source line: 1
- # push RBP
- # mov RBP, RSP
- # Source line: 1
- # vmulsd XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
- # pop RBP
- # ret
- #
-# 注意 只要参数中又浮点类型，Julia 就使用浮点指令
+# 试试把 Cat 放在前面
+fight(c::Cat, l::Lion) = println("The cat beats the Lion")
+# => fight (generic function with 4 methods)
+
+# 由于无法判断该使用哪个 fight 方法，而产生了错误
+try
+ fight(Lion("RAR"), Lion("brown", "rarrr"))
+ # => ERROR: MethodError: fight(::Lion, ::Lion) is ambiguous. Candidates:
+ # => fight(c::Cat, l::Lion) in Main at ...
+ # => fight(l::Lion, c::Cat) in Main at ...
+ # => Possible fix, define
+ # => fight(::Lion, ::Lion)
+ # => ...
+catch e
+ println(e)
+end
+# 在不同版本的 Julia 中错误信息可能有所不同
+
+fight(l::Lion, l2::Lion) = println("The lions come to a tie")
+# => fight (generic function with 5 methods)
+fight(Lion("RAR"), Lion("brown", "rarrr")) # => The lions come to a tie
+
+
+# 深入编译器之后
+# 你还可以看看 llvm 以及它生成的汇编代码
+
+square_area(l) = l * l # => square_area (generic function with 1 method)
+square_area(5) # => 25
+
+# 当我们喂给 square_area 一个整数时会发生什么？
+code_native(square_area, (Int32,), syntax = :intel)
+ # .text
+ # ; Function square_area {
+ # ; Location: REPL[116]:1 # 函数序言 (Prologue)
+ # push rbp
+ # mov rbp, rsp
+ # ; Function *; {
+ # ; Location: int.jl:54
+ # imul ecx, ecx # 求 l 的平方，并把结果放在 ECX 中
+ # ;}
+ # mov eax, ecx
+ # pop rbp # 还原旧的基址指针(base pointer)
+ # ret # 返回值放在 EAX 中
+ # nop dword ptr [rax + rax]
+ # ;}
+# 使用 syntax 参数指定输出语法。默认为 AT&T 格式，这里指定为 Intel 格式
+
+code_native(square_area, (Float32,), syntax = :intel)
+ # .text
+ # ; Function square_area {
+ # ; Location: REPL[116]:1
+ # push rbp
+ # mov rbp, rsp
+ # ; Function *; {
+ # ; Location: float.jl:398
+ # vmulss xmm0, xmm0, xmm0 # 标量双精度乘法 (AVX)
+ # ;}
+ # pop rbp
+ # ret
+ # nop word ptr [rax + rax]
+ # ;}
+
+code_native(square_area, (Float64,), syntax = :intel)
+ # .text
+ # ; Function square_area {
+ # ; Location: REPL[116]:1
+ # push rbp
+ # mov rbp, rsp
+ # ; Function *; {
+ # ; Location: float.jl:399
+ # vmulsd xmm0, xmm0, xmm0 # 标量双精度乘法 (AVX)
+ # ;}
+ # pop rbp
+ # ret
+ # nop word ptr [rax + rax]
+ # ;}
+
+# 注意！只要参数中有浮点数，Julia 就会使用浮点指令
# 让我们计算一下圆的面积
-circle_area(r) = pi * r * r # circle_area (generic function with 1 method)
-circle_area(5) # 78.53981633974483
-
-code_native(circle_area, (Int32,))
- # .section __TEXT,__text,regular,pure_instructions
- # Filename: none
- # Source line: 1
- # push RBP
- # mov RBP, RSP
- # Source line: 1
- # vcvtsi2sd XMM0, XMM0, EDI # Load integer (r) from memory
- # movabs RAX, 4593140240 # Load pi
- # vmulsd XMM1, XMM0, QWORD PTR [RAX] # pi * r
- # vmulsd XMM0, XMM0, XMM1 # (pi * r) * r
- # pop RBP
- # ret
- #
-
-code_native(circle_area, (Float64,))
- # .section __TEXT,__text,regular,pure_instructions
- # Filename: none
- # Source line: 1
- # push RBP
- # mov RBP, RSP
- # movabs RAX, 4593140496
- # Source line: 1
- # vmulsd XMM1, XMM0, QWORD PTR [RAX]
- # vmulsd XMM0, XMM1, XMM0
- # pop RBP
- # ret
- #
+circle_area(r) = pi * r * r # => circle_area (generic function with 1 method)
+circle_area(5) # => 78.53981633974483
+
+code_native(circle_area, (Int32,), syntax = :intel)
+ # .text
+ # ; Function circle_area {
+ # ; Location: REPL[121]:1
+ # push rbp
+ # mov rbp, rsp
+ # ; Function *; {
+ # ; Location: operators.jl:502
+ # ; Function *; {
+ # ; Location: promotion.jl:314
+ # ; Function promote; {
+ # ; Location: promotion.jl:284
+ # ; Function _promote; {
+ # ; Location: promotion.jl:261
+ # ; Function convert; {
+ # ; Location: number.jl:7
+ # ; Function Type; {
+ # ; Location: float.jl:60
+ # vcvtsi2sd xmm0, xmm0, ecx # 从内存中读取整数 r
+ # movabs rax, 497710928 # 读取 pi
+ # ;}}}}}
+ # ; Function *; {
+ # ; Location: float.jl:399
+ # vmulsd xmm1, xmm0, qword ptr [rax] # pi * r
+ # vmulsd xmm0, xmm1, xmm0 # (pi * r) * r
+ # ;}}
+ # pop rbp
+ # ret
+ # nop dword ptr [rax]
+ # ;}
+
+code_native(circle_area, (Float64,), syntax = :intel)
+ # .text
+ # ; Function circle_area {
+ # ; Location: REPL[121]:1
+ # push rbp
+ # mov rbp, rsp
+ # movabs rax, 497711048
+ # ; Function *; {
+ # ; Location: operators.jl:502
+ # ; Function *; {
+ # ; Location: promotion.jl:314
+ # ; Function *; {
+ # ; Location: float.jl:399
+ # vmulsd xmm1, xmm0, qword ptr [rax]
+ # ;}}}
+ # ; Function *; {
+ # ; Location: float.jl:399
+ # vmulsd xmm0, xmm1, xmm0
+ # ;}
+ # pop rbp
+ # ret
+ # nop dword ptr [rax + rax]
+ # ;}
```
+
+## 拓展阅读材料
+
+你可以在 [Julia 中文文档](http://docs.juliacn.com/latest/) / [Julia 文档(en)](https://docs.julialang.org/)
+中获得关于 Julia 的更多细节。
+
+如果有任何问题可以去 [Julia 中文社区](http://discourse.juliacn.com/) / [官方社区(en)](https://discourse.julialang.org/) 提问，大家对待新手都非常的友好。
diff --git a/zh-cn/matlab-cn.html.markdown b/zh-cn/matlab-cn.html.markdown
index 2fbccfc4..d215755c 100644
--- a/zh-cn/matlab-cn.html.markdown
+++ b/zh-cn/matlab-cn.html.markdown
@@ -10,9 +10,12 @@ lang: zh-cn
---
-MATLAB 是 MATrix LABoratory （矩阵实验室）的缩写，它是一种功能强大的数值计算语言，在工程和数学领域中应用广泛。
+MATLAB 是 MATrix LABoratory（矩阵实验室）的缩写。
+它是一种功能强大的数值计算语言，在工程和数学领域中应用广泛。
-如果您有任何需要反馈或交流的内容，请联系本教程作者[@the_ozzinator](https://twitter.com/the_ozzinator)、[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com)。
+如果您有任何需要反馈或交流的内容，请联系本教程作者：
+[@the_ozzinator](https://twitter.com/the_ozzinator)
+或 [osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com)。
```matlab
% 以百分号作为注释符
@@ -45,7 +48,7 @@ edit('myfunction.m') % 在编辑器中打开指定函数或脚本
type('myfunction.m') % 在命令窗口中打印指定函数或脚本的源码
profile on % 打开 profile 代码分析工具
-profile of % 关闭 profile 代码分析工具
+profile off % 关闭 profile 代码分析工具
profile viewer % 查看 profile 代码分析工具的分析结果
help command % 在命令窗口中显示指定命令的帮助文档
@@ -113,7 +116,7 @@ b(2) % ans = 符
% 元组（cell 数组）
a = {'one', 'two', 'three'}
a(1) % ans = 'one' - 返回一个元组
-char(a(1)) % ans = one - 返回一个字符串
+a{1} % ans = one - 返回一个字符串
% 结构体
@@ -210,8 +213,8 @@ size(A) % 返回矩阵的行数和列数，ans = 3 3
A(1, :) =[] % 删除矩阵的第 1 行
A(:, 1) =[] % 删除矩阵的第 1 列
-transpose(A) % 矩阵转置，等价于 A'
-ctranspose(A) % 矩阵的共轭转置（对矩阵中的每个元素取共轭复数）
+transpose(A) % 矩阵（非共轭）转置，等价于 A.' （注意！有个点）
+ctranspose(A) % 矩阵的共轭转置（对矩阵中的每个元素取共轭复数），等价于 A'
% 元素运算 vs. 矩阵运算
@@ -219,18 +222,20 @@ ctranspose(A) % 矩阵的共轭转置（对矩阵中的每个元素取共轭复
% 在运算符加上英文句点就是对矩阵中的元素进行元素计算
% 示例如下：
A * B % 矩阵乘法，要求 A 的列数等于 B 的行数
-A .* B % 元素乘法，要求 A 和 B 形状一致（A 的行数等于 B 的行数， A 的列数等于 B 的列数）
-% 元素乘法的结果是与 A 和 B 形状一致的矩阵，其每个元素等于 A 对应位置的元素乘 B 对应位置的元素
+A .* B % 元素乘法，要求 A 和 B 形状一致，即两矩阵行列数完全一致
+ % 元素乘法的结果是与 A 和 B 形状一致的矩阵
+ % 其每个元素等于 A 对应位置的元素乘 B 对应位置的元素
% 以下函数中，函数名以 m 结尾的执行矩阵运算，其余执行元素运算：
exp(A) % 对矩阵中每个元素做指数运算
expm(A) % 对矩阵整体做指数运算
sqrt(A) % 对矩阵中每个元素做开方运算
-sqrtm(A) % 对矩阵整体做开放运算（即试图求出一个矩阵，该矩阵与自身的乘积等于 A 矩阵）
+sqrtm(A) % 对矩阵整体做开方运算（即试图求出一个矩阵，该矩阵与自身的乘积等于 A 矩阵）
% 绘图
-x = 0:.10:2*pi; % 生成一向量，其元素从 0 开始，以 0.1 的间隔一直递增到 2*pi（pi 就是圆周率）
+x = 0:0.1:2*pi; % 生成一向量，其元素从 0 开始，以 0.1 的间隔一直递增到 2*pi
+ % 其中 pi 为圆周率
y = sin(x);
plot(x,y)
xlabel('x axis')
@@ -288,7 +293,10 @@ clf clear % 清除图形窗口中的图像，并重置图像属性
% 也可以用 gcf 函数返回当前图像的句柄
h = plot(x, y); % 在创建图像时显式地保存图像句柄
set(h, 'Color', 'r')
-% 颜色代码：'y' 黄色，'m' 洋红色，'c' 青色，'r' 红色，'g' 绿色，'b' 蓝色，'w' 白色，'k' 黑色
+% 颜色代码：
+% 'y' 黄色，'m' 洋红，'c' 青色
+% 'r' 红色，'g' 绿色，'b' 蓝色
+% 'w' 白色，'k' 黑色
set(h, 'Color', [0.5, 0.5, 0.4])
% 也可以使用 RGB 值指定颜色
set(h, 'LineStyle', '--')
@@ -328,7 +336,8 @@ load('myFileName.mat') % 将指定文件中的变量载入到当前工作空间
% 与脚本文件类似，同样以 .m 作为后缀名
% 但函数文件可以接受用户输入的参数并返回运算结果
% 并且函数拥有自己的工作空间（变量域），不必担心变量名称冲突
-% 函数文件的名称应当与其所定义的函数的名称一致（比如下面例子中函数文件就应命名为 double_input.m）
+% 函数文件的名称应当与其所定义的函数的名称一致
+% 比如下面例子中函数文件就应命名为 double_input.m
% 使用 'help double_input.m' 可返回函数定义中第一行注释信息
function output = double_input(x)
% double_input(x) 返回 x 的 2 倍
@@ -463,14 +472,16 @@ triu(x) % 返回 x 的上三角这部分
tril(x) % 返回 x 的下三角这部分
cross(A, B) % 返回 A 和 B 的叉积（矢量积、外积）
dot(A, B) % 返回 A 和 B 的点积（数量积、内积），要求 A 和 B 必须等长
-transpose(A) % A 的转置，等价于 A'
+transpose(A) % 矩阵（非共轭）转置，等价于 A.' （注意！有个点）
fliplr(A) % 将一个矩阵左右翻转
flipud(A) % 将一个矩阵上下翻转
% 矩阵分解
-[L, U, P] = lu(A) % LU 分解：PA = LU，L 是下三角阵，U 是上三角阵，P 是置换阵
-[P, D] = eig(A) % 特征值分解：AP = PD，D 是由特征值构成的对角阵，P 的各列就是对应的特征向量
-[U, S, V] = svd(X) % 奇异值分解：XV = US，U 和 V 是酉矩阵，S 是由奇异值构成的半正定实数对角阵
+[L, U, P] = lu(A) % LU 分解：PA = LU，L 是下三角阵，U 是上三角阵，P 是置换阵
+[P, D] = eig(A) % 特征值分解：AP = PD
+ % D 是由特征值构成的对角阵，P 的各列就是对应的特征向量
+[U, S, V] = svd(X) % 奇异值分解：XV = US
+ % U 和 V 是酉矩阵，S 是由奇异值构成的半正定实数对角阵
% 常用向量函数
max % 最大值
@@ -489,5 +500,5 @@ perms(x) % x 元素的全排列
## 相关资料
-* 官方网页：[http://http://www.mathworks.com/products/matlab/](http://www.mathworks.com/products/matlab/)
-* 官方论坛：[http://www.mathworks.com/matlabcentral/answers/](http://www.mathworks.com/matlabcentral/answers/)
+* 官方网页：[MATLAB - 技术计算语言 - MATLAB & Simulink](https://ww2.mathworks.cn/products/matlab.html)
+* 官方论坛：[MATLAB Answers - MATLAB Central](https://ww2.mathworks.cn/matlabcentral/answers/)
diff --git a/zh-cn/python3-cn.html.markdown b/zh-cn/python3-cn.html.markdown
index 211ce0c5..fd962305 100644
--- a/zh-cn/python3-cn.html.markdown
+++ b/zh-cn/python3-cn.html.markdown
@@ -10,13 +10,13 @@ filename: learnpython3-cn.py
lang: zh-cn
---
-Python是由吉多·范罗苏姆(Guido Van Rossum)在90年代早期设计。它是如今最常用的编程
-语言之一。它的语法简洁且优美，几乎就是可执行的伪代码。
+Python 是由吉多·范罗苏姆(Guido Van Rossum)在 90 年代早期设计。
+它是如今最常用的编程语言之一。它的语法简洁且优美，几乎就是可执行的伪代码。
-欢迎大家斧正。英文版原作Louie Dinh [@louiedinh](http://twitter.com/louiedinh)
-或着Email louiedinh [at] [谷歌的信箱服务]。中文翻译Geoff Liu。
+欢迎大家斧正。英文版原作 Louie Dinh [@louiedinh](http://twitter.com/louiedinh)
+邮箱 louiedinh [at] [谷歌的信箱服务]。中文翻译 Geoff Liu。
-注意：这篇教程是特别为Python3写的。如果你想学旧版Python2，我们特别有另一篇教程。
+注意：这篇教程是基于 Python 3 写的。如果你想学旧版 Python 2，我们特别有[另一篇教程](http://learnxinyminutes.com/docs/python/)。
```python
@@ -70,15 +70,15 @@ not True # => False
not False # => True
# 逻辑运算符，注意and和or都是小写
-True and False #=> False
-False or True #=> True
+True and False # => False
+False or True # => True
# 整数也可以当作布尔值
-0 and 2 #=> 0
--5 or 0 #=> -5
-0 == False #=> True
-2 == True #=> False
-1 == True #=> True
+0 and 2 # => 0
+-5 or 0 # => -5
+0 == False # => True
+2 == True # => False
+1 == True # => True
# 用==判断相等
1 == 1 # => True
@@ -113,10 +113,11 @@ False or True #=> True
# 可以重复参数以节省时间
"{0} be nimble, {0} be quick, {0} jump over the {1}".format("Jack", "candle stick")
-#=> "Jack be nimble, Jack be quick, Jack jump over the candle stick"
+# => "Jack be nimble, Jack be quick, Jack jump over the candle stick"
# 如果不想数参数，可以用关键字
-"{name} wants to eat {food}".format(name="Bob", food="lasagna") #=> "Bob wants to eat lasagna"
+"{name} wants to eat {food}".format(name="Bob", food="lasagna")
+# => "Bob wants to eat lasagna"
# 如果你的Python3程序也要在Python2.5以下环境运行，也可以用老式的格式化语法
"%s can be %s the %s way" % ("strings", "interpolated", "old")
@@ -132,8 +133,8 @@ None is None # => True
# 所有其他值都是True
bool(0) # => False
bool("") # => False
-bool([]) #=> False
-bool({}) #=> False
+bool([]) # => False
+bool({}) # => False
####################################################
@@ -233,7 +234,8 @@ filled_dict = {"one": 1, "two": 2, "three": 3}
filled_dict["one"] # => 1
-# 用keys获得所有的键。因为keys返回一个可迭代对象，所以在这里把结果包在list里。我们下面会详细介绍可迭代。
+# 用 keys 获得所有的键。
+# 因为 keys 返回一个可迭代对象，所以在这里把结果包在 list 里。我们下面会详细介绍可迭代。
# 注意：字典键的顺序是不定的，你得到的结果可能和以下不同。
list(filled_dict.keys()) # => ["three", "two", "one"]
@@ -261,7 +263,7 @@ filled_dict.setdefault("five", 5) # filled_dict["five"]设为5
filled_dict.setdefault("five", 6) # filled_dict["five"]还是5
# 字典赋值
-filled_dict.update({"four":4}) #=> {"one": 1, "two": 2, "three": 3, "four": 4}
+filled_dict.update({"four":4}) # => {"one": 1, "two": 2, "three": 3, "four": 4}
filled_dict["four"] = 4 # 另一种赋值方法
# 用del删除
@@ -362,7 +364,7 @@ else: # else语句是可选的，必须在所有的except之后
filled_dict = {"one": 1, "two": 2, "three": 3}
our_iterable = filled_dict.keys()
-print(our_iterable) # => range(1,10) 是一个实现可迭代接口的对象
+print(our_iterable) # => dict_keys(['one', 'two', 'three'])，是一个实现可迭代接口的对象
# 可迭代对象可以遍历
for i in our_iterable:
@@ -376,17 +378,17 @@ our_iterator = iter(our_iterable)
# 迭代器是一个可以记住遍历的位置的对象
# 用__next__可以取得下一个元素
-our_iterator.__next__() #=> "one"
+our_iterator.__next__() # => "one"
# 再一次调取__next__时会记得位置
-our_iterator.__next__() #=> "two"
-our_iterator.__next__() #=> "three"
+our_iterator.__next__() # => "two"
+our_iterator.__next__() # => "three"
# 当迭代器所有元素都取出后，会抛出StopIteration
our_iterator.__next__() # 抛出StopIteration
# 可以用list一次取出迭代器所有的元素
-list(filled_dict.keys()) #=> Returns ["one", "two", "three"]
+list(filled_dict.keys()) # => Returns ["one", "two", "three"]
diff --git a/zh-cn/swift-cn.html.markdown b/zh-cn/swift-cn.html.markdown
index c25b2918..18bc52ed 100644
--- a/zh-cn/swift-cn.html.markdown
+++ b/zh-cn/swift-cn.html.markdown
@@ -110,7 +110,7 @@ anyObjectVar = "Changed value to a string, not good practice, but possible."
//
-// Mark: 数组与字典（关联数组）
+// MARK: 数组与字典（关联数组）
//
/*
@@ -214,9 +214,9 @@ func greet(name: String, day: String) -> String {
}
greet("Bob", day: "Tuesday")
-// 第一个参数表示外部参数名和内部参数名使用同一个名称。
+// 第一个参数`_`表示不使用外部参数名，忽略`_`表示外部参数名和内部参数名使用同一个名称。
// 第二个参数表示外部参数名使用 `externalParamName` ，内部参数名使用 `localParamName`
-func greet2(requiredName requiredName: String, externalParamName localParamName: String) -> String {
+func greet2(_ requiredName: String, externalParamName localParamName: String) -> String {
return "Hello \(requiredName), the day is \(localParamName)"
}
greet2(requiredName:"John", externalParamName: "Sunday") // 调用时，使用命名参数来指定参数的值
@@ -250,7 +250,7 @@ var increment = makeIncrementer()
increment(7)
// 强制进行指针传递 (引用传递)，使用 `inout` 关键字修饰函数参数
-func swapTwoInts(inout a: Int, inout b: Int) {
+func swapTwoInts(a: inout Int, b: inout Int) {
let tempA = a
a = b
b = tempA
@@ -521,7 +521,7 @@ class MyShape: Rect {
// 在 optional 属性，方法或下标运算符后面加一个问号，可以优雅地忽略 nil 值，返回 nil。
// 这样就不会引起运行时错误 (runtime error)
- if let reshape = self.delegate?.canReshape?() where reshape {
+ if let reshape = self.delegate?.canReshape?() {
// 注意语句中的问号
self.delegate?.reshape?()
}
@@ -575,10 +575,10 @@ print(foundAtIndex == 2) // true
// 自定义运算符可以以下面的字符打头:
// / = - + * % < > ! & | ^ . ~
// 甚至是 Unicode 的数学运算符等
-prefix operator !!! {}
+prefix operator !!!
// 定义一个前缀运算符，使矩形的边长放大三倍
-prefix func !!! (inout shape: Square) -> Square {
+prefix func !!! (shape: inout Square) -> Square {
shape.sideLength *= 3
return shape
}
@@ -591,8 +591,8 @@ print(mySquare.sideLength) // 4
print(mySquare.sideLength) // 12
// 运算符也可以是泛型
-infix operator <-> {}
-func <-><T: Equatable> (inout a: T, inout b: T) {
+infix operator <->
+func <-><T: Equatable> (a: inout T, b: inout T) {
let c = a
a = b
b = c