Ruby 学习笔记（和 Python3 语法进行对比）-白红宇

Ruby 学习笔记（和 Python3 语法进行对比）

阅读量：4230 次

发布时间：2019-05-26

本文共 44054 字，大约阅读时间需要 146 分钟。

我是先接触 Python3 的，如果我自己主动来选择，可能不会再去学 Ruby（可能先入为主的思想太根深蒂固了，不过最主要的还是太懒了），然鹅由于种种原因，我还是要来看一下Ruby（真是天理难容，/大哭/大哭/大哭），虽然大家都说 Ruby 和 Python 的语法差不多（好像确实如此——不过既然如此，为何要弄两个来折磨大家呢？），所以学习的时候我准备把这两种语言的语法对比一下（给自己找点看下去的动力），毕竟语言不过是解决问题的工具，没什么好坏之分（强行安慰一下自己）。至于开发工具嘛！JetBrains 的全家桶真香，Ruby 和 Python 分别用 RubyMine 和 PyCharm 就好。

Ruby on rails 是 Ruby 的 Web 应用程序框架，据说很牛掰，不过咱也不知道咱也不敢问，等我后面接触到了再说，目前的话，就先当个 surprise 期待着吧！好东西自然分享给大家了，下面的参考资料很不错的哟，也是本文的主要参考资料：

learn x in y minutes where x= Ruby ：

learn x in y minutes where x= Python ：

Ruby 代码风格指南：

Ruby 源码安装

解压一个安装包，进入解压文件夹。

[root@master packages]# ll | grep ruby-2.7.1drwxr-xr-x. 28 root    root         8192 Aug 23 14:52 ruby-2.7.1-rw-r--r--.  1 root    root     16816471 Mar 31 21:12 ruby-2.7.1.tar.gz[root@master packages]# cd ruby-2.7.1[root@master ruby-2.7.1]# pwd/root/packages/ruby-2.7.1

编译安装：

[root@master ~]# ./configure --prefix=/usr/local/ruby-2.7.1[root@master ~]# make && make install

添加以下软连接，否则可能提示找不到：

[root@master packages]# ln -fs /usr/local/ruby-2.7.1/bin/ruby /usr/bin/ruby[root@master packages]# ln -fs /usr/local/ruby-2.7.1/bin/gem /usr/bin/gem[root@master packages]# ln -fs /usr/local/ruby-2.7.1/bin/bundle /usr/bin/bundle

安装完成：

[root@master ~]# ruby -vruby 2.7.1p83 (2020-03-31 revision a0c7c23c9c) [x86_64-linux][root@master ~]# gem -v3.1.2[root@master ~]# bundle -vBundler version 2.1.4

我是在 centOS 虚拟机安装的解释器，可以使用 yum install ruby 命令安装，但是安装的可能不是最新的：

Ruby 依赖包安装

依赖包的话就使用 gem install 命令进行安装，有时候由于网络和墙的原因会一直卡住不动，不过也可以手动下载依赖包进行安装，比如说我安装 pry 的时候就碰到了这种情况，最后手动下载 .gem 文件安装成功（记得添加 --local 参数哟，表示你想使用本地文件进行安装，不然 gem 又会从源地址去下载去了）：

[root@master packages]# gem install --local pry-0.13.1.gem Successfully installed method_source-1.0.0Successfully installed coderay-1.1.3Successfully installed pry-0.13.1Parsing documentation for method_source-1.0.0Installing ri documentation for method_source-1.0.0invalid options: -SNw2(invalid options are ignored)Parsing documentation for coderay-1.1.3Installing ri documentation for coderay-1.1.3Parsing documentation for pry-0.13.1Installing ri documentation for pry-0.13.1Done installing documentation for method_source, coderay, pry after 3 seconds3 gems installed

安装后版本如下：

[root@master ~]# ruby --versionruby 2.0.0p648 (2015-12-16) [x86_64-linux][root@master ~]# python3 --versionPython 3.6.8[root@master ~]# gem --version2.0.14.1[root@master ~]# pip3 --versionpip 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 --versionPry 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 ~]# python3Python 3.6.8 (default, Aug  7 2019, 17:28:10) [GCC 4.8.5 20150623 (Red Hat 4.8.5-39)] on linuxType "help", "copyright", "credits" or "license" for more information.>>> print("Hello World")Hello World

