02-ruby-basics/02.07-hashes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Hash"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "散列表 `Hash`，在一些编程语言中也称为 `Dictionary`， `Map` ，是一种由键值对组成的数据结构。\n",
    "\n",
    "我们把键想象成字典中的单词，值想象成词对应的定义，那么—— 一个词可以对应一个或者多个定义，但是这些定义只能通过这个词来进行查询。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 基本操作"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 空 `Hash`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ruby** 使用 `{}` 或者 `Hash.new()` 来创建一个空的 `Hash`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hash"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = {}\n",
    "h.class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Hash"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = Hash.new()\n",
    "h.class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有了 `Hash` 之后，可以用索引键值的方法向其中添加元素，也可以通过索引来查看元素的值："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 插入键值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"one\"=>\"this is number 1\", \"two\"=>\"this is number 2\"}"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h[\"one\"] = \"this is number 1\"\n",
    "h[\"two\"] = \"this is number 2\"\n",
    "h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 查看键值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"this is number 1\""
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h['one']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 更新键值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{\"one\"=>\"this is number 1, too\", \"two\"=>\"this is number 2\"}"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h[\"one\"] = \"this is number 1, too\"\n",
    "h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 初始化 `Hash`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到，**Ruby** 使用`key => value`这样的结构来表示 `Hash` 中的元素结构，事实上，可以直接使用这样的结构来初始化一个 `Hash`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"this is number 1\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = {'one' => 'this is number 1', 'two' => 'this is number 2'}\n",
    "b['one']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Hash` 顺序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ruby** 中 `Hash` 默认实现会帮我们维护插入的顺序，当使用 `puts` 方法时，会按照插入键值的先后顺序进行显示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"one\"=>\"this is number 1, too\", \"two\"=>\"this is number 2\"}\n"
     ]
    }
   ],
   "source": [
    "puts h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"one\"=>\"this is number 1\", \"two\"=>\"this is number 2\"}\n"
     ]
    }
   ],
   "source": [
    "puts b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因此，**Ruby**中不能用支持用数字索引按顺序查看 `Hash` 中的值，而且数字本身也有可能成为键值，这样会引起混淆："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "[\"one\", \"this is number 1, too\"]\n"
     ]
    }
   ],
   "source": [
    "puts h[0] == nil\n",
    "puts h.to_a[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 键类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "出于`hash`效率的目的，键值我们最好使用不可变类型，因为**Ruby**中**String**是可变的，一般建议在用到**String**作为键值的场景，替换为**Symbol**。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{:one=>\"this is number 1\", :two=>\"this is number 2\"}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h1 = {:one => 'this is number 1', :two => 'this is number 2'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "等价于："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{:one=>\"this is number 1\", :two=>\"this is number 2\"}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h2 = {one: 'this is number 1', two: 'this is number 2'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "this is number 1\n",
      "this is number 2\n"
     ]
    }
   ],
   "source": [
    "puts h1 == h2\n",
    "\n",
    "puts h1[:one]\n",
    "puts h2[:two]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在不可变类型中，`Integer` 和 `Symbol` 是 `Hash` 中最常用的类型；而 `Float` 通常不推荐用来做键，原因如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n",
      "{3.3000000000000003=>6.6}\n"
     ]
    }
   ],
   "source": [
    "data = {}\n",
    "data[1.1 + 2.2] = 6.6\n",
    "\n",
    "puts data[3.3] == nil\n",
    "puts data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "事实上，观察`data`的值就会发现，这个错误是由浮点数的精度问题所引起的："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `Hash` 方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  `fetch` 方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "之前已经见过，用索引可以找到一个键对应的值，但是当 `Hash` 中没有这个键的时候，会返回 `nil`，如果需要键值找不到的时候抛 `KeyError` 异常，这时候可以使用 `Hash` 的 `fetch` 方法来处理这种情况，其用法如下：\n",
    "\n",
    "    `h.fetch(key [,default])`\n",
    "\n",
    "返回 `Hash` 中键 `key` 对应的值，如果没有这个键，返回 `default` 指定的值（如果不指定，则抛 `KeyError` 异常）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"this is number 2\""
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h = {}\n",
    "h[:one] = \"this is number 1\"\n",
    "h[:two] = \"this is number 2\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "索引不存在的键值会返回 `nil`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "puts h[:three] == nil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "改用 `fetch` 方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Catch exception: key not found: :three\n"
     ]
    }
   ],
   "source": [
    "begin\n",
    "  print h.fetch(:three)\n",
    "rescue Exception => e\n",
    "  puts \"Catch exception: #{e}\"\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "指定默认值参数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"undefined\""
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.fetch(:three, \"undefined\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `delete` 方法删除元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`delete` 方法可以用来弹出 `Hsh` 中某个键对应的值，同时也可以指定默认参数：\n",
    "\n",
    "    `h.delete(key)`\n",
    "\n",
    "删除并返回 `Hash` 中键 `key` 对应的值，如果没有这个键，返回 `nil`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{:one=>\"this is number 1\", :two=>\"this is number 2\"}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "弹出并返回值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"this is number 2\""
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h.delete(:two)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{:one=>\"this is number 1\"}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "h"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "弹出不存在的键值："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "true\n"
     ]
    }
   ],
   "source": [
    "puts h.delete(:three) == nil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `update` 或 `merge!` 方法更新 `Hash`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "之前已经知道，可以通过索引来插入、修改单个键值对，但是如果想对多个键值对进行操作，这种方法就显得比较麻烦，好在有 `update` 或者 `merge!` 方法：\n",
    "\n",
    "```ruby\n",
    "h.update(other_hash)\n",
    "h.merge!(other_hash)\n",
    "```\n",
    "\n",
    "将 `Hash` `other_hash`中的内容更新到`h`中去。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{:first=>\"Jmes\", :last=>\"Zhan\", :born=>2012}\n"
     ]
    }
   ],
   "source": [
    "person = {}\n",
    "person[:first] = \"Jmes\"\n",
    "person[:last] = \"Zhan\"\n",
    "person[:born] = 2012\n",
    "puts person"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "把'first'改成'James'，同时插入'middle'的值'Clerk'："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{:first=>\"James\", :last=>\"Zhan\", :born=>2012, :middle=>\"Clerk\"}\n"
     ]
    }
   ],
   "source": [
    "person_modifications = {first: 'James', middle: 'Clerk'}\n",
    "person.merge!(person_modifications)\n",
    "puts person"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `has_key?` 查询 `Hash` 中是否有该键"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{:cows=>1, :dogs=>5, :cats=>3}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barn = {cows: 1, dogs: 5, cats: 3}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`has_key?`，`key?` 可以用来判断 `Hash` 中是否有某个特定的键："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barn.has_key?(:chickens)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barn.key?(:cows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `keys` 方法，`values`  方法和 `items`  方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`h.keys()` 返回一个由所有键组成的列表；\n",
    "\n",
    "`h.values()` 返回一个由所有值组成的列表；\n",
    "\n",
    "`h.entries()` 或者 `h.to_a()` 返回一个由所有键值对元组组成的列表；"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[:cows, :dogs, :cats]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barn.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 3]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barn.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[:cows, 1], [:dogs, 5], [:cats, 3]]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barn.entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[:cows, 1], [:dogs, 5], [:cats, 3]]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "barn.to_a()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Ruby 2.4.1",
   "language": "ruby",
   "name": "ruby"
  },
  "language_info": {
   "file_extension": ".rb",
   "mimetype": "application/x-ruby",
   "name": "ruby",
   "version": "2.4.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}