我是先接触 Python3 的，如果我自己主动来选择，可能不会再去学 Ruby（可能先入为主的思想太根深蒂固了，不过最主要的还是太懒了），然鹅由于种种原因，我还是要来看一下Ruby（真是天理难容，/大哭/大哭/大哭），虽然大家都说 Ruby 和 Python 的语法差不多（好像确实如此——不过既然如此，为何要弄两个来折磨大家呢？），所以学习的时候我准备把这两种语言的语法对比一下（给自己找点看下去的动力），毕竟语言不过是解决问题的工具，没什么好坏之分（强行安慰一下自己）。至于开发工具嘛！JetBrains 的全家桶真香，Ruby 和 Python 分别用 RubyMine 和 PyCharm 就好。
Ruby on rails 是 Ruby 的 Web 应用程序框架，据说很牛掰，不过咱也不知道咱也不敢问，等我后面接触到了再说，目前的话，就先当个 surprise 期待着吧！好东西自然分享给大家了，下面的参考资料很不错的哟，也是本文的主要参考资料：
learn x in y minutes where x= Ruby ：https://learnxinyminutes.com/docs/ruby/
learn x in y minutes where x= Python ：https://learnxinyminutes.com/docs/python/
软件和解释器安装之类的我就不多说了，我是在 centOS 虚拟机安装的解释器，可以使用 yum install ruby 命令安装，也可以下载压缩包进行安装：
依赖包的话就使用 gem install 命令进行安装，有时候由于网络和墙的原因会一直卡住不动，不过也可以手动下载依赖包进行安装，比如说我安装 pry 的时候就碰到了这种情况，最后手动下载 .gem 文件安装成功（记得添加 --local 参数哟，表示你想使用本地文件进行安装，不然 gem 又会从源地址去下载去了），安装后版本如下：
[root@master ~]# ruby --version
ruby 2.0.0p648 (2015-12-16) [x86_64-linux]
[root@master ~]# python3 --version
Python 3.6.8
[root@master ~]# gem --version
2.0.14.1
[root@master ~]# pip3 --version
pip 9.0.3 from /usr/lib/python3.6/site-packages (python 3.6)
# 可以先用 wget 命令下载依赖文件
[root@master ~]# ll
-rw-r--r--. 1 root root 92672 May 30 15:24 coderay-1.1.3.gem
-rw-r--r--. 1 root root 13824 Mar 19 21:11 method_source-1.0.0.gem
-rw-r--r--. 1 root root 155136 Apr 12 15:35 pry-0.13.1.gem
[root@master ~]# gem install --local coderay-1.1.3.gem
[root@master ~]# gem install --local method_source-1.0.0.gem
[root@master ~]# gem install --local pry-0.13.1.gem
[root@master ~]# pry --version
Pry version 0.13.1 on Ruby 2.0.0
[1] pry(main)> puts "Hello World"
Hello World
=> nil
[2] pry(main)>
Hello World
pry（或者自带的 irb，pry 会更好用一些）可以打开 Ruby 控制台，就像在命令行输入 python3 会进入 Python 命令行一样。话不多说，先来个 Hello world 看看！哇，这俩货的 Hello world 用法都是一样的，你敢信？除了 Ruby 的输出多一个 => nil 之外，好像确实没什么区别，这儿的 nil 你可以把它当成 Python3 里边的 None，也就是箭头 => 右边的 nil 是它的返回值。毕竟这儿只是输出个字符串，自然没什么好返回的。还有一点，Ruby 使用 true 和 false 表示真和假，Python3 使用 True 和 False表示真和假，看起来 Ruby 确实更简化些，至少敲字符的时候省去了摁住 Shift 键的烦恼。
# Ruby
[root@master ~]# pry
[1] pry(main)> print "Hello World"
Hello World=> nil
[2] pry(main)> # Python3
[root@master ~]# python3
Python 3.6.8 (default, Aug 7 2019, 17:28:10)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-39)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print("Hello World")
Hello World
先不要慌，咱们继续往下看，Ruby 的输出有 print ，puts，p，可见花样是玩出了新高度的，四则运算这块好像区别也不大，只不过涉及到除法的时候，Python3 输出的结果是 Float 型的，如果是 Python2，就和这儿的 Ruby 是一样的了：
# Ruby
irb(main):001:0> puts "Hello World"
Hello World
=> nil
# 注意输出的字符串和返回的 nil 没在同一行，相当于输出后换行了
irb(main):002:0> p "Hello World"
"Hello World"
=> "Hello World"
# 注意字符串给自动添加上了双引号，告诉你输出的是个 “字符串”，而且返回值不是 nil 了语法特点
括号
Ruby 语法特点是括号能去掉的它就去掉了（这种特点让他的语法更像是介于 Shell 和 Python之间），比如数组反转（print，puts, p之类），使用的时候可加可不加括号（不强制！如果你之前习惯了 Shell 的语法，你可能习惯性不加括号；如果你之前习惯了 Python3 的语法，你可能习惯性加上括号）：
[136] pry(main)> names
=> ["I", "am", "Looking"]
[137] pry(main)> names.reverse
=> ["Looking", "am", "I"]
[138] pry(main)> names.reverse()
=> ["Looking", "am", "I"]
[139] pry(main)> names
=> ["I", "am", "Looking"]
[140] pry(main)> print "Hello World"
Hello World=> nil
[141] pry(main)> print("Hello World")
Hello World=> nil
就算括号实在不愿去掉或者实在没法去掉，也尽量让你少摁 ←键，比如就出现了下面这种 names.[]0 的骚操作：
[134] pry(main)> names
=> ["I", "am", "Looking"]
[142] pry(main)> names[0]
=> "I"
[135] pry(main)> names.[]0
=> "I"
而 Python 在 Python3 以后更加强调加括号表示调用，不加括号表示引用，所以在 Python3 以后的版本都不支持（不兼容） print "Hello World" 了，必须用 print("Hello World") 才可以。
[root@master ~]# python
Python 2.7.5 (default, Jun 20 2019, 20:27:34)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-36)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> print "Hello World"
Hello World
>>>
[6]+ Stopped python
[root@master ~]# python3
Python 3.6.8 (default, Aug 7 2019, 17:28:10)
[GCC 4.8.5 20150623 (Red Hat 4.8.5-39)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> print "Hello World"
File "<stdin>", line 1
print "Hello World"
^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello World")?
>>>
end
Ruby另外一个特点应该就是那些个数不清的 end 了，当然 end 也不是Ruby独有的，像MATLAB之类的，语法也有这种特点（这样的话，代码是否能运行就不依赖于缩进了）。
! 和 ？
可以把它当做一种默认的约定的规范， 只是为了根据语意实现自释义，所以一般来说大家都愿意遵守这种规范。
“！”，这个符号通常情况下本身就有小心警告的意思。因此，方法调用如果使用没有叹号结尾的方法，你在调用它的时候会得到当前对象的一个拷贝而不会修改原始对象，而如果使用带有叹号的方法，你在调用它的时候会直接修改当前对象的值（这个时候要时刻提醒自己注意原对象的改变）。
[78] pry(main)> company_name = "Dunder Mifflin"
=> "Dunder Mifflin"
[79] pry(main)> company_name.upcase
=> "DUNDER MIFFLIN"
[80] pry(main)> company_name
=> "Dunder Mifflin"
[81] pry(main)> company_name.upcase!
=> "DUNDER MIFFLIN"
[82] pry(main)> company_name
=> "DUNDER MIFFLIN"
[31] pry(main)> names = ["I", "am", "Looking"]
=> ["I", "am", "Looking"]
[32] pry(main)> names.reverse
=> ["Looking", "am", "I"]
[33] pry(main)> names
=> ["I", "am", "Looking"]
[34] pry(main)> names.reverse!
=> ["Looking", "am", "I"]
[35] pry(main)> names
=> ["Looking", "am", "I"]
“？”，被用于标示谓词，即返回Boolean值的方法，如Array.empty?（判断数组中元素是否为空），当然自己定义方法的时候如果返回布尔类型的话也可以加上“？”。
[84] pry(main)> array = [1, 2, 3, 4, 5]
=> [1, 2, 3, 4, 5]
[86] pry(main)> array.empty?
=> false
# eg
[99] pry(main)> def success?(field)
[99] pry(main)* field.size > 5 ? true : false
[99] pry(main)* end
=> nil
[100] pry(main)> success?([1, 2])
=> false
[101] pry(main)> success?([1, 2, 3, 4, 5, 6])
=> true
[103] pry(main)>
return
更严谨的说，Ruby 的方法也是尽可能不用 return，除非迫不得已（比如要提前返回一些东西）。有点像用括号一样，一般默认返回方法里边最后一个表达式的值。
# Ruby
def return_test
"hello world"
"I am Looking"
end
return_result = return_test
puts return_result
D:\Ruby23-x64\bin\ruby.exe D:/MyProject/Ruby/workspace/test.rb
I am Looking
Process finished with exit code 0
--------------------------------------------------------------------------------
def return_test
return "hello world"
"I am Looking"
end
return_result = return_test
puts return_result
D:\Ruby23-x64\bin\ruby.exe D:/MyProject/Ruby/workspace/test.rb
hello world
Process finished with exit code 0当然，Python 也可以不用 return，除非你不需要函数返回任何东西。
# Python3
def return_test():
"hello world"
"I am Looking"
return_result = return_test()
print(return_result)
"D:\Program Files\Python36\python3.exe" D:/MyProject/Python/workspace/test.py
None
Process finished with exit code 0
--------------------------------------------------------------------------------
def return_test():
return "hello world"
"I am Looking"
return_result = return_test()
print(return_result)
"D:\Program Files\Python36\python3.exe" D:/MyProject/Python/workspace/test.py
hello world
Process finished with exit code 0注释
单行注释都使用 # ，多行注释稍有差别
# Ruby
# This is a comment
=begin
This is a multi-line comment.
The beginning line must start with "=begin"
and the ending line must start with "=end".
You can do this, or start each line in
a multi-line comment with the # character.
=end
puts "Hello World"# Python
# Single line comments start with a number symbol.
"""
Multiline strings can be written
using three "s, and are often used
as documentation.
"""
print("Hello World")
基本四则运算
# Ruby
irb(main):011:0> 1
=> 1
irb(main):012:0> 100
=> 100
irb(main):013:0> 3.1415
=> 3.1415
irb(main):014:0> 1 + 1
=> 2
irb(main):015:0> 2 - 3
=> -1
irb(main):016:0> 5 * 10
=> 50
irb(main):017:0> 100 / 4
=> 25
irb(main):018:0> 20 + 8 / 2
=> 24
irb(main):019:0> (20 + 8) / 2
=> 14
irb(main):020:0> 2 ** 3
=> 8
irb(main):021:0> Math.sin(3.1415)
=> 9.265358966049026e-05
irb(main):022:0> Math.sqrt(10000)
=> 100.0
# Python3
>>> 1
1
>>> 100
100
>>> 3.1415
3.1415
>>> 1 + 1
2
>>> 2 - 3
-1
>>> 5 * 10
50
>>> 100 / 4
25.0
>>> 20 + 8 / 2
24.0
>>> (20 + 8) / 2
14.0
>>> 2 ** 3
8
>>> math.sin(3.1415)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'math' is not defined
>>> import math
>>> math.sin(3.1415)
9.265358966049026e-05
>>> math.sqrt(10000)
100.0
变量和对象
# Ruby
[1] pry(main)> true
=> true
[2] pry(main)> false
=> false
[3] pry(main)> nil
=> nil
[4] pry(main)> true.class
=> TrueClass
[5] pry(main)> false.class
=> FalseClass
[6] pry(main)> nil.class
=> NilClass
[11] pry(main)> !false
=> true
[12] pry(main)> !!false
=> false
[13] pry(main)> !true
=> false
[14] pry(main)> !!true
=> true
[15] pry(main)> !nil
=> true
[16] pry(main)> !!nil
=> false
[17] pry(main)> !0
=> false
[18] pry(main)> !!0
=> true
[19] pry(main)> !""
(pry):19: warning: string literal in condition
=> false
[20] pry(main)> !!""
(pry):20: warning: string literal in condition
=> true
[23] pry(main)> "hello " << "world"
=> "hello world"
[24] pry(main)> "hello " + "world"
=> "hello world"
[11] pry(main)> # 变量的作用域通过我们对它的命名进行定义
[12] pry(main)> # 以 $ 开头的变量为全局变量
[13] pry(main)> $var = "I'm a global var"
=> "I'm a global var"
[14] pry(main)> defined? $var #=> "global-variable"
=> "global-variable"
[15] pry(main)>
[16] pry(main)> # 以 @ 开头的变量为实例变量
[17] pry(main)> @var = "I'm an instance var"
=> "I'm an instance var"
[18] pry(main)> defined? @var #=> "instance-variable"
=> "instance-variable"
[19] pry(main)>
[20] pry(main)> # 以 @@ 开头的变量为类变量
[21] pry(main)> @@var = "I'm a class var"
=> "class variable"
[30] pry(main)> defined? @@var #=> "class variable"
=> "class variable"
[23] pry(main)>
[24] pry(main)> # 以大写字母开头的为常量
[25] pry(main)> Var = "I'm a constant"
=> "I'm a constant"
[26] pry(main)> defined? Var
=> "constant"
# Python3
>>> True
True
>>> False
False
>>> None
>>> type(True)
<class 'bool'>
>>> type(False)
<class 'bool'>
>>> type(None)
<class 'NoneType'>
>>> not False
True
>>> not not False
False
>>> not True
False
>>> not not True
True
>>> not None
True
>>> not not None
False
>>> "hello " + "world"
'hello world'
比较运算
# Ruby
irb(main):022:0> 2 == 2
=> true
irb(main):023:0> 1 == 2
=> false
irb(main):024:0> 3 > 1
=> true
irb(main):025:0> 3 > 3
=> false
irb(main):026:0> 3 >= 3
=> true
irb(main):027:0> 3 < 1
=> false
irb(main):028:0> 3 < 3
=> false
irb(main):029:0> 3 <= 3
=> true
irb(main):030:0> "Ruby" == "Ruby"
=> true
irb(main):031:0> "Ruby" == "Python"
=> false
irb(main):032:0> 1 != 1
=> false
# Python3
>>> 2 == 2
True
>>> 1 == 2
False
>>> 3 > 1
True
>>> 3 > 3
False
>>> 3 >= 3
True
>>> 3 < 1
False
>>> 3 < 3
False
>>> 3 <= 3
True
>>> "Python" == "Python"
True
>>> "Python" == "Ruby"
False
>>> 1 != 1
False
添加判断
# Ruby
[71] pry(main)> if true
[71] pry(main)* 'if statement'
[71] pry(main)* elsif false
[71] pry(main)* 'else if, optional'
[71] pry(main)* else
[71] pry(main)* 'else, also optional'
[71] pry(main)* end
=> "if statement"
irb(main):033:0> a = 20
=> 20
[22] pry(main)> if a >= 10
[22] pry(main)* puts "bigger"
[22] pry(main)* else
[22] pry(main)* puts "smaller"
[22] pry(main)* end
bigger
=> nil
# 当然，对Ruby来说，缩进不缩进都无所谓啦，毕竟人家又不靠缩进吃饭，即使你像下面这么些也还是可以正常执行
# 不过，为了可读性，最好不要这么做啦！
irb(main):039:0> if a >= 10
irb(main):040:1> print "bigger"
irb(main):041:1> else
irb(main):042:1* print "smaller"
irb(main):043:1> end
bigger=> nil
irb(main):044:0> # Python3
# 记得一定要缩进哟
>>> if True:
... 'if statement'
... elif False:
... 'else if, optional'
... else:
... 'else, also optional'
...
'if statement'
>>> a = 20
>>> if a >= 10:
... print("bigger")
... else:
... print("smaller")
...
bigger循环比较
# Ruby
irb(main):044:0> i = 1
=> 1
irb(main):045:0> while i <= 10
irb(main):046:1> puts i
irb(main):047:1> i += 1
irb(main):048:1> end
1
2
3
4
5
6
7
8
9
10
=> nil
------------------------------------------------------------
irb(main):049:0> 10.times do
irb(main):050:1* puts "Hello World"
irb(main):051:1> end
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
=> 10
# Python3
>>> i = 1
>>> while i <= 10:
... print(i)
... i += 1
...
1
2
3
4
5
6
7
8
9
10
------------------------------------------------------------
>>> i = 1
>>> while i <= 10:
... print("Hello World")
... i += 1
...
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
Hello World
数组（列表）比较及元素遍历
数组字面量通过[]中以逗号分隔定义，且支持range定义。
- （1）数组通过[]索引访问
- （2）通过赋值操作插入、删除、替换元素
- （3）通过+，－号进行合并和删除元素，且集合做为新集合出现
- （4）通过<<号向原数据追加元素
- （5）通过*号重复数组元素
- （6）通过｜和&符号做并集和交集操作（注意顺序）
# Ruby
irb(main):052:0> names = ["I", "am", "Looking"]
=> ["I", "am", "Looking"]
irb(main):053:0> names[0]
=> "I"
[26] pry(main)> names.first
=> "I"
[64] pry(main)> names.[] 0 # 这个操作确实有点骚
=> "I"
irb(main):054:0> names[0] = "i"
=> "i"
irb(main):055:0> names
=> ["i", "am", "Looking"]
[27] pry(main)> names.last
=> "Looking"
[28] pry(main)> names[-1]
=> "Looking"
[66] pry(main)> names << "!"
=> ["I", "am", "Looking", "!"]
[67] pry(main)> names.push("!")
=> ["I", "am", "Looking", "!", "!"]
[70] pry(main)> names.include?("Looking")
=> true
irb(main):056:0> names.size
=> 3
irb(main):057:0> names.length
=> 3
[55] pry(main)> names
=> ["I", "am", "Looking"]
[56] pry(main)> names.reverse # 不会修改原数组
=> ["Looking", "am", "I"]
[57] pry(main)> names
=> ["I", "am", "Looking"]
[58] pry(main)> names.reverse! # 会修改原数组
=> ["Looking", "am", "I"]
[59] pry(main)> names
=> ["Looking", "am", "I"]
irb(main):058:0> names.each do |name|
irb(main):059:1* puts name
irb(main):060:1> end
i
am
Looking
=> ["i", "am", "Looking"]
[85] pry(main)> names.each_with_index do |element, index|
[85] pry(main)* puts "#{element} is number #{index} in the array"
[85] pry(main)* end
I is number 0 in the array
am is number 1 in the array
Looking is number 2 in the array
=> ["I", "am", "Looking"]
irb(main):064:0> names.each {
irb(main):065:1* puts "Hello World"
irb(main):066:1> }
Hello World
Hello World
Hello World
=> ["i", "am", "Looking"]
irb(main):067:0> names.each do
irb(main):068:1* puts "Hello World"
irb(main):069:1> end
Hello World
Hello World
Hello World
=> ["i", "am", "Looking"]
# Python3
>>> names = ["I", "am", "Looking"]
>>> names[0]
'I'
>>> names[0] = "i"
>>> names
['i', 'am', 'Looking']
>>> names[-1]
'Looking'
>>> len(names)
3
>>> names
['I', 'am', 'Looking']
>>> names.reverse() # 会修改原列表元素顺序
>>> names
['Looking', 'am', 'I']
>>> names = ["I", "am", "Looking"]
>>> names.append("!")
>>> names
['I', 'am', 'Looking', '!']
>>> "Looking" in names
True
>>> for name in names:
... print(name)
...
i
am
Looking
>>> for index, element in enumerate(names):
... print(f"{element} is number {index} in the array")
...
I is number 0 in the array
am is number 1 in the array
Looking is number 2 in the array
>>> for name in names:
... print("Hello World")
...
Hello World
Hello World
Hello World
散列（字典）比较
# Ruby
# Ruby当中符号也可以作为
irb(main):071:0> address = {name:"Looking", pinyin:"lukaiyi", postal:"405902"}
=> {:name=>"Looking", :pinyin=>"lukaiyi", :postal=>"405902"}
irb(main):074:0* address = {:name=>"Looking", :pinyin=>"lukaiyi", :postal=>"405902"}
=> {:name=>"Looking", :pinyin=>"lukaiyi", :postal=>"405902"}
irb(main):014:0> address[:name]
=> "Looking"
irb(main):015:0> address["name".to_sym]
=> "Looking"
irb(main):016:0>
# Ruby在好些地方加括号和不加括号区别不大，就比如 print， puts, p
# Python则不一样，加括号表示调用，不加括号表示引用，指向函数代码所在的地址
[73] pry(main)> address.keys
=> ["name", "pinyin", "postal"]
[74] pry(main)> address.keys()
=> ["name", "pinyin", "postal"]
[75] pry(main)> address.values
=> ["Looking", "lukaiyi", "405902"]
irb(main):007:0> address = {"name"=>"Looking", "pinyin"=>"lukaiyi", "postal"=>"405902"}
=> {"name"=>"Looking", "pinyin"=>"lukaiyi", "postal"=>"405902"}
irb(main):011:0> address["name"]
=> "Looking"
irb(main):012:0> address[:name.to_s]
=> "Looking"
irb(main):016:0> sym = :foo
=> :foo
irb(main):017:0> sym.to_s
=> "foo"
irb(main):018:0> "foo"
=> "foo"
irb(main):019:0> "foo".to_sym
=> :foo
irb(main):021:0> address[:tel] = "123456789"
=> "123456789"
irb(main):022:0> address
=> {:name=>"Looking", :pinyin=>"lukaiyi", :postal=>"405902", :tel=>"123456789"}
irb(main):023:0> address.each do |key, value|
irb(main):024:1* puts "#{key}: #{value}"
irb(main):025:1> end
name: Looking
pinyin: lukaiyi
postal: 405902
tel: 123456789
=> {:name=>"Looking", :pinyin=>"lukaiyi", :postal=>"405902", :tel=>"123456789"}
# Python3
# Python3 字典的 key 需要可哈希化
>>> address = {"name": "Looking", "pinyin":"lukaiyi", "postal":"405902"}
>>> address
{'name': 'Looking', 'pinyin': 'lukaiyi', 'postal': '405902'}
>>> address = dict(name="Looking", pinyin="lukaiyi", postal="405902")
>>> address
{'name': 'Looking', 'pinyin': 'lukaiyi', 'postal': '405902'}
# Ruby在好些地方加括号和不加括号区别不大，但是Python对这块倒是区分得很严格的
# Python加括号表示调用，不加括号表示引用，指向函数代码所在的地址
>>> address.keys()
dict_keys(['name', 'pinyin', 'postal'])
>>> address.keys
<built-in method keys of dict object at 0x7f3af9f405a0>
>>> address.values()
dict_values(['Looking', 'lukaiyi', '405902'])
>>> address.values
<built-in method values of dict object at 0x7f3af9f405a0>
>>> address["tel"] = "123456789"
>>> address
{'name': 'Looking', 'pinyin': 'lukaiyi', 'postal': '405902', 'tel': '123456789'}
>>> for key, value in address.items():
... print(key, ":", value)
...
name : Looking
pinyin : lukaiyi
postal : 405902
tel : 123456789
字符串与模式匹配
# Ruby
irb(main):026:0> /cde/ =~ "abcdefgh"
=> 2
irb(main):027:0> /Cde/ =~ "abcdefgh"
=> nil
irb(main):028:0> /Cde/i =~ "abcdefgh"
=> 2
irb(main):029:0> /Cde/i =~ "abcdEfgh"
=> 2
irb(main):031:0> names = ["Looking", "Luck", "John"]
=> ["Looking", "Luck", "John"]
irb(main):032:0> names.each do |name|
irb(main):033:1* if /o/ =~ name
irb(main):034:2> puts name
irb(main):035:2> end
irb(main):036:1> end
Looking
John
=> ["Looking", "Luck", "John"]
# Python3
>>> "abcdefgh".find("cde")
2
>>> "abcdefgh".find("Cde")
-1
>>> "abcdefgh".find("Cde".lower())
2
>>> "abcdefgh".lower().find("Cde".lower())
2
>>> names = ["Looking", "Luck", "John"]
>>> for name in names:
... if 'o' in name:
... print(name)
...
Looking
John
变量比较
变量在使用之前都需要先赋值，这应该是它们的相同点了。
# Ruby
sub.rb
$x = 1 #对全局变量赋值
x = 1 #对本地量赋值
test.rb
$x = 0
x = 0
require './sub'
p $x
p x
D:\Ruby23-x64\bin\ruby.exe D:/MyProject/Ruby/workspace/test.rb
1
0
Process finished with exit code 0
------------------------------------------------------------
irb(main):037:0> x + 1
NameError: undefined local variable or method `x' for main:Object
from (irb):37
from /usr/bin/irb:12:in `<main>'
# Ruby使用全大写来表示常量，常量重新赋值的话还会报警告消息。
irb(main):038:0> TEST = 1
=> 1
irb(main):039:0> TEST = 2
(irb):39: warning: already initialized constant TEST
(irb):38: warning: previous definition of TEST was here
=> 2
------------------------------------------------------------
# 保留字重新赋值会提示语法错误，Python3也不例外
irb(main):041:0> if = 1
SyntaxError: (irb):41: syntax error, unexpected '='
if = 1
^
from /usr/bin/irb:12:in `<main>'
------------------------------------------------------------
irb(main):043:0> a, b, c = 1, 2, 3
=> [1, 2, 3]
irb(main):044:0> a, b, c = 1, 2, 3, 4
=> [1, 2, 3, 4]
irb(main):045:0> c
=> 3
irb(main):046:0> a, b, *c = 1, 2, 3, 4
=> [1, 2, 3, 4]
irb(main):047:0> a, b = b, a
=> [2, 1]
irb(main):048:0> c
=> [3, 4]
# Python3
>>> x + 1
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'x' is not defined
------------------------------------------------------------
# Python3一般也使用全大写来表示常量，但是你要改的话就该，反正不关我们Python的事儿，我就当你知道你在做什么就是了。
>>> TEST = 1
>>> TEST = 2
------------------------------------------------------------
>>> if = 1
File "<stdin>", line 1
if = 1
^
SyntaxError: invalid syntax
------------------------------------------------------------
>>> a, b, c = 1, 2, 3
>>> a, b, c = 1, 2, 3, 4
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 3)
>>> a, b, *c = 1, 2, 3, 4
>>> a, b
(1, 2)
>>> a, b = b, a
>>> a, b
(2, 1)
>>> c
[3, 4]
常用循环函数
# Ruby
[87] pry(main)> doubled = array.map do |element|
[87] pry(main)* element * 2
[87] pry(main)* end
=> [2, 4, 6, 8, 10]
[91] pry(main)> array.map {|s| s. * 2}
=> [2, 4, 6, 8, 10]
[93] pry(main)> array.inject(0) {|sum, n| sum + n } # 括号的0表示sum的初始值，可不写，不写的时候括号也可以去掉
=> 15
[92] pry(main)> array.reduce(:+)
=> 15
[98] pry(main)> a = ["FOO", "BAR", "BAZ"]
=> ["FOO", "BAR", "BAZ"]
[99] pry(main)> a.map{|s| s.downcase}
=> ["foo", "bar", "baz"]
[100] pry(main)> a.map(&:downcase)
=> ["foo", "bar", "baz"]
[101] pry(main)> a
=> ["FOO", "BAR", "BAZ"]# Python3
>>> [ 2*x for x in array]
[2, 4, 6, 8, 10]
>>> array = [1, 2, 3, 4, 5]
>>> list(map(lambda x: 2*x, array))
[2, 4, 6, 8, 10]
>>> list(filter(lambda x: x>3, array))
[4, 5]
>>> from functools import reduce
>>> reduce(lambda x, y: x + y, array)
15
>>> a = ["FOO", "BAR", "BAZ"]
>>> [x.lower() for x in a]
['foo', 'bar', 'baz']
>>> list(map(lambda x:x.lower(), a))
['foo', 'bar', 'baz']
>>> a
['FOO', 'BAR', 'BAZ']
unless，case，until 结构
对不起，Python 表示我没这些花里胡哨的东东，直接用 not 它不香吗？多出的这些单词大家不认识怎么办？（/哈哈）
# Ruby
[102] pry(main)> a = 10
=> 10
[103] pry(main)> b = 20
=> 20
[104] pry(main)> unless a > b
[104] pry(main)* puts "a not greater than b"
[104] pry(main)* else
[104] pry(main)* puts "a greater than b"
[104] pry(main)* end
a not greater than b
=> nil
------------------------------------------------------------
[105] pry(main)> grade = 82
=> 82
[106] pry(main)> case grade
[106] pry(main)* when 90..100
[106] pry(main)* puts 'Hooray!'
[106] pry(main)* when 80...90
[106] pry(main)* puts 'OK job'
[106] pry(main)* else
[106] pry(main)* puts 'You failed!'
[106] pry(main)* end
OK job
=> nil
# 注意 m..n 语法的细节哟！中间两个点表示包含左右两端的数，三个点的话不包含右边的数哟！
[113] pry(main)> (80..90).include?(80)
=> true
[114] pry(main)> (80..90).include?(90)
=> true
[119] pry(main)> (80...90).include?(80)
=> true
[120] pry(main)> (80...90).include?(90)
=> false
------------------------------------------------------------
[121] pry(main)> sum = 0
=> 0
[122] pry(main)> i = 1
=> 1
[123] pry(main)> while sum < 50
[123] pry(main)* sum += i
[123] pry(main)* i += 1
[123] pry(main)* end
=> nil
[124] pry(main)> puts sum
55
=> nil
[125] pry(main)> sum = 0
=> 0
[126] pry(main)> i = 1
=> 1
[127] pry(main)> until sum >= 50
[127] pry(main)* sum += i
[127] pry(main)* i += 1
[127] pry(main)* end
=> nil
[128] pry(main)> puts sum
55
=> nil
# Python3
>>> if not a > b:
... print("a not greater than b")
... else:
... print("a greater than b")
...
a not greater than b
------------------------------------------------------------
>>> grade = 82
>>> if 90 <= grade <= 100:
... print('Hooray!')
... elif 80 <= grade < 90:
... print('OK job')
... else:
... print('You failed!')
...
OK job
------------------------------------------------------------
# Ruby 里边有的说用 not 不直观，反正我真的没看出来哪点不直观
>>> sum = 0
>>> i = 1
>>> while not sum >= 50:
... sum += i
... i += 1
...
>>> print(sum)
55
异常处理
两种语言异常处理的对应关系大家自己慢慢看哟，除了名字意外，其实也差不错的。
# Ruby
[148] pry(main)> begin
[148] pry(main)* # Code here that might raise an exception
[148] pry(main)* raise NoMemoryError, 'You ran out of memory.'
[148] pry(main)* rescue NoMemoryError => exception_variable
[148] pry(main)* puts 'NoMemoryError was raised', exception_variable
[148] pry(main)* rescue RuntimeError => other_exception_variable
[148] pry(main)* puts 'RuntimeError was raised now'
[148] pry(main)* else
[148] pry(main)* puts 'This runs if no exceptions were thrown at all'
[148] pry(main)* ensure
[148] pry(main)* puts 'This code always runs no matter what'
[148] pry(main)* end
NoMemoryError was raised
You ran out of memory.
This code always runs no matter what
=> nil
# Python3
>>> try:
... # Code here that might raise an exception
... raise MemoryError('Your ran out of memory.')
... except MemoryError as exception_variable:
... print("MemoryError was raised", exception_variable, sep='\n')
... except RuntimeError as other_exception_variable:
... print("RuntimeError was raised now")
... else:
... print("This runs if no exceptions were thrown at all")
... finally:
... print("This code always runs no matter what")
...
MemoryError was raised
Your ran out of memory.
This code always runs no matter what
方法（函数）
# Ruby
[1] pry(main)> def double(x)
[1] pry(main)* x * 2
[1] pry(main)* end
=> nil
[2] pry(main)> double(2)
=> 4
[3] pry(main)> double 3
=> 6
[4] pry(main)> double double 3
=> 12
[1] pry(main)> def sum(x, y)
[1] pry(main)* x + y
[1] pry(main)* end
=> nil
[2] pry(main)> sum 3, 4
=> 7
[3] pry(main)> sum sum(3, 4), 5
=> 12
[4] pry(main)> def surround
[4] pry(main)* puts '{'
[4] pry(main)* yield
[4] pry(main)* puts '}'
[4] pry(main)* end
=> nil
[5] pry(main)>
[6] pry(main)> surround { puts 'hello world' }
{
hello world
}
=> nil
# 这儿对块简单的理解就是在原来 yield 的地方执行了块里边的语句
# yield 后边如果有参数的话，也可以传递到块里边去
[34] pry(main)> def guests
[34] pry(main)* yield 4
[34] pry(main)* end
=> nil
[35] pry(main)> guests{|n| "You have #{n} guests."}
=> "You have 4 guests."
# 但是如果方法的最后一个参数前带有 &，那么您可以向该方法传递一个块。
# 而且这个块可被赋给最后一个参数。如果 * 和 & 同时出现在参数列表中，& 应放在后面。
[23] pry(main)> def guests(&block)
[23] pry(main)* block.call(4)
[23] pry(main)* end
=> nil
[24] pry(main)> guests{|n| "You have #{n} guests."}
=> "You have 4 guests."
# Python3
>>> def double(x):
... return x * 2
...
>>> double(2)
4
>>> double(3)
6
>>> double(double(3))
12
>>> def sum(x, y):
... return x + y
...
>>> sum(3, 4)
7
>>> sum(sum(3, 4), 5)
12
参数的匹配和解包
这块这两种语言用法是类似的
# Ruby
# 当 * 和 ** 符号出现在函数定义的参数中时，表示任意数目参数收集
[39] pry(main)> def guests(*array)
[39] pry(main)* array.each { |guest| puts guest }
[39] pry(main)* end
=> nil
[42] pry(main)> guests('hello', 'world')
hello
world
=> ["hello", "world"]
# * 和 ** 符号出现在函数调用的参数中时，表示会解包参数的集合
[44] pry(main)> def guests(a, b, c, d)
[44] pry(main)* puts a, b, c, d
[44] pry(main)* end
=> nil
[46] pry(main)> guests(*['hello', 'world', 'ruby', 'python'])
hello
world
ruby
python
=> nil
# 解包和匹配合体示例
[1] pry(main)> def best(first, second, third, *others)
[1] pry(main)* puts "Winners are #{first}, #{second}, and #{third}."
[1] pry(main)* puts "There were #{others.count} other participants."
[1] pry(main)* end
=> nil
[2] pry(main)> ranked_competitors = ["John", "Sally", "Dingus", "Moe", "Marcy"]
=> ["John", "Sally", "Dingus", "Moe", "Marcy"]
[3] pry(main)> best *ranked_competitors
Winners are John, Sally, and Dingus.
There were 2 other participants.
=> nil
# Python3
>>> def guests(*array):
... for guest in array:
... print(guest)
...
# 当 * 和 ** 符号出现在函数定义的参数中时，表示任意数目参数收集
>>> guests('hello', 'world')
hello
world
>>> def guests(a, b, c, d):
... print(a, b, c, d, sep='\n')
...
# * 和 ** 符号出现在函数调用的参数中时，表示会解包参数的集合
>>> guests(*['hello', 'world', 'ruby', 'python'])
hello
world
ruby
python
# 解包和匹配合体示例
>>> def best(first, second, third, *others):
... print(f"Winners are, {first}, {second} and {third}.")
... print(f"There were {len(others)} other participants.")
...
>>> best(*ranked_competitors)
Winners are, John, Sally and Dingus.
There were 2 other participants.map，reduce 和 reject（filter）
这儿的话就 reject 和 filter 稍微有点差别，一个是排除满足条件的（reject），一个是筛选出满足条件的（filter）。
# Ruby
[50] pry(main)> array = ['Watch', 'these', 'words', 'get', 'upcased']
=> ["Watch", "these", "words", "get", "upcased"]
[51] pry(main)> array.map(&:upcase)
=> ["WATCH", "THESE", "WORDS", "GET", "UPCASED"]
[52] pry(main)> array.map do |item|
[52] pry(main)* item.upcase!
[52] pry(main)* end
=> ["WATCH", "THESE", "WORDS", "GET", "UPCASED"]
[57] pry(main)> array = [1, 2, 3, 4, 5]
=> [1, 2, 3, 4, 5]
[59] pry(main)> sum = array.reduce(&:+)
=> 15
[60] pry(main)> multiplication = array.reduce(&:*)
=> 120
[61] pry(main)>
[67] pry(main)> array = [1, 2, 3, 4, 5]
=> [1, 2, 3, 4, 5]
[68] pry(main)> array.reject{|x| x < 4}
=> [4, 5]
# Python3
>>> array = ['Watch', 'these', 'words', 'get', 'upcased']
>>> array
['Watch', 'these', 'words', 'get', 'upcased']
>>> list(map(lambda x: x.upper(), array))
['WATCH', 'THESE', 'WORDS', 'GET', 'UPCASED']
>>> from functools import reduce
>>> array = [1, 2, 3, 4, 5]
>>> sum = reduce(lambda x, y: x + y, array)
>>> sum
15
>>> multiplication = reduce(lambda x, y: x * y, array)
>>> multiplication
120
>>> array = [1, 2, 3, 4, 5]
>>> list(filter(lambda x: x < 4, array))
[1, 2, 3]类
# Ruby
class Human
# 类变量，被类的所有实例共享
@@species = 'H. sapiens'
# 初始化
def initialize(name, age = 0)
# 实例变量初始化, 实例变量无法脱离方法进行声明和定义
@name = name
# 如果 age 没有，取默认值
@age = age
end
# set 方法
def name=(name)
@name = name
end
# get 方法
def name
@name
end
# attr_accessor相当于attr_reader和attr_writer的合集，实际上是在定义类成员变量的时候就给他定义了一个get和set方法。
attr_accessor :age
# 在ruby中，类成员变量都是私有的，不能直接通过（类名.成员变量名）这样来对成员变量值进行操作。
# get/set 方法也可以像下面这么单独创建，如果没有创建的话，不能按照如下这样使用：
# 实例对象.age
# 实例对象.age = 2
attr_reader :age # get
attr_writer :age # set
def say_something(msg) # 实例方法
puts msg
end
# 类方法通过 self 与实例方法进行区分，只能通过类进行调用
def self.say(msg)
puts msg
end
# 可以通过类方法或者实例方法修改类变量
# 实例方法
def modify_species(new_species)
@@species = new_species
end
def species
@@species
end
end
# Instantiating of a class
jim = Human.new('Jim Halpert')
dwight = Human.new('Dwight K. Schrute')
# You can call the methods of the generated object.
puts jim.species #=> "H. sapiens"
puts jim.name #=> "Jim Halpert"
jim.name = "Jim Halpert II" #=> "Jim Halpert II"
puts jim.name #=> "Jim Halpert II"
puts dwight.species #=> "H. sapiens"
puts dwight.name #=> "Dwight K. Schrute"
# 调用类方法
Human.say('Hi') #=> "Hi"
jim.say_something("Hello") #=> "Hello"
jim.modify_species("animals")
puts jim.species #=> "animals"
jim.modify_species("H. sapiens")
puts jim.species #=> "H. sapiens"
puts jim.age #=> 0
jim.age = 5
puts jim.age #=> 5# Python3
class Human:
# 类属性，被类的所有实例共享
species = "H. sapiens"
def __init__(self, name, age=0):
self.name = name
self._age = age
# An instance method. All methods take "self" as the first argument
def say(self, msg):
print("{name}: {message}".format(name=self.name, message=msg))
# Another instance method
def sing(self):
return 'yo... yo... microphone check... one two... one two...'
# A class method is shared among all instances
# They are called with the calling class as the first argument
@classmethod
def get_species(cls):
return cls.species
# A static method is called without a class or instance reference
@staticmethod
def grunt():
return "*grunt*"
# A property is just like a getter.
# It turns the method age() into an read-only attribute of the same name.
# There's no need to write trivial getters and setters in Python, though.
@property # getter
def age(self):
return self._age
# This allows the property to be set
@age.setter
def age(self, age):
self._age = age
# This allows the property to be deleted
@age.deleter
def age(self):
del self._age
# 当 Python 解释器读取一个源码文件时，它会执行其中所有代码
# 用 __name__ 确保这个代码块只有为主程序时才执行。
if __name__ == '__main__':
i = Human(name="Ian")
i.say("hi") # "Ian: hi"
j = Human("Joel")
j.say("hello") # "Joel: hello"
i.say(i.get_species()) # "Ian: H. sapiens"
Human.species = "H. neanderthalensis"
i.say(i.get_species()) # => "Ian: H. neanderthalensis"
j.say(j.get_species()) # => "Joel: H. neanderthalensis"
# 通过类调用静态方法
print(Human.grunt()) # => "*grunt*"
# 通过实例对象调用静态方法
print(i.grunt()) # => "*grunt*"
# 更新实例属性
i.age = 42
# 获取属性
i.say(i.age) # => "Ian: 42"
j.say(j.age) # => "Joel: 0"
# 删除属性
del i.age
--------------------------------------------------------------------------------
class Human:
species = 'H. sapiens'
def __init__(self, name, age=0):
self.name = name
self.age = age
# 实例方法，第一个参数需要是self，它表示一个具体的实例对象本身，因为方法可能用的实例本身的一些变量
def instance_method(self):
print(f"Hello, I am instance_method, my name is {self.name}")
# 如果用staticmethod装饰，那么就可以无视这个self，而将这个方法当成一个普通的函数使用
@staticmethod
def static_method():
print("Hello, I am static_method")
return "Hello, I am static_method"
# 如果用classmethod，它的第一个参数是cls，它表示这个类本身，可以通过类名进行调用
# 可在类方法中使用静态方法
@classmethod
def class_method(cls):
print(cls.static_method() + " called by class_method")
print("Hello, I am class_method")
jim = Human('Jim Halpert')
dwight = Human('Dwight K. Schrute')
print(jim.species)
print(Human.species)
jim.instance_method()
jim.static_method()
Human.static_method()
Human.class_method()
"D:\Program Files\Python36\python3.exe" D:/MyProject/Python/workspace/test.py
H. sapiens
H. sapiens
Hello, I am instance_method, my name is Jim Halpert
Hello, I am static_method
Hello, I am static_method
Hello, I am static_method
Hello, I am static_method called by class_method
Hello, I am class_method
Process finished with exit code 0子类
# Ruby
# 基类
class Human
@@foo = 0
# 下面这两个函数类似于类变量的 get/set 方法
def self.foo
@@foo
end
def self.foo=(value)
@@foo = value
end
end
# 派生类（子类）
class Worker < Human
end
puts Human.foo #=> 0
puts Worker.foo #=> 0
# 类变量被它的所有子类共享
puts Human.foo = 2
puts Worker.foo #=> 2
--------------------------------------------------------------------------------
class Human
@bar = 0
def self.bar
@bar
end
def self.bar=(value)
@bar = value
end
end
class Doctor < Human
end
# 类实例变量不被子类所共享
Human.bar #=> 0
Doctor.bar #=> nil# Python3
class Human:
# 类属性，被类的所有实例共享
species = "H. sapiens"
def __init__(self, name, age=0):
self.name = name
self._age = age
# An instance method. All methods take "self" as the first argument
def say(self, msg):
print("{name}: {message}".format(name=self.name, message=msg))
# Another instance method
def sing(self):
return 'yo... yo... microphone check... one two... one two...'
# A class method is shared among all instances
# They are called with the calling class as the first argument
@classmethod
def get_species(cls):
return cls.species
# A static method is called without a class or instance reference
@staticmethod
def grunt():
return "*grunt*"
# A property is just like a getter.
# It turns the method age() into an read-only attribute of the same name.
# There's no need to write trivial getters and setters in Python, though.
@property # getter
def age(self):
return self._age
# This allows the property to be set
@age.setter
def age(self, age):
self._age = age
# This allows the property to be deleted
@age.deleter
def age(self):
del self._age
class Superhero(Human):
species = 'Superhuman'
def __init__(self, name, movie=False,
superpowers=["super strength", "bulletproofing"]):
# add additional class attributes:
self.fictional = True
self.movie = movie
# be aware of mutable default values, since defaults are shared
self.superpowers = superpowers
super().__init__(name) # 调用父类的初始化函数
# override the sing method
def sing(self):
return 'Dun, dun, DUN!'
# add an additional instance method
def boast(self):
for power in self.superpowers:
print("I wield the power of {pow}!".format(pow=power))
if __name__ == '__main__':
sup = Superhero(name="Tick")
# Instance type checks
if isinstance(sup, Human):
print('I am human') # 超级英雄也是人，所以实例化的对象仍然是父类的一个实例
if type(sup) is Superhero:
print('I am a superhero')
# 子类会优先去自己类本身找相应的方法和属性，找不到才到父类继续寻找
print(sup.get_species()) # => Superhuman
# Calls overridden method
print(sup.sing()) # => Dun, dun, DUN!
# Calls method from Human
sup.say('Spoon') # => Tick: Spoon
# Call method that exists only in Superhero
sup.boast() # => I wield the power of super strength!
# => I wield the power of bulletproofing!
# Inherited class attribute
sup.age = 31
print(sup.age) # => 31
# Attribute that only exists within Superhero
print('Am I Oscar eligible? ' + str(sup.movie))module
简单理解你就把他当成一个 namespace （命名空间），这样在调用的时候不至于太混乱。
# Ruby
# trig.rb
module Trig
PI = 3.141592654
def Trig.sin(x)
Math.sin(x)
end
def Trig.cos(x)
Math.cos(x)
end
end
--------------------------------------------------------------------------------
# moral.rb
module Moral
VERY_BAD = 0
BAD = 1
def Moral.sin(badness)
Math.sin(badness)
end
end
--------------------------------------------------------------------------------
# test.rb
$LOAD_PATH << '.'
# $LOAD_PATH << '.' 让 Ruby 知道必须在当前目录中搜索被引用的文件
require 'trig.rb'
require 'moral'
y = Trig.sin(Trig::PI/4)
wrongdoing = Moral.sin(Moral::VERY_BAD)
puts y, wrongdoing
D:\Ruby23-x64\bin\ruby.exe D:/MyProject/Ruby/workspace/test.rb
0.7071067812590626
0.0
Process finished with exit code 0
--------------------------------------------------------------------------------
# Ruby
module ModuleExample
def foo
'foo'
end
end
# include modules 将他们的方法和类实例进行绑定（也即只能通过生成的实例来进行调用）
# extend modules 将他们的方法和类本身进行绑定 （也即只能通过类本身进行调用）
class Person
include ModuleExample
end
class Book
extend ModuleExample
end
puts Person.foo #=> NoMethodError: undefined method `foo' for Person:Class
puts Person.new.foo #=> "foo"
puts Book.foo #=> "foo"
puts Book.new.foo #=> NoMethodError: undefined method `foo'
--------------------------------------------------------------------------------
module ConcernExample
def self.included(base)
base.extend(ClassMethods)
base.send(:include, InstanceMethods)
end
module ClassMethods
def bar
'bar'
end
end
module InstanceMethods
def qux
'qux'
end
end
end
class Something
include ConcernExample
end
puts Something.bar #=> "bar"
puts Something.qux #=> NoMethodError: undefined method `qux'
puts Something.new.bar #=> NoMethodError: undefined method `bar'
puts Something.new.qux #=> "qux"
JSON文件解析
新建 input.json 文件
# input.json
{
"President": "Alan Isaac",
"CEO": "David Richardson",
"India": [
"Sachin Tendulkar",
"Virender Sehwag",
"Gautam Gambhir"
],
"Srilanka": [
"Lasith Malinga",
"Angelo Mathews",
"Kumar Sangakkara"
],
"England": [
"Alastair Cook",
"Jonathan Trott",
"Kevin Pietersen"
]
}# Ruby
[1] pry(main)> require 'json'
=> true
[2] pry(main)> require 'pp'
=> false
[3] pry(main)> json = File.read('input.json')
=> "{\n \"President\": \"Alan Isaac\",\n \"CEO\": \"David Richardson\",\n \n \"India\": [\n \"Sachin Tendulkar\",\n \"Virender Sehwag\",\n \"Gautam Gambhir\"\n ],\n \n \"Srilanka\": [\n \"Lasith Malinga\",\n \"Angelo Mathews\",\n \"Kumar Sangakkara\"\n ],\n \n \"England\": [\n \"Alastair Cook\",\n \"Jonathan Trott\",\n \"Kevin Pietersen\"\n ]\n}\n"
[4] pry(main)> obj = JSON.parse(json)
=> {"President"=>"Alan Isaac",
"CEO"=>"David Richardson",
"India"=>["Sachin Tendulkar", "Virender Sehwag", "Gautam Gambhir"],
"Srilanka"=>["Lasith Malinga", "Angelo Mathews", "Kumar Sangakkara"],
"England"=>["Alastair Cook", "Jonathan Trott", "Kevin Pietersen"]}
[5] pry(main)> obj['President']
=> "Alan Isaac"
# Python3
>>> import json
>>> with open('input.json', 'r') as f:
... data = json.load(f)
...
>>> data
{'President': 'Alan Isaac', 'CEO': 'David Richardson', 'India': ['Sachin Tendulkar', 'Virender Sehwag', 'Gautam Gambhir'], 'Srilanka': ['Lasith Malinga', 'Angelo Mathews', 'Kumar Sangakkara'], 'England': ['Alastair Cook', 'Jonathan Trott', 'Kevin Pietersen']}
>>> type(data)
<class 'dict'>
>>> data['President']
'Alan Isaac'目录遍历
# Ruby
parentDir = 'D:\\MyProject\\Python\\DataStructure\\DataSet2014\\'
def find_all_file(filepath)
if File.directory?(filepath)
Dir.foreach(filepath) do |filename|
if filename != "." and filename != ".."
find_all_file(filepath + "\\" + filename)
end
end
else
puts filepath
end
end
find_all_file parentDir# Python3
import os
parentDir = 'D:\\MyProject\\Python\\DataStructure\\DataSet2014'
def find_all_file(parentDir):
if os.path.isdir(parentDir):
dir_list = os.listdir(parentDir)
paths = [os.path.join('%s\\%s' % (parentDir, tt)) for tt in dir_list]
for path in paths:
find_all_file(path)
else:
print(parentDir)
find_all_file(parentDir)