先不要慌，咱们继续往下看，Ruby 的输出有 print ，puts，p，可见花样是玩出了新高度的，四则运算这块好像区别也不大，只不过涉及到除法的时候，Python3 输出的结果是 Float 型的，如果是 Python2，就和这儿的 Ruby 是一样的了：

# Rubyirb(main):001:0> puts "Hello World"Hello World=> nil# 注意输出的字符串和返回的 nil 没在同一行，相当于输出后换行了irb(main):002:0> p "Hello World""Hello World"=> "Hello World"# 注意字符串给自动添加上了双引号，告诉你输出的是个 “字符串”，而且返回值不是 nil 了

Here Document

# test.rbputs <<~EOF  this is the first line  this is the second lineEOF[root@master ruby_learning]# ruby test.rbthis is the first linethis is the second line------------------------------------------------------# test.rbputs <<-EOF  this is the first line  this is the second lineEOF[root@master ruby_learning]# ruby test.rb  this is the first line  this is the second line

Proc （lambda）

Proc 和 lambda 的区别

# lambda 函数参数检查更为严格[1] pry(main)> prc1 = Proc.new do |a, b, c|[1] pry(main)*   puts [a, b, c].inspect[1] pry(main)* end  => #
   
    [2] pry(main)> prc1.call(1, 2)[1, 2, nil]=> nil[3] pry(main)> prc2 = lambda do |a, b, c|[3] pry(main)*   puts [a, b, c].inspect[3] pry(main)* end  => #
    
     [4] pry(main)> prc2.call(1, 2)ArgumentError: wrong number of arguments (given 2, expected 3)from (pry):5:in "block in __pry__"------------------------------------------------------------# lambda 可以用 return 返回值[5] pry(main)> def power_of(n)[5] pry(main)*   lambda do |x|[5] pry(main)*     return x ** n[5] pry(main)*   end  [5] pry(main)* end  => :power_of[6] pry(main)> cube = power_of(3)=> #
     
      [7] pry(main)> cube.call(5)=> 125[8] pry(main)> def power_of(n)[8] pry(main)*   Proc.new do |x|[8] pry(main)*     return x ** n[8] pry(main)*   end  [8] pry(main)* end  => :power_of[9] pry(main)> cube = power_of(3)=> #
      
       [10] pry(main)> cube.call(5)LocalJumpError: unexpected returnfrom (pry):18:in `block in power_of'

Proc 自定义带块函数

[11] pry(main)> def total(from, to, &block)[11] pry(main)*   result = 0  [11] pry(main)*   from.upto(to) do |num|  [11] pry(main)*     if block    [11] pry(main)*       result += block.call(num)      [11] pry(main)*     else  [11] pry(main)*       result += num[11] pry(main)*     end  [11] pry(main)*   end  [11] pry(main)*   return result[11] pry(main)* end  => :total[12] pry(main)> total(1, 10)=> 55[13] pry(main)> total(1, 10) { |num| num ** 2 }=> 385

%Q, %q, %W, %w, %x, %r, %s, %i

边界符号可以用如下其他符号替换

|...|, #...#, !...!, +...+, (...), [...], <...>, /.../

# Ruby[8] pry(main)> name = "Ruby"=> "Ruby"[9] pry(main)> %Q{hello, my name is #{name}}=> "hello, my name is Ruby"[10] pry(main)> %q{hello, my name is #{name}}=> "hello, my name is \#{name}"[15] pry(main)> %W{hello world #{name}}=> ["hello", "world", "Ruby"][16] pry(main)> %w{hello world #{name}}=> ["hello", "world", "\#{name}"][17] pry(main)> %x{ls}=> "debugtest.rb\ngrep.rb\ntest1.txt\ntest2.rb\ntest.py\ntest.rb\ntest.txt\n"[18] pry(main)> what_ruby = 'this is ruby'=> "this is ruby"[19] pry(main)> %r{/home/#{what_ruby}}=> /\/home\/this is ruby/[20] pry(main)> %s{hello}=> :hello[21] pry(main)> %i{hello world}=> [:hello, :world]

语法特点

括号

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 ~]# pythonPython 2.7.5 (default, Jun 20 2019, 20:27:34) [GCC 4.8.5 20150623 (Red Hat 4.8.5-36)] on linux2Type "help", "copyright", "credits" or "license" for more information.>>> print "Hello World"Hello World>>> [6]+  Stopped                 python[root@master ~]# python3Python 3.6.8 (default, Aug  7 2019, 17:28:10) [GCC 4.8.5 20150623 (Red Hat 4.8.5-39)] on linuxType "help", "copyright", "credits" or "license" for more information.>>> print "Hello World"  File "
   
    ", 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，除非迫不得已（比如要提前返回一些东西）。有点像用括号一样，一般默认返回方法里边最后一个表达式的值。

# Rubydef return_test  "hello world"  "I am Looking"endreturn_result = return_testputs return_resultD:\Ruby23-x64\bin\ruby.exe D:/MyProject/Ruby/workspace/test.rbI am LookingProcess finished with exit code 0--------------------------------------------------------------------------------def return_test  return "hello world"  "I am Looking"endreturn_result = return_testputs return_resultD:\Ruby23-x64\bin\ruby.exe D:/MyProject/Ruby/workspace/test.rbhello worldProcess finished with exit code 0

当然，Python 也可以不用 return，除非你不需要函数返回任何东西。

# Python3def 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.pyNoneProcess 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.pyhello worldProcess finished with exit code 0

注释

单行注释都使用 # ，多行注释稍有差别

# Ruby# This is a comment=beginThis 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 ina multi-line comment with the # character.=endputs "Hello World"

# Python# Single line comments start with a number symbol."""Multiline strings can be writtenusing three "s, and are often usedas documentation."""print("Hello World")

基本四则运算

# Rubyirb(main):011:0> 1=> 1irb(main):012:0> 100=> 100irb(main):013:0> 3.1415=> 3.1415irb(main):014:0> 1 + 1=> 2irb(main):015:0> 2 - 3=> -1irb(main):016:0> 5 * 10=> 50irb(main):017:0> 100 / 4=> 25irb(main):018:0> 20 + 8 / 2=> 24irb(main):019:0> (20 + 8) / 2=> 14irb(main):020:0> 2 ** 3=> 8irb(main):021:0> Math.sin(3.1415)=> 9.265358966049026e-05irb(main):022:0> Math.sqrt(10000)=> 100.0

# Python3>>> 11>>> 100100>>> 3.14153.1415>>> 1 + 12>>> 2 - 3-1>>> 5 * 1050>>> 100 / 425.0>>> 20 + 8 / 224.0>>> (20 + 8) / 214.0>>> 2 ** 38>>> math.sin(3.1415)Traceback (most recent call last):  File "
   
    ", line 1, in 
    
     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>>> TrueTrue>>> FalseFalse>>> None>>> type(True)
   
    >>> type(False)
    
     >>> type(None)
     
      >>> not FalseTrue>>> not not FalseFalse>>> not TrueFalse>>> not not TrueTrue>>> not NoneTrue>>> not not NoneFalse>>> "hello " + "world"'hello world'

比较运算

# Rubyirb(main):022:0> 2 == 2=> trueirb(main):023:0> 1 == 2=> falseirb(main):024:0> 3 > 1=> trueirb(main):025:0> 3 > 3=> falseirb(main):026:0> 3 >= 3=> trueirb(main):027:0> 3 < 1=> falseirb(main):028:0> 3 < 3=> falseirb(main):029:0> 3 <= 3=> trueirb(main):030:0> "Ruby" == "Ruby"=> trueirb(main):031:0> "Ruby" == "Python"=> falseirb(main):032:0> 1 != 1=> false

# Python3>>> 2 == 2True>>> 1 == 2False>>> 3 > 1True>>> 3 > 3False>>> 3 >= 3True>>> 3 < 1False>>> 3 < 3False>>> 3 <= 3True>>> "Python" == "Python"True>>> "Python" == "Ruby"False>>> 1 != 1False

添加判断

# 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 >= 10irb(main):040:1> print "bigger"irb(main):041:1> elseirb(main):042:1* print "smaller"irb(main):043:1> endbigger=> nilirb(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

循环比较

# Rubyirb(main):044:0> i = 1=> 1irb(main):045:0> while i <= 10irb(main):046:1>     puts iirb(main):047:1>     i += 1irb(main):048:1> end12345678910=> nil------------------------------------------------------------irb(main):049:0> 10.times do irb(main):050:1*    puts "Hello World"irb(main):051:1> endHello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello World=> 10

# Python3>>> i = 1>>> while i <= 10:...     print(i)...     i += 1... 12345678910------------------------------------------------------------>>> i = 1>>> while i <= 10:...     print("Hello World")...     i += 1... Hello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello WorldHello World

数组（列表）比较及元素遍历

数组字面量通过[]中以逗号分隔定义，且支持range定义。

（1）数组通过[]索引访问

（2）通过赋值操作插入、删除、替换元素

（3）通过+，－号进行合并和删除元素，且集合做为新集合出现

（4）通过<<号向原数据追加元素

（5）通过*号重复数组元素

（6）通过｜和&符号做并集和交集操作（注意顺序）

# Rubyirb(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")=> trueirb(main):056:0> names.size=> 3irb(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 nameirb(main):060:1> endiamLooking=> ["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 arrayam is number 1 in the arrayLooking 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 WorldHello WorldHello World=> ["i", "am", "Looking"]irb(main):067:0> names.each doirb(main):068:1*     puts "Hello World"irb(main):069:1> endHello WorldHello WorldHello 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 namesTrue>>> for name in names:...     print(name)... iamLooking>>> for index, element in enumerate(names):...     print(f"{element} is number {index} in the array")... I is number 0 in the arrayam is number 1 in the arrayLooking is number 2 in the array>>> for name in names:...     print("Hello World")... Hello WorldHello WorldHello 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=> :fooirb(main):017:0> sym.to_s=> "foo"irb(main):018:0> "foo"=> "foo"irb(main):019:0> "foo".to_sym=> :fooirb(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> endname: Lookingpinyin: lukaiyipostal: 405902tel: 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
   
    >>> address.values()dict_values(['Looking', 'lukaiyi', '405902'])>>> address.values
    
     >>> address["tel"] = "123456789">>> address{'name': 'Looking', 'pinyin': 'lukaiyi', 'postal': '405902', 'tel': '123456789'}>>> for key, value in address.items():...     print(key, ":", value)... name : Lookingpinyin : lukaiyipostal : 405902tel : 123456789

字符串与模式匹配

# Rubyirb(main):026:0> /cde/ =~ "abcdefgh"=> 2irb(main):027:0> /Cde/ =~ "abcdefgh"=> nilirb(main):028:0> /Cde/i =~ "abcdefgh"=> 2irb(main):029:0> /Cde/i =~ "abcdEfgh"=> 2irb(main):031:0> names = ["Looking", "Luck", "John"]=> ["Looking", "Luck", "John"]irb(main):032:0> names.each do |name|irb(main):033:1*   if /o/ =~ nameirb(main):034:2>     puts nameirb(main):035:2>   endirb(main):036:1> endLookingJohn=> ["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)... LookingJohn

变量比较

变量在使用之前都需要先赋值，这应该是它们的相同点了。

# Rubysub.rb$x = 1 #对全局变量赋值x = 1 #对本地量赋值test.rb$x = 0x = 0require './sub'p $xp xD:\Ruby23-x64\bin\ruby.exe D:/MyProject/Ruby/workspace/test.rb10Process finished with exit code 0------------------------------------------------------------irb(main):037:0> x + 1NameError: undefined local variable or method `x' for main:Object	from (irb):37	from /usr/bin/irb:12:in `
   
    '# Ruby使用全大写来表示常量，常量重新赋值的话还会报警告消息。irb(main):038:0> TEST = 1=> 1irb(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 = 1SyntaxError: (irb):41: syntax error, unexpected '='if = 1    ^	from /usr/bin/irb:12:in `
    
     '------------------------------------------------------------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=> 3irb(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 + 1Traceback (most recent call last):  File "
   
    ", line 1, in 
    
     NameError: name 'x' is not defined------------------------------------------------------------# Python3一般也使用全大写来表示常量，但是你要改的话就该，反正不关我们Python的事儿，我就当你知道你在做什么就是了。>>> TEST = 1>>> TEST = 2------------------------------------------------------------>>> if = 1  File "
     
      ", line 1    if = 1       ^SyntaxError: invalid syntax------------------------------------------------------------>>> a, b, c = 1, 2, 3>>> a, b, c = 1, 2, 3, 4Traceback (most recent call last):  File "
      
       ", line 1, in 
       
        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 sum55=> 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 sum55=> 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 raisedYou 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 raisedYour 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')helloworld=> ["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'])helloworldrubypython=> 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')helloworld>>> def guests(a, b, c, d):...     print(a, b, c, d, sep='\n')... # * 和 ** 符号出现在函数调用的参数中时，表示会解包参数的集合>>> guests(*['hello', 'world', 'ruby', 'python'])helloworldrubypython# 解包和匹配合体示例>>> 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 和 select（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.select{|x| x < 4}=> [1, 2, 3]

