diary recommendation.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import pymongo\n",
    "import matplotlib.pyplot as plt\n",
    "import jieba\n",
    "import re\n",
    "from math import sqrt\n",
    "import datetime\n",
    "import wordcloud\n",
    "import os\n",
    "import snownlp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 把excel中的数据读入mongodb中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_excel('diary.xlsx')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "client = pymongo.MongoClient('localhost',27017)\n",
    "db = client.diary\n",
    "column = db.diary\n",
    "#每次重新插入数据库时，都要先清空\n",
    "column.delete_many({})\n",
    "for index in range(df.shape[0]):\n",
    "    try:\n",
    "        everyday = dict(df.iloc[index])\n",
    "    #     del everyday['日期']\n",
    "        column.insert_one(everyday)\n",
    "    except:\n",
    "        print(index)\n",
    "        print(everyday['日期'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 从数据库中读出数据，把日记中的诸多信息分别赋值给多个变量供后面使用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "cursor = column.find()\n",
    "cursor_new = cursor.clone()\n",
    "keys = list(cursor_new[0].keys()) #后面搜索功能用到着\n",
    "word_len = {}\n",
    "text = ''\n",
    "everyday_text = {}\n",
    "everyday_item_text = {}\n",
    "days = [] #存放所有日记的日期\n",
    "for day in cursor_new:\n",
    "    word_num = 0\n",
    "    days.append(day['日期'])\n",
    "    everyday_text[day['日期']] = ''\n",
    "    everyday_item_text[day['日期']] = {}\n",
    "    for key in keys:\n",
    "        #统计是字符串的值，其他暂不能统计\n",
    "        if key != '_id' : #and type(day[key]) == str\n",
    "            word_num += len(str(day[key]))\n",
    "            text += str(day[key])\n",
    "            everyday_text[day['日期']] += str(day[key])\n",
    "            everyday_item_text[day['日期']][key] = day[key]\n",
    "    word_len[day['日期']] = word_num\n",
    "# print(word_len)\n",
    "# print(len(text))\n",
    "# print(everyday_text['2020.3.28'])\n",
    "# print(everyday_item_text['2020.3.27']['警言'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list(word_len.keys())\n",
    "# word_len.values\n",
    "#正常显示中文\n",
    "\n",
    "plt.rcParams[\"font.sans-serif\"] = [\"SimHei\"]\n",
    "\n",
    "# 正常显示负号\n",
    "plt.rcParams[\"axes.unicode_minus\"] = False\n",
    "\n",
    "def plt_picture():\n",
    "    plt.bar(range(len(word_len.keys())), word_len.values())\n",
    "    plt.xlabel(\"日期\")\n",
    "    plt.ylabel('字数')\n",
    "    plt.title('每天日记的字数统计')\n",
    "    plt.show()\n",
    "    \n",
    "    plt.plot(range(len(word_len.keys())), word_len.values())\n",
    "    plt.xlabel(\"日期\")\n",
    "    plt.ylabel('每日字数')\n",
    "    plt.title('每天日记的字数统计')\n",
    "    plt.show()\n",
    "    \n",
    "    # 每天字数增加进度折线 思路来源: >得到APP，每天听本书，《暗时间》，提到进度条\n",
    "    everyday_word_len = word_len.values()\n",
    "    increase_word_len = []\n",
    "    sum_len = 0\n",
    "    for each in everyday_word_len:\n",
    "        sum_len += each\n",
    "        increase_word_len.append(sum_len)\n",
    "    plt.plot(range(len(increase_word_len)), increase_word_len)\n",
    "    plt.xlabel(\"日期\")\n",
    "    plt.ylabel('总字数字数')\n",
    "    plt.title('每天字数统计')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_statistics():\n",
    "    words = list(word_len.values())\n",
    "    word_sum = np.sum(words)\n",
    "    word_mean = np.mean(words)\n",
    "    word_median = np.median(words)\n",
    "    day_len = len(days)\n",
    "    print('日记天数：',day_len,'\\n','总字数：',word_sum,'\\n','平均字数：',word_mean,'\\n','字数中位数：',word_median)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 功能"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. 获得日记中的所有文本，并且分词"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Building prefix dict from the default dictionary ...\n",
      "Loading model from cache C:\\Users\\hp\\AppData\\Local\\Temp\\jieba.cache\n",
      "Loading model cost 0.966 seconds.\n",
      "Prefix dict has been built successfully.\n"
     ]
    }
   ],
   "source": [
    "def jieba_depart(text):\n",
    "    test_text = text\n",
    "    test_text = re.sub(r'[^\\u4e00-\\u9fa5]+', '', test_text) #把非汉字的字符去掉\n",
    "    word_depart = jieba.cut(test_text)\n",
    "    words = list(word_depart)\n",
    "    return words\n",
    "\n",
    "words = jieba_depart(text)\n",
    "# print(words)\n",
    "# for word in words:\n",
    "#     print(word)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. 把列表中的单词统计词频"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nplt.bar(range(len(word_num_dict.keys())), word_num_dict.values())\\nplt.xlabel(\"单词\")\\nplt.ylabel(\\'频率\\')\\nplt.title(\\'日记词频统计\\')\\nplt.show()   \\n'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "def get_word_num(word_list):\n",
    "    word_num_dict = {}\n",
    "    for word in word_list:\n",
    "        if word not in word_num_dict:\n",
    "            word_num_dict.setdefault(word,1)\n",
    "        else:\n",
    "            word_num_dict[word] += 1\n",
    "    return word_num_dict\n",
    "\n",
    "word_num_dict = get_word_num(words)\n",
    "\n",
    "'''\n",
    "plt.bar(range(len(word_num_dict.keys())), word_num_dict.values())\n",
    "plt.xlabel(\"单词\")\n",
    "plt.ylabel('频率')\n",
    "plt.title('日记词频统计')\n",
    "plt.show()   \n",
    "'''"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. 根据词频排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def word_num_sort(word_num_dict):\n",
    "    word_num_tuple = zip(word_num_dict.values(), word_num_dict.keys())\n",
    "    sort_word_num = sorted(word_num_tuple, reverse=True)\n",
    "    return sort_word_num\n",
    "sort_word_num = word_num_sort(word_num_dict)\n",
    "# print(sort_word_num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. 选取指定范围的词，频率太高的，太低的都不太具有代表性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def select_word(sort_word_num, start=0.08, end=0.3):\n",
    "    length = len(sort_word_num)\n",
    "    start_index = int(length * start)\n",
    "    end_index = int(length * end)\n",
    "    represent = sort_word_num[start_index:end_index]\n",
    "    return represent\n",
    "\n",
    "# print(select_word(sort_word_num, 0.08, 0.13))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 获得任意一天的代表词频字典，类似于每个用户对物品的评价字典，构造数据集"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "critics = {}\n",
    "\n",
    "for key,value in everyday_text.items():\n",
    "    everyday_words = jieba_depart(value)\n",
    "    everyday_word_num_sort = word_num_sort(get_word_num(everyday_words))\n",
    "     \n",
    "    word_num = select_word(everyday_word_num_sort)\n",
    "    word_num_dict = {}\n",
    "    for word in word_num:\n",
    "        word_num_dict[word[1]] = word[0]\n",
    "    critics[key] = word_num_dict\n",
    "\n",
    "# print(critics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 基于用户的协同过滤算法，推荐相似的一天。相似度量可选。 >《集体智慧编程》"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sim_distance(prefs, person1, person2):\n",
    "    si = {}\n",
    "    for item in prefs[person1]:\n",
    "        if item in prefs[person2]:\n",
    "            si[item] = 1\n",
    "\n",
    "    if len(si) == 0:\n",
    "        return 0\n",
    "\n",
    "    sum_of_squares = sum([pow(prefs[person1][item]-prefs[person2][item],2) for item in prefs[person1] if item in prefs[person2]])\n",
    "\n",
    "    # print(sum_of_squares)\n",
    "    return 1/(1+sqrt(sum_of_squares))\n",
    "def sim_pearson(prefs, p1, p2):\n",
    "    si = {}\n",
    "    for item in prefs[p1]:\n",
    "        if item in prefs[p2]:\n",
    "            si[item] = 1\n",
    "\n",
    "    n = len(si)\n",
    "#     print(n)\n",
    "    if n == 0:\n",
    "        return 0\n",
    "\n",
    "    sum1 = sum([prefs[p1][it] for it in si])\n",
    "    sum2 = sum([prefs[p2][it] for it in si])\n",
    "\n",
    "    sum1Sq = sum([pow(prefs[p1][it],2) for it in si])\n",
    "    sum2Sq = sum([pow(prefs[p2][it],2) for it in si])\n",
    "\n",
    "    pSum = sum([prefs[p1][it]*prefs[p2][it] for it in si])\n",
    "\n",
    "    #计算皮尔逊评价值\n",
    "    num = pSum - (sum1 * sum2 / n)\n",
    "#     print(num)\n",
    "    den = sqrt((sum1Sq-pow(sum1,2)/n)*(sum2Sq-pow(sum2, 2)/n))\n",
    "#     print(den)\n",
    "    if den == 0:\n",
    "        return 0\n",
    "\n",
    "    r = num / den\n",
    "\n",
    "    return r\n",
    "\n",
    "#输出与某天日记最相似的n个日记\n",
    "def topMatches(prefs, person, n=5, similarity=sim_pearson):\n",
    "    scores=[(similarity(prefs,person,other), other) for other in prefs if other != person]\n",
    "    scores.sort()\n",
    "    scores.reverse()\n",
    "    return scores[0:n]\n",
    "\n",
    "#推荐可能用到的词\n",
    "def getRecommendations(prefs, person, n=5, similarity=sim_pearson):\n",
    "    totals = {}\n",
    "    simSums = {}\n",
    "    for other in prefs:\n",
    "    #不要和自己作比较\n",
    "        if other == person:\n",
    "            continue\n",
    "        sim = similarity(prefs, person, other)\n",
    "\n",
    "        #忽略评价值为零，或者小于零的情况\n",
    "        if sim<=0:\n",
    "            continue\n",
    "        for item in prefs[other]:\n",
    "\n",
    "          #只对自己还未看过的电影进行评价\n",
    "          if item not in prefs[person] or prefs[person][item] == 0:\n",
    "            #相似度*评价值\n",
    "            totals.setdefault(item, 0)\n",
    "            totals[item] += prefs[other][item]*sim\n",
    "            #相似度之和\n",
    "            simSums.setdefault(item, 0)\n",
    "            simSums[item] += sim\n",
    "    #建立一个归一化的列表\n",
    "    rankings = [(total/simSums[item],item) for item,total in totals.items()]\n",
    "    \n",
    "    #返回经过排序的列表\n",
    "    rankings.sort()\n",
    "    rankings.reverse()\n",
    "    return rankings[0:5]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. 查看任意一天的所有日记信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def look_everyday(date):\n",
    "    return everyday_text[date]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(topMatches(critics,'2020.3.26'))\n",
    "# print(getRecommendations(critics,'2020.4.2'))\n",
    "# print(look_everyday('2020.4.2'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. 显示任意一天任一个单项的日记"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-25.0\n"
     ]
    }
   ],
   "source": [
    "def diary_item(day, item):\n",
    "    if item in everyday_item_text[day]:\n",
    "        return everyday_item_text[day][item]\n",
    "    else:\n",
    "        return ''\n",
    "print(diary_item('2020.4.2','钱'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. 显示任意一项的每天的日记"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def item_everyday(days, item):\n",
    "    for everyday in days:\n",
    "        print(everyday,diary_item(everyday, item))\n",
    "# item_everyday(days, '交流')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 获取之前任意一天与到今天的距离"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pre_date的格式'2020.3.20'\n",
    "def date_distance(pre_date):\n",
    "    pre_date_str = pre_date.split('.')\n",
    "    curr_time = datetime.datetime.now()\n",
    "    pre_time = datetime.datetime(int(pre_date_str[0]),int(pre_date_str[1]),int(pre_date_str[2]))\n",
    "    cur_time = datetime.datetime(curr_time.year,curr_time.month,curr_time.day)\n",
    "    return (cur_time - pre_time).days"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. 搜索功能"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_anything(find_str):\n",
    "    for day in days:\n",
    "        for key in keys:\n",
    "            if key != '_id' and type(diary_item(day,key))==str:\n",
    "                if find_str in diary_item(day, key):\n",
    "                    dd = date_distance(day)\n",
    "                    print(day,'距今',dd,'天')\n",
    "                    print(key,'{',diary_item(day, key),'}')\n",
    "# 高级版本的搜索，输入两个词，如果andor='and'那么就是返回两个词同时存在的日记，or时返回两者中至少有一个\n",
    "# no返回有第一个词没有第二个词的日记\n",
    "def find_anything2(find_str1, find_str2, andor):\n",
    "    if andor == 'and':\n",
    "        for day in days:\n",
    "            for key in keys :\n",
    "                if key != '_id' and type(diary_item(day,key))==str:\n",
    "                    if find_str1 in diary_item(day, key) and find_str2 in diary_item(day, key):\n",
    "                        dd = date_distance(day)\n",
    "                        print(day,'距今',dd,'天')\n",
    "                        print(key,'{',diary_item(day, key),'}')\n",
    "    elif andor == 'or':\n",
    "        for day in days:\n",
    "            for key in keys:\n",
    "                if key != '_id' and type(diary_item(day,key))==str:\n",
    "                    if find_str1 in diary_item(day, key) or find_str2 in diary_item(day, key):\n",
    "                        dd = date_distance(day)\n",
    "                        print(day,'距今',dd,'天')\n",
    "                        print(key,'{',diary_item(day, key),'}')\n",
    "    elif andor == 'no':\n",
    "        for day in days:\n",
    "            for key in keys:\n",
    "                if key != '_id' and type(diary_item(day,key))==str:\n",
    "                    if find_str1 in diary_item(day, key) and find_str2 not in diary_item(day, key):\n",
    "                        dd = date_distance(day)\n",
    "                        print(day,'距今',dd,'天')\n",
    "                        print(key,'{',diary_item(day, key),'}')\n",
    "# find_anything2('学习','妈','and')\n",
    "# find_anything('放纵')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 利用pandas这个工具对日记进行分析"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 分组统计"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态评分\n",
      "0.0    3\n",
      "1.0    4\n",
      "2.0    3\n",
      "Name: 状态评分, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "def group(key):\n",
    "    mind = df[key].groupby(df[key]).size()\n",
    "    print(mind)\n",
    "group('状态评分')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. 制作图云"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = wordcloud.WordCloud(width=1000,\n",
    "                       height=700,\n",
    "                       background_color='white',\n",
    "                       font_path='msyh.ttc')\n",
    "def generate_wordcloud():\n",
    "    for day in days[:-2]: #这里对于之前的日记不重复生成词云\n",
    "        day_str = day.replace('.','年',1)\n",
    "        day_str = day_str.replace('.','月',1)\n",
    "        picture_path_name = 'D:/日记/日记习惯系统/词云图片/' + day_str + '.png'\n",
    "        if os.path.exists(picture_path_name):\n",
    "            pass\n",
    "        else:\n",
    "            w.generate(look_everyday(day))\n",
    "            w.to_file(picture_path_name)\n",
    "    for day in days[-2:]: #但是对于最后两天的日记，每次都重新生成词云\n",
    "        day_str = day.replace('.','年',1)\n",
    "        day_str = day_str.replace('.','月',1)\n",
    "        picture_path_name = 'D:/日记/日记习惯系统/词云图片/' + day_str + '.png'\n",
    "        w.generate(look_everyday(day))\n",
    "        w.to_file(picture_path_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# generate_wordcloud()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 绘制直方图的函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plt_bar(keys, values, xlabel, ylabel, title, types='bar'):\n",
    "    if types == 'bar':\n",
    "        plt.bar(keys, values)\n",
    "    else:\n",
    "        plt.plot(keys, values)\n",
    "#     for a, b in zip(keys, values):\n",
    "#         plt.text(a, b + 0.05, '%.0f' % b, ha='center', va='bottom', fontsize=10)\n",
    "    plt.xlabel(xlabel)\n",
    "    plt.ylabel(ylabel)\n",
    "    plt.title(title)\n",
    "    plt.show()\n",
    "#     plt.savefig('D:/git project/math/fama.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. 情感分析 （比较费时,分析的不太准，因为主要针对电商文本）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def feeling():\n",
    "    feelings = {}\n",
    "    for day in days:\n",
    "        feeling = snownlp.SnowNLP(look_everyday(day)).sentiments\n",
    "        feelings[day] = feeling\n",
    "    return feelings\n",
    "# feelings = feeling()\n",
    "# plt_bar(range(len(feelings.keys())),feelings.values(),'日期','积极程度','情感分析','zhe')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13. 统计花销\n",
    "+ 如何判断nan，他不等于他自己来"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "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": [
    "def money_cal():\n",
    "    result = {}\n",
    "    for day in days:\n",
    "        money = diary_item(day, '钱')\n",
    "        if money != money:\n",
    "            money = 0\n",
    "        result[day] = money\n",
    "    return result\n",
    "moneys = money_cal()\n",
    "# print(money_cal())\n",
    "plt_bar(range(len(moneys.keys())),moneys.values(),'日期','钱','每日收支')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 统一打印分析报告"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "日记天数： 61 \n",
      " 总字数： 46921 \n",
      " 平均字数： 769.1967213114754 \n",
      " 字数中位数： 748.0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "print_statistics()\n",
    "plt_picture()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}