diff --git a/jgurganu.ipynb b/jgurganu.ipynb new file mode 100644 index 0000000..3b94147 --- /dev/null +++ b/jgurganu.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": { + "scrolled": true + }, + "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": 25, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21\n" + ] + } + ], + "source": [ + "def Fibonacci(n): \n", + " if n==1: \n", + " return 0 \n", + " elif n==2: \n", + " return 1\n", + " else: \n", + " return Fibonacci(n-1)+Fibonacci(n-2) \n", + " \n", + "num = 9 #could put 1000000\n", + " \n", + "print(Fibonacci(9))" + ] + }, + { + "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": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.523\n", + "0.4994707198625361\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "tosses = np.random.binomial(1, .5, 1000)\n", + "print(np.mean(tosses))\n", + "print(np.std(tosses))" + ] + }, + { + "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": 33, + "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 numpy as np\n", + "import matplotlib.pyplot as plt\n", + "x = np.random.normal((0,5))\n", + "e = np.random.normal((0,1))\n", + "y = 0.5*x+e\n", + "scatterp = plt.scatter(x,y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "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 +}