\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "3b4a1f57",
"metadata": {
"tags": []
},
"source": [
"The following cell downloads a file and runs some code that is used specifically for this book.\n",
"You don't have to understand this code yet, but you should run it before you do anything else in this notebook.\n",
"Remember that you can run the code by selecting the cell and pressing the play button (a triangle in a circle) or hold down `Shift` and press `Enter`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "213f9d96",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"from os.path import basename, exists\n",
"\n",
"def download(url):\n",
" filename = basename(url)\n",
" if not exists(filename):\n",
" from urllib.request import urlretrieve\n",
"\n",
" local, _ = urlretrieve(url, filename)\n",
" print(\"Downloaded \" + str(local))\n",
" return filename\n",
"\n",
"download('https://github.com/porttack/working-in-python/raw/v3/working_in_python.py');\n",
"\n",
"import working_in_python"
]
},
{
"cell_type": "markdown",
"id": "2968273e",
"metadata": {},
"source": [
"# Welcome"
]
},
{
"cell_type": "markdown",
"id": "333a6fc9",
"metadata": {
"tags": []
},
"source": [
"# Programming as a way of thinking\n",
"\n",
"The first goal of this book is to teach you how to program in Python.\n",
"But learning to program means learning a new way to think, so the second goal of this book is to help you think like a computer scientist.\n",
"This way of thinking combines some of the best features of mathematics, engineering, and natural science.\n",
"Like mathematicians, computer scientists use formal languages to denote ideas -- specifically computations.\n",
"Like engineers, they design things, assembling components into systems and evaluating trade-offs among alternatives.\n",
"Like scientists, they observe the behavior of complex systems, form hypotheses, and test predictions.\n",
"\n",
"We will start with the most basic elements of programming and work our way up.\n",
"In this chapter, we'll see how Python represents numbers, letters, and words.\n",
"And you'll learn to perform arithmetic operations.\n",
"\n",
"You will also start to learn the vocabulary of programming, including terms like operator, expression, value, and type.\n",
"This vocabulary is important -- you will need it to understand the rest of the book, to communicate with other programmers, and to use and understand virtual assistants."
]
},
{
"cell_type": "markdown",
"id": "a371aea3",
"metadata": {},
"source": [
"## Arithmetic operators\n",
"\n",
"An **arithmetic operator** is a symbol that represents an arithmetic computation. For example, the plus sign, `+`, performs addition."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2568ec84",
"metadata": {},
"outputs": [],
"source": [
"30 + 12"
]
},
{
"cell_type": "markdown",
"id": "fc0e7ce8",
"metadata": {},
"source": [
"The minus sign, `-`, is the operator that performs subtraction."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c4e75456",
"metadata": {},
"outputs": [],
"source": [
"43 - 1"
]
},
{
"cell_type": "markdown",
"id": "63e4e780",
"metadata": {},
"source": [
"The asterisk, `*`, performs multiplication."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "022a7b16",
"metadata": {},
"outputs": [],
"source": [
"6 * 7"
]
},
{
"cell_type": "markdown",
"id": "a6192d13",
"metadata": {},
"source": [
"And the forward slash, `/`, performs division:\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "05ae1098",
"metadata": {},
"outputs": [],
"source": [
"84 / 2"
]
},
{
"cell_type": "markdown",
"id": "641ad233",
"metadata": {},
"source": [
"Notice that the result of the division is `42.0` rather than `42`. That's because there are two types of numbers in Python: \n",
"\n",
"* **integers**, which represent numbers with no fractional or decimal part, and \n",
"\n",
"* **floating-point numbers**, which represent integers and numbers with a decimal point.\n",
"\n",
"If you add, subtract, or multiply two integers, the result is an integer.\n",
"But if you divide two integers, the result is a floating-point number.\n",
"Python provides another operator, `//`, that performs **integer division**.\n",
"The result of integer division is always an integer."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4df5bcaa",
"metadata": {},
"outputs": [],
"source": [
"84 // 2"
]
},
{
"cell_type": "markdown",
"id": "b2a620ab",
"metadata": {},
"source": [
"Integer division is also called \"floor division\" because it always rounds down (toward the \"floor\"). "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ef08d549",
"metadata": {},
"outputs": [],
"source": [
"85 // 2"
]
},
{
"cell_type": "markdown",
"id": "41e2886a",
"metadata": {},
"source": [
"Finally, the operator `**` performs exponentiation; that is, it raises a\n",
"number to a power:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "df933e80",
"metadata": {},
"outputs": [],
"source": [
"7 ** 2"
]
},
{
"cell_type": "markdown",
"id": "b2502fb6",
"metadata": {},
"source": [
"In some other languages, the caret, `^`, is used for exponentiation, but in Python\n",
"it is a bitwise operator called XOR.\n",
"If you are not familiar with bitwise operators, the result might be unexpected:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "306b6b88",
"metadata": {},
"outputs": [],
"source": [
"7 ^ 2"
]
},
{
"cell_type": "markdown",
"id": "30078370",
"metadata": {},
"source": [
"I won't cover bitwise operators in this book, but you can read about\n",
"them at ."
]
},
{
"cell_type": "markdown",
"id": "0f5b7e97",
"metadata": {},
"source": [
"## Expressions\n",
"\n",
"A collection of operators and numbers is called an **expression**.\n",
"An expression can contain any number of operators and numbers.\n",
"For example, here's an expression that contains two operators."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6e68101d",
"metadata": {},
"outputs": [],
"source": [
"6 + 6 ** 2"
]
},
{
"cell_type": "markdown",
"id": "8e95039c",
"metadata": {},
"source": [
"Notice that exponentiation happens before addition.\n",
"Python follows the order of operations you might have learned in a math class: exponentiation happens before multiplication and division, which happen before addition and subtraction.\n",
"\n",
"In the following example, multiplication happens before addition."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ffc25598",
"metadata": {},
"outputs": [],
"source": [
"12 + 5 * 6"
]
},
{
"cell_type": "markdown",
"id": "914a60d8",
"metadata": {},
"source": [
"If you want the addition to happen first, you can use parentheses."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8dd1bd9a",
"metadata": {},
"outputs": [],
"source": [
"(12 + 5) * 6"
]
},
{
"cell_type": "markdown",
"id": "67ae0ae9",
"metadata": {},
"source": [
"Every expression has a **value**.\n",
"For example, the expression `6 * 7` has the value `42`."
]
},
{
"cell_type": "markdown",
"id": "caebaa51",
"metadata": {},
"source": [
"## Arithmetic functions\n",
"\n",
"In addition to the arithmetic operators, Python provides a few **functions** that work with numbers.\n",
"For example, the `round` function takes a floating-point number and rounds it off to the nearest integer."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1e3d5e01",
"metadata": {},
"outputs": [],
"source": [
"round(42.4)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d1b220b9",
"metadata": {},
"outputs": [],
"source": [
"round(42.6)"
]
},
{
"cell_type": "markdown",
"id": "f5738b4b",
"metadata": {},
"source": [
"The `abs` function computes the absolute value of a number.\n",
"For a positive number, the absolute value is the number itself."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ff742476",
"metadata": {},
"outputs": [],
"source": [
"abs(42)"
]
},
{
"cell_type": "markdown",
"id": "e518494a",
"metadata": {},
"source": [
"For a negative number, the absolute value is positive."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9247c1a3",
"metadata": {},
"outputs": [],
"source": [
"abs(-42)"
]
},
{
"cell_type": "markdown",
"id": "6969ce45",
"metadata": {},
"source": [
"When we use a function like this, we say we're **calling** the function.\n",
"An expression that calls a function is a **function call**.\n",
"\n",
"When you call a function, the parentheses are required.\n",
"If you leave them out, you get an error message."
]
},
{
"cell_type": "markdown",
"id": "5a73bfd5",
"metadata": {
"tags": []
},
"source": [
"NOTE: The following cell uses `%%expect`, which is a Jupyter \"magic command\" that means we expect the code in this cell to produce an error. For more on this topic, see the\n",
"[Jupyter notebook introduction](https://colab.research.google.com/github/AllenDowney/ThinkPython/blob/v3/chapters/jupyter_intro.ipynb)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4674b7ca",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"\n",
"abs 42"
]
},
{
"cell_type": "markdown",
"id": "7d356f1b",
"metadata": {},
"source": [
"You can ignore the first line of this message; it doesn't contain any information we need to understand right now.\n",
"The second line is the code that contains the error, with a caret (`^`) beneath it to indicate where the error was discovered.\n",
"\n",
"The last line indicates that this is a **syntax error**, which means that there is something wrong with the structure of the expression.\n",
"In this example, the problem is that a function call requires parentheses.\n",
"\n",
"Let's see what happens if you leave out the parentheses *and* the value."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7d3e8127",
"metadata": {},
"outputs": [],
"source": [
"abs"
]
},
{
"cell_type": "markdown",
"id": "94478885",
"metadata": {},
"source": [
"A function name all by itself is a legal expression that has a value.\n",
"When it's displayed, the value indicates that `abs` is a function, and it includes some additional information I'll explain later."
]
},
{
"cell_type": "markdown",
"id": "31a85d17",
"metadata": {},
"source": [
"## Strings\n",
"\n",
"In addition to numbers, Python can also represent sequences of letters, which are called **strings** because the letters are strung together like beads on a necklace.\n",
"To write a string, we can put a sequence of letters inside straight quotation marks."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bd8ae45f",
"metadata": {},
"outputs": [],
"source": [
"'Hello'"
]
},
{
"cell_type": "markdown",
"id": "d20050d8",
"metadata": {},
"source": [
"It is also legal to use double quotation marks."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "01d0055e",
"metadata": {},
"outputs": [],
"source": [
"\"world\""
]
},
{
"cell_type": "markdown",
"id": "76f5edb7",
"metadata": {},
"source": [
"Double quotes make it easy to write a string that contains an apostrophe, which is the same symbol as a straight quote."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0295acab",
"metadata": {},
"outputs": [],
"source": [
"\"it's a small \""
]
},
{
"cell_type": "markdown",
"id": "d62d4b1c",
"metadata": {},
"source": [
"Strings can also contain spaces, punctuation, and digits."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cf918917",
"metadata": {},
"outputs": [],
"source": [
"'Well, '"
]
},
{
"cell_type": "markdown",
"id": "9ad47f7a",
"metadata": {},
"source": [
"The `+` operator works with strings; it joins two strings into a single string, which is called **concatenation**"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "aefe6af1",
"metadata": {},
"outputs": [],
"source": [
"'Well, ' + \"it's a small \" + 'world.'"
]
},
{
"cell_type": "markdown",
"id": "0ad969a3",
"metadata": {},
"source": [
"The `*` operator also works with strings; it makes multiple copies of a string and concatenates them."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "42e9e4e2",
"metadata": {},
"outputs": [],
"source": [
"'Spam, ' * 4"
]
},
{
"cell_type": "markdown",
"id": "dfba16a5",
"metadata": {},
"source": [
"The other arithmetic operators don't work with strings.\n",
"\n",
"Python provides a function called `len` that computes the length of a string.\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a5e837db",
"metadata": {},
"outputs": [],
"source": [
"len('Spam')"
]
},
{
"cell_type": "markdown",
"id": "d91e00b3",
"metadata": {},
"source": [
"Notice that `len` counts the letters between the quotes, but not the quotes.\n",
"\n",
"When you create a string, be sure to use straight quotes.\n",
"The back quote, also known as a backtick, causes a syntax error."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e3f65f19",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"\n",
"`Hello`"
]
},
{
"cell_type": "markdown",
"id": "40d893d1",
"metadata": {},
"source": [
"Smart quotes, also known as curly quotes, are also illegal."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a705b980",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"\n",
"‘Hello’"
]
},
{
"cell_type": "markdown",
"id": "5471d4f8",
"metadata": {},
"source": [
"## Values and types\n",
"\n",
"So far we've seen three kinds of values:\n",
"\n",
"* `2` is an integer,\n",
"\n",
"* `42.0` is a floating-point number, and \n",
"\n",
"* `'Hello'` is a string.\n",
"\n",
"A kind of value is called a **type**.\n",
"Every value has a type -- or we sometimes say it \"belongs to\" a type.\n",
"\n",
"Python provides a function called `type` that tells you the type of any value.\n",
"The type of an integer is `int`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3df8e2c5",
"metadata": {},
"outputs": [],
"source": [
"type(2)"
]
},
{
"cell_type": "markdown",
"id": "b137814c",
"metadata": {},
"source": [
"The type of a floating-point number is `float`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c4732c8d",
"metadata": {},
"outputs": [],
"source": [
"type(42.0)"
]
},
{
"cell_type": "markdown",
"id": "266dea4e",
"metadata": {},
"source": [
"And the type of a string is `str`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8f65ac45",
"metadata": {},
"outputs": [],
"source": [
"type('Hello, World!')"
]
},
{
"cell_type": "markdown",
"id": "76d216ed",
"metadata": {},
"source": [
"The types `int`, `float`, and `str` can be used as functions.\n",
"For example, `int` can take a floating-point number and convert it to an integer (always rounding down)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "84b22f2f",
"metadata": {},
"outputs": [],
"source": [
"int(42.9)"
]
},
{
"cell_type": "markdown",
"id": "dcd8d114",
"metadata": {},
"source": [
"And `float` can convert an integer to a floating-point value."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9b66ee21",
"metadata": {},
"outputs": [],
"source": [
"float(42)"
]
},
{
"cell_type": "markdown",
"id": "eda70b61",
"metadata": {},
"source": [
"Now, here's something that can be confusing.\n",
"What do you get if you put a sequence of digits in quotes?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f64e107c",
"metadata": {},
"outputs": [],
"source": [
"'126'"
]
},
{
"cell_type": "markdown",
"id": "fdded653",
"metadata": {},
"source": [
"It looks like a number, but it is actually a string."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "609a8153",
"metadata": {},
"outputs": [],
"source": [
"type('126')"
]
},
{
"cell_type": "markdown",
"id": "2683ac35",
"metadata": {},
"source": [
"If you try to use it like a number, you might get an error."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1cf21da4",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"\n",
"'126' / 3"
]
},
{
"cell_type": "markdown",
"id": "32c11cc4",
"metadata": {},
"source": [
"This example generates a `TypeError`, which means that the values in the expression, which are called **operands**, have the wrong type.\n",
"The error message indicates that the `/` operator does not support the types of these values, which are `str` and `int`.\n",
"\n",
"If you have a string that contains digits, you can use `int` to convert it to an integer."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d45e6a60",
"metadata": {},
"outputs": [],
"source": [
"int('126') / 3"
]
},
{
"cell_type": "markdown",
"id": "86935d56",
"metadata": {},
"source": [
"If you have a string that contains digits and a decimal point, you can use `float` to convert it to a floating-point number."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "db30b719",
"metadata": {},
"outputs": [],
"source": [
"float('12.6')"
]
},
{
"cell_type": "markdown",
"id": "03103ef4",
"metadata": {},
"source": [
"When you write a large integer, you might be tempted to use commas\n",
"between groups of digits, as in `1,000,000`.\n",
"This is a legal expression in Python, but the result is not an integer.\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d72b6af1",
"metadata": {},
"outputs": [],
"source": [
"1,000,000"
]
},
{
"cell_type": "markdown",
"id": "3d24af71",
"metadata": {},
"source": [
"Python interprets `1,000,000` as a comma-separated sequence of integers.\n",
"We'll learn more about this kind of sequence later.\n",
"\n",
"You can use underscores to make large numbers easier to read."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e19bf7e7",
"metadata": {},
"outputs": [],
"source": [
"1_000_000"
]
},
{
"cell_type": "markdown",
"id": "1761cbac",
"metadata": {},
"source": [
"## Formal and natural languages\n",
"\n",
"**Natural languages** are the languages people speak, like English, Spanish, and French. They were not designed by people; they evolved naturally.\n",
"\n",
"**Formal languages** are languages that are designed by people for specific applications. \n",
"For example, the notation that mathematicians use is a formal language that is particularly good at denoting relationships among numbers and symbols.\n",
"Similarly, programming languages are formal languages that have been designed to express computations."
]
},
{
"cell_type": "markdown",
"id": "1bf3d2dc",
"metadata": {},
"source": [
"Although formal and natural languages have some features in\n",
"common there are important differences:\n",
"\n",
"* Ambiguity: Natural languages are full of ambiguity, which people deal with by\n",
" using contextual clues and other information. Formal languages are\n",
" designed to be nearly or completely unambiguous, which means that\n",
" any program has exactly one meaning, regardless of context.\n",
"\n",
"* Redundancy: In order to make up for ambiguity and reduce misunderstandings,\n",
" natural languages use redundancy. As a result, they are\n",
" often verbose. Formal languages are less redundant and more concise.\n",
"\n",
"* Literalness: Natural languages are full of idiom and metaphor. Formal languages mean exactly what they say."
]
},
{
"cell_type": "markdown",
"id": "78a1cec8",
"metadata": {},
"source": [
"Because we all grow up speaking natural languages, it is sometimes hard to adjust to formal languages.\n",
"Formal languages are more dense than natural languages, so it takes longer to read them.\n",
"Also, the structure is important, so it is not always best to read from top to bottom, left to right.\n",
"Finally, the details matter. Small errors in spelling and\n",
"punctuation, which you can get away with in natural languages, can make\n",
"a big difference in a formal language."
]
},
{
"cell_type": "markdown",
"id": "4358fa9a",
"metadata": {},
"source": [
"## Debugging\n",
"\n",
"Programmers make mistakes. For whimsical reasons, programming errors are called **bugs** and the process of tracking them down is called **debugging**.\n",
"\n",
"Programming, and especially debugging, sometimes brings out strong emotions. If you are struggling with a difficult bug, you might feel angry, sad, or embarrassed.\n",
"\n",
"Preparing for these reactions might help you deal with them. One approach is to think of the computer as an employee with certain strengths, like speed and precision, and particular weaknesses, like lack of empathy and inability to grasp the big picture.\n",
"\n",
"Your job is to be a good manager: find ways to take advantage of the strengths and mitigate the weaknesses. And find ways to use your emotions to engage with the problem, without letting your reactions interfere with your ability to work effectively.\n",
"\n",
"Learning to debug can be frustrating, but it is a valuable skill that is useful for many activities beyond programming. At the end of each chapter there is a section, like this one, with my suggestions for debugging. I hope they help!"
]
},
{
"cell_type": "markdown",
"id": "33b8ad00",
"metadata": {},
"source": [
"## Glossary\n",
"\n",
"**arithmetic operator:**\n",
"A symbol, like `+` and `*`, that denotes an arithmetic operation like addition or multiplication.\n",
"\n",
"**integer:**\n",
"A type that represents numbers with no fractional or decimal part.\n",
"\n",
"**floating-point:**\n",
"A type that represents integers and numbers with decimal parts.\n",
"\n",
"**integer division:**\n",
"An operator, `//`, that divides two numbers and rounds down to an integer.\n",
"\n",
"**expression:**\n",
"A combination of variables, values, and operators.\n",
"\n",
"**value:**\n",
"An integer, floating-point number, or string -- or one of other kinds of values we will see later.\n",
"\n",
"**function:**\n",
"A named sequence of statements that performs some useful operation.\n",
"Functions may or may not take arguments and may or may not produce a result.\n",
"\n",
"**function call:**\n",
"An expression -- or part of an expression -- that runs a function.\n",
"It consists of the function name followed by an argument list in parentheses.\n",
"\n",
"**syntax error:**\n",
"An error in a program that makes it impossible to parse -- and therefore impossible to run.\n",
"\n",
"**string:**\n",
" A type that represents sequences of characters.\n",
"\n",
"**concatenation:**\n",
"Joining two strings end-to-end.\n",
"\n",
"**type:**\n",
"A category of values.\n",
"The types we have seen so far are integers (type `int`), floating-point numbers (type ` float`), and strings (type `str`).\n",
"\n",
"**operand:**\n",
"One of the values on which an operator operates.\n",
"\n",
"**natural language:**\n",
"Any of the languages that people speak that evolved naturally.\n",
"\n",
"**formal language:**\n",
"Any of the languages that people have designed for specific purposes, such as representing mathematical ideas or computer programs.\n",
"All programming languages are formal languages.\n",
"\n",
"**bug:**\n",
"An error in a program.\n",
"\n",
"**debugging:**\n",
"The process of finding and correcting errors."
]
},
{
"cell_type": "markdown",
"id": "145066ee",
"metadata": {},
"source": [
"\n",
"**See also:** the [full vocabulary glossary](https://python.porttack.com/alignment/ap-vocabulary-glossary.html) collects every term in this book, alphabetized, alongside the complete AP CSP exam vocabulary list.\n",
""
]
},
{
"cell_type": "markdown",
"id": "ed4ec01b",
"metadata": {},
"source": [
"## Exercises"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "06d3e72c",
"metadata": {
"tags": []
},
"outputs": [],
"source": [
"# This cell tells Jupyter to provide detailed debugging information\n",
"# when a runtime error occurs. Run it before working on the exercises.\n",
"\n",
"%xmode Verbose"
]
},
{
"cell_type": "markdown",
"id": "03c1ef93",
"metadata": {},
"source": [
"### Exercise\n",
"\n",
"You might wonder what `round` does if a number ends in `0.5`.\n",
"The answer is that it sometimes rounds up and sometimes rounds down.\n",
"Try these examples and see if you can figure out what rule it follows."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5d358f37",
"metadata": {},
"outputs": [],
"source": [
"round(42.5)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "12aa59a3",
"metadata": {},
"outputs": [],
"source": [
"round(43.5)"
]
},
{
"cell_type": "markdown",
"id": "2cd03bcb",
"metadata": {},
"source": [
"### Exercise\n",
"\n",
"When you learn about a new feature, you should try it out and make mistakes on purpose.\n",
"That way, you learn the error messages, and when you see them again, you will know what they mean.\n",
"It is better to make mistakes now and deliberately than later and accidentally.\n",
"\n",
"1. You can use a minus sign to make a negative number like `-2`. What happens if you put a plus sign before a number? What about `2++2`?\n",
"\n",
"2. What happens if you have two values with no operator between them, like `4 2`?\n",
"\n",
"3. If you call a function like `round(42.5)`, what happens if you leave out one or both parentheses?"
]
},
{
"cell_type": "markdown",
"id": "1fb0adfe",
"metadata": {},
"source": [
"### Exercise\n",
"\n",
"Recall that every expression has a value, every value has a type, and we can use the `type` function to find the type of any value.\n",
"\n",
"What is the type of the value of the following expressions? Make your best guess for each one, and then use `type` to find out.\n",
"\n",
"* `765`\n",
"\n",
"* `2.718`\n",
"\n",
"* `'2 pi'`\n",
"\n",
"* `abs(-7)`\n",
"\n",
"* `abs(-7.0)`\n",
"\n",
"* `abs`\n",
"\n",
"* `int`\n",
"\n",
"* `type`"
]
},
{
"cell_type": "markdown",
"id": "23762eec",
"metadata": {},
"source": [
"### Exercise\n",
"\n",
"The following questions give you a chance to practice writing arithmetic expressions.\n",
"\n",
"1. How many seconds are there in 42 minutes 42 seconds?\n",
"\n",
"2. How many miles are there in 10 kilometers? Hint: there are 1.61 kilometers in a mile.\n",
"\n",
"3. If you run a 10 kilometer race in 42 minutes 42 seconds, what is your average pace in seconds per mile? \n",
" \n",
"4. What is your average pace in minutes and seconds per mile?\n",
"\n",
"5. What is your average speed in miles per hour?\n",
"\n",
"If you already know about variables, you can use them for this exercise.\n",
"If you don't, you can do the exercise without them -- and then we'll see them in the next chapter."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8fb50f30",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "5eceb4fb",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "fee97d8d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "a998258c",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "2e0fc7a9",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "d25268d8",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "523d9b0f",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "332a8a5a",
"metadata": {},
"source": [
"### Exercise\n",
"\n",
"\n",
"The following cell raises a `TypeError`.\n",
"\n",
"1. Run it, then in a comment explain what the error message means, using the two type names it mentions.\n",
"2. Fix the code so it runs, using `str`.\n",
"3. In the next cell, fix the same problem a different way, using `int` on a numeric string instead.\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1bfabe58",
"metadata": {},
"outputs": [],
"source": [
"'Total: ' + 10"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5dec4f33",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "3d30c0ee",
"metadata": {},
"source": [
"### Exercise\n",
"\n",
"\n",
"In your own words, what's the difference between `/` and `//`? Answer in the markdown cell below -- double-click it to edit, then press `Shift+Enter` to render it.\n",
""
]
},
{
"cell_type": "markdown",
"id": "10f37a2b",
"metadata": {},
"source": [
"*Type your answer here.*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ca083ccf",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "1a2b3c4d",
"metadata": {},
"source": [
"\n",
"## Homework\n",
"\n",
"These five exercises are your homework for this chapter, about 30 minutes total.\n",
""
]
},
{
"cell_type": "markdown",
"id": "5e6f7a8b",
"metadata": {},
"source": [
"\n",
"### Exercise 1: order of operations\n",
"\n",
"The formula for converting Celsius to Fahrenheit is `F = C * 9/5 + 32`.\n",
"\n",
"1. Write an expression that converts 20°C to Fahrenheit. Predict the answer before you run the cell.\n",
"2. Now write `C * 9 / (5 + 32)` using the same value of `C`. In a comment, explain in one sentence why this gives a different — and wrong — answer.\n",
""
]
},
{
"cell_type": "markdown",
"id": "9c0d1e2f",
"metadata": {},
"source": [
"\n",
"### Exercise 2: splitting cookies\n",
"\n",
"You have 23 cookies to split evenly among 5 students.\n",
"\n",
"1. Write an expression using `//` for how many whole cookies each student gets.\n",
"2. Without using the `%` operator (we haven't covered it yet), write an expression using only `-`, `*`, and `//` for how many cookies are left over.\n",
""
]
},
{
"cell_type": "markdown",
"id": "3a4b5c6d",
"metadata": {},
"source": [
"\n",
"### Exercise 3: name banner\n",
"\n",
"Using `+` and `*`, build a one-line banner that includes your name, decorated with a border made of a repeated character (for example, dashes or asterisks).\n",
"\n",
"Then use `len` on your name and answer in a comment: is the number `len` gives you what you expected? Why or why not?\n",
""
]
},
{
"cell_type": "markdown",
"id": "7e8f9a0b",
"metadata": {},
"source": [
"\n",
"### Exercise 4: fix the TypeError\n",
"\n",
"The cell below raises a `TypeError`.\n",
"\n",
"1. In a comment, explain what the error message means, using the names of the two operand types it mentions.\n",
"2. Fix the code so it runs, using `str`.\n",
"3. Then fix the same problem a different way, using `int` on a numeric string instead.\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "extra-exercises-typeerror-buggy",
"metadata": {},
"outputs": [],
"source": [
"'Score: ' + 95"
]
},
{
"cell_type": "markdown",
"id": "1c2d3e4f",
"metadata": {},
"source": [
"\n",
"### Exercise 5: reflection\n",
"\n",
"Describe a time you debugged something that wasn't code -- a recipe, a Wi-Fi problem, directions that didn't work. What was the \"bug,\" and how did you find it?\n",
""
]
},
{
"cell_type": "markdown",
"id": "extra-exercises-copy-heading",
"metadata": {},
"source": [
"\n",
"### Finished? Copy your work\n",
"\n",
"This isn't part of Exercise 5 -- it's a tool. Run the cell below to copy this notebook (including anything you've run) so you can paste it into a document.\n",
""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "extra-exercises-copy-button",
"metadata": {},
"outputs": [],
"source": [
"working_in_python.show_copy_notebook_button()"
]
},
{
"cell_type": "markdown",
"id": "a7f4edf8",
"metadata": {
"tags": []
},
"source": [
"\n",
"---\n",
"\n",
"**Working in Python** — modified by Eric Brown for a high school Computer Science Principles class. Source and modifications: [github.com/porttack/working-in-python](https://github.com/porttack/working-in-python)\n",
"\n",
"---\n",
"\n",
"\n",
"[Think Python: 3rd Edition](https://allendowney.github.io/ThinkPython/index.html)\n",
"\n",
"Copyright 2024 [Allen B. Downey](https://allendowney.com)\n",
"\n",
"Code license: [MIT License](https://mit-license.org/)\n",
"\n",
"Text license: [Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International](https://creativecommons.org/licenses/by-nc-sa/4.0/)\n",
"\n",
"\n",
"---\n",
"\n",
"## Standards alignment\n",
"\n",
"**AP CSP:** [3.3 Mathematical Expressions](https://python.porttack.com/alignment/apcsp-standards-reference.html#T-3.3), [3.4 Strings](https://python.porttack.com/alignment/apcsp-standards-reference.html#T-3.4) (Big Idea 3, 30–35% of the exam). Also [1.2 Program Function and Purpose](https://python.porttack.com/alignment/apcsp-standards-reference.html#T-1.2) and [1.4 Identifying and Correcting Errors](https://python.porttack.com/alignment/apcsp-standards-reference.html#T-1.4) (Big Idea 1, 10–13%), headers only.\n",
"**California 9-12:** no standard names this content on its own. California treats basic arithmetic and expressions as prior knowledge by this grade band.\n",
"**CSTA 2026:** not carried. CSTA's High School band assumes basic expressions and types are already established by middle school.\n",
"**CA CTE (ICT):** [C4.4](https://python.porttack.com/alignment/ca-ict-anchor-standards-reference.html#T-C4.4), [C4.6](https://python.porttack.com/alignment/ca-ict-anchor-standards-reference.html#T-C4.6) (Pathway C, Software and Systems Development). Also [C5.6](https://python.porttack.com/alignment/ca-ict-anchor-standards-reference.html#T-C5.6), headers only.\n",
"\n",
"This chapter's expressions and arithmetic operators are exactly what the exam calls mathematical expressions. Strings begin here too, but the exam's full string content isn't reached until chapter 8. The `int`/`float`/`str` types and syntax errors introduced here are also ICT's C4.4 (data types) and C4.6 (language syntax) directly.\n",
""
]
}
],
"metadata": {
"celltoolbar": "Tags",
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"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.10.11"
}
},
"nbformat": 4,
"nbformat_minor": 5
}