kaggle05loop.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "kaggle05loop.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMdoJctehKPIThynncFSXgF",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/kalz2q/mycolabnotebooks/blob/master/kaggle05loop.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENTj9XMzgHaX",
        "colab_type": "text"
      },
      "source": [
        "# kaggle05loop.ipynb"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5K849kXOfnPj",
        "colab_type": "text"
      },
      "source": [
        "# メモ\n",
        "\n",
        "1.  kaggleのPython tutorialをベスにColabのノートブックを作成している。\n",
        "1.  Colabで開いて読まれることを想定。\n",
        "1.  元ファイル (https://www.kaggle.com/colinmorris/loops-and-list-comprehensions )\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "toPQJDF61GHp",
        "colab_type": "text"
      },
      "source": [
        "# ループ\n",
        "\n",
        "ループは同じコードを繰り返し実行する方法のこと。\n",
        "\n",
        "例を示そう。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6gAT9C_j1SXR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "1065ce44-afe8-4a07-9132-2bf73654e489"
      },
      "source": [
        "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
        "for planet in planets:\n",
        "    print(planet, end=' ') # print all on same line"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Mercury Venus Earth Mars Jupiter Saturn Uranus Neptune "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QeUmaqxdgML9",
        "colab_type": "text"
      },
      "source": [
        "`for`ループでは次のようなことが行われる。\n",
        "\n",
        "* 使われる変数がしていされる。今回の場合`planet`\n",
        "* ループする値のセット。今回の場合は`planets`\n",
        "* `in`という単語を使っての変数と値のセットとのリンク\n",
        "\n",
        "`in`の右側に来るオブジェクトは繰り返しをサポートするものならなんでもよい。基本的にはなんらかのグループでループできるもの。リスト以外ではタプルも使える。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SIrqrLI6ALue",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "d273d604-26bf-4936-e0b5-854fdfbde75c"
      },
      "source": [
        "multiplicands = (2, 2, 2, 3, 3, 5)\n",
        "product = 1\n",
        "for mult in multiplicands:\n",
        "    product = product * mult\n",
        "\n",
        "product"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "360"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8IWJD-uVgPhd",
        "colab_type": "text"
      },
      "source": [
        "文字列の文字についてもループできる。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OplDO1YOAdr0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "50e9b00e-fbaf-40e2-80a8-6a67c3c74f0d"
      },
      "source": [
        "s = 'steganograpHy is the practicE of conceaLing a file, message, image, or video within another fiLe, message, image, Or video.'\n",
        "msg = ''\n",
        "# print all the uppercase letters in s, one at a time\n",
        "for char in s:\n",
        "    if char.isupper():\n",
        "        print(char, end='')      "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "HELLO"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sIQD561CgS6m",
        "colab_type": "text"
      },
      "source": [
        "### range()\n",
        "\n",
        "`range()`は数列をつくる関数で、ループを書くときに役に立つ。\n",
        "\n",
        "たとえば同じ作業を5回やりたいとする:\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "roiIh3eOBF2k",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 104
        },
        "outputId": "9b5734c6-cdb2-45c8-8efc-d604b04fa13d"
      },
      "source": [
        "for i in range(5):\n",
        "    print(\"Doing important work. i =\", i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Doing important work. i = 0\n",
            "Doing important work. i = 1\n",
            "Doing important work. i = 2\n",
            "Doing important work. i = 3\n",
            "Doing important work. i = 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l4Y__AcJBDHw",
        "colab_type": "text"
      },
      "source": [
        "### while ループ\n",
        "\n",
        "`while`ループは条件を満たしている間、繰り返す。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dvsgrfVsBY5N",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c56d4fbc-94a4-4e17-e599-2c123bb9f669"
      },
      "source": [
        "i = 0\n",
        "while i < 10:\n",
        "    print(i, end=' ')\n",
        "    i += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 1 2 3 4 5 6 7 8 9 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_BF8GlV0gXZL",
        "colab_type": "text"
      },
      "source": [
        "`while`ループの引数はブール式として評価され、ループは式が`False`になるまで繰り返される。\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yBJfdR4648fo",
        "colab_type": "text"
      },
      "source": [
        "### List 内包表記\n",
        "\n",
        "Pythonのリスト内包表記はたいへん人気がある。。\n",
        "\n",
        "理解するためにまず例をみよう。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dVA0M3vKV2tV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5afa2615-9389-472a-dc76-379edbd147d7"
      },
      "source": [
        "squares = [n**2 for n in range(10)]\n",
        "squares"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BUJDb7GZgdY7",
        "colab_type": "text"
      },
      "source": [
        "これをリスト内包表記でなくあらわすとしたら次のようになる。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0LqYOeoqWH5F",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d705dd8d-d92f-4fb7-f615-d0842a0b4124"
      },
      "source": [
        "squares = []\n",
        "for n in range(10):\n",
        "    squares.append(n**2)\n",
        "squares"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0g-YfjN0WF_5",
        "colab_type": "text"
      },
      "source": [
        "次のは`if`を使ったリスト内包表記である。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YE9iKEwcWdHl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "88ada980-616f-4685-fff0-2756a0c99edf"
      },
      "source": [
        "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
        "short_planets = [planet for planet in planets if len(planet) < 6]\n",
        "short_planets"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Venus', 'Earth', 'Mars']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wlk1wUSCWcAF",
        "colab_type": "text"
      },
      "source": [
        "`SQL`の`WHERE`節に似ていると言える。\n",
        "\n",
        "次の例ではループ変数に`if`条件文でフィルターをかけて、それを変形している。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XIAPutwTXOCD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "77a65271-f2db-4e86-8b3d-88ca2fe70d56"
      },
      "source": [
        "# str.upper() returns an all-caps version of a string\n",
        "loud_short_planets = [planet.upper() + '!' for planet in planets if len(planet) < 6]\n",
        "loud_short_planets"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['VENUS!', 'EARTH!', 'MARS!']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V1gJ6uJ1glI2",
        "colab_type": "text"
      },
      "source": [
        "リスト内包表記の左部分はループ変数を含む必要はないが、たいていは含んでいる。\n",
        "\n",
        "次のプログラムはリスト内包表記の左部分にループ変数を含まない例である。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dcmHx59nusMj",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c1211925-e321-4c68-e0cb-2424c727d911"
      },
      "source": [
        "planets = ['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune']\n",
        "[32 for planet in planets]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[32, 32, 32, 32, 32, 32, 32, 32]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TSGU-RZXuknR",
        "colab_type": "text"
      },
      "source": [
        "リスト内包表記と`min`、`max`、`sum`などの関数を組み合わせるとリスト内包表記を使わなければ何行にもなるプログラムを一行で書くことができる場合がある。\n",
        "\n",
        "次の2つのコードセルは同じことをやっている。\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6qnYlO2Q4Ro1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "bc01c282-ff31-47fa-9bbf-2a6b7fe957e4"
      },
      "source": [
        "def count_negatives(nums):\n",
        "    \"\"\"Return the number of negative numbers in the given list.\n",
        "    \n",
        "    >>> count_negatives([5, -1, -2, 0, 3])\n",
        "    2\n",
        "    \"\"\"\n",
        "    n_negative = 0\n",
        "    for num in nums:\n",
        "        if num < 0:\n",
        "            n_negative = n_negative + 1\n",
        "    return n_negative\n",
        "\n",
        "count_negatives([5, -1, -2, 0, 3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HtZCwZ5d4Q1F",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6547fc2a-e8d7-4755-85ed-c6fe445842f4"
      },
      "source": [
        "def count_negatives(nums):\n",
        "    return len([num for num in nums if num < 0])\n",
        "\n",
        "count_negatives([5, -1, -2, 0, 3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Fev8CsN6gsCV",
        "colab_type": "text"
      },
      "source": [
        "コードを短くすることだけが目的ならば次のようなのはどうか。\n",
        "\n",
        "\n",
        "Well if all we care about is minimizing the length of our code, this third solution is better still!\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YDLbbuhVkfqR",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def count_negatives(nums):\n",
        "    # Reminder: in the \"booleans and conditionals\" exercises, we learned about a quirk of \n",
        "    # Python where it calculates something like True + True + False + True to be equal to 3.\n",
        "    return sum([num < 0 for num in nums])\n",
        "\n",
        "count_negatives([5, -1, -2, 0, 3])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G-MUOy34g0S-",
        "colab_type": "text"
      },
      "source": [
        "どの解決方法が最善か、は主観的なものだが、短いコードはそれだけで価値がある。\n",
        "\n",
        "しかし、`The Zen of Python`のつぎのくだりを心に留めておくことも大切だ。\n",
        "\n",
        "```\n",
        "読みやすさは大切だ。\n",
        "明示的であることは暗黙的了解よりよいことだ。\n",
        "```\n",
        "\n",
        "リスト内包表記のようなツールを使ってプログラムを短く読みやすくしよう。多くの場合、短いプログラムは理解もしやすい。\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "74VrSgDon443",
        "colab_type": "text"
      },
      "source": [
        "# 練習問題\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kp8aqa2XoFhL",
        "colab_type": "text"
      },
      "source": [
        "### 問題 1\n",
        "\n",
        "デバッグは運任せと感じたことがあるだろうか?\n",
        "\n",
        "次のプログラムを完成させよう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7yXi3eWboH05",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "6cfcabf6-1ed8-43e2-a397-2dfeb7441bdd"
      },
      "source": [
        "# Try to identify the bug and fix it in the cell below:\n",
        "# def has_lucky_number:\n",
        "#     \"\"\"Return whether the given list of numbers is lucky. A lucky list contains\n",
        "#     at least one number divisible by 7.\n",
        "#     \"\"\"\n",
        "#     for num in nums:\n",
        "#         if num % 7 == 0:\n",
        "#             return True\n",
        "#         else:\n",
        "#             return False\n",
        "\n",
        "def has_lucky_number(nums):\n",
        "    \"\"\"Return whether the given list of numbers is lucky. A lucky list contains\n",
        "    at least one number divisible by 7.\n",
        "    \"\"\"\n",
        "    answer = False\n",
        "    for num in nums:\n",
        "        if num % 7 == 0:\n",
        "            answer = True\n",
        "            break\n",
        "    return answer\n",
        "\n",
        "print (has_lucky_number([1, 2, 3]))\n",
        "print (has_lucky_number([1, 2, 3, 7]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LphfeqynoMod",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "### 問題 2\n",
        "\n",
        "次のプログラムはコメントを外して実行するとエラーになる。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RGJY0NhnoQM9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# [1, 2, 3, 4] > 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HNmmlwv4rbdY",
        "colab_type": "text"
      },
      "source": [
        "書き直してみよう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tsenOdt2rfNf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d0d6bc0b-e723-4ccc-b690-1d1d441bc8f8"
      },
      "source": [
        "def greater_than_two (nums) :\n",
        "    answer = []\n",
        "    for num in nums :\n",
        "        if num > 2 :\n",
        "            answer.append(num)\n",
        "    return answer\n",
        "\n",
        "print (greater_than_two([1, 2, 3, 4])) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZcHShAmzoRp1",
        "colab_type": "text"
      },
      "source": [
        "`R`とPythonはnumpyとpandasというライブラリーがあり、リストと2を比べて `[False, False, True, True]`のようなブール型のリストを返す機能がある。\n",
        "\n",
        "対応する要素が`n`より大きいかどうかをブール型の要素のリストで返す関数を作る。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tCvFZoKLoVrC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b8958aa9-c7e1-4aa7-a763-cce792fdf776"
      },
      "source": [
        "def elementwise_greater_than(L, thresh):\n",
        "    \"\"\"Return a list with the same length as L, where the value at index i is \n",
        "    True if L[i] is greater than thresh, and False otherwise.\n",
        "    \n",
        "    >>> elementwise_greater_than([1, 2, 3, 4], 2)\n",
        "    [False, False, True, True]\n",
        "    \"\"\"\n",
        "    answer = []\n",
        "    for num in L :\n",
        "        answer.append(num > thresh)\n",
        "    return answer\n",
        "\n",
        "\n",
        "elementwise_greater_than([1, 2, 3, 4], 2)\n"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[False, False, True, True]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w2q2tgL8oW--",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "### 問題 3\n",
        "\n",
        "食事のリストについて、同じ食事が2日続けて出されていれば`True`、そうでなければ`False`を返すプログラムを書く。\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_nHwkmnBoZHK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "1684f864-13aa-44e1-854a-ee343ad309d7"
      },
      "source": [
        "def menu_is_boring(meals):\n",
        "    \"\"\"Given a list of meals served over some period of time, return True if the\n",
        "    same meal has ever been served two days in a row, and False otherwise.\n",
        "    \"\"\"\n",
        "    answer = False\n",
        "    for i in range(len(meals) - 1) :\n",
        "        if meals[i] == meals[i + 1] :\n",
        "            answer = True\n",
        "    return answer\n",
        "\n",
        "meals = [\"curry\", \"cutlet\", \"soup\", \"sushi\"]\n",
        "print (menu_is_boring(meals))\n",
        "meals = [\"curry\", \"cutlet\",  \"soup\", \"sushi\", \"sushi\"]\n",
        "print (menu_is_boring(meals))\n"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XsM3R2JRoaxm",
        "colab_type": "text"
      },
      "source": [
        "### 問題 4\n",
        "\n",
        "Pythonカジノにはブラックジャックのテーブルの横にスロットマシンがある。\n",
        "\n",
        "`play_slot_machine()`を実行すると、賞金がでる。普通は0ドルを返してくるが、運がよければ大金が手に入る。\n",
        "\n",
        "試しにやってみよう。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wvY-BRAGocR3",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# play_slot_machine()"
      ],
      "execution_count": 32,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oZdk9kPWoeZI",
        "colab_type": "text"
      },
      "source": [
        "ところで、1回1ドルかかるって言ったっけ。気にしなくていい、あとで請求書が行くから。\n",
        "\n",
        "1回スロットマシンでプレイするたびの期待される儲け(ロス)はいくらか。カジノはそれを秘密にするけれど、モンテカルロ法によって推測することができる。シミュレーションで回数を繰り返して平均値をとることによって期待値を計算する方法である。\n",
        "\n",
        "次の関数を完成させる。"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-6-lKStLoi8v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def estimate_average_slot_payout(n_runs):\n",
        "    \"\"\"Run the slot machine n_runs times and return the average net profit per run.\n",
        "    Example calls (note that return value is nondeterministic!):\n",
        "    >>> estimate_average_slot_payout(1)\n",
        "    -1\n",
        "    >>> estimate_average_slot_payout(1)\n",
        "    0.5\n",
        "    \"\"\"\n",
        "    result = []\n",
        "    for x in range(1, n_runs):\n",
        "        result.append(play_slot_machine())\n",
        "    return (sum(result) - n_runs)/n_runs\n",
        "\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}