Streamline previous content
This commit is contained in:
parent
fe13817605
commit
ca8fefdce1
13 changed files with 5091 additions and 3409 deletions
|
|
@ -48,7 +48,7 @@
|
|||
"source": [
|
||||
"As our introductory example, we want to calculate the *average* of all *evens* in a **list** of numbers: `[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]`.\n",
|
||||
"\n",
|
||||
"While we could try to develop an [analytical solution](https://math.stackexchange.com/questions/935405/what-s-the-difference-between-analytical-and-numerical-approaches-to-problems/935446#935446) (i.e., derive some equation with \"pen and paper\"), we solve the task programmatically instead.\n",
|
||||
"While we are used to finding an [analytical solution](https://math.stackexchange.com/questions/935405/what-s-the-difference-between-analytical-and-numerical-approaches-to-problems/935446#935446) in math (i.e., derive some equation with \"pen and paper\"), we solve this task *programmatically* instead.\n",
|
||||
"\n",
|
||||
"We start by creating a list called `numbers` that holds all the individual numbers between **brackets** `[` and `]`."
|
||||
]
|
||||
|
|
@ -114,7 +114,7 @@
|
|||
"\n",
|
||||
"Intuitively, the line `for number in numbers` describes a \"loop\" over all the numbers in the `numbers` list, one at a time.\n",
|
||||
"\n",
|
||||
"The `if number % 2 == 0` may look disturbing at first sight. Both the `%` and `==` must have an unintuitive meaning here. Luckily, the **comment** in the same line after the `#` symbol has the answer: The program only does something if the current `number` is even.\n",
|
||||
"The `if number % 2 == 0` may look confusing at first sight. Both `%` and `==` must have an unintuitive meaning here. Luckily, the **comment** in the same line after the `#` symbol has the answer: The program does something only for an even `number`.\n",
|
||||
"\n",
|
||||
"In particular, it increases `count` by `1` and adds the current `number` onto the [running](https://en.wikipedia.org/wiki/Running_total) `total`. Both `count` and `number` are initially set to `0` and the single `=` symbol reads as \"... is *set* equal to ...\". It could not indicate a mathematical equation as, for example, `count` is generally not equal to `count + 1`.\n",
|
||||
"\n",
|
||||
|
|
@ -200,7 +200,7 @@
|
|||
"source": [
|
||||
"Note how only two of the previous four code cells generate an **output** while two remained \"silent\" (i.e., there is no \"**Out[...]**\" after running the cell).\n",
|
||||
"\n",
|
||||
"By default, Jupyter notebooks show the value of a cell's last **expression**. This output can be suppressed by ending the last line with a semicolon `;`."
|
||||
"By default, Jupyter notebooks show the value of the **expression** in the last line of a code cell only. This output can be suppressed by ending the last line with a semicolon `;`."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -249,7 +249,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"To visualize something before the end of the cell, we use the built-in [print()](https://docs.python.org/3/library/functions.html#print) **function**. Here, the parentheses `()` indicate that we execute code defined somewhere else."
|
||||
"To visualize something before the end of the cell, we use the built-in [print()](https://docs.python.org/3/library/functions.html#print) **function**. Here, the parentheses `()` indicate that we execute code written somewhere else."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -331,9 +331,9 @@
|
|||
"\n",
|
||||
"The arithmetic operators either \"operate\" with the number immediately following them (= **unary** operators; e.g., negation) or \"process\" the two numbers \"around\" them (= **binary** operators; e.g., addition).\n",
|
||||
"\n",
|
||||
"By definition, operators have **no** permanent **side effects** in the computer's memory. Although the code cells in this section do indeed create *new* numbers in memory (e.g., `77 + 13` creates `90`), they are immediately \"forgotten\" as they are not stored in a **variable** like `numbers` or `average` above. We continue this thought further below when we compare **expressions** with **statements**.\n",
|
||||
"By definition, operators have **no** permanent **side effects** in the computer's memory. Although the code cells in this section do indeed create *new* numbers in memory (e.g., `77 + 13` creates `90`), they are immediately \"forgotten\" as they are not stored in a **variable** like `numbers` or `average` above. We develop this thought further at the end of this chapter when we compare **expressions** with **statements**.\n",
|
||||
"\n",
|
||||
"Let's see some examples of operators. We start with the binary `+` and the `-` operators for addition and subtraction. Binary operators are designed to resemble what mathematicians call [infix notation](https://en.wikipedia.org/wiki/Infix_notation) and have the expected meaning."
|
||||
"Let's see some examples of operators. We start with the binary `+` and the `-` operators for addition and subtraction. Binary operators mimic what mathematicians call [infix notation](https://en.wikipedia.org/wiki/Infix_notation) and have the expected meaning."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -392,7 +392,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"The `-` operator is used as a unary operator as well. Then it just flips the sign of a number."
|
||||
"The `-` operator may be used as a unary operator as well. Then it just flips the sign of a number."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -617,7 +617,9 @@
|
|||
"source": [
|
||||
"The remainder is `0` *only if* a number is *divisible* by another.\n",
|
||||
"\n",
|
||||
"A popular convention in both, computer science and mathematics, is to abbreviate \"only if\" as **iff**, which is short for \"**[if and only if](https://en.wikipedia.org/wiki/If_and_only_if)**.\" The iff means that a remainder of `0` implies that a number is divisible by another but also that a number divisible by another implies a remainder of `0`. The implication goes in *both* directions!"
|
||||
"A popular convention in both, computer science and mathematics, is to abbreviate \"only if\" as **iff**, which is short for \"**[if and only if](https://en.wikipedia.org/wiki/If_and_only_if)**.\" The iff means that a remainder of `0` implies that a number is divisible by another but also that a number divisible by another implies a remainder of `0`. The implication goes in *both* directions!\n",
|
||||
"\n",
|
||||
"So, `49` is divisible by `7`."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -652,7 +654,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"Modulo division is also useful if we, for example, need to get the last couple of digits of a large integer."
|
||||
"Modulo division is also useful if we want to extract the last couple of digits in a large integer."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -711,7 +713,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"The [divmod()](https://docs.python.org/3/library/functions.html#divmod) built-in function combines the integer and modulo divisions into one operation. However, this is not an operator but a function. Also, [divmod()](https://docs.python.org/3/library/functions.html#divmod) returns a \"pair\" of integers and not just one object."
|
||||
"The built-in [divmod()](https://docs.python.org/3/library/functions.html#divmod) function combines the integer and modulo divisions into one operation. However, this is not an operator but a function. Also, [divmod()](https://docs.python.org/3/library/functions.html#divmod) returns a \"pair\" of integers and not just one."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -781,7 +783,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"The standard [order of precedence](https://docs.python.org/3/reference/expressions.html#operator-precedence) from mathematics applies (i.e., \"PEMDAS\" rule)."
|
||||
"The standard [order of precedence](https://docs.python.org/3/reference/expressions.html#operator-precedence) from mathematics applies (i.e., [PEMDAS](http://mathworld.wolfram.com/PEMDAS.html) rule) when several operators are combined."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -988,7 +990,7 @@
|
|||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"140706351197104"
|
||||
"140398796190992"
|
||||
]
|
||||
},
|
||||
"execution_count": 28,
|
||||
|
|
@ -1012,7 +1014,7 @@
|
|||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"140706351380256"
|
||||
"140398796375888"
|
||||
]
|
||||
},
|
||||
"execution_count": 29,
|
||||
|
|
@ -1036,7 +1038,7 @@
|
|||
{
|
||||
"data": {
|
||||
"text/plain": [
|
||||
"140706351003760"
|
||||
"140398796056176"
|
||||
]
|
||||
},
|
||||
"execution_count": 30,
|
||||
|
|
@ -1056,7 +1058,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"These addresses are *not* meaningful for anything other than checking if two variables **point** at the same object. Let's create a second variable `d` and also set it to `789`."
|
||||
"These addresses are *not* meaningful for anything other than checking if two variables reference the *same* object. Let's create a second variable `d` and also set it to `789`."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1507,7 +1509,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"In this book, we follow the convention of creating strings with **double quotes** `\"` instead of the **single quotes** `'` to which Python defaults in its literal output for `str` objects. Both types of quotes may be used interchangeably."
|
||||
"In this book, we follow the convention of creating strings with **double quotes** `\"` instead of the **single quotes** `'` to which Python defaults in its *literal* notation for `str` objects. Both types of quotes may be used interchangeably."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1825,7 +1827,7 @@
|
|||
"source": [
|
||||
"Thus, adhering to just syntax rules is *never* enough. Over time, **best practices** and **style guides** were created to make it less likely for a developer to mess up a program and also to allow \"onboarding\" him as a contributor to an established code base, often called **legacy code**, faster. These rules are not enforced by Python itself: Badly styled code still runs. At the very least, Python programs should be styled according to [PEP 8](https://www.python.org/dev/peps/pep-0008/) and documented \"inline\" (i.e., in the code itself) according to [PEP 257](https://www.python.org/dev/peps/pep-0257/).\n",
|
||||
"\n",
|
||||
"An easier to read version of PEP 8 is [here](https://pep8.org/). The video below features a well known \"[Pythonista](https://en.wiktionary.org/wiki/Pythonista)\" talking about the importance of code style."
|
||||
"An easier to read version of PEP 8 is [here](https://pep8.org/). The video below features a well known **[Pythonista](https://en.wiktionary.org/wiki/Pythonista)** talking about the importance of code style."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -1852,7 +1854,7 @@
|
|||
" "
|
||||
],
|
||||
"text/plain": [
|
||||
"<IPython.lib.display.YouTubeVideo at 0x7ff8c00b5358>"
|
||||
"<IPython.lib.display.YouTubeVideo at 0x7fb124565080>"
|
||||
]
|
||||
},
|
||||
"execution_count": 52,
|
||||
|
|
@ -1873,7 +1875,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"For example, while the above code to calculate the average of the even numbers from `1` through `12` is correct, a Pythonista would re-write it in a more \"Pythonic\" way and use the [sum()](https://docs.python.org/3/library/functions.html#sum) and [len()](https://docs.python.org/3/library/functions.html#len) (= \"length\") [built-in functions](https://docs.python.org/3/library/functions.html) (cf., [Chapter 2](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/02_functions.ipynb#Built-in-Functions)) as well as a so-called **list comprehension** (cf., [Chapter 7](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/07_sequences.ipynb#List-Comprehensions)). Pythonic code runs faster in many cases and is less error-prone."
|
||||
"For example, while the above code to calculate the average of the even numbers in `[7, 11, 8, 5, 3, 12, 2, 6, 9, 10, 1, 4]` is correct, a Pythonista would rewrite it in a more \"Pythonic\" way and use the [sum()](https://docs.python.org/3/library/functions.html#sum) and [len()](https://docs.python.org/3/library/functions.html#len) (= \"length\") [built-in functions](https://docs.python.org/3/library/functions.html) (cf., [Chapter 2](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/02_functions.ipynb#Built-in-Functions)) as well as a so-called **list comprehension** (cf., [Chapter 7](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/07_sequences.ipynb#List-Comprehensions)). Pythonic code runs faster in many cases and is less error-prone."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2075,7 +2077,7 @@
|
|||
"\n",
|
||||
"At the same time, for a beginner's course, it is often easier to code linearly.\n",
|
||||
"\n",
|
||||
"In real data science projects, one would probably employ a mixed approach and put re-usable code into so-called Python modules (i.e., *.py* files; cf., [Chapter 2](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/02_functions.ipynb#Local-Modules-and-Packages)) and then use Jupyter notebooks to build up a linear report or storyline for a business argument to be made."
|
||||
"In real data science projects, one would probably employ a mixed approach and put reusable code into so-called Python modules (i.e., *.py* files; cf., [Chapter 2](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/02_functions.ipynb#Local-Modules-and-Packages)) and then use Jupyter notebooks to build up a linear report or storyline for a business argument to be made."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2097,9 +2099,9 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"**Variables** are created with the **[assignment statement](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)** `=`, which is *not* an operator, mainly because of its side effect of making a **[name](https://docs.python.org/3/reference/lexical_analysis.html#identifiers)** point to an object in memory.\n",
|
||||
"**Variables** are created with the **[assignment statement](https://docs.python.org/3/reference/simple_stmts.html#assignment-statements)** `=`, which is *not* an operator, mainly because of its side effect of making a **[name](https://docs.python.org/3/reference/lexical_analysis.html#identifiers)** reference an object in memory.\n",
|
||||
"\n",
|
||||
"We read the terms **variable**, **name**, and **identifier** used interchangebly in many Python-related texts. In this book, we adopt the following convention: First, we treat *name* and *identifier* as perfect synonyms but only use the term *name* in the text for clarity. Second, whereas *name* only refers to a string of letters, numbers, and some other symbols, a *variable* refers to the combination of a *name* and a *pointer* to some object in memory."
|
||||
"We read the terms **variable**, **name**, and **identifier** used interchangebly in many Python-related texts. In this book, we adopt the following convention: First, we treat *name* and *identifier* as perfect synonyms but only use the term *name* in the text for clarity. Second, whereas *name* only refers to a string of letters, numbers, and some other symbols, a *variable* means the combination of a *name* and a *reference* to an object in memory."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2124,7 +2126,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"When referenced, a variable evaluates to the value of the object it points to. Colloquially, we could say that `a` evaluates to `20.0`, but this would not be an accurate description of what is going on in memory. We see some more colloquialisms in this section but should always relate this to what Python actually does in memory."
|
||||
"When used as a *literal*, a variable evaluates to the value of the object it references. Colloquially, we could say that `a` evaluates to `20.0`, but this would not be an accurate description of what is going on in memory. We see some more colloquialisms in this section but should always relate this to what Python actually does in memory."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2172,7 +2174,7 @@
|
|||
},
|
||||
"outputs": [],
|
||||
"source": [
|
||||
"a = 20 # this makes a point to an object of a different type"
|
||||
"a = 20 # this makes a reference an object of a different type"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2281,7 +2283,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"Variables are **[de-referenced](https://docs.python.org/3/reference/simple_stmts.html#the-del-statement)** (i.e., \"deleted\") with the `del` statement. It does *not* delete the object to which a variable points to but merely removes the variable's name from the \"global list of all names.\""
|
||||
"Variables are **[dereferenced](https://docs.python.org/3/reference/simple_stmts.html#the-del-statement)** (i.e., \"deleted\") with the `del` statement. It does *not* delete the object a variable references but merely removes the variable's name from the \"global list of all names.\""
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2594,9 +2596,9 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"It is *crucial* to understand that *several* variables may point to the *same* object in memory. Not having this in mind may lead to many hard to track down bugs.\n",
|
||||
"It is *crucial* to understand that *several* variables may reference the *same* object in memory. Not having this in mind may lead to many hard to track down bugs.\n",
|
||||
"\n",
|
||||
"Make `b` point to whatever object `a` is pointing to."
|
||||
"Make `b` reference whatever object `a` is referencing."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2670,7 +2672,7 @@
|
|||
"source": [
|
||||
"For \"simple\" types like `int` or `float` this never causes troubles.\n",
|
||||
"\n",
|
||||
"Let's \"change the value\" of `a`. To be precise, let's create a *new* `123` object and make `a` point to it."
|
||||
"Let's \"change the value\" of `a`. To be precise, let's create a *new* `123` object and make `a` reference it."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2718,7 +2720,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"`b` \"is still the same\" as before. To be precise, `b` still points to the *same object* as before."
|
||||
"`b` \"is still the same\" as before. To be precise, `b` still references the *same object* as before."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2753,7 +2755,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"However, if a variable points to an object of a more \"complex\" type (e.g., `list`), \"weird\" things happen."
|
||||
"However, if a variable references an object of a more \"complex\" type (e.g., `list`), \"weird\" things happen."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2816,7 +2818,7 @@
|
|||
"source": [
|
||||
"Let's change the first element of `x`.\n",
|
||||
"\n",
|
||||
"[Chapter 7](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/07_sequences.ipynb#The-list-Type) discusses lists in more depth. For now, let's view a `list` object as some sort of **container** that holds an arbitrary number of pointers to other objects and treat the brackets `[]` attached to it as just another operator, called the **indexing operator**. `x[0]` instructs Python to first follow the pointer from the global list of all names to the `x` object. Then, it follows the first pointer it finds there to the `1` object. The indexing operator must be an operator as we merely read the first element and do not change anything in memory.\n",
|
||||
"[Chapter 7](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/07_sequences.ipynb#The-list-Type) discusses lists in more depth. For now, let's view a `list` object as some sort of **container** that holds an arbitrary number of references to other objects and treat the brackets `[]` attached to it as just another operator, called the **indexing operator**. `x[0]` instructs Python to first follow the reference from the global list of all names to the `x` object. Then, it follows the first reference it finds there to the `1` object. The indexing operator must be an operator as we merely read the first element and do not change anything in memory.\n",
|
||||
"\n",
|
||||
"Note how Python **begins counting at 0**. This is not the case for many other languages, for example, [MATLAB](https://en.wikipedia.org/wiki/MATLAB), [R](https://en.wikipedia.org/wiki/R_%28programming_language%29), or [Stata](https://en.wikipedia.org/wiki/Stata). To understand why this makes sense, see this short [note](https://www.cs.utexas.edu/users/EWD/transcriptions/EWD08xx/EWD831.html) by one of the all-time greats in computer science, the late [Edsger Dijkstra](https://en.wikipedia.org/wiki/Edsger_W._Dijkstra)."
|
||||
]
|
||||
|
|
@ -2853,7 +2855,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"To change the first entry in the list, we use the assignment statement `=` again. Here, this does *not* create a *new* variable (or overwrite an existing one) but only changes the object to which the first pointer in the `x` list points to. As we only change parts of the `x` object, we say that we **mutate** (i.e., \"change\") its **state**. To use the bag analogy from above, we keep the same bag but \"flip\" some of the $0$s into $1$s and some of the $1$s into $0$s."
|
||||
"To change the first entry in the list, we use the assignment statement `=` again. Here, this does *not* create a *new* variable, or overwrite an existing one, but only changes the object which the first element in `x` referenced. As we only change parts of the `x` object, we say that we **mutate** (i.e., \"change\") its **state**. To use the bag analogy from above, we keep the same bag but \"flip\" some of the $0$s into $1$s and some of the $1$s into $0$s."
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2901,7 +2903,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"The changes made to the object `x` is pointing to are also seen through the `y` variable!"
|
||||
"The changes made to the object `x` is referencing can also be seen through the `y` variable!"
|
||||
]
|
||||
},
|
||||
{
|
||||
|
|
@ -2938,11 +2940,11 @@
|
|||
"source": [
|
||||
"The illustrated difference in behavior has to do with the fact that integers and floats are **immutable** types while lists are **mutable**.\n",
|
||||
"\n",
|
||||
"In the first case, an object cannot be changed \"in place\" once it is created in memory. When we assigned `123` to the already existing `a`, we did not change the $0$s and $1$s in the object `a` pointed to before the assignment but created a new integer object and made `a` point to it while the `b` variable is *not* affected.\n",
|
||||
"In the first case, an object cannot be changed \"in place\" once it is created in memory. When we assigned `123` to the already existing `a`, we did not change the $0$s and $1$s in the object `a` referenced before the assignment but created a new integer object and made `a` reference it while the `b` variable is *not* affected.\n",
|
||||
"\n",
|
||||
"In the second case, `x[0] = 99` creates a *new* integer object `99` and merely changes the first pointer in the `x` list.\n",
|
||||
"In the second case, `x[0] = 99` creates a *new* integer object `99` and merely changes the first reference in the `x` list.\n",
|
||||
"\n",
|
||||
"In general, the assignment statement creates a new name and makes it point to whatever object is on the right-hand side *iff* the left-hand side is a *pure* name (i.e., it contains no operators like the indexing operator in the example). Otherwise, it *mutates* an already existing object. And, we always must expect that the latter might have more than one variable pointing to it.\n",
|
||||
"In general, the assignment statement creates a new name and makes it reference whatever object is on the right-hand side *iff* the left-hand side is a *pure* name (i.e., it contains no operators like the indexing operator in the example). Otherwise, it *mutates* an already existing object. And, we always must expect that the latter might have more than one variable referencing it.\n",
|
||||
"\n",
|
||||
"Visualizing what is going on in the memory with a tool like [PythonTutor](http://pythontutor.com/visualize.html#code=x%20%3D%20%5B1,%202,%203%5D%0Ay%20%3D%20x%0Ax%5B0%5D%20%3D%2099%0Aprint%28y%5B0%5D%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false) might be helpful for a beginner."
|
||||
]
|
||||
|
|
@ -3226,7 +3228,7 @@
|
|||
" "
|
||||
],
|
||||
"text/plain": [
|
||||
"<IPython.lib.display.YouTubeVideo at 0x7ff8c011af28>"
|
||||
"<IPython.lib.display.YouTubeVideo at 0x7fb1245d4320>"
|
||||
]
|
||||
},
|
||||
"execution_count": 95,
|
||||
|
|
@ -3258,7 +3260,7 @@
|
|||
}
|
||||
},
|
||||
"source": [
|
||||
"An **[expression](https://docs.python.org/3/reference/expressions.html)** is any syntactically correct **combination** of **variables** and **literals** with **operators**.\n",
|
||||
"An **[expression](https://docs.python.org/3/reference/expressions.html)** is any syntactically correct *combination* of *variables* and *literals* with *operators*.\n",
|
||||
"\n",
|
||||
"In simple words, anything that may be used on the right-hand side of an assignment statement without creating a `SyntaxError` is an expression.\n",
|
||||
"\n",
|
||||
|
|
@ -3645,7 +3647,7 @@
|
|||
"source": [
|
||||
"We use the `#` symbol to write comments in plain English right into the code.\n",
|
||||
"\n",
|
||||
"As a good practice, comments should not describe *what* happens (this should be evident by reading the code; otherwise, it is most likely badly written code) but *why* something happens.\n",
|
||||
"As a good practice, comments should *not* describe *what* happens (this should be evident by reading the code; otherwise, it is most likely badly written code) but *why* something happens.\n",
|
||||
"\n",
|
||||
"Comments may be added either at the end of a line of code, by convention separated with two spaces, or on a line on their own."
|
||||
]
|
||||
|
|
@ -3732,9 +3734,9 @@
|
|||
"\n",
|
||||
"\n",
|
||||
"- input (examples)\n",
|
||||
" - (numeric) data from a CSV file\n",
|
||||
" - data from a CSV file\n",
|
||||
" - text entered on a command line\n",
|
||||
" - (relational) data obtained from a database\n",
|
||||
" - data obtained from a database\n",
|
||||
" - etc.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
|
|
@ -3749,20 +3751,20 @@
|
|||
" - distinct and well-contained areas/parts of the memory that hold the actual data\n",
|
||||
" - the concept by which Python manages the memory for us\n",
|
||||
" - can be classified into objects of the same **type** (i.e., same abstract \"structure\" but different concrete data)\n",
|
||||
" - built-in objects (incl. **literals**) vs. user-defined objects (cf., Chapter 8)\n",
|
||||
" - built-in objects (incl. **literals**) vs. user-defined objects (cf., Chapter 9)\n",
|
||||
" - e.g., `1`, `1.0`, and `\"one\"` are three different objects of distinct types that are also literals (i.e., by the way we type them into the command line Python knows what the value and type are)\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- variables\n",
|
||||
" - storage of intermediate **state**\n",
|
||||
" - **names** that point to **objects** in **memory**\n",
|
||||
" - e.g., `x = 1` creates the variable `x` that points to the object `1`\n",
|
||||
" - are **names** referencing **objects** in **memory**\n",
|
||||
" - e.g., `x = 1` creates the variable `x` that references the object `1`\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- operators\n",
|
||||
" - special built-in symbols that perform operations with objects in memory\n",
|
||||
" - usually, operate with one or two objects\n",
|
||||
" - e.g., addition `+`, subtraction `-`, multiplication `*`, and division `/` all take two objects whereas the negation `-` only takes one\n",
|
||||
" - e.g., addition `+`, subtraction `-`, multiplication `*`, and division `/` all take two objects, whereas the negation `-` only takes one\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- expressions\n",
|
||||
|
|
@ -3774,9 +3776,9 @@
|
|||
"\n",
|
||||
"- statements\n",
|
||||
" - instructions that **\"do\" something** and **have side effects** in memory\n",
|
||||
" - re-map names to different objects and *change* the state of the program\n",
|
||||
" - (re-)assign names to (different) objects, *change* an existing object *in place*, or, more conceptually, *change* the state of the program\n",
|
||||
" - usually, work with expressions\n",
|
||||
" - e.g., the assignment statement `=` makes a name point to an object\n",
|
||||
" - e.g., the assignment statement `=` makes a name reference an object\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- comments\n",
|
||||
|
|
@ -3788,6 +3790,7 @@
|
|||
" - named sequences of instructions\n",
|
||||
" - the smaller parts in a larger program\n",
|
||||
" - make a program more modular and thus easier to understand\n",
|
||||
" - include [built-in functions](https://docs.python.org/3/library/functions.html) like [print()](https://docs.python.org/3/library/functions.html#print), [sum()](https://docs.python.org/3/library/functions.html#sum), or [len()](https://docs.python.org/3/library/functions.html#len)\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- flow control (cf., [Chapter 3](https://nbviewer.jupyter.org/github/webartifex/intro-to-python/blob/master/03_conditionals.ipynb))\n",
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue