Skip to content

Instantly share code, notes, and snippets.

@BurcakAsal

BurcakAsal/PythonNumpy.ipynb

Created October 7, 2019 09:13
Show Gist options
  • Save BurcakAsal/fb1916fb1a2e6fb6d10f80dac7802a4a to your computer and use it in GitHub Desktop.
Save BurcakAsal/fb1916fb1a2e6fb6d10f80dac7802a4a to your computer and use it in GitHub Desktop.
Download ZIP
BBM409_2019_Python/Numpy_Tutorial
Display the source blob
Display the rendered blob
Raw
PythonNumpy.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# BBM409 Fundamentals of MACHINE LEARNİNG LAB."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# WEEK 1 - INTRODUCTION TO PYTHON\n",
"\n",
"Instructor : Aykut ERDEM\n",
"\n",
"TA : Burcak ASAL\n",
"\n",
"Time : Monday 15:00-17:00\n",
"\n",
"Office hours : Monday 14:00-15:00\n",
"\n",
"Class webpage : https://web.cs.hacettepe.edu.tr/~aykut/classes/fall2019/bbm406/\n",
"\n",
"Piazza :https://piazza.com/hacettepe.edu.tr/fall2019/bbm406\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Grading\n",
"\n",
"•Quizzes (20%) (Your lowest 2 quiz grades will be dropped.)\n",
"\n",
"•Three assignments (done individually) which involve both theoretical and programming exercises (20%+30%+30%)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Python\n",
"\n",
"\n",
"Python is a high-level, dynamically typed multiparadigm programming language. Python code is often said to be almost like pseudocode, since it allows you to express very powerful ideas in very few lines of code while being very readable.\n",
"\n",
"Rich, built-in collection types:\n",
"\n",
"• Lists\n",
"\n",
"• Tuples\n",
"\n",
"• Dictionaries (maps)\n",
"\n",
"• Sets"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello World\n"
]
}
],
"source": [
"# Writing first program\n",
"\n",
"print(\"Hello World\")"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'int'>\n",
"3\n",
"4\n",
"2\n",
"6\n",
"9\n",
"4\n",
"8\n",
"<class 'float'>\n",
"2.5 3.5 5.0 6.25\n",
"----------------------------------------\n",
"<class 'bool'>\n",
"False\n",
"True\n",
"False\n",
"True\n",
"----------------------------------------\n",
"hello\n",
"5\n",
"hello world\n",
"hello world 12\n",
"----------------------------------------\n",
"Hello\n",
"HELLO\n",
" hello\n",
" hello \n",
"he(ell)(ell)o\n",
"world\n"
]
}
],
"source": [
"# Basic data types\n",
"\n",
"\"\"\"Like most languages, Python has a number of basic types including integers, floats, booleans, and strings. \n",
"These data types behave in ways that are familiar from other programming languages.\"\"\"\n",
"\n",
"#Numbers: Integers and floats work as you would expect from other languages:\n",
"\n",
"x = 3\n",
"print(type(x))\n",
"print(x)\n",
"print(x + 1)\n",
"print(x - 1)\n",
"print(x * 2)\n",
"print(x ** 2)\n",
"x += 1\n",
"print(x)\n",
"x *= 2\n",
"print(x)\n",
"y = 2.5\n",
"print(type(y))\n",
"print(y, y + 1, y * 2, y ** 2)\n",
"\n",
"print(\"----------------------------------------\")\n",
"\n",
"# Booleans: Python implements all of the usual operators for Boolean logic, but uses \n",
"#English words rather than symbols (&&, ||, etc.):\n",
"\n",
"t = True\n",
"f = False\n",
"print(type(t))\n",
"print(t and f)\n",
"print(t or f)\n",
"print(not t)\n",
"print(t != f)\n",
"\n",
"print(\"----------------------------------------\")\n",
"\n",
"#Strings: Python has great support for strings:\n",
"\n",
"hello = 'hello'\n",
"world = \"world\"\n",
"print(hello)\n",
"print(len(hello))\n",
"hw = hello + ' ' + world \n",
"print(hw)\n",
"hw12 = '%s %s %d' % (hello, world, 12) \n",
"print(hw12)\n",
"\n",
"print(\"----------------------------------------\")\n",
"\n",
"#String objects have a bunch of useful methods; for example:\n",
"s = \"hello\"\n",
"print(s.capitalize()) # Capitalize a string; prints \"Hello\"\n",
"print(s.upper()) # Convert a string to uppercase; prints \"HELLO\"\n",
"print(s.rjust(7)) # Right-justify a string, padding with spaces; prints \" hello\"\n",
"print(s.center(7)) # Center a string, padding with spaces; prints \" hello \"\n",
"print(s.replace('l', '(ell)')) # Replace all instances of one substring with another;\n",
" # prints \"he(ell)(ell)o\"\n",
"print(' world '.strip()) # Strip leading and trailing whitespace; prints \"world\"\n",
"\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n"
]
}
],
"source": [
"# Increment and Decrement Operators in Python\n",
"\n",
"\n",
"# A Sample Python program to show loop (unlike many # other languages, it doesn't use ++) \n",
"for i in range(0, 5): \n",
" print(i) \n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n",
"4\n",
"----------------------------------------\n",
"5\n",
"6\n",
"----------------------------------------\n",
"b is divisible by a\n",
"----------------------------------------\n",
"a is not divisible by b\n",
"----------------------------------------\n"
]
}
],
"source": [
"# Variables, Expressions, Conditions and Functions\n",
"\n",
"# Variables\n",
"\"\"\"Variables need not be declared first in python. They can be used directly. \n",
"Variables in python are case sensitive as most of the other programming languages.\"\"\"\n",
"\n",
"a = 3\n",
"A = 4\n",
"print(a) \n",
"print(A) \n",
"print(\"----------------------------------------\")\n",
"\n",
"\n",
"# Expressions\n",
"\"\"\"Arithmetic operations in python can be performed by using arithmetic operators and some of the in-built functions.\"\"\"\n",
"\n",
"a = 2\n",
"b = 3\n",
"c = a + b \n",
"print(c) \n",
"d = a * b \n",
"print(d) \n",
"print(\"----------------------------------------\")\n",
"\n",
"# Conditions\n",
"\"\"\"Conditional output in python can be obtained by using if-else and elif (else if) statements.\"\"\"\n",
"\n",
"a = 3\n",
"b = 9\n",
"if b % a == 0 : \n",
" print(\"b is divisible by a\")\n",
"elif b + 1 == 10: \n",
" print(\"Increment in b produces 10\")\n",
"else: \n",
" print(\"You are in else statement\")\n",
"print(\"----------------------------------------\")\n",
" \n",
"# Functions\n",
"\"\"\"A function in python is declared by the keyword ‘def’ before the name of the function. \n",
"The return type of the function need not be specified explicitly in python. \n",
"The function can be invoked by writing the function name followed by the parameter list in the brackets.\"\"\"\n",
"\n",
"\n",
"# Function for checking the divisibility \n",
"# Notice the indentation after function declaration \n",
"# and if and else statements \n",
"def checkDivisibility(a, b = 5): \n",
" if a % b == 0 : \n",
" print(\"a is divisible by b\")\n",
" else: \n",
" print(\"a is not divisible by b\")\n",
"#Driver program to test the above function \n",
"checkDivisibility(4) \n",
"print(\"----------------------------------------\")\n"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"This is a string\n",
"----------------------------------------\n",
"[1, 'a', 'string', 3]\n",
"[1, 'a', 'string', 3, 6]\n",
"[1, 'a', 'string', 3]\n",
"a\n"
]
},
{
"ename": "NameError",
"evalue": "name 'xs' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-17-e4be25bb13d5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 25\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 26\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 27\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mxs\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# Negative indices count from the end of the list; prints \"2\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 28\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m 29\u001b[0m \u001b[1;31m#Slicing: In addition to accessing list elements one at a time,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
"\u001b[0;31mNameError\u001b[0m: name 'xs' is not defined"
]
}
],
"source": [
"# Strings, Lists, Tuples, Iterations\n",
"\n",
"# Strings\n",
"\"\"\"A string is a sequence of characters. It can be declared in python by using double quotes. \n",
"Strings are immutable, i.e., they cannot be changed.\"\"\"\n",
"# Assigning string to a variable \n",
"a = \"This is a string\"\n",
"print(a) \n",
"print(\"----------------------------------------\")\n",
"\n",
"\n",
"#Lists\n",
"\"\"\"Lists are one of the most powerful tools in python. They are just like the arrays declared in other languages. \n",
"But the most powerful thing is that list need not be always homogenous. \n",
"A single list can contain strings, integers, as well as objects. \n",
"Lists can also be used for implementing stacks and queues. Lists are mutable, i.e., they can be altered once declared.\"\"\"\n",
"\n",
"# Declaring a list \n",
"L = [1, \"a\" , \"string\" , 1+2] \n",
"print(L) \n",
"L.append(6) \n",
"print(L)\n",
"L.pop() # Remove and return the last element of the list\n",
"print(L)\n",
"print(L[1])\n",
"\n",
"print(xs[-1]) # Negative indices count from the end of the list; prints \"2\"\n",
"\n",
"#Slicing: In addition to accessing list elements one at a time, \n",
"#Python provides concise syntax to access sublists; this is known as slicing:\n",
"\n",
"nums = list(range(5)) # range is a built-in function that creates a list of integers\n",
"print(nums) # Prints \"[0, 1, 2, 3, 4]\"\n",
"print(nums[2:4]) # Get a slice from index 2 to 4 (exclusive); prints \"[2, 3]\"\n",
"print(nums[2:]) # Get a slice from index 2 to the end; prints \"[2, 3, 4]\"\n",
"print(nums[:2]) # Get a slice from the start to index 2 (exclusive); prints \"[0, 1]\"\n",
"print(nums[:]) # Get a slice of the whole list; prints \"[0, 1, 2, 3, 4]\"\n",
"print(nums[:-1]) # Slice indices can be negative; prints \"[0, 1, 2, 3]\"\n",
"nums[2:4] = [8, 9] # Assign a new sublist to a slice\n",
"print(nums) # Prints \"[0, 1, 8, 9, 4]\"\n",
"\n",
"print(\"----------------------------------------\")\n",
"\n",
"\n",
"# Tuples\n",
"\"\"\"A tuple is a sequence of immutable Python objects. \n",
"Tuples are just like lists with the exception that tuples cannot be changed once declared. \n",
"Tuples are usually faster than lists.\"\"\"\n",
"\n",
"tup = (1, \"a\", \"string\", 1+2) \n",
"print(tup )\n",
"print(tup[1]) \n",
"print(\"----------------------------------------\")\n",
"\n",
"\n",
"# Iterations\n",
"\"\"\"Iterations or looping can be performed in python by ‘for’ and ‘while’ loops. \n",
"Apart from iterating upon a particular condition, we can also iterate on strings, lists, and tuples.\"\"\"\n",
"\n",
"# Example1: Iteration by while loop for a condition\n",
"i = 1\n",
"while (i < 10): \n",
" i += 1\n",
" print(i) \n",
"print(\"----------------------------------------\")\n",
"\n",
"\n",
"# Example 2: Iteration by for loop on string\n",
"s = \"Hello World\"\n",
"for i in s : \n",
" print(i) \n",
"print(\"----------------------------------------\")\n",
"\n",
"\n",
"# Example 3: Iteration by for loop on list\n",
"L = [1, 4, 5, 7, 8, 9] \n",
"for i in L: \n",
" print(i), \n",
"print(\"----------------------------------------\")\n",
" \n",
"#Example 4 : Iteration by for loop for range\n",
"for i in range(0, 10): \n",
" print(i) \n",
"print(\"----------------------------------------\")\n",
"\n",
"# List comprehensions\n",
"\n",
"\"\"\"When programming, frequently we want to transform one type of data into another. \n",
"As a simple example, consider the following code that computes square numbers:\"\"\"\n",
"\n",
"nums = [0, 1, 2, 3, 4]\n",
"squares = []\n",
"for x in nums:\n",
" squares.append(x ** 2)\n",
"print(squares) \n",
"print(\"----------------------------------------\")\n",
"# You can make this code simpler using a list comprehension:\n",
"nums = [0, 1, 2, 3, 4]\n",
"squares = [x ** 2 for x in nums]\n",
"print(squares) \n",
"print(\"----------------------------------------\")\n",
"\n",
"#List comprehensions can also contain conditions:\n",
"\n",
"nums = [0, 1, 2, 3, 4]\n",
"even_squares = [x ** 2 for x in nums if x % 2 == 0]\n",
"print(even_squares)\n",
"print(\"----------------------------------------\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Dictionaris\n",
"\n",
"\"\"\"A dictionary stores (key, value) pairs, similar to a Map in Java or an object in Javascript.\"\"\"\n",
"\n",
"d = {'cat': 'cute', 'dog': 'furry'}\n",
"print(d['cat'])\n",
"print('cat' in d) # Check if a dictionary has a given key; prints \"True\"\n",
"d['fish'] = 'wet' # Set an entry in a dictionary\n",
"print(d['fish']) # Prints \"wet\"\n",
"# print(d['monkey']) # KeyError: 'monkey' not a key of d\n",
"print(d.get('monkey', 'N/A')) # Get an element with a default; prints \"N/A\"\n",
"print(d.get('fish', 'N/A')) # Get an element with a default; prints \"wet\"\n",
"del d['fish'] # Remove an element from a dictionary\n",
"print(d.get('fish', 'N/A')) # \"fish\" is no longer a key; prints \"N/A\"\n",
"print(\"----------------------------------------\")\n",
"\n",
"\n",
"#If you want access to keys and their corresponding values, use the items method:\n",
"d = {'person': 2, 'cat': 4, 'spider': 8}\n",
"for animal, legs in d.items():\n",
" print('A %s has %d legs' % (animal, legs))\n",
"print(\"----------------------------------------\")\n",
"\n",
"# Dictionary comprehensions: These are similar to list comprehensions, but allow you to easily construct dictionaries. \n",
"nums = [0, 1, 2, 3, 4]\n",
"even_num_to_square = {x: x ** 2 for x in nums if x % 2 == 0}\n",
"print(even_num_to_square)\n",
"print(\"----------------------------------------\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Sets\n",
"\n",
"\"\"\"A set is an unordered collection of distinct elements.\"\"\"\n",
"animals = {'cat', 'dog'}\n",
"print('cat' in animals) # Check if an element is in a set; prints \"True\"\n",
"print('fish' in animals) # prints \"False\"\n",
"animals.add('fish') # Add an element to a set\n",
"print('fish' in animals) # Prints \"True\"\n",
"print(len(animals)) # Number of elements in a set; prints \"3\"\n",
"animals.add('cat') # Adding an element that is already in the set does nothing\n",
"print(len(animals)) # Prints \"3\"\n",
"animals.remove('cat') # Remove an element from a set\n",
"print(len(animals)) # Prints \"2\"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# Classes\n",
"\n",
"\"\"\"The syntax for defining classes in Python is straightforward:\"\"\"\n",
"\n",
"class Greeter(object):\n",
"\n",
" # Constructor\n",
" def __init__(self, name):\n",
" self.name = name # Create an instance variable\n",
"\n",
" # Instance method\n",
" def greet(self, loud=False):\n",
" if loud:\n",
" print('HELLO, %s!' % self.name.upper())\n",
" else:\n",
" print('Hello, %s' % self.name)\n",
"\n",
"g = Greeter('Fred') # Construct an instance of the Greeter class\n",
"g.greet() # Call an instance method; prints \"Hello, Fred\"\n",
"g.greet(loud=True) # Call an instance method; prints \"HELLO, FRED!\"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Numpy\n",
"\n",
"Numpy is the core library for scientific computing in Python. It provides a high-performance multidimensional array object, and tools for working with these arrays."
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"<class 'numpy.ndarray'>\n",
"(3,)\n",
"1 2 3\n",
"[5 2 3]\n",
"(2, 3)\n",
"1 2 4\n",
"----------------------------------------\n",
"[[0. 0.]\n",
" [0. 0.]]\n",
"----------------------------------------\n",
"[[1. 1.]]\n",
"----------------------------------------\n",
"[[7 7]\n",
" [7 7]]\n",
"----------------------------------------\n",
"[[1. 0.]\n",
" [0. 1.]]\n",
"----------------------------------------\n",
"[[0.74114014 0.75512823]\n",
" [0.11460861 0.99426372]]\n",
"----------------------------------------\n"
]
}
],
"source": [
"\"\"\"We can initialize numpy arrays from nested Python lists, and access elements using square brackets:\"\"\"\n",
"\n",
"import numpy as np\n",
"\n",
"a = np.array([1, 2, 3]) # Create a rank 1 array\n",
"print(type(a)) # Prints \"<class 'numpy.ndarray'>\"\n",
"print(a.shape) # Prints \"(3,)\"\n",
"print(a[0], a[1], a[2]) # Prints \"1 2 3\"\n",
"a[0] = 5 # Change an element of the array\n",
"print(a) # Prints \"[5, 2, 3]\"\n",
"\n",
"b = np.array([[1,2,3],[4,5,6]]) # Create a rank 2 array\n",
"print(b.shape) # Prints \"(2, 3)\"\n",
"print(b[0, 0], b[0, 1], b[1, 0]) # Prints \"1 2 4\"\n",
"print(\"----------------------------------------\")\n",
"\n",
"#Numpy also provides many functions to create arrays:\n",
"import numpy as np\n",
"\n",
"a = np.zeros((2,2))\n",
"print(a) \n",
"print(\"----------------------------------------\")\n",
"\n",
"b = np.ones((1,2)) \n",
"print(b)\n",
"print(\"----------------------------------------\")\n",
"\n",
"c = np.full((2,2), 7)\n",
"print(c) \n",
"print(\"----------------------------------------\")\n",
"\n",
"d = np.eye(2)\n",
"print(d) \n",
"print(\"----------------------------------------\")\n",
"\n",
"e = np.random.random((2,2))\n",
"print(e)\n",
"print(\"----------------------------------------\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Array math\n",
"\n",
"Basic mathematical functions operate elementwise on arrays, and are available both as operator overloads and as functions in the numpy module:"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[[ 6. 8.]\n",
" [10. 12.]]\n",
"[[ 6. 8.]\n",
" [10. 12.]]\n",
"----------------------------------------\n",
"[[-4. -4.]\n",
" [-4. -4.]]\n",
"[[-4. -4.]\n",
" [-4. -4.]]\n",
"----------------------------------------\n",
"[[ 5. 12.]\n",
" [21. 32.]]\n",
"[[ 5. 12.]\n",
" [21. 32.]]\n",
"----------------------------------------\n",
"[[0.2 0.33333333]\n",
" [0.42857143 0.5 ]]\n",
"[[0.2 0.33333333]\n",
" [0.42857143 0.5 ]]\n",
"----------------------------------------\n",
"[[1. 1.41421356]\n",
" [1.73205081 2. ]]\n",
"----------------------------------------\n",
"219\n",
"219\n",
"----------------------------------------\n",
"[29 67]\n",
"[29 67]\n",
"----------------------------------------\n",
"[[19 22]\n",
" [43 50]]\n",
"[[19 22]\n",
" [43 50]]\n",
"----------------------------------------\n"
]
}
],
"source": [
"import numpy as np\n",
"\n",
"x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
"y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
"\n",
"# Elementwise sum; both produce the array\n",
"print(x + y)\n",
"print(np.add(x, y))\n",
"print(\"----------------------------------------\")\n",
"\n",
"# Elementwise difference; both produce the array\n",
"print(x - y)\n",
"print(np.subtract(x, y))\n",
"print(\"----------------------------------------\")\n",
"\n",
"# Elementwise product; both produce the array\n",
"print(x * y)\n",
"print(np.multiply(x, y))\n",
"print(\"----------------------------------------\")\n",
"\n",
"# Elementwise division; both produce the array\n",
"print(x / y)\n",
"print(np.divide(x, y))\n",
"print(\"----------------------------------------\")\n",
"\n",
"# Elementwise square root; produces the array\n",
"print(np.sqrt(x))\n",
"print(\"----------------------------------------\")\n",
"\n",
"x = np.array([[1,2],[3,4]])\n",
"y = np.array([[5,6],[7,8]])\n",
"\n",
"v = np.array([9,10])\n",
"w = np.array([11, 12])\n",
"\n",
"# Inner product of vectors;\n",
"print(v.dot(w))\n",
"print(np.dot(v, w))\n",
"print(\"----------------------------------------\")\n",
"\n",
"# Matrix / vector product; both produce the rank 1 array\n",
"print(x.dot(v))\n",
"print(np.dot(x, v))\n",
"print(\"----------------------------------------\")\n",
"\n",
"# Matrix / matrix product; both produce the rank 2 array\n",
"print(x.dot(y))\n",
"print(np.dot(x, y))\n",
"print(\"----------------------------------------\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note : Python examples are taken from https://www.geeksforgeeks.org/python-language-introduction/ .\n",
" Numpy examples are taken from http://cs231n.github.io/python-numpy-tutorial/ "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
},
{
"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.6.5"
}
},
"nbformat": 4,
"nbformat_minor": 2
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment