hon3.7/json/__init__.py'>\n",
"numbers list n=11\n",
"spam int 1\n",
"text str # This is not a comment b<...>cause it's inside quotes.\n",
"width int 20\n"
]
}
],
"source": [
"%whos"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You might see a number of variables here in the list but it should include the variables `area`, `width`, and `height` which we defined at the start of this subsection.\n",
"\n",
"Variables can hold all types of information, not just single number as we will see. In fact, when we get into data analysis, we will read in entire datasets into a variable, and our graphs, statistical tests, and results will all be placed into variables. So it is good to understand the concept of variables and the rules for naming them.\n",
"\n",
"Variables can also be used temporarily to move things around. For instance, let's define variables `x` and `y`."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [],
"source": [
"x = 2\n",
"y = 7"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We would like to swap the values, so that `x` has the value of `y` and `y` has the value of `x`. To do this, we need to stay organized because if we just assign the value of y directly to x, it will overwrite it. So instead we will create a third \"temporary\" variable to swap them:"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x = 1\n",
"y = 2\n"
]
}
],
"source": [
"tmp = x\n",
"x = y\n",
"y = tmp\n",
"print(\"x = \", x)\n",
"print(\"y = \", y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To save space in Python, you can define multiple variables at once on the same line:"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10 20\n"
]
}
],
"source": [
"width, height = 10, 20\n",
"print(\"width = \", width)\n",
"print(\"height = \", height)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This type of compact notation can even be used to more efficiently swap variables:"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x = 2\n",
"y = 1\n"
]
}
],
"source": [
"x, y = 1, 2\n",
"x, y = y, x\n",
"print(\"x = \", x)\n",
"print(\"y = \", y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Messing with text (i.e., strings)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"Besides numbers, Python can also manipulate strings. Strings are small pieces of text that can be manipulated in Python. Strings can be enclosed in single quotes (`'...'`) or double quotes (`\"...\"`) with the same result. Use `\\` to escape quotes, that is, to use a quote within the string itself:"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'spam eggs'"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'spam eggs' # Single quotes."
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\"doesn't\""
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'doesn\\'t' # Use \\' to escape the single quote..."
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"\"doesn't\""
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"\"doesn't\" # ...or use double quotes instead."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In the interactive interpreter and Jupyter notebooks, the output string is enclosed in quotes and special characters are escaped with backslashes. Although this output sometimes looks different from the input (the enclosing quotes could change), the two strings are equivalent. The string is enclosed in double quotes if the string contains a single quote and no double quotes; otherwise, it's enclosed in single quotes. The [`print()`](https://docs.python.org/3.6/library/functions.html#print) function produces a more readable output by omitting the enclosing quotes and by printing escaped and special characters:"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'\"Isn\\'t,\" she said.'"
]
},
"execution_count": 49,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'\"Isn\\'t,\" she said.'"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\"Isn't,\" she said.\n"
]
}
],
"source": [
"print('\"Isn\\'t,\" she said.')"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'First line.\\nSecond line.'"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"s = 'First line.\\nSecond line.' # \\n means newline.\n",
"s # Without print(), \\n is included in the output."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First line.\n",
"Second line.\n"
]
}
],
"source": [
"print(s) # With print(), \\n produces a new line."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"String literals can span multiple lines and are delineated by triple-quotes: `\"\"\"...\"\"\"` or `'''...'''`. End of lines are automatically included in the string, but it's possible to prevent this by adding a `\\` at the end of the line. For example, without a `\\`, the following example includes an extra line at the beginning of the output:"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"Usage: thingy [OPTIONS]\n",
" -h Display this usage message\n",
" -H hostname Hostname to connect to\n",
"\n"
]
}
],
"source": [
"print(\"\"\"\n",
"Usage: thingy [OPTIONS]\n",
" -h Display this usage message\n",
" -H hostname Hostname to connect to\n",
"\"\"\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Strings can be *concatenated* (glued together) with the `+` operator, and repeated with `*`:"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'unununium'"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 3 times 'un', followed by 'ium'\n",
"3 * 'un' + 'ium'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To concatenate variables, or a variable and a literal, use `+`:"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Python'"
]
},
"execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"prefix = 'Py'\n",
"prefix + 'thon'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Strings can be *indexed* (subscripted), with the first character having index 0. There is no separate character type; a character is simply a string of size one:"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'P'"
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word = 'Python'\n",
"word[0] # Character in position 0."
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'n'"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[5] # Character in position 5."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Indices may also be negative numbers, which means to start counting from the end of the string. Note that because -0 is the same as 0, negative indices start from -1:"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'n'"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[-1] # Last character."
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'o'"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[-2] # Second-last character."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In addition to indexing, which extracts individual characters, Python also supports *slicing*, which extracts a substring. To slide, you indicate a *range* in the format `start:end`, where the start position is included but the end position is excluded:"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Py'"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[0:2] # Characters from position 0 (included) to 2 (excluded)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you omit either position, the default start position is 0 and the default end is the length of the string:"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Py'"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[:2] # Character from the beginning to position 2 (excluded)."
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'on'"
]
},
"execution_count": 63,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[4:] # Characters from position 4 (included) to the end."
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'on'"
]
},
"execution_count": 64,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[-2:] # Characters from the second-last (included) to the end."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This characteristic means that `s[:i] + s[i:]` is always equal to `s`:"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Python'"
]
},
"execution_count": 66,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[:2] + word[2:]"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Python'"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"word[:4] + word[4:]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One way to remember how slices work is to think of the indices as pointing between characters, with the left edge of the first character numbered 0. Then the right edge of the last character of a string of *n* characters has index *n*. For example:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" +---+---+---+---+---+---+\n",
" | P | y | t | h | o | n |\n",
" +---+---+---+---+---+---+\n",
" 0 1 2 3 4 5 6\n",
"-6 -5 -4 -3 -2 -1\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The first row of numbers gives the position of the indices 0...6 in the string; the second row gives the corresponding negative indices. The slice from *i* to *j* consists of all characters between the edges labeled *i* and *j*, respectively.\n",
"\n",
"For non-negative indices, the length of a slice is the difference of the indices, if both are within bounds. For example, the length of `word[1:3]` is 2.\n",
"\n",
"Attempting to use an index that is too large results in an error:"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [
{
"ename": "IndexError",
"evalue": "string index out of range",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mword\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m42\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# The word only has 6 characters.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mIndexError\u001b[0m: string index out of range"
]
}
],
"source": [
"word[42] # The word only has 6 characters."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Python strings are [immutable](https://docs.python.org/3.5/glossary.html#term-immutable), which means they cannot be changed. Therefore, assigning a value to an indexed position in a string results in an error:"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {},
"outputs": [
{
"ename": "TypeError",
"evalue": "'str' object does not support item assignment",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mword\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'J'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
]
}
],
"source": [
"word[0] = 'J'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The built-in function [`len()`](https://docs.python.org/3.5/library/functions.html#len) returns the length of a string:"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"34"
]
},
"execution_count": 70,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"s = 'supercalifragilisticexpialidocious'\n",
"len(s)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A couple of other useful things for strings are changing to upper or lower case:"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'PYTHON'"
]
},
"execution_count": 72,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"s = 'Python'\n",
"s.upper()"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'python'"
]
},
"execution_count": 73,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"s.lower()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can also test if a part of a string is inside a larger string (more on conditionals later):"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'thon' in 'Python'"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 75,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'todd' in 'Python'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Reverse a string"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'nohtyP'"
]
},
"execution_count": 79,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"s[::-1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Split a string into parts based on a particular character:"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['milk', ' eggs', ' chocolate', ' ice cream', ' bananas', ' cereal', ' coffee']"
]
},
"execution_count": 80,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"s = 'milk, eggs, chocolate, ice cream, bananas, cereal, coffee'\n",
"s.split(',')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The above cut the string up into a smaller string each time it encountered a comma. The results is a list... speaking of!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Case examples"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ok so maybe you are thinking, why do I need to program with strings? Well here are a couple of use cases where string as useful."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For example, if you want to load a file from the internet you often use a string to represent the file name. This code snippet loads the welcome screen for the [psiturk](http://psiturk.org) package. Notice how a string is used to represent the url (i.e., the thing starting 'https')."
]
},
{
"cell_type": "code",
"execution_count": 118,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"https://psiturk.org\n",
" ______ ______ __ ______ __ __ ______ __ __ \n",
"/\\ == \\ /\\ ___\\ /\\ \\ /\\__ _\\ /\\ \\/\\ \\ /\\ == \\ /\\ \\/ / \n",
"\\ \\ _-/ \\ \\___ \\ \\ \\ \\ \\/_/\\ \\/ \\ \\ \\_\\ \\ \\ \\ __< \\ \\ _\"-. \n",
" \\ \\_\\ \\/\\_____\\ \\ \\_\\ \\ \\_\\ \\ \\_____\\ \\ \\_\\ \\_\\ \\ \\_\\ \\_\\ \n",
" \\/_/ \\/_____/ \\/_/ \\/_/ \\/_____/ \\/_/ /_/ \\/_/\\/_/ \n",
" \n",
" an open platform for science on Amazon Mechanical Turk\n",
" \t\t\t\t\t\t\t\t\t\n",
"--------------------------------------------------------------------\n",
"System status:\n",
"\n",
"Hi all, You need to be running psiTurk version >= 2.0.0 to use the \n",
"Ad Server feature! \n",
"\n",
"The latest stable version is 2.3.0.\n",
"\n",
"**ALERT**: Due to a recent Amazon API deprecation, you need to install psiturk version 2.3.0 or later.\n",
"\n",
"Check https://github.com/NYUCCL/psiTurk or https://psiturk.org for \n",
"latest info.\n",
"\n"
]
}
],
"source": [
"import urllib.request\n",
"import json\n",
"\n",
"for line in urllib.request.urlopen(\"https://api.psiturk.org/status_msg?version=2.3\"):\n",
" message = json.loads(line.decode('utf-8'))\n",
" print(message['status'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Collections"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Everything we have considered so far is mostly single elements (numbers, strings). However, we often also need to deal with collections of numbers and things (actually a string is pretty much a collection of individual characters, but...). There are three built-in types of collections that are useful to know about for this class: lists, dictionaries, and sets."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Lists"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![](\"./images/lists.png\")
![](\"./images/dictionaries.png\")
\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" student | \n",
" grades | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" 1 | \n",
" 0.95 | \n",
"
\n",
" \n",
" | 1 | \n",
" 2 | \n",
" 0.27 | \n",
"
\n",
" \n",
" | 2 | \n",
" 3 | \n",
" 0.45 | \n",
"
\n",
" \n",
" | 3 | \n",
" 4 | \n",
" 0.80 | \n",
"
\n",
" \n",
"
\n",
"
![](\"./images/sets.png\")
![](\"./images/tests.png\")
![](\"./images/ifthen2.png\")
\n",
"```\n",
"\n",
"where `expression` is a true/false (Boolean) as described in the previous section and `` is some collection of lines that will be executed only if the expression is `True`.\n",
"\n",
"For a more example, lets create a variable called 'myvar' and set it equal to 10. Then we will write a short program that prints 'hi':"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Mow the lawn\n",
"Weed the garden\n",
"Walk the dog\n"
]
}
],
"source": [
"weather = 'nice'\n",
"\n",
"if weather == 'nice':\n",
" print('Walk the dog')\n",
" print('Mow the lawn')\n",
" print('Weed the flower bed')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The important thing about this code is that you could run it even if you weren't sure what the value of `weather` was because it was set earlier in the program or by some other piece of complex code. Thus, it lets you run a special bit of code depending on the value of a variable.\n",
"\n",
"The situation you would use this type of code in is very intuitive... sometimes you only do certain step when something is true (like take an umbrella when it is raining).\n",
"\n",
"Now there is a couple of **very important** but sometimes **subtle or confusing** parts about this.\n",
"\n",
"First is that you'll notice that the lines which reads `print()` are not aligned with the rest of the code in that cell. This is because the first character of that line is the tab character (the one on your keyboard you sometimes use to start the first line of a paragraph when writing).\n",
"\n",
"In Python this spacing is **very important**. Any line that is tabbed over from the line above it is known as a \"code block\":"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"this is not\n"
]
}
],
"source": [
"myvar = 10\n",
"myvar2 = 20\n",
"\n",
"if myvar == myvar2:\n",
" # this is inside the code block\n",
" print(\"this is\")\n",
" print(\"a code block\")\n",
"\n",
"# this is not in the code block because it is not tabbed over\n",
"print(\"this is not\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"All programming languages have some type of code block syntax, but in Python, you just use tab and untab to do this. This feature might actually be one of the main reasons Python is so popular (I kid you not). The reason is this is a very elegant way to indicate code blocks and it makes the code very readable compared to other languages. The simplicity can sometimes be confusing for new users, though, because you really have to keep track of the level of indentation of your code. It is not a big deal once you get used to it but at first you will need to be on-guard about which lines are or are not tabbed over."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"this is\n",
"a code block\n",
"this is not\n"
]
}
],
"source": [
"myvar = 10\n",
"myvar2 = 10\n",
"\n",
"if myvar == myvar2:\n",
" print(\"this is\")\n",
" print(\"a code block\")\n",
"\n",
"print(\"this is not\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Consider the two contrasting examples above (the one just now and the one before it). In one, `myvar` and `myvar2` have a different value. Thus, the equal `==` test fails (return `False`) and then the tabbed code block is skipped. In the second example, the value of the test is `True` so the code block is run. In both cases, the final print (which is *not* tabbed over) runs no matter what (so it is printed out in both examples). The general structure is this:\n",
"\n",
"![](\"./images/ifthen.png\")
![](\"./images/forloops.png\")
![](\"./images/functions.png\")
\n",
" \n",
" \n",
"```\n",
"\n",
"This just gives you a general sense of those functions are organized and is not a valid Python command!\n",
"\n",
"Let's look at an actual version."
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {},
"outputs": [],
"source": [
"def my_function():\n",
" print(\"Hello from my function\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice two things about this function. First is that is has no parameters (which is fine... we'll talk about how to add them later). Second, when you run this code cell, nothing happens. This is because this simply **defines** the function but does not run it. To run this function someplace else in our code, we would write:"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello from my function\n"
]
}
],
"source": [
"my_function()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here we \"executed\" (i.e., ran) the function by calling its name with the parentheses.\n",
"\n",
"Functions can be combined with other elements of Python to create more complex program flows. For example, we can combine a custom function with a for loop:"
]
},
{
"cell_type": "code",
"execution_count": 63,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"*\n",
"***\n",
"*****\n",
"*\n",
"***\n",
"*****\n",
"*\n",
"***\n",
"*****\n",
"*\n",
"***\n",
"*****\n"
]
}
],
"source": [
"def my_ramp():\n",
" print('*')\n",
" print('***')\n",
" print('*****')\n",
"\n",
"for i in range(4):\n",
" my_ramp()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The above code, which prints out a ramping set of stars four times, is much more efficient than if you repeated the print statements 16 times."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Parameters"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Functions can take different types of \"parameters\", which are essentially variables that are created at the start of the execution of the function. This is helpful for making more abstract functions that perform some computation with their inputs. For example:"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {},
"outputs": [],
"source": [
"def add(x, y):\n",
" print(\"The sum is \", x+y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The `add` functions we just defined takes two parameters `x` and `y`. These parameters are then used as the operands to an addition operation. As a result, we can run this function many times with different inputs and get different results:"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The sum is 3\n"
]
}
],
"source": [
"add(1,2)"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"The sum is 62\n"
]
}
],
"source": [
"add(34,28)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Return values"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The functions we have considered so far simply print something out and then finish. However, sometimes you might like to have your function give back one or more result for further processing by other parts of your program. For instance, instead of printing out the sum of x and y, we can redefine the sum() function to return the sum using a special keyword `return`:"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {},
"outputs": [],
"source": [
"def sum(x,y):\n",
" return x+y"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now when we run this function, instead of printing out a message, the value of the sum is calculated and passed back."
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"9"
]
},
"execution_count": 70,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum(4,5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This allows you to continue to do additional processing. For example, we can add two numbers and then compute the square root of them:"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.0"
]
},
"execution_count": 71,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"import math\n",
"\n",
"math.sqrt(sum(4,5))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can return multiple values from a function if you want. For example, we could create a function call `arithmetic` that does a number of operations to x and y and returns them all:"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [],
"source": [
"def arithmetic(x,y):\n",
" _sum = x+y\n",
" _diff = x-y\n",
" _prod = x*y\n",
" _div = x/y\n",
" return _sum, _diff, _prod, _div"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This new function gives back a `tuple` (similar to a list) that contains all four of the results in one step."
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(10, 4, 21, 2.3333333333333335)"
]
},
"execution_count": 73,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"arithmetic(7,3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Importing additional functionality"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One of the best features of Python, and one reason contributing to its popularity is the large number of add on packages. For example, there are packages for data analysis (`pandas`), plotting (`matplotlib` or `seaborn`), etc... These packages are not all loaded automatically. Instead at the start of your notebook or program, you often need to **import** this functionality. There are a couple of ways to import packages. Generally you need to know the name of the package and details about what functions or methods it provides. Most packages have tons of great documentation. For example, `pandas` a library we will use a lot in class has extensive documentation on the [pydata website](https://pandas.pydata.org/pandas-docs/stable/). "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Basic importing is accomplished with the `import` command. For example, to import the back math functions in Python just type:"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {},
"outputs": [],
"source": [
"import math"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we can access the methods provided by the math function using the `.` (dot) operator. Any function that the `math` library provides is accessible to us now using `math.`. For example, to compute the cosine of a number:"
]
},
{
"cell_type": "code",
"execution_count": 75,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.5403023058681398"
]
},
"execution_count": 75,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"math.cos(1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Sometimes we want to import a library but rename it so that it is easier to type. For instance we will use the pandas library a lot in class. If we type `import pandas` that will load the library but that means everytime we use a pandas function it will need to begin with the `pandas.` syntax. This can be a lot of typing. As a result many popular packages are imported using the `import as ` syntax. This imports the library but immediately changes its name, usually to something simpler and shorter for easy typing. For example it is traditional to import pandas and rename it `pd`. Thus to import pandas this way, we would type this at the top of our notebook or script:"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now we have access to the pandas function using `pd.`. For example, we can create a new pandas *dataframe* like this:"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" student | \n",
" grades | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" 1 | \n",
" 0.95 | \n",
"
\n",
" \n",
" | 1 | \n",
" 2 | \n",
" 0.27 | \n",
"
\n",
" \n",
" | 2 | \n",
" 3 | \n",
" 0.45 | \n",
"
\n",
" \n",
" | 3 | \n",
" 4 | \n",
" 0.80 | \n",
"
\n",
" \n",
"
\n",
"
![](\"./images/python.png\")
![](\"./images/function-call.png\")
![](\"./images/calculator.png\")
![](\"./images/variable.png\")
![](\"./images/strings.png\")