Skip to content

Instantly share code, notes, and snippets.

@mikephys8

mikephys8/day1.ipynb

Forked from anandology/day1.ipynb
Last active August 29, 2015 14:08
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save mikephys8/8c93558f5ed9b916a9e6 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save mikephys8/8c93558f5ed9b916a9e6 to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
day1.ipynb
{
"metadata": {
"name": ""
},
"nbformat": 3,
"nbformat_minor": 0,
"worksheets": [
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Python Training at LinkedIn - Day 1\n",
"\n",
"Jan 28-30, 2014 - [Anand Chitipothu](http://anandology.com)"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print \"Good Morning!\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Good Morning!\n"
]
}
],
"prompt_number": 1
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"3 + 4"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 2,
"text": [
"7"
]
}
],
"prompt_number": 2
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can also write the python program in a file and run it as a script."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file a.py\n",
"print 3 + 4"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Overwriting a.py\n"
]
}
],
"prompt_number": 3
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python a.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"7\r\n"
]
}
],
"prompt_number": 4
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Variables**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"There is no need to declare variables up-front. You can start using them as and when needed."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = 5\n",
"print x*x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"25\n"
]
}
],
"prompt_number": 5
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And there is no need to tell Python what type it is."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = \"hello\"\n",
"print x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"hello\n"
]
}
],
"prompt_number": 6
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python is strongly-typed. It is an error to add a number to a string. No implicit conversion is done."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"1 + \"3\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "unsupported operand type(s) for +: 'int' and 'str'",
"output_type": "pyerr",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-7-a9d4b5316843>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m1\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;34m\"3\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
]
}
],
"prompt_number": 7
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you use an undefined variable, it is an error."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"# y is not defined here\n",
"x + y"
],
"language": "python",
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'y' is not defined",
"output_type": "pyerr",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-10-c74b59957f6e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# y is not defined here\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mNameError\u001b[0m: name 'y' is not defined"
]
}
],
"prompt_number": 10
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And it is possible to assign multiple values at once."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a, b = 1, 2\n",
"print a\n",
"print b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"1\n",
"2\n"
]
}
],
"prompt_number": 11
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"How do you swap values of two variables?"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"tmp = a\n",
"b = a\n",
"a = tmp\n",
"print a, b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"1 1\n"
]
}
],
"prompt_number": 12
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a, b = 1, 2"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 14
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"a, b = b, a"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 15
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print a, b"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"2 1\n"
]
}
],
"prompt_number": 16
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Functions"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = 4\n",
"print x*x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"16\n"
]
}
],
"prompt_number": 17
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def square(x):\n",
" return x*x\n",
"\n",
"print square(4)\n",
"print square(2+3)\n",
"print square(square(2))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"16\n",
"25\n",
"16\n"
]
}
],
"prompt_number": 18
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `cube` to compute cube of a number.\n",
"\n",
" >>> cube(2)\n",
" 8\n",
" >>> cube(3)\n",
" 27"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"square(5)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 19,
"text": [
"25"
]
}
],
"prompt_number": 19
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"square"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 20,
"text": [
"<function __main__.square>"
]
}
],
"prompt_number": 20
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"f = square\n",
"print f(5)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"25\n"
]
}
],
"prompt_number": 21
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"f"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 22,
"text": [
"<function __main__.square>"
]
}
],
"prompt_number": 22
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def sum_of_squares(x, y):\n",
" return square(x) + square(y)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 23
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"sum_of_squares(3, 4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 24,
"text": [
"25"
]
}
],
"prompt_number": 24
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"How to implement `sum_of_cubes`?"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def cube(x):\n",
" return x*x*x"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 25
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def sum_of_cubes(x, y):\n",
" return cube(x) + cube(y)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 26
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print sum_of_cubes(3, 4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"91\n"
]
}
],
"prompt_number": 27
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can pass function as argument too."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def sumof(f, x, y):\n",
" return f(x) + f(y)\n",
"\n",
"print sumof(square, 3, 4)\n",
"print sumof(cube, 3, 4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"25\n",
"91\n"
]
}
],
"prompt_number": 28
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Built-in Functions**"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"min(3, 4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 29,
"text": [
"3"
]
}
],
"prompt_number": 29
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"max(4, 6)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 30,
"text": [
"6"
]
}
],
"prompt_number": 30
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"len(\"helloworld\")"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 31,
"text": [
"10"
]
}
],
"prompt_number": 31
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"hello\" + str(1)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 32,
"text": [
"'hello1'"
]
}
],
"prompt_number": 32
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"int(\"3\") + 2"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 33,
"text": [
"5"
]
}
],
"prompt_number": 33
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `count_digits` to count number of digits in a given number.\n",
" \n",
" >>> count_digits(5)\n",
" 1\n",
" >>> count_digits(12345)\n",
" 5\n",
" \n",
"Hint: Use built-in function `str`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Built-in function `help` shows help on a function or a module."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"help(min)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Help on built-in function min in module __builtin__:\n",
"\n",
"min(...)\n",
" min(iterable[, key=func]) -> value\n",
" min(a, b, c, ...[, key=func]) -> value\n",
" \n",
" With a single iterable argument, return its smallest item.\n",
" With two or more arguments, return the smallest argument.\n",
"\n"
]
}
],
"prompt_number": 36
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**print vs. return**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Lets look at the following 2 functions."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def square1(x):\n",
" print x*x\n",
"\n",
"square1(4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"16\n"
]
}
],
"prompt_number": 38
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def square2(x):\n",
" return x*x\n",
"\n",
"print square2(4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"16\n"
]
}
],
"prompt_number": 39
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What is the difference between these two? Which one is better and why?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"How do you compute square of square of a number?"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"square2(square2(2))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 40,
"text": [
"16"
]
}
],
"prompt_number": 40
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can't do that with `square1`."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Methods"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Methods are functions that operate on an object."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = \"hello\"\n",
"print x.upper()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"HELLO\n"
]
}
],
"prompt_number": 41
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"Hello\".lower()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 45,
"text": [
"'hello'"
]
}
],
"prompt_number": 45
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"mathematics\".count(\"mat\")"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 42,
"text": [
"2"
]
}
],
"prompt_number": 42
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"Mathematics\".count(\"mat\")"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 44,
"text": [
"1"
]
}
],
"prompt_number": 44
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `icount` to count number of occurances of a substring in the given string, ignoring the case.\n",
"\n",
" >>> icount(\"mathematics\", \"mat\")\n",
" 2\n",
" >>> icount(\"Mathematics\", \"mat\")\n",
" 2\n",
" >>> icount(\"Mathematics\", \"MAT\")\n",
" 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Conditional Expressions"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"age = 30\n",
"print age > 20"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"True\n"
]
}
],
"prompt_number": 46
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print age < 20"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"False\n"
]
}
],
"prompt_number": 47
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"age == 30"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 48,
"text": [
"True"
]
}
],
"prompt_number": 48
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"age != 25"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 49,
"text": [
"True"
]
}
],
"prompt_number": 49
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"python\" == \"python\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 50,
"text": [
"True"
]
}
],
"prompt_number": 50
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"python\" > \"perl\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 51,
"text": [
"True"
]
}
],
"prompt_number": 51
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"python\" > \"java\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 52,
"text": [
"True"
]
}
],
"prompt_number": 52
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"python\" > \"zoo\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 53,
"text": [
"False"
]
}
],
"prompt_number": 53
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"not \"python\" > \"zoo\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 54,
"text": [
"True"
]
}
],
"prompt_number": 54
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"name = \"joe\"\n",
"age = 25"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 55
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"name == \"joe\" and age > 20"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 56,
"text": [
"True"
]
}
],
"prompt_number": 56
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Wrtite a function `istreq` to test if 2 strings are equal ignoring the case.\n",
"\n",
" >>> istreq(\"python\", \"PYTHON\")\n",
" True\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python has `in` and `not in` operators for testing for contains. "
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"man\" in \"woman\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 57,
"text": [
"True"
]
}
],
"prompt_number": 57
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"hell\" in \"hello\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 58,
"text": [
"True"
]
}
],
"prompt_number": 58
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"el\" in \"hello\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 59,
"text": [
"True"
]
}
],
"prompt_number": 59
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## If Statement"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"n = 26\n",
"if n % 2 == 0:\n",
" print \"even\"\n",
"else:\n",
" print \"odd\""
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"even\n"
]
}
],
"prompt_number": 62
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `minimum` to compute minimum of given 2 numbers. Do it without using the built-in `min` function.\n",
"\n",
" >>> minimum(3, 6)\n",
" 3\n",
" >>> minimum(7, 4)\n",
" 4"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `minimum3` to compute minimum of 3 numbers. Can you use the above `minimum` function in implementing this?\n",
"\n",
" >>> minimum3(4, 9, 2)\n",
" 2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Solutions to above problems:"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def minimum(x, y):\n",
" if x < y:\n",
" return x\n",
" else:\n",
" return y\n",
" \n",
"print minimum(3, 5)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"3\n"
]
}
],
"prompt_number": 63
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def minimum3(x, y, z):\n",
" m = minimum(x, y)\n",
" return minimum(m, z)\n",
" # return minimum(minimum(x, y), z)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 64
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Lists"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [\"a\", \"b\", \"c\"]"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 71
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"['a', 'b', 'c']\n"
]
}
],
"prompt_number": 72
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"len(x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 73,
"text": [
"3"
]
}
],
"prompt_number": 73
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[0]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 74,
"text": [
"'a'"
]
}
],
"prompt_number": 74
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[1]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 75,
"text": [
"'b'"
]
}
],
"prompt_number": 75
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[2]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 76,
"text": [
"'c'"
]
}
],
"prompt_number": 76
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[3]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"ename": "IndexError",
"evalue": "list index out of range",
"output_type": "pyerr",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-77-ed224ad0520d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mIndexError\u001b[0m: list index out of range"
]
}
],
"prompt_number": 77
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Modules"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"import time"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 78
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"That imported the time module in to current namespace."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"time"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 79,
"text": [
"<module 'time' from '/Users/anand/pyenvs/sandbox27/lib/python2.7/lib-dynload/time.so'>"
]
}
],
"prompt_number": 79
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"time.asctime()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 80,
"text": [
"'Tue Jan 28 11:48:04 2014'"
]
}
],
"prompt_number": 80
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a program `date.py` that prints the current date and time."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Reading command-line arguments**"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"%%file args.py\n",
"import sys\n",
"print sys.argv"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"Writing args.py\n"
]
}
],
"prompt_number": 81
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python args.py"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"['args.py']\r\n"
]
}
],
"prompt_number": 82
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python args.py hello"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"['args.py', 'hello']\r\n"
]
}
],
"prompt_number": 83
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"!python args.py hello world"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"['args.py', 'hello', 'world']\r\n"
]
}
],
"prompt_number": 84
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write program `echo.py` that takes one argument from the command line and prints it back.\n",
"\n",
"<pre>\n",
"$ python echo.py hello\n",
"hello\n",
"$ python echo.py hello world\n",
"hello\n",
"</pre>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem:** Write program `square.py` that takes a number as command-line argument and prints its square.\n",
"\n",
"<pre>\n",
"$ python square.py 5\n",
"25\n",
"$ python square.py 4\n",
"16\n",
"</pre>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem:** Write a program `add.py` that takes 2 numbers as command line arguments and prints their sum.\n",
"\n",
"<pre>\n",
"$ python add.py 2 3\n",
"5\n",
"</pre>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## For Loop"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [\"a\", \"b\", \"c\"]\n",
"for a in x:\n",
" print a"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"a\n",
"b\n",
"c\n"
]
}
],
"prompt_number": 85
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `my_sum` that takes a list of numbers as argument and returns their sum.\n",
" \n",
" >>> my_sum([1, 2, 3, 4, 5])\n",
" 15\n",
" \n",
"Note: You should do this without using the built-in `sum` function."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Appending new elements to a list**"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `append` method is used to add new elements to a list at the end."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [\"a\", \"b\", \"c\"]\n",
"x.append(\"d\")\n",
"print x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"['a', 'b', 'c', 'd']\n"
]
}
],
"prompt_number": 87
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `squares` that takes a list of numbers as arguments and returns a new list containing their squares.\n",
"\n",
" >>> squares([1, 2, 3, 4, 5])\n",
" [1, 4, 9, 16, 25]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `evens` that takes a list of numbers as argument and returns a list containing only the even numbers from the given list.\n",
"\n",
" >>> evens([1, 2, 3, 4, 5, 6, 7, 8])\n",
" [2, 4, 6, 8]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `xmap` to take a function `f` and a list of values and returns a list containing result of `f` applied to each value in the list.\n",
"\n",
" >>> xmap(square, [1, 2, 3, 4])\n",
" [1, 4, 9, 16]\n",
" >>> xmap(cube, [1, 2, 3, 4])\n",
" [1, 8, 27, 64]\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Pitfalls in modifying lists**"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [1, 2, 3, 4]\n",
"y = x\n",
"x.append(5)\n",
"print x\n",
"print y"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[1, 2, 3, 4, 5]\n",
"[1, 2, 3, 4, 5]\n"
]
}
],
"prompt_number": 1
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def append(lst, value):\n",
" lst.append(value)\n",
"\n",
"x = [1, 2, 3, 4]\n",
"append(x, 5)\n",
"print x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[1, 2, 3, 4, 5]\n"
]
}
],
"prompt_number": 2
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [1, 2, 3, 4]\n",
"y = list(x) # make a copy x\n",
"x.append(5)\n",
"print x, y"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[1, 2, 3, 4, 5] [1, 2, 3, 4]\n"
]
}
],
"prompt_number": 3
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [1, 2, 3, 4]\n",
"y = [1, 2, 3, 4]\n",
"z = x\n",
"print x == y, x is y\n",
"print x == z, x is z"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"True False\n",
"True True\n"
]
}
],
"prompt_number": 4
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print id(x), id(y), id(z)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"4334368096 4334367808 4334368096\n"
]
}
],
"prompt_number": 5
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**The range function**"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"range(10)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 6,
"text": [
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
]
}
],
"prompt_number": 6
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"range(3, 10)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 8,
"text": [
"[3, 4, 5, 6, 7, 8, 9]"
]
}
],
"prompt_number": 8
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"sum([1, 2, 3, 4])"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 9,
"text": [
"10"
]
}
],
"prompt_number": 9
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"How do you find sum of first 10 integers?"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"sum(range(1, 11))"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 10,
"text": [
"55"
]
}
],
"prompt_number": 10
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem:** Write a function `sum_of_integers` that takes a number n and computes sum of integers from 1..n.\n",
"\n",
" >>> sum_of_integers(10)\n",
" 55"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `sum_of_squares` that takes a number and computes sum of squares of integers from 1..n.\n",
"\n",
" >>> sum_of_squares(3)\n",
" 14\n",
" >>> sum_of_squares(4)\n",
" 30"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem:** Write a funtion `sigma`, that takes function `f`, `begin` and `end` and computes sum of f applied to `begin`..`end`.\n",
"\n",
" >>> def square(x):\n",
" ... return x*x\n",
" ...\n",
" >>> sigma(square, 1, 4)\n",
" 30"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def sigma(f, begin, end):\n",
" numbers = range(begin, end+1)\n",
" \n",
" values = []\n",
" for n in numbers:\n",
" values.append(f(n))\n",
" \n",
" return sum(values)\n",
"\n",
"def square(x):\n",
" return x * x\n",
"print sigma(square, 1, 4)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"30\n"
]
}
],
"prompt_number": 16
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**List Indexing**"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = ['a', 'b', 'c', 'd']"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 14
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[0]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 15,
"text": [
"'a'"
]
}
],
"prompt_number": 15
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[-1]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 17,
"text": [
"'d'"
]
}
],
"prompt_number": 17
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[len(x)-1]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 18,
"text": [
"'d'"
]
}
],
"prompt_number": 18
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[0] = 'aa'\n",
"print x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"['aa', 'b', 'c', 'd']\n"
]
}
],
"prompt_number": 19
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"'b' in x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 20,
"text": [
"True"
]
}
],
"prompt_number": 20
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"'z' in x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 21,
"text": [
"False"
]
}
],
"prompt_number": 21
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**List Slicing**"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = ['a', 'b', 'c', 'd', 'e', 'f', 'g']"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 22
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[0:3] # first three elements"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 23,
"text": [
"['a', 'b', 'c']"
]
}
],
"prompt_number": 23
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[:3]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 24,
"text": [
"['a', 'b', 'c']"
]
}
],
"prompt_number": 24
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[3:] # 3 to the end"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 25,
"text": [
"['d', 'e', 'f', 'g']"
]
}
],
"prompt_number": 25
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[-3:] # last 3 elements"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 26,
"text": [
"['e', 'f', 'g']"
]
}
],
"prompt_number": 26
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[:] # make a copy of the list"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 27,
"text": [
"['a', 'b', 'c', 'd', 'e', 'f', 'g']"
]
}
],
"prompt_number": 27
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a program `sum.py` that takes multiple numbers as command line arguments and prints their sum.\n",
"\n",
"<pre>\n",
"$ python sum.py 1 2 3 4\n",
"10\n",
"$ python sum.py 1 2 3 4 5 6 7 8 9 10\n",
"55\n",
"</pre>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Slicing has optional third field."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 29,
"text": [
"['a', 'b', 'c', 'd', 'e', 'f', 'g']"
]
}
],
"prompt_number": 29
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[0:6:2]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 31,
"text": [
"['a', 'c', 'e']"
]
}
],
"prompt_number": 31
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[::2]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 32,
"text": [
"['a', 'c', 'e', 'g']"
]
}
],
"prompt_number": 32
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[::-1]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 33,
"text": [
"['g', 'f', 'e', 'd', 'c', 'b', 'a']"
]
}
],
"prompt_number": 33
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"len(x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 34,
"text": [
"7"
]
}
],
"prompt_number": 34
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Sorting Lists**"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [2, 10, 4, 3, 7]\n",
"x.sort() # sorts list in-place\n",
"print x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[2, 3, 4, 7, 10]\n"
]
}
],
"prompt_number": 35
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [2, 10, 4, 3, 7]\n",
"y = sorted(x) # returns a new sorted list\n",
"print y"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[2, 3, 4, 7, 10]\n"
]
}
],
"prompt_number": 37
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = [2, 4, -5, 7, -8, 9]\n",
"print sorted(x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[-8, -5, 2, 4, 7, 9]\n"
]
}
],
"prompt_number": 40
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"How can we sort this list on absolute value of the numbers instead?"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print sorted(x, key=abs)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"[2, 4, -5, 7, -8, 9]\n"
]
}
],
"prompt_number": 41
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Example:** Sorting names by length."
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"names = [\"C\", \"Java\", \"Haskell\", \n",
" \"Ruby\", \"Python\"]"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 43
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"sorted(names)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 44,
"text": [
"['C', 'Haskell', 'Java', 'Python', 'Ruby']"
]
}
],
"prompt_number": 44
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"sorted(names, key=len)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 45,
"text": [
"['C', 'Java', 'Ruby', 'Python', 'Haskell']"
]
}
],
"prompt_number": 45
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem:** Write a function `isorted` that takes a list of strings and returns a new list with the names sorted ignoring the case.\n",
"\n",
" >>> isorted([\"Python\", \"C\", \"java\", \"ruby\"])\n",
" [\"C\", \"java\", \"Python\", \"ruby\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Tuples"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = (1, 2, 3)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 46
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"len(x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 47,
"text": [
"3"
]
}
],
"prompt_number": 47
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[0]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 48,
"text": [
"1"
]
}
],
"prompt_number": 48
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = 1, 2, 3"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 49
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 50,
"text": [
"(1, 2, 3)"
]
}
],
"prompt_number": 50
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"def minmax(a, b):\n",
" return min(a, b), max(a, b)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 51
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x, y = minmax(5, 2)\n",
"print x, y"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"2 5\n"
]
}
],
"prompt_number": 52
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print minmax(5, 2)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"(2, 5)\n"
]
}
],
"prompt_number": 53
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = (1, 2)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 54
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"y = (1+2)*3"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 55
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"z = (1,)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 56
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Sets"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = set([1, 5, 3, 4, 2])"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 57
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"print x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"set([1, 2, 3, 4, 5])\n"
]
}
],
"prompt_number": 58
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"4 in x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 59,
"text": [
"True"
]
}
],
"prompt_number": 59
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x.add(5)"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 60
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 61,
"text": [
"{1, 2, 3, 4, 5}"
]
}
],
"prompt_number": 61
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Strings"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x = \"hello\"\n",
"y = 'world'"
],
"language": "python",
"metadata": {},
"outputs": [],
"prompt_number": 62
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"z = \"\"\"First line\n",
"Second line\n",
"Third line\n",
"Line with \"quotes\" in them.\n",
"\"\"\"\n",
"\n",
"print z"
],
"language": "python",
"metadata": {},
"outputs": [
{
"output_type": "stream",
"stream": "stdout",
"text": [
"First line\n",
"Second line\n",
"Third line\n",
"Line with \"quotes\" in them.\n",
"\n"
]
}
],
"prompt_number": 63
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 64,
"text": [
"'hello'"
]
}
],
"prompt_number": 64
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"len(x)"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 65,
"text": [
"5"
]
}
],
"prompt_number": 65
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[0]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 66,
"text": [
"'h'"
]
}
],
"prompt_number": 66
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"x[:4]"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 67,
"text": [
"'hell'"
]
}
],
"prompt_number": 67
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"hello world\".split()"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 68,
"text": [
"['hello', 'world']"
]
}
],
"prompt_number": 68
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"a-b-c-d\".split(\"-\")"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 69,
"text": [
"['a', 'b', 'c', 'd']"
]
}
],
"prompt_number": 69
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `count_words`, that takes a string and return the number of words in it.\n",
"\n",
" >>> count_words(\"hello world\")\n",
" 2\n",
" >>> count_words(\"python practice book\")\n",
" 3\n",
" \n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem** Write a function `getext` to find the extension of given filename.\n",
"\n",
" >>> getext(\"a.py\")\n",
" 'py'\n",
" >>> getext(\"a.c\")\n",
" 'c'\n",
" >>> getext(\"a.tar.gz\")\n",
" 'gz'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Joining Strings**"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [
"\"-\".join([\"a\", \"b\", \"c\"])"
],
"language": "python",
"metadata": {},
"outputs": [
{
"metadata": {},
"output_type": "pyout",
"prompt_number": 70,
"text": [
"'a-b-c'"
]
}
],
"prompt_number": 70
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem:** Write a function `pathjoin` that takes a list of path names and joins them into single path.\n",
"\n",
" >>> pathjoin([\"foo\", \"bar\", \"a.py\"])\n",
" 'foo/bar/a.py'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem:** Write a function `extsort` to sort given filenames by extension.\n",
" \n",
" >>> extsort(['a.c', 'a.py', 'b.py', 'bar.txt', 'foo.txt', 'x.c'])\n",
" ['a.c', 'x.c', 'a.py', 'b.py', 'bar.txt', 'foo.txt']\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Other useful methods on strings:\n",
"\n",
"* `strip`\n",
"* `replace`\n",
"* `startswith`\n",
"* `endswith`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Problem:** Write a function `plural` to return plural of a word.\n",
"\n",
" >>> plural('word')\n",
" 'words'\n",
" >>> plural('language')\n",
" 'languages'\n",
" >>> plural('try')\n",
" 'tries'\n",
" >>> plural('constituency')\n",
" 'constituencies'\n",
" >>> plural('life')\n",
" 'lives'"
]
},
{
"cell_type": "code",
"collapsed": false,
"input": [],
"language": "python",
"metadata": {},
"outputs": []
}
],
"metadata": {}
}
]
}
Display the source blob
Display the rendered blob
Raw
day2.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
day3.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment