{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "# From Web to Plot\n",
    "pythonプログラムの実例の一つとして、\n",
    "Internetで入手可能なデータを取り込んで、グラフ化してみます。\n",
    "東洋経済オンラインがwebで公開している、Covid19の時系列データを\n",
    "取り込み、グラフ化してみます。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "## web上のデータをダウンロード\n",
    "まずはweb上で公開されているcsvデータをローカルファイルにダウンロードしてみます。python3では`urllib`モジュールの`request`サブモジュールを使って、指定したURLの内容をプログラムを使って読み込むことができます。\n",
    "このモジュールをプログラムで利用するために、このモジュールをインポート（`import`)します。\n",
    "\n",
    "pythonには豊富な標準ライブラリモジュールが用意されています。また、第三者によって提供されているモジュールも豊富です。Pythonでのプログラム開発では、これらのモジュールをうまく使いこなすことがコツの一つです。文献／web pageを利用して必要なモジュールを探してみましょう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import urllib.request"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "ここでは、`urllib.request` モジュールの中の `urlopen()`関数だけが必要です。　この様な場合には、`urlopen`関数だけを選択的にインポートすることができます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from urllib.request import urlopen"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "次にデータをダウンロードするURLのリストを作っておきます。このリストに`dataurls`という名前をつけておきます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "dataurls=(\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/pcr_positive_daily.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/pcr_tested_daily.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/cases_total.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/recovery_total.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/death_total.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/pcr_case_daily.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/severe_daily.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/effective_reproduction_number.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/demography.csv\",\n",
    "        \"https://toyokeizai.net/sp/visual/tko/covid19/csv/prefectures.csv\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "source": [
    "python3にはデータ(オブジェクト）の並びを表現するためにふたつのデータ形, リスト( [,] )とタプル( (,) ) が用意されています。リストはデータを作成した後で、要素を変更(取り替え）することができますが、タプルはその要素を変更(取り替え）することができません。URLのリストはプログラム中で変更する必要はありませんから、`dataurls`はURLのタプルとして定義しました。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "次に、URLで指定されるcsvファイル(csv:comma separated value,カンマ区切り形式）をローカルファイルにダウンドードする関数　`load()`　を定義します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def load(dataurl):\n",
    "    fn=dataurl.split(\"/\")[-1]\n",
    "    with urlopen(dataurl) as inf , open(fn,\"wb\") as outf:\n",
    "        print (\"downloading :\", fn)\n",
    "        data=inf.read()\n",
    "        outf.write(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "`def`キーワードを使って、関数`load（）`を定義しています。`load`の引数は`dataurl`です。\n",
    "関数の本体は、`:`に続く文で定義します。関数本体のプログラム文は`def`キーワードに対してインデントされています。同様に`with`文の本体(`:`のあとの文）も`with`に対してインデントされていることに気をつけてください。インデントにTABを使うこともできますが、1byte文字の空白`' '`を使うことを推奨します。\n",
    "このpythonでのブロック構造の表現はちょっと特殊ですが、出来上がったプログラムが読みやすくなることを狙って採用されています。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "この関数`load()` は `dataurl` の最後の要素であるファイル名と同じ名前のローカルファイルにデータを保存します。 `dataurl` の文字列は `\"/\"` を区切りとして切り分けられます`dataurl.split(\"/\")` 。\n",
    "切り分けたリストの最後の要素`[-1]` がファイル名 `xxxx.csv` です。\n",
    "\n",
    "`urlopen()`で確立したwebとの接続を `inf`, 書き込み用(`w`)にオープンしたバイナリ形式データ(`b`)のファイル指示子を`outf`として使うことを`with ... as ...,:`構文で宣言しています。\n",
    "\n",
    "この構文(context manager)を使うことで、確実にこれらのフィアル／接続がこのセクション実行後に自動的に`close`されることが保証されます。\n",
    "\n",
    "あとはデータを読み込んで、`data=inf.read()`, それをファイルに書き出す、`outf.write(data)`、だけです。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "dataurlsの各要素についてこの関数を呼び出します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "downloading : pcr_positive_daily.csv\n",
      "downloading : pcr_tested_daily.csv\n",
      "downloading : cases_total.csv\n",
      "downloading : recovery_total.csv\n",
      "downloading : death_total.csv\n",
      "downloading : pcr_case_daily.csv\n",
      "downloading : severe_daily.csv\n",
      "downloading : effective_reproduction_number.csv\n",
      "downloading : demography.csv\n",
      "downloading : prefectures.csv\n"
     ]
    }
   ],
   "source": [
    "import os, certifi\n",
    "os.environ[\"SSL_CERT_FILE\"]=certifi.where()\n",
    "\n",
    "for dataurl in dataurls:\n",
    "    load(dataurl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## CSVから SQL Dtabaseへの変換\n",
    "データの検索などの操作はCVSデータをSQL Database（ここではsqlite3データベースを利用）に変換することで、簡単に行えるようになります。 この変換は色々な手法がありますが、今回試してみた結果pandasのdataframeを経由する方法が簡単確実です。\n",
    "\n",
    "pandasは最近話題のanacond/minicondaなどでも使われているpythonでのデータ処理向けのライブラリです。 dataframeと呼ばれるデータ構造を提供しており、 単純なアレイ構造を超えた取扱を実現しています。ただ、使いこなしにはある程度の練習が必要な様です。ここでは`dataframe` の備えるcvs/sqlへの読み書きの機能だけを使います。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "まず`dataframe`形のデータを使える様に、`pandas`モジュールをインポートしましょう。`sqlite3`, `os` もインポートしておきます。\n",
    "`os.path`モジュールからは`splitext`関数だけをインポートしておきます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "import pandas\n",
    "import sqlite3\n",
    "from os.path import splitext\n",
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "source": [
    "次に一つのdataurlについて、先ほどダウンロードした csvファイルを読み込み、sqlデータベースのテーブルとして追加する関数`from_cvs_to_sql()` 関数を定義します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def from_csv_to_df(dataurl):\n",
    "    fn=dataurl.split(\"/\")[-1]\n",
    "    df=pandas.read_csv(fn)\n",
    "    return df\n",
    "\n",
    "def from_csv_to_sql(dataurl):\n",
    "    fn=dataurl.split(\"/\")[-1]\n",
    "    df=from_csv_to_df(fn)\n",
    "    with sqlite3.connect('covid19.db') as con:\n",
    "        print (\"convert \",splitext(fn)[0])\n",
    "        df.to_sql(splitext(fn)[0],con)\n",
    "    os.remove(fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "convert  pcr_positive_daily\n",
      "convert  pcr_tested_daily\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/site-packages/pandas/core/generic.py:2779: UserWarning: The spaces in these column names will not be changed. In pandas versions < 0.14, spaces were converted to underscores.\n",
      "  sql.to_sql(\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "convert  cases_total\n",
      "convert  recovery_total\n",
      "convert  death_total\n",
      "convert  pcr_case_daily\n",
      "convert  severe_daily\n",
      "convert  effective_reproduction_number\n",
      "convert  demography\n",
      "convert  prefectures\n"
     ]
    }
   ],
   "source": [
    "import os, certifi\n",
    "os.environ[\"SSL_CERT_FILE\"]=certifi.where()\n",
    "\n",
    "try:\n",
    "    os.remove('covid19.db')\n",
    "except FileNotFoundError:\n",
    "    pass\n",
    "for dataurl in dataurls:\n",
    "    from_csv_to_sql(dataurl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## sql databaseの確認\n",
    "作成されたデータベースのschemaをチェックしてみましょう。\n",
    "sqlite3ではデータベースに含まれるテーブルなどのschme情報は、 `sqlite_master`テーブルに存在します。この中の`SQL`欄をみることで、それぞれのテーブルが持つカラムとそのデータ型を知ることもできますが、sqlite3では`PRAGMA`機能を使って、それらの情報を取り出すこともできます。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "******* table: pcr_positive_daily *******\n",
      "sql: CREATE TABLE \"pcr_positive_daily\" (\n",
      "\"index\" INTEGER,\n",
      "  \"日付\" TEXT,\n",
      "  \"PCR 検査陽性者数(単日)\" INTEGER,\n",
      "  \"Unnamed: 2\" REAL,\n",
      "  \"Unnamed: 3\" TEXT\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 日付 TEXT 0 None 0\n",
      "2 PCR 検査陽性者数(単日) INTEGER 0 None 0\n",
      "3 Unnamed: 2 REAL 0 None 0\n",
      "4 Unnamed: 3 TEXT 0 None 0\n",
      "******* table: pcr_tested_daily *******\n",
      "sql: CREATE TABLE \"pcr_tested_daily\" (\n",
      "\"index\" INTEGER,\n",
      "  \"日付\" TEXT,\n",
      "  \"PCR 検査実施件数(単日)\" INTEGER\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 日付 TEXT 0 None 0\n",
      "2 PCR 検査実施件数(単日) INTEGER 0 None 0\n",
      "******* table: cases_total *******\n",
      "sql: CREATE TABLE \"cases_total\" (\n",
      "\"index\" INTEGER,\n",
      "  \"日付\" TEXT,\n",
      "  \"入院治療を要する者\" INTEGER\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 日付 TEXT 0 None 0\n",
      "2 入院治療を要する者 INTEGER 0 None 0\n",
      "******* table: recovery_total *******\n",
      "sql: CREATE TABLE \"recovery_total\" (\n",
      "\"index\" INTEGER,\n",
      "  \"日付\" TEXT,\n",
      "  \"退院、療養解除となった者\" INTEGER\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 日付 TEXT 0 None 0\n",
      "2 退院、療養解除となった者 INTEGER 0 None 0\n",
      "******* table: death_total *******\n",
      "sql: CREATE TABLE \"death_total\" (\n",
      "\"index\" INTEGER,\n",
      "  \"日付\" TEXT,\n",
      "  \"死亡者数\" INTEGER\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 日付 TEXT 0 None 0\n",
      "2 死亡者数 INTEGER 0 None 0\n",
      "******* table: pcr_case_daily *******\n",
      "sql: CREATE TABLE \"pcr_case_daily\" (\n",
      "\"index\" INTEGER,\n",
      "  \"日付\" TEXT,\n",
      "  \"国立感染症研究所\" INTEGER,\n",
      "  \"検疫所\" INTEGER,\n",
      "  \"地方衛生研究所・保健所\" INTEGER,\n",
      "  \"民間検査会社\" INTEGER,\n",
      "  \"大学等\" INTEGER,\n",
      "  \"医療機関\" REAL\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 日付 TEXT 0 None 0\n",
      "2 国立感染症研究所 INTEGER 0 None 0\n",
      "3 検疫所 INTEGER 0 None 0\n",
      "4 地方衛生研究所・保健所 INTEGER 0 None 0\n",
      "5 民間検査会社 INTEGER 0 None 0\n",
      "6 大学等 INTEGER 0 None 0\n",
      "7 医療機関 REAL 0 None 0\n",
      "******* table: severe_daily *******\n",
      "sql: CREATE TABLE \"severe_daily\" (\n",
      "\"index\" INTEGER,\n",
      "  \"日付\" TEXT,\n",
      "  \"重症者数\" INTEGER\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 日付 TEXT 0 None 0\n",
      "2 重症者数 INTEGER 0 None 0\n",
      "******* table: effective_reproduction_number *******\n",
      "sql: CREATE TABLE \"effective_reproduction_number\" (\n",
      "\"index\" INTEGER,\n",
      "  \"日付\" TEXT,\n",
      "  \"実効再生産数\" REAL\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 日付 TEXT 0 None 0\n",
      "2 実効再生産数 REAL 0 None 0\n",
      "******* table: demography *******\n",
      "sql: CREATE TABLE \"demography\" (\n",
      "\"index\" INTEGER,\n",
      "  \"year\" INTEGER,\n",
      "  \"month\" INTEGER,\n",
      "  \"date\" INTEGER,\n",
      "  \"age_group\" TEXT,\n",
      "  \"tested_positive\" INTEGER,\n",
      "  \"hospitalized\" INTEGER,\n",
      "  \"serious\" INTEGER,\n",
      "  \"death\" INTEGER\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 year INTEGER 0 None 0\n",
      "2 month INTEGER 0 None 0\n",
      "3 date INTEGER 0 None 0\n",
      "4 age_group TEXT 0 None 0\n",
      "5 tested_positive INTEGER 0 None 0\n",
      "6 hospitalized INTEGER 0 None 0\n",
      "7 serious INTEGER 0 None 0\n",
      "8 death INTEGER 0 None 0\n",
      "******* table: prefectures *******\n",
      "sql: CREATE TABLE \"prefectures\" (\n",
      "\"index\" INTEGER,\n",
      "  \"year\" INTEGER,\n",
      "  \"month\" INTEGER,\n",
      "  \"date\" INTEGER,\n",
      "  \"prefectureNameJ\" TEXT,\n",
      "  \"prefectureNameE\" TEXT,\n",
      "  \"testedPositive\" INTEGER,\n",
      "  \"peopleTested\" REAL,\n",
      "  \"hospitalized\" REAL,\n",
      "  \"serious\" TEXT,\n",
      "  \"discharged\" REAL,\n",
      "  \"deaths\" TEXT,\n",
      "  \"effectiveReproductionNumber\" REAL\n",
      ")\n",
      "------ field info -----\n",
      "rowid name type nullable defalut pk(primary key)\n",
      "0 index INTEGER 0 None 0\n",
      "1 year INTEGER 0 None 0\n",
      "2 month INTEGER 0 None 0\n",
      "3 date INTEGER 0 None 0\n",
      "4 prefectureNameJ TEXT 0 None 0\n",
      "5 prefectureNameE TEXT 0 None 0\n",
      "6 testedPositive INTEGER 0 None 0\n",
      "7 peopleTested REAL 0 None 0\n",
      "8 hospitalized REAL 0 None 0\n",
      "9 serious TEXT 0 None 0\n",
      "10 discharged REAL 0 None 0\n",
      "11 deaths TEXT 0 None 0\n",
      "12 effectiveReproductionNumber REAL 0 None 0\n",
      "****** data count in tables ******\n",
      "table\tcout\n",
      "pcr_positive_daily \t 467\n",
      "pcr_tested_daily \t 444\n",
      "cases_total \t 448\n",
      "recovery_total \t 454\n",
      "death_total \t 438\n",
      "pcr_case_daily \t 433\n",
      "severe_daily \t 447\n",
      "effective_reproduction_number \t 422\n",
      "demography \t 10\n",
      "prefectures \t 19454\n"
     ]
    }
   ],
   "source": [
    "def dump_table_info(dbf):\n",
    "    db=sqlite3.connect(dbf)\n",
    "    cur=db.cursor()\n",
    "    table_info =cur.execute(\"select name,sql from sqlite_master where type = 'table'\").fetchall()\n",
    "    for tbl,sql in table_info:\n",
    "        print (\"******* table: {:s} *******\".format(tbl))\n",
    "        print (\"sql:\",sql)\n",
    "        print (\"------ field info -----\")\n",
    "        cur.execute(\"PRAGMA table_info({:s});\".format(tbl))\n",
    "        print (\"rowid\",\"name\",\"type\",\"nullable\",\"defalut\", \"pk(primary key)\")\n",
    "        for e in cur.fetchall():\n",
    "            print (*e)\n",
    "            \n",
    "    print(\"****** data count in tables ******\")\n",
    "    print( \"table\\tcout\")\n",
    "    for tbl,sql in table_info:\n",
    "        cur.execute(\"select count(*) from %s;\"%tbl)\n",
    "        print (tbl,\"\\t\", cur.fetchone()[0])\n",
    "\n",
    "dump_table_info(\"covid19.db\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "この様に、csvに含まれるデータから、SQL テーブルの各コラムのデータ型も適切に選択されていることがわかります。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "## データのプロット\n",
    "作成されたデータベースから、茨城県の2021年の日毎の陽性者数の推移をグラフにしてみます。グラフのプロットには`matplotlib`モジュールの`pyplot`サブモジュールを使います。\n",
    "また、日付データを適切に取り扱うために`datetime`モジュールも使います。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "#%matplotlib inline #なくても良いようです。\n",
    "import matplotlib.pyplot as pyplot\n",
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def plot_positive(pref):\n",
    "    with sqlite3.connect(\"covid19.db\") as db:\n",
    "        cur=db.cursor()\n",
    "        data=cur.execute(\n",
    "            \"\"\"\n",
    "            select year, month, date, testedPositive, peopleTested\n",
    "            from  prefectures \n",
    "            where  prefectureNameJ == \\\"{}\\\" \n",
    "            and    (year,month) >= (2020,10)\n",
    "            order by year,month,date;\n",
    "            \"\"\".format(pref)\n",
    "        ).fetchall()\n",
    "        xdata=[datetime.date(y,m,d) for y,m,d,*v in data]\n",
    "        ydata=[v for y,m,d,*v in data]\n",
    "        pyplot.xlabel(\"date\")\n",
    "        pyplot.ylabel(\"Positive\")\n",
    "        pyplot.plot(xdata,[v[0] for v in ydata])\n",
    "        pyplot.draw()\n",
    "        locs,labels=pyplot.xticks()\n",
    "        pyplot.xticks(locs[::2], labels[::2],font=\"Hiragino Mincho ProN\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_positive(\"茨城県\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pyplot.clf()\n",
    "plot_positive(\"東京都\")\n",
    "#pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dataframe を使って、同様のことができるか確認してみる。\n",
    "\n",
    "Dataframeを使って同様のグラフを書かせてみた。 loc（）メソッドを使うと、SQLのselect相当のことが可能。\n",
    "StringIOを使うことで、中間のcsvファイルを生成せずにDataFrameに変換ができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import io\n",
    "from io import StringIO, BytesIO\n",
    "\n",
    "def load_csv_to_df(dataurl):\n",
    "    fn=dataurl.split(\"/\")[-1]\n",
    "    with urlopen(dataurl) as inf:\n",
    "        print (\"downloading :\", fn)\n",
    "        data=inf.read().decode('utf-8') # binary dataをUnicodeに変換\n",
    "        sio=io.StringIO(data) # dataをStringIOにセット。\n",
    "    df=pandas.read_csv(sio) #\n",
    "    return df\n",
    "\n",
    "def plot_positive_df(pref):\n",
    "    #load(dataurls[-1]) #csv を読んで\n",
    "    #df=load_csv_to_df(dataurls[-1]) # pandas dataframe に変換\n",
    "    df= pandas.read_csv(urlopen(dataurls[-1]))\n",
    "    # .loc()メソッドを使って、データを選択。\n",
    "    # df=df.loc[(df.prefectureNameJ == \"{}\".format(pref)) & \n",
    "    #           ((df.year > 2020) | ((df.year == 2020) & (df.month >= 10))) , :]\n",
    "    df=df.loc[df.apply(\n",
    "                 lambda x:\n",
    "                    (x.prefectureNameJ == \"{}\".format(pref))\n",
    "                    and ((x.year,x.month) > (2020,10)), axis=1) , :]\n",
    "    #df=df[df.prefectureNameJ == \"{}\".format(pref)][(df.year > 2020)]\n",
    "    # \"datetime\" column を追加。\n",
    "    df['datetime']=df.apply(lambda x:datetime.date(x.year, x.month,x.date), axis=1)\n",
    "    # line plotでプロットしてみる。\n",
    "    df.plot.line(x=\"datetime\",y=\"testedPositive\")   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_positive_df(\"茨城県\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAEJCAYAAACpATGzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAu80lEQVR4nO3deXgV5d3G8e8PEnYIW0BICAEBIWwhBBDRCqKIYMUFBTeoUpFXrV3dfau1+qrVarUolSoiioAiFKwLUMBCVZawL7KEPWELCQlrAkme948z2BjDlpzknJzcn+vKlXOeeWbm9zAJd2Y5M+acQ0RExN8qBboAEREJTQoYEREpFQoYEREpFQoYEREpFQoYEREpFQoYEREpFWcNGDMbZ2b7zWxtEdN+a2bOzBp6783MXjezZDNbbWYJBfoON7PN3tfwAu1dzWyNN8/rZmZee30zm+P1n2Nm9fwzZBERKQvnsgczHuhfuNHMmgH9gJ0Fmq8BWntfI4ExXt/6wFNAD6A78FSBwBgD3FNgvlPrehSY65xrDcz13ouISDkRdrYOzrkFZhZbxKRXgYeBGQXaBgETnO/Tm4vMrK6ZNQF6A3OccxkAZjYH6G9mXwF1nHOLvPYJwPXAF96yenvLfQ/4CnjkbPU2bNjQxcYWVa6IiJzOsmXLDjjnIv25zLMGTFHMbBCQ6pxb5R3ROiUK2FXgfYrXdqb2lCLaARo75/Z4r/cCjc+lttjYWJKSks5xJCIiAmBmO/y9zPMOGDOrATyO7/BYmXDOOTM77T1tzGwkvkNyxMTElFVZIiJyBsW5iuxCoAWwysy2A9HAcjO7AEgFmhXoG+21nak9uoh2gH3e4TW87/tPV5BzbqxzLtE5lxgZ6dc9PBERKabzDhjn3BrnXCPnXKxzLhbfYa0E59xeYCYwzLua7GIgyzvMNQvoZ2b1vJP7/YBZ3rRDZnaxd/XYMP57TmcmcOpqs+H88FyPiIgEubMeIjOzSfhOtjc0sxTgKefcO6fp/jkwAEgGjgF3ATjnMszsj8BSr98zp074A/fhu1KtOr6T+1947S8AH5nZCGAHcMt5jayAkydPkpKSQnZ2dnEXIaWsWrVqREdHEx4eHuhSRMRPLNRu15+YmOgKn+Tftm0btWvXpkGDBhS6KEGCgHOO9PR0Dh8+TIsWLQJdjkiFZGbLnHOJ/lxmhfgkf3Z2tsIliJkZDRo00B6mSIipEAEDKFyCnLaPSOipMAEjIhKqdmUc45lP15N17GSgS/kBBUwZyMzM5M033yzWvH/5y184duzYec3z1Vdfce211wIwfvx4IiMjiY+PJy4ujr///e/nXcPf/vY3JkyY8P3ydu/e/f20n//856xfv/68lykiJZd57AS/+3gVvV/+ivcXbSdpR8bZZypDCpgyUNYBU9iQIUNYuXIlX331FY8//jj79u07r/lHjRrFsGHDgB8HzNtvv01cXFyJ6hOR8/fNlgNc/ZcF/GNFKnddEsuCh/vQt9053fCkzChgysCjjz7Kli1biI+P56GHHuKll16iW7dudOrUiaeeegqAo0ePMnDgQDp37kyHDh2YMmUKr7/+Ort376ZPnz706dMHgNmzZ9OzZ08SEhK4+eabOXLkCABffvklbdu2JSEhgWnTphVZR6NGjbjwwgvZsWMHc+fOpUuXLnTs2JG7776bnJyc72uNi4ujU6dO/O53vwPg6aef5uWXX2bq1KkkJSVx++23Ex8fz/Hjx+nduzdJSUn87W9/46GHHvp+XePHj+eBBx4A4IMPPqB79+7Ex8dz7733kpeXVzr/0CIVxMxVuxk+bgm1qobxj/t78eS1cTSJqB7osn6kWPciK8/+8Ok61u8+5NdlxjWtw1M/bX/a6S+88AJr165l5cqVzJ49m6lTp7JkyRKcc1x33XUsWLCAtLQ0mjZtymeffQZAVlYWERERvPLKK8yfP5+GDRty4MABnn32Wf71r39Rs2ZNXnzxRV555RUefvhh7rnnHubNm0erVq0YMmRIkXVs3bqVrVu3Eh0dTY8ePZg7dy5t2rRh2LBhjBkzhjvvvJPp06ezYcMGzIzMzMwfzD948GBGjx7Nyy+/TGLiD69mvOmmm+jZsycvvfQSAFOmTOGJJ57gu+++Y8qUKXz99deEh4dz3333MXHixO/3iETk/Lz3zXae/nQd3ZrX5+/DE4moHryfHdMeTBmbPXs2s2fPpkuXLiQkJLBhwwY2b95Mx44dmTNnDo888ggLFy4kIiLiR/MuWrSI9evX06tXL+Lj43nvvffYsWMHGzZsoEWLFrRu3Roz44477vjBfFOmTCE+Pp5bb72Vt956i7S0NFq0aEGbNm0AGD58OAsWLCAiIoJq1aoxYsQIpk2bRo0aNc55XJGRkbRs2ZJFixaRnp7Ohg0b6NWrF3PnzmXZsmV069aN+Ph45s6dy9atW0v2jyhSATnneGXOJp6auY6+bRszYUT3oA4XqIB7MGfa0ygLzjkee+wx7r333h9NW758OZ9//jlPPvkkffv25fe///2P5r3qqquYNGnSD9pXrlx5xnUOGTKE0aNHf/9+1apVRfYLCwtjyZIlzJ07l6lTpzJ69GjmzZt3jiODoUOH8tFHH9G2bVtuuOEGzAznHMOHD+f5558/5+WIyA/l5Tt+P2MtExfv5Oau0Tx/Y0fCKgf//kHwVxgCateuzeHDhwG4+uqrGTdu3PfnTlJTU9m/fz+7d++mRo0a3HHHHTz00EMsX778R/NefPHFfP311yQnJwO+8zabNm2ibdu2bN++nS1btgD8KIAKu+iii9i+ffv3y3n//fe5/PLLOXLkCFlZWQwYMIBXX321yCAqWE9hN9xwAzNmzGDSpEkMHToUgL59+zJ16lT27/fdqzQjI4MdO/x+V3CRkJWTm8cvJi1n4uKdjLr8Qv40uFO5CBeogHswgdCgQQN69epFhw4duOaaa7jtttvo2bMnALVq1eKDDz4gOTmZhx56iEqVKhEeHs6YMWMAGDlyJP3796dp06bMnz+f8ePHc+utt35/Uv7ZZ5+lTZs2jB07loEDB1KjRg0uu+yy04YA+O779e6773LzzTeTm5tLt27dGDVqFBkZGQwaNIjs7Gzf7vgrr/xo3p/97GeMGjWK6tWr8+233/5gWr169WjXrh3r16+ne/fuAMTFxfHss8/Sr18/8vPzCQ8P54033qB58+Z++bcVCWVHcnIZOSGJb7ak8+TAdvz8spaBLum8VIh7kX333Xe0a9cuQBXJudJ2EvmvrWlHGPXBMrakHeWlwZ24MSH67DOVQGnci0x7MCIiQST9SA4fLNrJ3xdupUpYJd67qzuXtm4Y6LKKRQEjIhIEcnLzeHvhNkbPS+b4yTyuaNuIP17fgai6wff5lnNVYQLGOacbKgaxUDtUK3I+Th0O27TvCNd0uIDf9ruIVo1qBbqsEqsQAVOtWjXS09N1y/4gdep5MNWqVQt0KSJlbva6vfz2o1WEh1Xi3bu60eeiRoEuyW8qRMBER0eTkpJCWlpaoEuR0zj1REuRiiIv3/HqnE2Mnp9Mp+gIxtzRtVwfDitKhQiY8PBwPSlRRILGwaMn+OWUlSzYlMbQbs14+rr2VAuvHOiy/K5CBIyISLD496Y0Hp+2hrTDOTx/Y0du7R4T6JJKjQJGRKQMpGYe58UvNjBz1W4ujKzJx6N60rlZ3UCXVaoUMCIipSQv3zF/w37+uXo3X6zdC8CDV7Tivj6tQvKQWGEKGBERP8vLd0xdtos3v9rCjvRj1K0Rzk1do7m/T6uQO5F/JgoYERE/WrUrk/+dsZbVKVl0jo7gkdsTuCquMeHl5AaV/qSAERHxg4NHT/DS7I1MWrKTyFpVeW1oPNd1blqhP3ungBERKYH8fMfHy3bxwhcbOJSdy929WvCrK1tTu1pwPwysLChgRESKadWuTJ7+dB0rdmbSLbYezwzqQLsmdQJdVtBQwIiInIeUg8dYuPkA05ensmR7Bg1rVeHPN3fmxoSoCn04rCgKGBGRsziZl8/MlbuZtGQnSTsOAtCsfnWeHNiOW7o1o44OhxVJASMichon8/KZtjyF0fOT2ZVxnJYNa/JI/7ZcFdeICyNraY/lLM4aMGY2DrgW2O+c6+C1vQT8FDgBbAHucs5letMeA0YAecCDzrlZXnt/4DWgMvC2c+4Fr70FMBloACwD7nTOnTCzqsAEoCuQDgxxzm33z7BFRE7vRG4+nyxP4Y35yaQcPE6n6Aie/ml7rmjbSKFyHs7lwuzxQP9CbXOADs65TsAm4DEAM4sDhgLtvXneNLPKZlYZeAO4BogDbvX6ArwIvOqcawUcxBdOeN8Peu2vev1EREpN1rGTjF2whT4vf8Vj09bQoFZV3v1ZN2bc34u+7RorXM7TWfdgnHMLzCy2UNvsAm8XAYO914OAyc65HGCbmSUD3b1pyc65rQBmNhkYZGbfAVcAt3l93gOeBsZ4y3raa58KjDYzc3oylYj40YncfFbuymT6ihSmr0gl+2Q+3VvU57kbOnB5m0iFSgn44xzM3cAU73UUvsA5JcVrA9hVqL0HvsNimc653CL6R52axzmXa2ZZXv8DfqhZRCow5xwrdmUycdFOPl+zh+Mn86gWXonr46MYfkmsLjX2kxIFjJk9AeQCE/1TTrHrGAmMBIiJCd1bX4tIyRzJyWXGylQ+WLST7/YcomaVylzfJYreF0VyccsGRFTX1WD+VOyAMbOf4Tv537fAYatUoFmBbtFeG6dpTwfqmlmYtxdTsP+pZaWYWRgQ4fX/EefcWGAsQGJiog6hicgP7Eg/yrtfb2fqshSO5OTSrkkdnruhA4Pio6hVVRfTlpZi/ct6V4Q9DFzunDtWYNJM4EMzewVoCrQGlgAGtPauGEvFdyHAbc45Z2bz8Z3DmQwMB2YUWNZw4Ftv+jydfxGRc+WcY+n2g7zzn63MXr+PsErGtZ2acsfFzUmIqatzK2XgXC5TngT0BhqaWQrwFL6rxqoCc7yNtMg5N8o5t87MPgLW4zt0dr9zLs9bzgPALHyXKY9zzq3zVvEIMNnMngVWAO947e8A73sXCmTgCyURkdPafzibJdsyWJ2Sxax1e7+/Vf59vS9kWM9YGtepFugSKxQLtZ2CxMREl5SUFOgyRKSMpBw8xsxVu/ls9R7W7T4EQJXKlUiMrceNCdEM7NiE6lVC/+FeJWVmy5xzif5cpg4+iki5k3H0BJ+t2cPMlaks3e67dUuXmLo8dPVFXNqqIe2a1KFKWMV7/kqwUcCISLngnGNNahbv/Gcbn63eQ26+o1WjWvyuXxuu6xxFTIMagS5RClHAiEhQcs6xK+M4y3ZmsCblEPM37mfbgaPUqhrGsJ6x3NQ1irgmdXSyPogpYEQkaDjnWLf7EDNWpvLF2r2kHDwOQNWwSnSLrc/PL2vBTzs31d2LywkFjIgE3M70Y8xYmcqMVbtJ3n+EsErGT9pEcs9lLenRsj6tImsRVgGfaV/eKWBEJCD2Hcrms9V7+HT1blbszASge6zvHmADOjShXs0qgS1QSkwBIyKlzjnHlrQjzN+QxtrdWWw/cJTVqVk4B3FN6vBI/7ZcF9+UqLrVA12q+JECRkRKRW5ePku2ZTBr3V7mbtj//fmUqLrVaVa/Og9e0Zqfdm5Kq0a1AlyplBYFjIj4zcm8fL7Zks6Xa/cwa90+Mo6eoFp4JS5t1ZD/6X0hvS9qpL2UCkQBIyLFtu9QNut2Z7HtwDGWbsvgmy0HOJSdS80qlenbrjHXdLiAyy+KpEYV/VdTEWmri8h5OZqTy5dr9zJtRQrfbEnn1N2moupW5+r2F9Cv/QVc1roh1cJ1e5aKTgEjImd1KPskX67Zy+z1+/g6+QDHT+bRrH51fnFFay5v05CY+jWJrF010GVKkFHAiMiPOOf4bs9hFm5OY+n2DBZuPkBObj5Rdatzc2I013VuStfm9fQpejkjBYyI4Jxj8/4jzNuwn5U7M1m5K5O9h7IBaNmwJkO6NePGhGg6R0coVOScKWBEKrC9WdlMW5HCJ8tS2JJ2FIDYBjVIjK3HZa0b0ueiRjTSM1SkmBQwIhWMc45vt6bz1r+3snBzGvkOusXW465eLejbrhFNInQZsfiHAkakgjh2Ipd/rt7DxMU7WbUrk8jaVXngitbclBBF8wY1A12ehCAFjEgIO5Gbz9LtGXyxdg8zVuzmcE4uF0bW5JlB7bklsZkuJZZSpYARCUHJ+w8zcfFOPlmWwqHsXKqGVWJAxybc2j2GbrG6+kvKhgJGJERkHjvB7HX7+GR5Cou3ZRBe2bi6/QUMio+iV6sG+jS9lDn9xImUc3uyjvPm/C1MWbqLE3n5NG9Qg0evacvgrtE0rKUPP0rgKGBEyql9h7IZ89UWPlyyk/x8x82JzbitewwdovQYYQkOChiRcuREru8W+NNWpPDpqt3kO7i5azT392lFs/o1Al2eyA8oYETKgfQjObz79XbeX7SDrOMnqVGlMrf3aM6IS1soWCRoKWBEgtynq3bzxPQ1HM7J5eq4CxjcNZperRpSvYouMZbgpoARCVJHcnL5/Yy1TFueSnyzurw0uBOtG9cOdFki50wBIxKEVqdk8uCkFezMOMYv+7bmF1e0IqxypUCXJXJeFDAiQSQ/3/H3hVt5adZGGtWuypR7e9Ittn6gyxIpFgWMSJDYfzib3360ioWbD3BNhwt44cZORNQID3RZIsV21n1uMxtnZvvNbG2BtvpmNsfMNnvf63ntZmavm1myma02s4QC8wz3+m82s+EF2rua2RpvntfNu4D/dOsQCTV5+Y4PFu3gyj//m6XbM/i/Gzry5u0JChcp987loO54oH+htkeBuc651sBc7z3ANUBr72skMAZ8YQE8BfQAugNPFQiMMcA9Bebrf5Z1iISEnNw83vnPNvq8/BVP/mMt7ZtG8M9fXMZtPWL0QUkJCWc9ROacW2BmsYWaBwG9vdfvAV8Bj3jtE5xzDlhkZnXNrInXd45zLgPAzOYA/c3sK6COc26R1z4BuB744gzrECn3Nu49zK+mrOS7PYfoHlufxwe05er2FyhYJKQU9xxMY+fcHu/1XqCx9zoK2FWgX4rXdqb2lCLaz7QOkXLt8zV7+M1HK6lVNYy3hyVyZZx+tCU0lfgkv3POmZnzRzHFXYeZjcR3SI6YmJjSLEWkRN769xae/2IDCTF1eevORCJr62aUErqKe2H9Pu/QF973/V57KtCsQL9or+1M7dFFtJ9pHT/inBvrnEt0ziVGRkYWc0gipcc5x8uzNvL8Fxu4tlMTPrznYoWLhLziBsxM4NSVYMOBGQXah3lXk10MZHmHuWYB/cysnndyvx8wy5t2yMwu9q4eG1ZoWUWtQ6TceXXOJkbPT2Zot2a8NrSLniQpFcJZD5GZ2SR8J9sbmlkKvqvBXgA+MrMRwA7gFq/758AAIBk4BtwF4JzLMLM/Aku9fs+cOuEP3IfvSrXq+E7uf+G1n24dIuXKxMU7eH1eMrckRvP8jR11Il8qDPNd8BU6EhMTXVJSUqDLEAFg1rq9/M8Hy+h9USPG3tlVt3uRoGVmy5xzif5cpn7aRUrJsh0ZPDhpBR2j6zL6ti4KF6lw9BMvUgqS9x9hxHtJNK1bnXHDE6lRRXdlkopHASPiZ3uzshk+bglhlSrx3l3daVBLV4tJxaQ/q0T8aPa6vTw+fQ3HT+Qx5d6exDTQ0yal4tIejIifjF2whZHvL6NR7Wp8ct8ldIiKCHRJIgGlPRgRP5i8ZCf/9/kGBnZqwqu3xFMlTH+7iei3QKSE5m/Yz+PT13B5m0iFi0gB+k0QKYENew/xi0kraHtBHd68PUHhIlKAfhtEiinr2EnumZBEzaqVeednidSsqiPOIgXpN0KkGPLzHb/5aCV7s7KZcm9PmkRUD3RJIkFHezAixTDu623M3bCfJwfGkRCjp3mLFEUBI3KeUjOP8+fZm+jbthHDejYPdDkiQUsBI3Ke/jBzne/7oPa6M7LIGShgRM7DZ6v3MHv9Pn55ZWui6+lT+iJnooAROUd7so7z+PQ1dG5WlxGXtgh0OSJBTwEjcg7y8h2/mbKKk3n5vDYknnDdel/krHSZssg5eHN+Mt9uTedPgzsR27BmoMsRKRf0Z5jIWSzems6r/9rEoPim3Nw1OtDliJQbChiRM8g4eoJfTl5JTP0aPHdDR101JnIedIhM5DScc/zu41VkHD3BtPsuoZZuBSNyXrQHI3IaExfvZN6G/Tw+oK2e7SJSDAoYkSJkHTvJn2dv5OKW9Rl+SWygyxEplxQwIkV4be5mMo+f5PfX6tP6IsWlgBEpZEf6USZ8u52h3ZoR17ROoMsRKbcUMCKFjJ6XTOVKxq+vbBPoUkTKNQWMSAE70o8ybUUqt/WIoVGdaoEuR6RcU8CIFPDGfN/ey6jLLwx0KSLlngJGxLM3K5tpy1O5tVszGmvvRaTEFDAinve+3U6+c4y4tGWgSxEJCSUKGDP7tZmtM7O1ZjbJzKqZWQszW2xmyWY2xcyqeH2reu+TvemxBZbzmNe+0cyuLtDe32tLNrNHS1KryJkczcll4qIdXN3+AmIa6DkvIv5Q7IAxsyjgQSDROdcBqAwMBV4EXnXOtQIOAiO8WUYAB732V71+mFmcN197oD/wpplVNrPKwBvANUAccKvXV8TvPk7axaHsXH5+mfZeRPylpIfIwoDqZhYG1AD2AFcAU73p7wHXe68Hee/xpvc13yfYBgGTnXM5zrltQDLQ3ftKds5tdc6dACZ7fUX8KvPYCV6fl0z3FvXp2rxeoMsRCRnFDhjnXCrwMrATX7BkAcuATOdcrtctBYjyXkcBu7x5c73+DQq2F5rndO0ifvXy7I1kHT/JH65rH+hSREJKSQ6R1cO3R9ECaArUxHeIq8yZ2UgzSzKzpLS0tECUIOXUmpQsJi7eybCezWnXRJ/aF/GnkhwiuxLY5pxLc86dBKYBvYC63iEzgGgg1XudCjQD8KZHAOkF2wvNc7r2H3HOjXXOJTrnEiMjI0swJKlI8vMdT85YS4OaVfn1VfrUvoi/lSRgdgIXm1kN71xKX2A9MB8Y7PUZDszwXs/03uNNn+ecc177UO8qsxZAa2AJsBRo7V2VVgXfhQAzS1CvyA9MSdrFql2ZPDGwLXWqhQe6HJGQU+wnKDnnFpvZVGA5kAusAMYCnwGTzexZr+0db5Z3gPfNLBnIwBcYOOfWmdlH+MIpF7jfOZcHYGYPALPwXaE2zjm3rrj1ihS0K+MYL365ge6x9bk+Xqf2REqD+XYiQkdiYqJLSkoKdBkSxDKOnmDwmG9I955UeWFkrUCXJBJwZrbMOZfoz2XqGbBSoeTm5TPq/WWkZB5n4s97KFxESpFuFSMVyutzN7NkewZ/uqkT3WLrB7ockZCmgJEKY/HWdP46P5nBXaO5vovOu4iUNgWMVAg5uXk8Nm0NMfVr6AOVImVE52CkQnh74Ta2HjjK+Lu6UbOqfuxFyoL2YCTk7ck6zl/nbaZ/+wvofVGjQJcjUmEoYCTkfbh4Jzm5+TwxsF2gSxGpUBQwEtJy8/L5OCmFy9tE0qy+nvMiUpYUMBLSFmxOY++hbIZ2a3b2ziLiVwoYCWmTl+yiYa0qXNG2caBLEalwFDASsg4cyWHehv3clBBNlTD9qIuUNf3WSciauXI3ufmOm7pGB7oUkQpJASMha9qKFDpGRdCmce1AlyJSISlgJCRt3HuYtamHuDFBt4QRCRQFjISkaStSCKtk/LRz00CXIlJhKWAk5OTlO2as2E3viyJpWKtqoMsRqbAUMBJyvt2Szt5D2dyYoJP7IoGkgJGQM215CnWqhXFFW913TCSQFDASUo7m5PLF2r1c27kp1cIrB7ockQpNASMh5dNVuzl+Mo+bdPWYSMApYCRkHD+Rx2tzN9MxKoKEmHqBLkekwlPASMgY9/U29mRl8+TAdphZoMsRqfAUMBIS9h3K5s35yfSLa0yPlg0CXY6IoICREOCc46Gpq8lzjscH6KFiIsFCASPl3geLdrBgUxpPDIwjtmHNQJcjIh4FjJRrs9ft5Zl/rufyNpHc0SMm0OWISAEKGCm3vlizh/smLieuaQSv39pFJ/ZFgowCRsql9xft4P4Pl9MpOoL3R3Qnonp4oEsSkULCAl2AyPlwzvHy7I28MX8Lfds2YvRtCVSvok/siwSjEu3BmFldM5tqZhvM7Dsz62lm9c1sjplt9r7X8/qamb1uZslmttrMEgosZ7jXf7OZDS/Q3tXM1njzvG46BlKhnczL56Gpq3lj/hZu7d6Mt+7sqnARCWIlPUT2GvClc64t0Bn4DngUmOucaw3M9d4DXAO09r5GAmMAzKw+8BTQA+gOPHUqlLw+9xSYr38J65Vy6mhOLvdMSGLqshR+dWVr/u+GjoRV1hFekWBW7N9QM4sAfgK8A+CcO+GcywQGAe953d4DrvdeDwImOJ9FQF0zawJcDcxxzmU45w4Cc4D+3rQ6zrlFzjkHTCiwLKlA8vIdd49fyoJNaTx/Y0d+dWUbndAXKQdK8idgCyANeNfMVpjZ22ZWE2jsnNvj9dkLNPZeRwG7Csyf4rWdqT2liPYfMbORZpZkZklpaWklGJIEo7cXbmXxtgxevKkTt3bXpcgi5UVJAiYMSADGOOe6AEf57+EwALw9D1eCdZwT59xY51yicy4xMjKytFcnZWjzvsP8ec4mrm7fmMFd9QAxkfKkJAGTAqQ45xZ776fiC5x93uEtvO/7vempQLMC80d7bWdqjy6iXSqIPVnHuWv8UmpXDeO5GzrqsJhIOVPsgHHO7QV2mdlFXlNfYD0wEzh1JdhwYIb3eiYwzLua7GIgyzuUNgvoZ2b1vJP7/YBZ3rRDZnaxd/XYsALLkhC3/3A2t7+9mMxjJ3n3rm40rFU10CWJyHkq6edgfgFMNLMqwFbgLnyh9ZGZjQB2ALd4fT8HBgDJwDGvL865DDP7I7DU6/eMcy7De30fMB6oDnzhfUmIS808zu1/X8S+Qzm8d3d3OkXXDXRJIlIM5jtNEjoSExNdUlJSoMuQYsjLd0xfkcpLszZw7EQe4+/qRtfm9QNdlkiFYGbLnHOJ/lymPskvQWF35nHu/3A5K3Zm0jEqghdu6kj7phGBLktESkABIwG3dHsGIyckcTLP8eqQzgzqHEWlSjqhL1LeKWAkoBZvTeeu8Uu5IKIabw9LpGVkrUCXJCJ+ooCRgDkVLk0iqjFp5MU0ql0t0CWJiB/pZk4SEAoXkdCngJEyp3ARqRgUMFKmvt2icBGpKBQwUmY+StrFsHGLaVq3usJFpALQSX4pdQeO5PDcZ98xfUUql7VuyOhbE4iooUcci4Q6BYyUmt2Zx3nvm+18uGQn2SfzePCKVjzYt7UeFCZSQShgxO+cc3yclMLTn64jJzef/u0v4NdXtaZVo9qBLk1EypACRvwq89gJHp++hs/X7KVnywb8aXAnmtWvEeiyRCQAFDDiN99uSec3H60k7XAOj17Tlnsua0ll3fJFpMJSwEiJ5eU7XpmzkTe/2kKLBjWZfl8vOkbrRpUiFZ0CRkok+2Qev/1oFZ+t2cOQxGY8dV0cNarox0pEFDBSAnuyjvOLD1eQtOMgTwxoxz0/aRnokkQkiChg5Lzl5uUzfUUq//f5d+Tk5vPXW7vw085NA12WiAQZBYycs61pR5i5ajfTV6SyI/0YnaIj+MuQeN1iX0SKpICRs0o5eIxXZm9i+spUALrF1ueJAe24Kq4xZrpKTESKpoCR03LOMWnJLp79bD15+Y6Rl7Xk7ktb0LiO7iEmImengJEi7Uw/xmPTV/N1cjq9WjXgT4M7E1W3eqDLEpFyRAEjP5CX73j36238efYmKhn8cVB7bu/RnEr6wKSInCcFjHxv497DPPzJalbtyuSKto149voONNVei4gUkwKmgsvPdyzbeZDpK1L5OGkXtauF89rQeK7r3FQn8EWkRBQwFVTy/iP8Y0Uq/1iZSsrB41QLr8SNXaJ55Jq21K9ZJdDliUgIUMBUMFvSjvDk9LV8uzWdSgaXto7kt/3a0C/uAmpW1Y+DiPiP/kepIA5nn+Stf29l7IKtVK9SmccHtOX6LlF6bLGIlBoFTIg7kZvPxMU7+Ou8ZDKOnmBQfFOeGNhOwSIipU4BE6Kcc/xz9R5emrWRnRnHuOTCBjx2TTvdRl9EykyJA8bMKgNJQKpz7lozawFMBhoAy4A7nXMnzKwqMAHoCqQDQ5xz271lPAaMAPKAB51zs7z2/sBrQGXgbefcCyWtN9TtO5TN9BWpTF2WQvL+I7S9oDbj7+rG5W0idVWYiJQpf+zB/BL4DqjjvX8ReNU5N9nM/oYvOMZ43w8651qZ2VCv3xAziwOGAu2BpsC/zKyNt6w3gKuAFGCpmc10zq33Q80hxTnHws0HGPf1NhZsSiPfQdfm9Xjlls4Mio/SUyVFJCBKFDBmFg0MBJ4DfmO+P5GvAG7zurwHPI0vYAZ5rwGmAqO9/oOAyc65HGCbmSUD3b1+yc65rd66Jnt9FTAFrNqVyf/OWMvqlCwia1flvt6tuDEhSnc4FpGAK+kezF+Ah4Ha3vsGQKZzLtd7nwJEea+jgF0AzrlcM8vy+kcBiwoss+A8uwq19yiqCDMbCYwEiImJKf5oypFD2Sd5edZG3l+0g8haVXnxpo5c3yWKqmGVA12aiAhQgoAxs2uB/c65ZWbW228VFYNzbiwwFiAxMdEFspbSlpuXzyfLU/jz7E2kHclheM9YftuvDbWrhQe6NBGRHyjJHkwv4DozGwBUw3cO5jWgrpmFeXsx0UCq1z8VaAakmFkYEIHvZP+p9lMKznO69grn2Ilcpq9I5Z2F29h64Cjxzery9vBEOkXXDXRpIiJFKnbAOOceAx4D8PZgfuecu93MPgYG47uSbDgww5tlpvf+W2/6POecM7OZwIdm9gq+k/ytgSWAAa29q9JS8V0IcOrcToWwfvchPl29m39vTGPTvsPk5js6RNXhrTu70k8P+xKRIFcan4N5BJhsZs8CK4B3vPZ3gPe9k/gZ+AID59w6M/sI38n7XOB+51wegJk9AMzCd5nyOOfculKoN6jk5zs+W7OHd/6zjZW7MqlcyegeW597L29J74sakdi8noJFRMoFcy60TlkkJia6pKSkQJdRLCt2HuQPn65n5a5MWjasyZ09mzMoPko3nxSRUmdmy5xzif5cpj7JHwT2HcrmT19u5JPlKUTWrsrLN3fmxi5ResiXiJRrCpgAOpqTy9gFvhtQ5uU7Rl1+IQ9c0YpauquxiIQA/U8WAOlHcvhszR5Gz0tm/+EcBnZswsP9L6J5g5qBLk1ExG8UMGUg89gJFm4+wLdb01mTksW63VnkO+gSU5cxdyTQtXn9QJcoIuJ3CphS4pzj2y3pTFy8k1nr9pKb76hdLYyOURHc36cV/TtcQFyTOroiTERClgLGzzKPnWDqshQ+XLyTrQeOUrdGOD+7JJYBnZrQObqubjwpIhWGAsYPjuTkMve7fXy+Zg/zN6ZxIjefhJi6vHJLZwZ0bEK1cN0fTEQqHgXMeXLOse3AUdakZrF+zyHW7z7Ekm0Z5OTm06h2VW7rHsMtic2Ia1rn7AsTEQlhCphzkH0yj2+3pDNvw37mbdhPauZxAMIrG20a1+bW7jEM6NiExOb19NkVERGPAqaQ/HzH1gNHWLEzk+3pR/luz2G+2XKA7JP5VA+vzKWtG3Jfnwvp0qwerRrVokpYpUCXLCISlBQwntfnbuajpF3sP5zDidx8AMIqGTENajC0Wwx92jaiR4v6Op8iInKOFDCexnWq0i22Pg1rVaF1o9okNK9HbIMahFXWHoqISHEoYDxDusUwpFvFeBqmiEhZ0J/nIiJSKhQwIiJSKhQwIiJSKhQwIiJSKhQwIiJSKhQwIiJSKhQwIiJSKhQwIiJSKsw5F+ga/MrM0oAdxZy9IXDAj+UEWqiN55RQHFcojCkUxlBYqI3pTONp7pyL9OfKQi5gSsLMkpxziYGuw19CbTynhOK4QmFMoTCGwkJtTGU9Hh0iExGRUqGAERGRUqGA+aGxgS7Az0JtPKeE4rhCYUyhMIbCQm1MZToenYMREZFSoT0YEREpFeU6YMysmZnNN7P1ZrbOzH7ptdc3szlmttn7Xs9rv93MVpvZGjP7xsw6F1hWfzPbaGbJZvboGdb5pZllmtk/C7U/4M3rzKxhCIxnojf/WjMbZ2bhxRlTKYxrnJntN7O1Z1lnkeP3x3YKwjEVa1sF2RjeMbNV3vKnmlmtcxlDMI+pwPTXzexIeR+PmY03s21mttL7ij/rAJxz5fYLaAIkeK9rA5uAOOBPwKNe+6PAi97rS4B63utrgMXe68rAFqAlUAVYBcSdZp19gZ8C/yzU3gWIBbYDDUNgPAMA874mAf8T6O3kvf8JkACsPcP6Tjt+f2ynIBxTsbZVkI2hToF+r5xaf3neLt70ROB94Eh5Hw8wHhh8XvUX9xcsGL+AGcBVwEagSYENtLGIvvWAVO91T2BWgWmPAY+dYT29KfQfcoFp2ynBf1zBNh5v+q+B5wK9nQq0xZ7ll+Ss4/fndgqWMZV0WwXDGPCF5BjgkfK+XfD9Zz3fW1+xAibIxjOe8wyYcn2IrCAzi8X31+lioLFzbo83aS/QuIhZRgBfeK+jgF0FpqV4bQETLOPxDrfcCXxZnPmLWF4sxR/XuSrT7RksYyrJtgqGMZjZu9762gJ/Pc9l/0gQjOkBYGaB9ZZIEIwH4DnvENyrZlb1bAsLO8+VByXveO0nwK+cc4fM7PtpzjlnZq5Q/z74/vEvLdNCz1GQjedNYIFzbmFJFxRk4/KLIBtTsbZVsIzBOXeXmVXGFy5DgHeLu6xAj8nMmgI34zs64I/lBcM2egxfmFXBd7nzI8AzZ5qh3O/BeH+1fQJMdM5N85r3mVkTb3oTYH+B/p2At4FBzrl0rzkVaFZgsdFAqpn1KHBC67rSHotXX9CMx8yeAiKB3wTJuE637GYFxjWK04y/pGMoYr1BM6bibqtgGgOAcy4PmAzcdD7jCMIxdQFaAclmth2oYWbJ5Xg8OOf2OJ8cfOHf/azF++O4YKC+8B2vnQD8pVD7S/zwBNifvNcxQDJwSaH+YcBWoAX/PbHV/gzr7U0pnIMJpvEAPwe+AaoHy3YqMF8sZz6OfNbxl2Q7BduYirutgmUMXh2tCtT0MvByed8uhfoV9yR/0IyH/57zMeAvwAtnrb84gw6WL3y7fw5YDaz0vgYADYC5wGbgX0B9r//bwMECfZMKLGsAvis0tgBPnGGdC4E04Di+45NXe+0Peu9zgd3A2+V8PLnevKeW/fsg2U6TgD3ASa/eEadZZ5Hj98d2CsIxFWtbBcsY8B1J+RpYA6wFJlLgqrLyul0K9SluwATNeIB5BbbRB0Cts9WvT/KLiEipKPfnYEREJDgpYEREpFQoYEREpFQoYEREpFQoYEREpFQoYETOwsyeNrPfnWH69WYWdw7L+UE/M3vGzK70V50iwUYBI1Jy1+O7w+159XPO/d45969Sqkkk4BQwIkUwsyfMbJOZ/Qe4yGu7x8yWmu+5JZ+YWQ0zuwS4DnjJu93Ghd7Xl2a2zMwWmlnb0/Qbb2aDvWVvN7PnvWlJZpZgZrPMbIt3C49TdT3k1bDazP4QgH8akXMWEje7FPEnM+sKDAXi8f2OLAeWAdOcc3/3+jyL75PQfzWzmfhutTPVmzYXGOWc22xmPYA3nXNXFNGv8Kp3OufizexVfLdG7wVUw/fJ6b+ZWT+gNb57QBkw08x+4pxbUFr/FiIloYAR+bHLgOnOuWMAXjAAdPCCpS5QC5hVeEbvrreXAB8XCJCz3tbcc2o9a/DdhuMwcNjMcsysLtDP+1rh9auFL3AUMBKUFDAi5248cL1zbpWZ/Yyib8VeCch0zsUXY/k53vf8Aq9PvQ/Dt9fyvHPurWIsW6TM6RyMyI8tAK43s+pmVhvfI6XB98jaPd7t028v0P+wNw3n3CFgm5ndDGA+nQv3K6ZZwN3eXhJmFmVmjUqwPJFSpYARKcQ5txyYgu9W5V8AS71J/4vvaYJfAxsKzDIZeMjMVpjZhfjCZ4SZrQLWAYNO0+9865oNfAh8a2ZrgKmULLBESpXupiwiIqVCezAiIlIqFDAiIlIqFDAiIlIqFDAiIlIqFDAiIlIqFDAiIlIqFDAiIlIqFDAiIlIq/h9zdsNeEfYncwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_positive_df(\"東京都\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9",
   "language": "python",
   "name": "python3.9"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}