diff --git a/tjames17.ipynb b/tjames17.ipynb new file mode 100644 index 0000000..cdc3d0c --- /dev/null +++ b/tjames17.ipynb @@ -0,0 +1,290 @@ +{ + "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": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Make a 2 row x 3 column array of random numbers\n", + "[[0.47000102 0.0079848 0.9753783 ]\n", + " [0.30617977 0.41994193 0.17125758]]\n", + "Add 5 to every element\n", + "[[5.47000102 5.0079848 5.9753783 ]\n", + " [5.30617977 5.41994193 5.17125758]]\n", + "Get the first row\n", + "[5.47000102 5.0079848 5.9753783 ]\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": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "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": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "1\n", + "2\n", + "3\n", + "5\n", + "8\n", + "13\n", + "21\n", + "34\n", + "55\n", + "89\n", + "144\n", + "233\n", + "377\n", + "610\n", + "987\n", + "1597\n", + "2584\n", + "4181\n", + "6765\n", + "10946\n", + "17711\n", + "28657\n", + "46368\n", + "75025\n", + "121393\n", + "196418\n", + "317811\n", + "514229\n", + "832040\n" + ] + } + ], + "source": [ + "def F(n):\n", + " first = 0\n", + " second = 1\n", + " for num in range(0, n):\n", + " term = first \n", + " first = second\n", + " second = term + first\n", + " return term\n", + "\n", + "for i in range(1, 35):\n", + " if F(i) < 1000000:\n", + " print(F(i))" + ] + }, + { + "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": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean: 0.511\n", + "Standard deviation: 0.49987898535545583\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "n = 1\n", + "p = 0.5\n", + "s = np.random.binomial(n, p, 1000)\n", + "\n", + "print(\"Mean:\", np.mean(s))\n", + "print(\"Standard deviation:\", np.std(s))" + ] + }, + { + "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": 2, + "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", + "\n", + "e = np.random.normal(0,1,100)\n", + "x = np.random.normal(0,5,100)\n", + "y = 0.5*x+e\n", + "plt.scatter(x,y)\n", + "plt.show()\n" + ] + }, + { + "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 +}