# 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)>>> sum15>>> multiplication = reduce(lambda x, y: x * y, array)>>> multiplication120>>> array = [1, 2, 3, 4, 5]>>> list(filter(lambda x: x < 4, array))[1, 2, 3]

类

# Rubyclass 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  endend# Instantiating of a classjim = 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 #=> 0jim.age = 5puts jim.age #=> 5

# Python3class 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.pyH. sapiensH. sapiensHello, I am instance_method, my name is Jim HalpertHello, I am static_methodHello, I am static_methodHello, I am static_methodHello, I am static_method called by class_methodHello, I am class_methodProcess finished with exit code 0

子类

# Ruby# 基类class Human  @@foo = 0  # 下面这两个函数类似于类变量的 get/set 方法  def self.foo    @@foo  end  def self.foo=(value)    @@foo = value  endend# 派生类（子类）class Worker < Humanendputs Human.foo #=> 0puts Worker.foo #=> 0# 类变量被它的所有子类共享puts Human.foo = 2puts Worker.foo #=> 2--------------------------------------------------------------------------------class Human  @bar = 0  def self.bar    @bar  end  def self.bar=(value)    @bar = value  endendclass Doctor < Humanend# 类实例变量不被子类所共享Human.bar #=> 0Doctor.bar #=> nil

