Ruby：映射哈希

在Python中，我可以使用列表理解创建一个测试哈希，并对照一组测试进行检查。如何在ruby中实现同样的功能？我正在运行ruby 1.9.3

Python:

Ruby尝试：

---

你想要的是：

test = {}
(1..5).map { |i| test[i] = @investor.annual_return(i) }

---

你想要的是：

test = {}
(1..5).map { |i| test[i] = @investor.annual_return(i) }

---

如果我正确理解您的意图，您可以尝试以下方法：

{}.tap { |x| (1..5).each do |y| x[y] = @investor.annual_return(i) end }

---

如果我正确理解您的意图，您可以尝试以下方法：

{}.tap { |x| (1..5).each do |y| x[y] = @investor.annual_return(i) end }

---

我认为您的Ruby代码很好，这取决于您运行的Ruby版本

首先是：

class Investor
  def annual_return(i)
    i * i
  end
end

investor = Investor.new

在Ruby 1.9+中，这将起作用：

test = Hash[ (1..5).map { |x| [x, investor.annual_return(x)] } ]
test # => {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}

但是，在1.9版本之前，哈希不会转换包含键/值对的数组，因此我们必须更进一步，将嵌套元素展平为单个数组，然后将这些元素分解为哈希：

test = Hash[ *(1..5).map { |x| [x, investor.annual_return(x)] }.flatten ]
test # => {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}

结果是一样的，只是现在麻烦少了

为了说明Ruby在以这种方式构建散列时的作用：

(1..5).map { |x| [x, investor.annual_return(x)] }
# => [[1, 1], [2, 4], [3, 9], [4, 16], [5, 25]]

(1..5).map { |x| [x, investor.annual_return(x)] }.flatten
# => [1, 1, 2, 4, 3, 9, 4, 16, 5, 25]

---

我认为您的Ruby代码很好，这取决于您运行的Ruby版本

首先是：

class Investor
  def annual_return(i)
    i * i
  end
end

investor = Investor.new

在Ruby 1.9+中，这将起作用：

test = Hash[ (1..5).map { |x| [x, investor.annual_return(x)] } ]
test # => {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}

但是，在1.9版本之前，哈希不会转换包含键/值对的数组，因此我们必须更进一步，将嵌套元素展平为单个数组，然后将这些元素分解为哈希：

test = Hash[ *(1..5).map { |x| [x, investor.annual_return(x)] }.flatten ]
test # => {1=>1, 2=>4, 3=>9, 4=>16, 5=>25}

结果是一样的，只是现在麻烦少了

为了说明Ruby在以这种方式构建散列时的作用：

(1..5).map { |x| [x, investor.annual_return(x)] }
# => [[1, 1], [2, 4], [3, 9], [4, 16], [5, 25]]

(1..5).map { |x| [x, investor.annual_return(x)] }.flatten
# => [1, 1, 2, 4, 3, 9, 4, 16, 5, 25]

你经常看到：

test = (1..5).reduce({}) {|h, x| h[x] = @investor.annual_return(x); h}

但由于Ruby 1.9，许多人更喜欢：

部分原因是不需要像aka inject那样将对象h返回到迭代器。

您经常会看到：

test = (1..5).reduce({}) {|h, x| h[x] = @investor.annual_return(x); h}

但由于Ruby 1.9，许多人更喜欢：

---

部分原因是不需要像aka inject那样将对象h返回到迭代器。

您可以通过以下方法轻松完成：

(1..5).map { |x| [x, @investor.annual_return(x)] }.to_h

文件：

---

