From 37e9d9fff72753f6fcd774dc57721bdd92c44056 Mon Sep 17 00:00:00 2001 From: zdong7 Date: Mon, 31 Aug 2020 19:45:46 +0000 Subject: [PATCH] complete the Practice0 hw --- zdong7.ipynb | 264 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 zdong7.ipynb diff --git a/zdong7.ipynb b/zdong7.ipynb new file mode 100644 index 0000000..992344b --- /dev/null +++ b/zdong7.ipynb @@ -0,0 +1,264 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IPython version: %6.6s 7.17.0\n" + ] + } + ], + "source": [ + "import IPython\n", + "import json\n", + "# Numpy is a library for working with Arrays\n", + "import numpy as np\n", + "# SciPy implements many different numerical algorithms\n", + "import scipy as sp\n", + "# Pandas is good with data tables\n", + "import pandas as pd\n", + "# Module for plotting\n", + "import matplotlib\n", + "#BeautifulSoup parses HTML documents (once you get them via requests)\n", + "import bs4\n", + "# Nltk helps with some natural language tasks, like stemming\n", + "import nltk\n", + "# Bson is a binary format of json to be stored in databases\n", + "import bson\n", + "# Mongo is one of common nosql databases \n", + "# it stores/searches json documents natively\n", + "import pymongo\n", + "print (\"IPython version: %6.6s\", IPython.__version__)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Make a 2 row x 3 column array of random numbers\n", + "[[0.39860853 0.00172869 0.97968484]\n", + " [0.65524169 0.85791178 0.72916159]]\n", + "Add 5 to every element\n", + "[[5.39860853 5.00172869 5.97968484]\n", + " [5.65524169 5.85791178 5.72916159]]\n", + "Get the first row\n", + "[5.39860853 5.00172869 5.97968484]\n" + ] + } + ], + "source": [ + "#Here is what numpy can do\\n\",\n", + "print (\"Make a 2 row x 3 column array of random numbers\")\n", + "x = np.random.random((2, 3))\n", + "print (x)\n", + "\n", + "#array operation (as in R)\n", + "print (\"Add 5 to every element\")\n", + "x = x + 5\n", + "print (x)\n", + "\n", + "# get a slice (first row) (as in R)\n", + "print (\"Get the first row\")\n", + "print (x[0, :])" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# IPython is quite modern: just press at the end of the unfinished statement to see the documentation\n", + "# on possible completions.\n", + "# In the code cell below, type x., to find built-in operations for x\n", + "x.any" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline \n", + "import matplotlib.pyplot as plt\n", + "heads = np.random.binomial(500, .5, size=500)\n", + "histogram = plt.hist(heads, bins=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "# Task 1\n", + "## write a program to produce Fibonacci numbers up to 1000000" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040]\n" + ] + } + ], + "source": [ + "fn = 0\n", + "f0 = 0\n", + "f1 = 1\n", + "fnList = []\n", + "while fn < 1000000:\n", + " if fn == 0:\n", + " fnList.append(f0)\n", + "\n", + " fnList.append(f1)\n", + " fn = f0 + f1\n", + " f0 = f1\n", + " f1 = fn\n", + "\n", + "# Print the Fibonacci numbers list\n", + "print(fnList)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task 2\n", + "## write a program to simulate 1000 tosses of a fair coin (use np.random.binomial)\n", + "## Calculate the mean and standard deviation of that sample" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The mean is: 0.527000\n", + "\n", + "The standard deviation is: 0.499270\n", + "\n" + ] + } + ], + "source": [ + "n, p = 1, 0.5\n", + "mean = np.random.binomial(n, p, 1000)\n", + "res = np.mean(mean)\n", + "print(\"The mean is: %f\\n\" % res)\n", + "\n", + "stan = np.std(mean)\n", + "print(\"The standard deviation is: %f\\n\" % stan )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Task 3\n", + "## Produce a scatterplot of y = 0.5*x+e where x has gaussian (0, 5) and e has gaussian (0, 1) distributions \n", + "### use numpy.random.normal to generate gaussian distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline \n", + "import matplotlib.pyplot as plt\n", + "x = np.random.normal(0, 5, 50)\n", + "e = np.random.normal(0, 1, 50)\n", + "y = 0.5*x + e\n", + "gram = plt.scatter(x, y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.8.2" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +}