From 326e42ecdafa5f47ada67b556c0ca061c7b0d077 Mon Sep 17 00:00:00 2001 From: madphill Date: Thu, 3 Sep 2020 19:36:25 +0000 Subject: [PATCH] practice 0 --- mphill66.ipynb | 265 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 265 insertions(+) create mode 100644 mphill66.ipynb diff --git a/mphill66.ipynb b/mphill66.ipynb new file mode 100644 index 0000000..095b1a8 --- /dev/null +++ b/mphill66.ipynb @@ -0,0 +1,265 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "IPython version: %6.6s 6.1.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.20354485 0.87353642 0.79226415]\n", + " [ 0.26457656 0.23486214 0.8240387 ]]\n", + "Add 5 to every element\n", + "[[ 5.20354485 5.87353642 5.79226415]\n", + " [ 5.26457656 5.23486214 5.8240387 ]]\n", + "Get the first row\n", + "[ 5.20354485 5.87353642 5.79226415]\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": "iVBORw0KGgoAAAANSUhEUgAAAXoAAAD8CAYAAAB5Pm/hAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "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": 2, + "metadata": {}, + "outputs": [ + { + "ename": "RecursionError", + "evalue": "maximum recursion depth exceeded in comparison", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mRecursionError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mFibonacci\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "... last 1 frames repeated, from the frame below ...\n", + "\u001b[0;32m\u001b[0m in \u001b[0;36mFibonacci\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m 7\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 11\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFibonacci\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100000\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded in comparison" + ] + } + ], + "source": [ + "def Fibonacci(n): \n", + " if n<0: \n", + " print(\"no\")\n", + " elif n==1: \n", + " return 0\n", + " elif n==2: \n", + " return 1\n", + " else: \n", + " return Fibonacci(n-1)+Fibonacci(n-2) \n", + " \n", + "print(Fibonacci(100000)) " + ] + }, + { + "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": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean = 0.497 \n", + "std deviation = 0.4999909999189985\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "res = np.random.binomial(1, 1/2, 1000)\n", + "sd = np.std(res)\n", + "mean = np.mean(res)\n", + "\n", + "print(\"mean = \", mean, \"\\nstd deviation = \", sd)" + ] + }, + { + "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": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "x = np.random.normal(0, 5, 500)\n", + "e = np.random.normal(0, 1, 500)\n", + "\n", + "plt.scatter(x, e)\n", + "plt.show()" + ] + }, + { + "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 +}