diff --git a/Practice0.ipynb b/Practice0.ipynb deleted file mode 100644 index 4b16c03..0000000 --- a/Practice0.ipynb +++ /dev/null @@ -1,198 +0,0 @@ -{ - "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": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - }, - { - "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": null, - "metadata": { - "collapsed": true - }, - "outputs": [], - "source": [] - }, - { - "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": null, - "metadata": { - "collapsed": true - }, - "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.5.2" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/cfei1.ipynb b/cfei1.ipynb new file mode 100644 index 0000000..9511c60 --- /dev/null +++ b/cfei1.ipynb @@ -0,0 +1,255 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "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": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "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": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Make a 2 row x 3 column array of random numbers\n", + "[[0.85257809 0.98487037 0.68877815]\n", + " [0.48262433 0.04109368 0.31830499]]\n", + "Add 5 to every element\n", + "[[5.85257809 5.98487037 5.68877815]\n", + " [5.48262433 5.04109368 5.31830499]]\n", + "Get the first row\n", + "[5.85257809 5.98487037 5.68877815]\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": 8, + "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": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 " + ] + } + ], + "source": [ + "a, b = 0, 1\n", + "while a < 1000000:\n", + " print(a, end=' ')\n", + " a, b = b, a + b" + ] + }, + { + "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": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: 0.519\n", + "standard deviation: 0.49963886958482323\n" + ] + } + ], + "source": [ + "s = np.random.binomial(1, 0.5, 1000)\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": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "x = np.random.normal(0, 5, 100)\n", + "e = np.random.normal(0, 1, 100)\n", + "y = 0.5*x + e\n", + "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 +}