哈希[*array]用于从平面数组[key1，value1，key2，value2，keyN，valueN]构造哈希，而Arrayto_h用于从键值对数组[[key1，value1]，[key2，value2]，[keyN，valueN]构造哈希。

(1..5).map { |x| [x, @investor.annual_return(x)] }.to_h

文件：

---

散列[*array]用于从平面数组[key1，value1，key2，value2，keyN，valueN]构造散列，而Arrayto_h用于从键值对数组[[key1，value1]，[key2，value2]，[keyN，valueN]]构造散列。

因此，您希望将1到6映射到self.investor.annual_return1到self.investor.annual_return6{1=>self.investor.annual\u return1，2=>self.investor.annual\u return2…？annual\u return提取一个数组的值，该数组计算复利值。在这种情况下，我映射一个散列来创建这个值，而实际上不必键入：1=>10720.00，2=>11491.84，3=>12319.25，4=>13206.24，5=>14517.09然后@ennukiller就是answ呃，你需要。我必须查找列表理解，但维基百科中的定义似乎包含了一个谓词子句，我在你的示例中没有看到。在迭代1到5中，将数字作为键，并将该数字的函数返回值作为值，但只有当某个谓词子句也为真时，他们的python示例是：S=[2*x表示范围101中的x，如果x**2>3]，其Ruby示例为：1..100.选择{x}x**2>3}.收集{x}2*x}是的，你目前的答案和@ennuikiller的答案是一样的。我不认为Rubyists会用他的方式而不是你的方式来创建散列。但是看到你的方式，我实际上更喜欢它。我想听听铁杆Rubyists为什么两种方式都更好，因为到目前为止，我在学习Ru的过程中，他是唯一真正使用的方式嗯，我明白你的意思了。我会继续考虑它，并考虑你所说的。这个实现似乎使我所有的测试都通过了并且是安全的，我确保哈希打印出预期的结果：{ 1＝＞10720，2＝＞11491.84，3＝12319.25，4＝13206.24，5＝＞14157.09 }。因此，您希望将1到6映射到self.investor.annual_return1到self.investor.annual_return6作为{1=>self.investor.annual\u return1，2=>self.investor.annual\u return2…？annual\u return提取一个数组的值，该数组计算复利值。在这种情况下，我映射一个散列来创建这个值，而实际上不必键入：1=>10720.00，2=>11491.84，3=>12319.25，4=>13206.24，5=>14517.09然后@ennukiller就是answ呃，你需要。我必须查找列表理解，但维基百科中的定义似乎包含了一个谓词子句，我在你的示例中没有看到。在迭代1到5中，将数字作为键，并将该数字的函数返回值作为值，但只有当某个谓词子句也为真时，他们的python示例是：S=[2*x表示范围101中的x，如果x**2>3]，他们的Ruby示例是：1..100.选择{x}x**x**2>3}.收集{x}是的，你当前的答案和@ennuikiller的答案是一样的。我会冒险认为Rubyists会用他的方式而不是你的方式创建哈希。但是看到你的方式

---

实际上，我更喜欢它。我想听听那些铁杆红宝石爱好者为什么两种方法都更好，因为到目前为止，我在学习红宝石的过程中只看到了他的方法。嗯，我明白你的意思。我会坚持下去，仔细考虑你所说的话。这个实现似乎让我所有的测试都通过了，为了安全起见，我确保哈希打印出了预期的结果：{1=>10720.0，2=>11491.84，3=>12319.25，4=>13206.24，5=>14157.09}我一直在胡闹，我刚刚想出了一个合适的解决方案。这有点棘手，因为Ruby没有与Python的Dict理解相同的设置。你觉得我的实现怎么样？不要使用map，使用每个。虽然map将像each一样在该范围内迭代，但它将尝试在迭代时返回分配给test[i]的所有生成值的数组，这将浪费CPU时间。每个迭代器都是一个简单的迭代器，不会返回数组，因此效率更高。我一直在研究它，我刚刚想出了一个合适的解决方案。这有点棘手，因为Ruby没有与Python的Dict理解相同的设置。你觉得我的实现怎么样？不要使用map，使用每个。虽然map将像each一样在该范围内迭代，但它将尝试在迭代时返回分配给test[i]的所有生成值的数组，这将浪费CPU时间。每个都是一个简单的迭代器，不会返回数组，因此效率更高。我明白了，我感谢您的解释！我明白了，我很感激你的解释！天哪，这更容易理解。我在第一次使用reduce时尝试了它，但语法不正确。我只是对| x，h | h[x]的向后处理感到困惑。天哪，这更容易理解。我在第一次使用reduce时尝试了它，但语法不正确。我只是对| x，h | h[x]的向后处理感到困惑。