# Python3class 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._ageclass 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.rbmodule Trig  PI = 3.141592654  def Trig.sin(x)    Math.sin(x)  end  def Trig.cos(x)    Math.cos(x)  endend--------------------------------------------------------------------------------# moral.rbmodule Moral  VERY_BAD = 0  BAD = 1  def Moral.sin(badness)    Math.sin(badness)  endend--------------------------------------------------------------------------------# 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, wrongdoingD:\Ruby23-x64\bin\ruby.exe D:/MyProject/Ruby/workspace/test.rb0.70710678125906260.0Process finished with exit code 0--------------------------------------------------------------------------------# Rubymodule ModuleExample  def foo    'foo'  endend# include modules 将他们的方法和类实例进行绑定（也即只能通过生成的实例来进行调用）# extend modules 将他们的方法和类本身进行绑定 （也即只能通过类本身进行调用）class Person  include ModuleExampleendclass Book  extend ModuleExampleendputs Person.foo     #=> NoMethodError: undefined method `foo' for Person:Classputs 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  endendclass Something  include ConcernExampleendputs 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)
   
    >>> data['President']'Alan Isaac'

目录遍历

# RubyparentDir = '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  endendfind_all_file parentDir

# Python3import osparentDir = '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)

命令行参数解析

# Rubyrequire 'optparse'options = {}OptionParser.new do |opts|  opts.banner = 'here is help messages of the command line tool.'  options[:switch] = false  opts.on('-s', '--switch', 'Set options as switch') do    options[:switch] = true  end  opts.on('-n NAME', '--name Name', 'Pass-in single name') do |value|    options[:name] = value  end  opts.on('-a A,B', '--array A,B', Array, 'List of arguments') do |value|    options[:array] = value  endend.parse!puts options.inspect------------------------------------------------------------D:\MyProject\Ruby\workspace>ruby test.rb -hhere is help messages of the command line tool.    -s, --switch                     Set options as switch    -n, --name Name                  Pass-in single name    -a, --array A,B                  List of argumentsD:\MyProject\Ruby\workspace>ruby test.rb -s{:switch=>true}D:\MyProject\Ruby\workspace>ruby test.rb -n Looking{:switch=>false, :name=>"Looking"}D:\MyProject\Ruby\workspace>ruby test.rb -a Ruby, Python{:switch=>false, :array=>["Ruby"]}D:\MyProject\Ruby\workspace>ruby test.rb -a Ruby,Python{:switch=>false, :array=>["Ruby", "Python"]}

转载地址：http://ycjqi.baihongyu.com/

你可能感兴趣的文章

HTML Professional Projects

查看>>

Python Cookbook, Second Edition

查看>>

Java Extreme Programming Cookbook

查看>>

XSLT Cookbook

查看>>

Java Programming with Oracle JDBC

查看>>