static_files/presentations/02_Data_manipulation.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"provenance":[],"collapsed_sections":[],"toc_visible":true},"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.8.8"}},"cells":[{"cell_type":"markdown","metadata":{"id":"11n5gndbRzoY"},"source":["# Programming and data manipulation"]},{"cell_type":"markdown","source":["<table align=\"left\">\n","  <td>\n","    <a href=\"https://colab.research.google.com/github/phonchi/nsysu-math105A/blob/master/static_files/presentations/02_Data_manipulation.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n","  </td>\n","  <td>\n","    <a target=\"_blank\" href=\"https://kaggle.com/kernels/welcome?src=https://github.com/phonchi/nsysu-math105A/blob/master/static_files/presentations/02_Data_manipulation.ipynb\"><img src=\"https://kaggle.com/static/images/open-in-kaggle.svg\" /></a>\n","  </td>\n","</table>"],"metadata":{"id":"AIFsv_RZ1iV0"}},{"cell_type":"markdown","metadata":{"id":"SwFKFBMwRzoa"},"source":["## Introduction"]},{"cell_type":"markdown","metadata":{"id":"Ss9hRGHDRzob"},"source":["One of the essential features of computer programming languages such as `Python` is that they shield users from the tedious details of working with the \n","lowest levels of the machine. Having just completed much of topics on the lowest levels of data manipulation in computer, it is instructive to \n","review some of the major details that `Python` scripts shield the programmer \n","from needing to worry about.\n","\n","As we will explore in greater detail in Chapter 9, high-level programming language statements are mapped down to low-level machine instructions in order to be executed. A single `Python` statement might map to a single machine instruction, or to many tens or even hundreds of machine instructions, depending on the complexity of the statement and the efficiency of the machine language. Different implementations of the `Python` language interpreter, in concert with other elements of the computer's operating system software, take care of this mapping process for each particular computer processor. As a result, the `Python` programmer does not need to know whether she is executing her `Python` script on a RISC processor or a CISC processor.\n","\n","We can recognize many `Python` operations that correspond closely to \n","the basic machine instructions for modern computers or our hypotehetical computer. Addition of `Python` integers and floating point numbers clearly resembles the `ADDI` and `ADDF` op-codes of our simple machine. \n","Assigning values to variables surely involves the `LOAD`, `STORE`, and `MOVE` op-codes in some arrangement. `Python` shields us from worrying about which \n","processor registers are in use, but leverages the op-codes of the machine to \n","carry out our instructions. **We cannot see the instruction register, program \n","counter, or memory cell addresses, but the `Python` script executes sequentially, one statement after the other, in the same way as the simple machine language programs.**"]},{"cell_type":"markdown","source":["### Boolean expressions"],"metadata":{"id":"WjPuxQq1sA-3"}},{"cell_type":"markdown","source":["A boolean expression is an expression that is either true or false. The following examples use the operator `==`, which compares two operands and produces `True` if they are equal and `False` otherwise:"],"metadata":{"id":"TVuZi_rfsC9u"}},{"cell_type":"code","source":["5 == 5, 5 == 6"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"QYptoP__sAbn","executionInfo":{"status":"ok","timestamp":1665656455180,"user_tz":-480,"elapsed":268,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"509e26a1-7d5a-45c8-fd10-e7fa4ce694ec"},"execution_count":5,"outputs":[{"output_type":"execute_result","data":{"text/plain":["(True, False, True)"]},"metadata":{},"execution_count":5}]},{"cell_type":"markdown","source":["`True` and `False` are special values that belong to the class bool; they are not strings:"],"metadata":{"id":"cc7LkxgesPQf"}},{"cell_type":"code","source":["type(True), type(False)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"9eio5IH1sRe_","executionInfo":{"status":"ok","timestamp":1665656388598,"user_tz":-480,"elapsed":3,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"10691270-f0b2-4cac-c7a1-b0e286eedbd0"},"execution_count":2,"outputs":[{"output_type":"execute_result","data":{"text/plain":["(bool, bool)"]},"metadata":{},"execution_count":2}]},{"cell_type":"markdown","source":["The `==` operator is one of the comparison operators; the others are:\n","\n","\n","|            | Meaning                         |\n","|------------|---------------------------------|\n","| x != y     | x is not equal to y             |\n","| x > y      | x is greater than y             |\n","| x < y      | x is less than y                |\n","| x >= y     | x is greater than or equal to y |\n","| x <= y     | x is less than or equal to y    |\n","| x is y     | x is the same as y              |\n","| x is not y | x is not the same as y          |\n","\n","\n","> The `Python` symbols are different from the mathematical symbols for the same operations. A common error is to use a single equal sign `=` instead of a double equal sign `==`. Remember that `=` is an assignment operator and `==` is a comparison operator. There is no such thing as `=<` or `=>`."],"metadata":{"id":"DoBusgVgs4sP"}},{"cell_type":"markdown","source":["### Logic and Shift Operations"],"metadata":{"id":"vk4VMOiLBn7L"}},{"cell_type":"markdown","source":["Logic and shift operations can be executed on any kind of numerical data, but \n","because they often deal with individual bits of data, it is easiest to illustrate these operations with binary values. Just as `Python` uses the `‘0x’` prefix to specify values in hexadecimal, the `‘0b’` prefix can be used to specify values in binary."],"metadata":{"id":"3_gQhZxrBvQW"}},{"cell_type":"code","metadata":{"id":"IPO0BNIcRzob"},"source":["x  = 0b00110011\n","mask = 0b00001111"],"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Note that this is effectively no different from assigning `x` the value 51 (which is `110011` in binary) or `0x33` (which is 51 expressed in hexadecimal), or from assigning mask the value 15 (which is `1111` in binary) or `0x0F` (15 in hexadecimal). The representation we use to express the integer value in the `Python` assignment statement does not change how it is represented in the computer, only how human readers understand it.\n"],"metadata":{"id":"j3AXpU87B5bT"}},{"cell_type":"markdown","source":["Built-in Python operators exist for each of the bitwise logical operators \n","described in Chapter 4."],"metadata":{"id":"v0XnaAj9d2lo"}},{"cell_type":"code","source":["print(0b00000101 ^ 0b00000100)     # Prints 5 XOR 4, which is 1\n","print(0b00000101 | 0b00000100)     # Prints 5 OR 4, which is 5\n","print(0b00000101 & 0b00000100)     # Prints 5 AND 4, which is 4\n","print(~0b00000101)            # Prints NOT 5, which is -6"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"hIOPRyQneBTX","executionInfo":{"status":"ok","timestamp":1665656645701,"user_tz":-480,"elapsed":254,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"32c7b372-9631-4ead-dcae-1d450ed2831c"},"execution_count":6,"outputs":[{"output_type":"stream","name":"stdout","text":["1\n","5\n","4\n","-6\n"]}]},{"cell_type":"code","source":["print(0b00000101 or 0b00000100)     # Prints 5 OR 4, which is 5\n","print(0b00000101 and 0b00000100)     # Prints 5 AND 4, which is 4"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"A3UCE_SIxqZY","executionInfo":{"status":"ok","timestamp":1665656659991,"user_tz":-480,"elapsed":283,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"d4c950ba-64b7-40a1-f51c-3764b663cc3c"},"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["5\n","4\n"]}]},{"cell_type":"markdown","source":["Strictly speaking, the operands of the logical operators should be boolean expressions, but `Python` is not very strict. **Any nonzero number is interpreted as “true.”**"],"metadata":{"id":"a_uX7Epjy8WE"}},{"cell_type":"code","source":["17 and True"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"V6wQM7r2zAKi","executionInfo":{"status":"ok","timestamp":1665656748907,"user_tz":-480,"elapsed":256,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"959f86ff-f12b-4cc7-bbf6-aad794036577"},"execution_count":10,"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":10}]},{"cell_type":"markdown","source":["For all of these examples, `Python` will print the result in its default output \n","representation, which is base-10. If the user would also like the output to be \n","displayed in binary notation, a built-in function exists to convert any integer \n","value into the string of zero and one characters for the corresponding binary \n","representation."],"metadata":{"id":"yQxsUVRNeVJI"}},{"cell_type":"code","source":["print(0b10011010 & 0b11001001)   # Prints \"0b10001000\"\n","print(0b10011010 | 0b11001001)   # Prints \"0b11011011\"\n","print(0b10011010 ^ 0b11001001)   # Prints \"0b1010011\"\n","print(~0b00000101)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"KX4l9sUQ5xWT","executionInfo":{"status":"ok","timestamp":1665657164963,"user_tz":-480,"elapsed":2,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"cb885b68-b9b3-44a4-dcef-880c125beab5"},"execution_count":20,"outputs":[{"output_type":"stream","name":"stdout","text":["136\n","219\n","83\n","-6\n"]}]},{"cell_type":"code","source":["print(bin(0b10011010 & 0b11001001))   # Prints \"0b10001000\"\n","print(bin(0b10011010 | 0b11001001))   # Prints \"0b11011011\"\n","print(bin(0b10011010 ^ 0b11001001))   # Prints \"0b1010011\"\n","print(bin(~0b00000101)) #https://realpython.com/python-bitwise-operators/"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"2tKXO-A5etc3","executionInfo":{"status":"ok","timestamp":1665656803571,"user_tz":-480,"elapsed":300,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"b8c378d8-2d58-4341-a692-346b05b4b3e0"},"execution_count":11,"outputs":[{"output_type":"stream","name":"stdout","text":["0b10001000\n","0b11011011\n","0b1010011\n","-0b110\n"]}]},{"cell_type":"markdown","source":["Because newer versions of `Python` can use an arbitrary number of digits for \n","representing numbers, leading zeros are not printed. Thus, the third line above \n","prints only seven digits, rather than eight. Integers in `Python` are not fixed size. There's no int16, int32, uint8 and such. `Python` will just add bits as it needs to. That means a negative number cannot be represented by its complement, `0b11111011` is not `-5` as for `int8`, but `251`. Since binaries are ***potentially infinite***, there's no fixed position to place a sign bit. Thus, `Python` has to add the explicit unary `-`.\n","\n","If you want to get the binary representation for negative, fixed size integers, you can use the function below:"],"metadata":{"id":"kvF1a-WLe4PJ"}},{"cell_type":"code","source":["# https://stackoverflow.com/questions/39959491/how-to-convert-signed-string-to-its-binary-equivalent-in-python\n","def bin_int(number, size=8):\n","    max_val = int('0b' + ('1'* (size - 1)), 2)  # e.g. 0b01111111\n","    if number >=0:\n","        return bin(number)\n","    sign = int('0b1' + ('0' * size), 2)  # e.g. 0b10000000\n","    return bin(number + sign)"],"metadata":{"id":"cveHhzTTxfAs","executionInfo":{"status":"ok","timestamp":1665656969563,"user_tz":-480,"elapsed":594,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":12,"outputs":[]},{"cell_type":"code","source":["print(bin_int(~0b00000101))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"3gHgLYkYuLsE","executionInfo":{"status":"ok","timestamp":1665657017716,"user_tz":-480,"elapsed":383,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"efc5faf6-7a04-4619-93d8-2647b1a954e6"},"execution_count":15,"outputs":[{"output_type":"stream","name":"stdout","text":["0b11111010\n"]}]},{"cell_type":"markdown","source":["We will go back to this function latter on."],"metadata":{"id":"pzFVZQIGyt-C"}},{"cell_type":"markdown","source":["`Python's` built-in operators for performing logical shift operations consist \n","of dual greater-than and less-than symbols, visually suggesting the direction \n","of shift. The operand on the right of the operator indicates the number of bit \n","positions to shift."],"metadata":{"id":"zentVXlVe8LH"}},{"cell_type":"code","source":["print(0b00111100 >> 2)   # Prints  \"15\",  which is 0b00001111\n","print(0b00111100 << 2)   # Prints \"240\",  which is 0b11110000"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"yjI2v1IRfFdH","executionInfo":{"status":"ok","timestamp":1665381733438,"user_tz":-480,"elapsed":749,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"854dd460-ec91-41e4-a78e-a7ab5805fab6"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["15\n","240\n"]}]},{"cell_type":"markdown","source":["Remember that in addition to shifting bit masks left or right, bit shift operators are also an efficient way to multiply (left shift) or divide (right shift) by powers of 2.\n","\n","For arithmetic shift refer to https://realpython.com/python-bitwise-operators/"],"metadata":{"id":"0HEpPkhPfNN3"}},{"cell_type":"markdown","source":["## Control Structures"],"metadata":{"id":"_6ZotSZXEzN5"}},{"cell_type":"markdown","source":["### Conditional execution"],"metadata":{"id":"1NUilGNt2iJS"}},{"cell_type":"markdown","source":["The control op-codes like `JUMP` in machine language instructions affords us a mechanism for jumping from one part of a program to another. In higher-level languages like `Python`, this enables what are called **control structures**, syntax patterns that allow us to express algorithms more succinctly. One example of this is the **if-statement**, which allows a segment of code to be conditionally skipped if a Boolean value in the script is not true.\n","\n","<center><img src=\"https://www.py4e.com/images/if.svg\"></center>\n","<div align=\"center\"> source: https://www.py4e.com/html3/03-conditional </div>"],"metadata":{"id":"U_5LmIfNE165"}},{"cell_type":"code","metadata":{"id":"OLi_7GqcRzox","colab":{"base_uri":"https://localhost:8080/"},"outputId":"50ce1edb-f501-4b8b-f3d8-9e95e748c2ce","executionInfo":{"status":"ok","timestamp":1665387208888,"user_tz":-480,"elapsed":429,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"source":["x = 150\n","if x > 0:\n","  print('x is positive')"],"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x is positive\n"]}]},{"cell_type":"markdown","source":["The boolean expression after the `if` statement is called the condition. We end the `if` statement with a colon character (`:`) and the line(s) after the `if` statement are indented. If the logical condition is true, then the indented statement gets executed. If the logical condition is false, the indented statement is skipped.  The statement consists of a header line that ends with the colon character (:) followed by an indented block. Statements like this are called ***compound statements*** because they stretch across more than one line."],"metadata":{"id":"eLp7j4ueFK4h"}},{"cell_type":"markdown","source":["A second form of the `if` statement is alternative execution, in which there are two possibilities and the condition determines which one gets executed. The syntax looks like this:"],"metadata":{"id":"i7wWs6bj1CeU"}},{"cell_type":"code","source":["if x%2 == 0:\n","    print('x is even')\n","else:\n","    print('x is odd')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"j3ALfiYq1KNJ","executionInfo":{"status":"ok","timestamp":1665387517163,"user_tz":-480,"elapsed":2,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"ef0ee27a-f6d7-4734-90dc-97fd8b01e537"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x is even\n"]}]},{"cell_type":"markdown","source":["<center><img src=\"https://www.py4e.com/images/if-else.svg\"></center>\n","<div align=\"center\"> source: https://www.py4e.com/html3/03-conditional </div>"],"metadata":{"id":"wS5jvy7X1VNY"}},{"cell_type":"markdown","source":["Since the condition must either be true or false, exactly one of the alternatives will be executed. The alternatives are called ***branches***, because they are branches in the flow of execution."],"metadata":{"id":"Lk7kiHwr1hEh"}},{"cell_type":"markdown","source":["If the remainder when `x` is divided by 2 is 0, then we know that `x` is even, and the program displays a message to that effect. If the condition is false, the second set of statements is executed."],"metadata":{"id":"Yy0DjjkM1Pq5"}},{"cell_type":"markdown","source":["Sometimes there are more than two possibilities and we need more than two branches. One way to express a computation like that is a chained conditional:"],"metadata":{"id":"PCLnLflt1rZR"}},{"cell_type":"code","source":["y = 5\n","if x < y:\n","    print('x is less than y')\n","elif x > y:\n","    print('x is greater than y')\n","else:\n","    print('x and y are equal')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"NtHQJ54h1yTp","executionInfo":{"status":"ok","timestamp":1665387694945,"user_tz":-480,"elapsed":2,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"3af6417b-88d9-4398-8fdb-0aee8cb71de2"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["x is greater than y\n"]}]},{"cell_type":"markdown","source":["<center><img src=\"https://www.py4e.com/images/elif.svg\"></center>\n","<div align=\"center\"> source: https://www.py4e.com/html3/03-conditional </div>"],"metadata":{"id":"YzlT65M418D5"}},{"cell_type":"markdown","source":["### Loops and Iterations"],"metadata":{"id":"ydjopqnU2n_R"}},{"cell_type":"markdown","source":["Another control structure is the looping construct `while`, which allows \n","a segment of code to be executed multiple times, often subject to some \n","condition."],"metadata":{"id":"7EvWoL27Fbqx"}},{"cell_type":"code","source":["n = 0\n","while (n < 10):\n","  print(n)\n","  n = n + 1"],"metadata":{"id":"mJnA-rQOFIAm","colab":{"base_uri":"https://localhost:8080/"},"outputId":"9c888db1-27fd-4f47-a04a-0aa1da02ba4d","executionInfo":{"status":"ok","timestamp":1665382029603,"user_tz":-480,"elapsed":2,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["0\n","1\n","2\n","3\n","4\n","5\n","6\n","7\n","8\n","9\n"]}]},{"cell_type":"markdown","source":["More formally, here is the flow of execution for a `while` statement:\n","\n","1. Evaluate the condition, yielding `True` or `False`.\n","\n","2. If the condition is false, exit the `while` statement and continue execution at the next statement.\n","\n","3. If the condition is true, execute the body and then go back to step 1."],"metadata":{"id":"bXzLhOOb27tS"}},{"cell_type":"markdown","source":["This type of flow is called a ***loop*** because the third step loops back around to the top. We call each time we execute the body of the loop an iteration. The body of the loop should change the value of one or more variables so that eventually the condition becomes false and the loop terminates. We call the variable that changes each time the loop executes and controls when the loop finishes the iteration variable. If there is no iteration variable, the loop will repeat forever, resulting in an ***infinite loop***."],"metadata":{"id":"MLdwEwBq3N4B"}},{"cell_type":"markdown","source":["Sometimes we want to loop through a set of things such as a list of words, the lines in a file, or a list of numbers. When we have a list of things to loop through, we can construct a definite loop using a `for` statement. We call the `while` statement an indefinite loop because it simply loops until some condition becomes `False`, whereas the `for` loop is looping through a known set of items so it runs through as many iterations as there are items in the set."],"metadata":{"id":"j_G0ZuOx3uBH"}},{"cell_type":"code","source":["friends = ['Joseph', 'Glenn', 'Sally']\n","for friend in friends:\n","    print('Happy New Year:', friend)\n","print('Done!')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"JknbyYID4Gjo","executionInfo":{"status":"ok","timestamp":1665388283052,"user_tz":-480,"elapsed":3,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"caf3fe85-8684-4efd-dea0-50f39cf8a8c0"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Happy New Year: Joseph\n","Happy New Year: Glenn\n","Happy New Year: Sally\n","Done!\n"]}]},{"cell_type":"markdown","source":["We will spend more time examining these and other control structures in \n","Chapter 9 and beyond. **For now, we focus on a mechanism that allows us to \n","jump to another part of the program, carry out a desired task, and then return \n","to the program point from which we came.**"],"metadata":{"id":"wkjRdazv3skZ"}},{"cell_type":"markdown","source":["## Functions"],"metadata":{"id":"BV5LcxKvKnml"}},{"cell_type":"markdown","source":["We have already seen several built-in `Python` operations that do not follow the same syntactic form as the arithmetic and logic operators. The `print()`, `str()` and `bin()` operations are invoked using given names instead of symbols, and also involve parentheses wrapped around their operands. Both of these are examples of a `Python` language feature called functions. This abstraction allows us to reuse the expression many times without having \n","to duplicate it. Programming language allow us to use a name for a series of operations that should be performed on the given parameter or parameters. Due to the way that this language feature is mapped to lower-level machine languages, the appearance of a function in an expression or statement is known as a ***function call***, or sometimes ***calling*** a function. "],"metadata":{"id":"vxF99qxYKqKN"}},{"cell_type":"markdown","source":["From now on, we will follow the convention of including the parentheses \n","when talking about `Python` functions, such as `print()`, so as to clearly denote them as distinct from variables or other items.\n","\n","Functions come in many varieties beyond what we have already seen. \n","Some functions take more than one argument, such as the `max()` function:"],"metadata":{"id":"8In1DxXHibIu"}},{"cell_type":"code","source":["x = 1034\n","y = 1056\n","z = 2078\n","biggest = max(x, y, z)\n","print(biggest)   "],"metadata":{"id":"HIwnHarAHqN2","colab":{"base_uri":"https://localhost:8080/"},"outputId":"c7d09777-7520-46ee-cfc1-7157b24c5901","executionInfo":{"status":"ok","timestamp":1665382643990,"user_tz":-480,"elapsed":459,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["2078\n"]}]},{"cell_type":"markdown","source":["Multiple arguments are separated by commas within the parentheses. Some \n","functions ***return*** a value, which is to say that the function call itself can appear as part of a more complex expression, or as the right-hand side of an assignment statement. These are sometimes called ***fruitful functions***. This is the case for both `max()` (as above) and `bin()`. Other functions do not return a value, and usually are used as standalone statements, as is the case for `print()`. Functions that do not return a value are sometimes called ***void functions***, or ***procedures***, although `Python` makes no distinction in its syntax rules. It makes no sense to assign the result of a void function to a variable, as in"],"metadata":{"id":"kAGlrti-O_dS"}},{"cell_type":"code","source":["x = print('hello world!')     # x is assigned None\n","type(x)"],"metadata":{"id":"8ifgThqGNvNk","colab":{"base_uri":"https://localhost:8080/"},"outputId":"caba1f27-a863-4cd7-d8b9-83570dd066d9","executionInfo":{"status":"ok","timestamp":1665382869164,"user_tz":-480,"elapsed":3,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["hello world!\n"]},{"output_type":"execute_result","data":{"text/plain":["NoneType"]},"metadata":{},"execution_count":11}]},{"cell_type":"markdown","source":["Each of the functions we have seen so far is one of the few dozen built-in \n","functions that `Python` knows about, but there are extensive libraries of additional functions that a more advanced script can refer to. The `Python` library modules contain many useful functions that may not normally be required, but can be called upon when needed."],"metadata":{"id":"QjhF7W6YPnAX"}},{"cell_type":"code","source":["# Calculates the hypotenuse of a right triangle\n","import math\n","sideA = 3.0\n","sideB = 4.0\n","\n","# Calculate third side via Pythagorean Theorem\n","hypotenuse = math.sqrt(sideA**2 + sideB**2)\n","print(hypotenuse)"],"metadata":{"id":"wkv1unHkPbtO","colab":{"base_uri":"https://localhost:8080/"},"outputId":"19eedf9d-5e13-4297-9542-6ef6e93e242e","executionInfo":{"status":"ok","timestamp":1665658664184,"user_tz":-480,"elapsed":304,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":22,"outputs":[{"output_type":"stream","name":"stdout","text":["5.0\n"]}]},{"cell_type":"markdown","source":["In this example, the `import` statement forewarns the `Python` interpreter that he script refers to the library called `“math”`, which happens to be one of the \n","standard set of library modules that `Python` comes equipped with. The `sqrt()` \n","function defined within the `math` library module provides the square root of \n","the argument, which in this case was the expression of `sideA` squared plus \n","`sideB` squared. Note that the library function call includes both the module \n","name (`“math”`) and the function name (`“sqrt”`), joined by a period."],"metadata":{"id":"W2rEoIkLQQo6"}},{"cell_type":"markdown","source":["So far, we have only been using the functions that come with `Python`, but it is also possible to **add new functions**. A function definition specifies the name of a new function and the sequence of statements that execute when the function is called. Once we define a function, we can reuse the function over and over throughout our program."],"metadata":{"id":"2rjvv9c_49hH"}},{"cell_type":"code","source":["def print_lyrics():\n","    print(\"I'm a lumberjack, and I'm okay.\")\n","    print('I sleep all night and I work all day.')"],"metadata":{"id":"z5h4EQBx5C5v"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["`def` is a keyword that indicates that this is a function definition. The name of the function is `print_lyrics`. The rules for function names are the same as for variable names: letters, numbers and some punctuation marks are legal, but the first character can’t be a number. You can’t use a keyword as the name of a function, and you should avoid having a variable and a function with the same name."],"metadata":{"id":"OjBC9lOD5Ej_"}},{"cell_type":"markdown","source":["The empty parentheses after the name indicate that this function doesn’t take any arguments. **The first line of the function definition is called the header; the rest is called the body. The header has to end with a colon and the body has to be indented. By convention, the indentation is always four spaces. The body can contain any number of statements.**"],"metadata":{"id":"l6WwIYTq5X5i"}},{"cell_type":"markdown","source":["Some of the built-in functions we have seen require arguments. Inside the function, the arguments are assigned to variables called parameters. Here is an example of a user-defined function that takes an argument:"],"metadata":{"id":"66Ag5wzi5urZ"}},{"cell_type":"code","source":["def print_twice(bruce):\n","    print(bruce)\n","    print(bruce)"],"metadata":{"id":"K8RQuBiT51PG","executionInfo":{"status":"ok","timestamp":1665658839366,"user_tz":-480,"elapsed":436,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":23,"outputs":[]},{"cell_type":"markdown","source":["This function assigns the argument to a parameter named `bruce`. When the function is called, it prints the value of the parameter (whatever it is) twice."],"metadata":{"id":"yd6DFE4X54Yu"}},{"cell_type":"code","source":["print_twice('Spam')"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"zvWK8Vri59c2","executionInfo":{"status":"ok","timestamp":1665658839761,"user_tz":-480,"elapsed":2,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"571d679b-876a-4721-d241-aaaeea5ec948"},"execution_count":24,"outputs":[{"output_type":"stream","name":"stdout","text":["Spam\n","Spam\n"]}]},{"cell_type":"markdown","source":["## Input and Output"],"metadata":{"id":"LwTvxL92Rbgp"}},{"cell_type":"markdown","source":["`Python's` built-in operators allow numeric values to be manipulated and combined in a variety of familiar ways."],"metadata":{"id":"-YaC1zvFRfpB"}},{"cell_type":"markdown","source":["The previous example snippets and scripts have used the built-in `Python` \n","`print()` function to output results. Many programming languages provide \n","similar mechanisms for achieving input and output, providing programmers \n","with a convenient abstraction to move data in or out of the computer processor. In fact, these I/O built-ins communicate with the hardware controllers \n","and peripheral devices discussed in Chapter 5.\n","\n","None of our example scripts thus far have required any input from the \n","user. Simple user input can be accomplished with the built-in `Python` `input()` function."],"metadata":{"id":"dHd4W5apkxOL"}},{"cell_type":"code","source":["echo = input('Please enter a string to echo: ')\n","print(echo * 3)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"5JKg4qojkwVy","executionInfo":{"status":"ok","timestamp":1665658916059,"user_tz":-480,"elapsed":3800,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"e74dba41-8393-476e-a2ed-610cba85f44f"},"execution_count":25,"outputs":[{"output_type":"stream","name":"stdout","text":["Please enter a string to echo: 5\n","555\n"]}]},{"cell_type":"markdown","source":["The `input()` function takes as an optional argument a prompt string to present to the user when waiting for input. When run, this script will pause after displaying “Please enter a string to echo:”, and wait for the user to type something. When the user hits the enter key, the script assigns the string \n","of characters typed (**not including the enter key**,) to the variable `echo`. The second line of the script then outputs the string repeated three times. (Recall that the `‘*’` operator replicates string operands.)\n","\n","Armed with the ability to acquire input, let's rewrite our hypotenuse script to prompt a user for the side lengths rather than hardcode the values into assignment statements."],"metadata":{"id":"XkqWahmER-25"}},{"cell_type":"code","source":["# Calculates the hypotenuse of a right triangle\n","import math\n","# Inputting the side lengths, first try\n","sideA = input('Length of side A? ')\n","sideB = input('Length of side B? ')\n","# Calculate third side via Pythagorean Theorem\n","hypotenuse = math.sqrt(sideA**2 + sideB**2)\n","print(hypotenuse)"],"metadata":{"id":"7yub5hd3RqQz","colab":{"base_uri":"https://localhost:8080/","height":254},"outputId":"91b8c4d7-e715-48c3-aed5-415168644113","executionInfo":{"status":"error","timestamp":1665658979489,"user_tz":-480,"elapsed":5023,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":26,"outputs":[{"name":"stdout","output_type":"stream","text":["Length of side A? 3\n","Length of side B? 4\n"]},{"output_type":"error","ename":"TypeError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-26-51472d4e2fc7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0msideB\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Length of side B? '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;31m# Calculate third side via Pythagorean Theorem\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mhypotenuse\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msideA\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0msideB\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhypotenuse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n","\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'str' and 'int'"]}]},{"cell_type":"markdown","source":["At this point, the `Python` interpreter aborts the script! This type of error can be easy to create in a dynamically-typed language like \n","`Python`. Our hypotenuse calculation, which worked in the earlier version of \n","the script, now causes an error when the values have been read as input from \n","the user instead. The problem is indeed a `'TypeError'`, stemming from the \n","fact that `Python` no longer knows how to take the square of variable sideA, \n","because sideA is now a **character string** in this version of the script, rather than an integer as before. The problem comes from earlier in the script, when the values of sideA and sideB are returned from `input()`. This, too, is common when encountering errors with programming languages. **The `Python` interpreter attempts to provide the line of script responsible for the problem, but the real culprit is actually earlier in the script.**"],"metadata":{"id":"OTttc0pmSO6R"}},{"cell_type":"markdown","source":["In the string-echoing snippet above, it was clear that the value assigned \n","to echo should be the string of characters typed in by the user. The `input()` \n","function behaves in the same way in the hypotenuse program, even though \n","the programmer's intent is now to enter integer values. The representation of \n","the ASCII- or UTF-8-encoded string `“4”` differs from the two's complement \n","representation of the integer 4, and the Python script must explicitly make \n","the conversion from one representation to the other before proceeding to calculations with integers."],"metadata":{"id":"Pa3-z6XhmMi6"}},{"cell_type":"markdown","source":["Fortunately, remember that another built-in function provides the capability. The `int()` function attempts to convert its argument into an integer representation. If it cannot, an appropriate error message is produced."],"metadata":{"id":"OQ6wxUU7mhxb"}},{"cell_type":"code","source":["# Calculates the hypotenuse of a right triangle\n","import math\n","# Inputting the side lengths, with integer conversion\n","sideA = int(input('Length of side A? '))\n","sideB = int(input('Length of side B? '))\n","# Calculate third side via Pythagorean Theorem\n","hypotenuse = math.sqrt(sideA**2 + sideB**2)\n","print(hypotenuse)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"9lS7kkZAm0Aa","executionInfo":{"status":"ok","timestamp":1665659145895,"user_tz":-480,"elapsed":4927,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"c0b0f4ab-9b3f-42d5-8286-ca7ef1784ff1"},"execution_count":27,"outputs":[{"output_type":"stream","name":"stdout","text":["Length of side A? 3\n","Length of side B? 4\n","5.0\n"]}]},{"cell_type":"markdown","source":["The revised script operates as intended, and can be used for many right triangles without having to edit the script, as in the pre-input version.\n","As a final note, the `int()` function performs its conversion by carefully \n","examining the string argument and interpreting it as a number. If the input \n","string is a number, but not an integer, as for example, `“3.14”`, the `int()` function discards the fractional portion, and returns only the integer value. "],"metadata":{"id":"E0sQdx_zm6YZ"}},{"cell_type":"markdown","source":["## Bit manipulation and the convertor"],"metadata":{"id":"IIRrq_LF79Pv"}},{"cell_type":"code","source":["\"\"\"\n","This function shifts 1 over by i bits, creating a value being like 0001000. By\n","performing an OR with num, only value at bit i will change.\n","\"\"\"\n","def set_bit(num, i):\n","    return num | (1 << i)\n","\n","\"\"\"\n","This method operates in almost the reverse of set_bit\n","\"\"\"\n","def clear_bit(num, i):\n","    mask = ~(1 << i)\n","    return num & mask"],"metadata":{"id":"jkHBwY3A8L_Y","executionInfo":{"status":"ok","timestamp":1665659194133,"user_tz":-480,"elapsed":747,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":28,"outputs":[]},{"cell_type":"code","source":["print(bin(set_bit(0b0000, 3)))\n","print(bin(clear_bit(0b1111, 0)))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"3X2V9sEg8PV2","executionInfo":{"status":"ok","timestamp":1665659194807,"user_tz":-480,"elapsed":279,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"345a0898-b577-4a28-c825-7e55e0de4a7f"},"execution_count":29,"outputs":[{"output_type":"stream","name":"stdout","text":["0b1000\n","0b1110\n"]}]},{"cell_type":"code","source":["def bin_to_decimal(bin_string):\n","    \"\"\"\n","    Convert a binary value to its decimal equivalent\n","    >>> bin_to_decimal(\"101\")\n","    5\n","    >>> bin_to_decimal(\" 1010   \")\n","    10\n","    >>> bin_to_decimal(\"-11101\")\n","    -29\n","    >>> bin_to_decimal(\"0\")\n","    0\n","    \"\"\"\n","    bin_string = str(bin_string).strip()\n","    is_negative = bin_string[0] == \"-\"\n","    if is_negative:\n","      bin_string = bin_string[1:]\n","    decimal_number = 0\n","    for char in bin_string:\n","        decimal_number = 2 * decimal_number + int(char)\n","    return -decimal_number if is_negative else decimal_number"],"metadata":{"id":"jIELZIyg6C8v","executionInfo":{"status":"ok","timestamp":1665659196385,"user_tz":-480,"elapsed":2,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":30,"outputs":[]},{"cell_type":"code","source":["bin_to_decimal(\"101\"), bin_to_decimal(\" 1010   \"), bin_to_decimal(\"-11101\"), bin_to_decimal(\"0\")"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"xpJjxXbE6zUo","executionInfo":{"status":"ok","timestamp":1665659198661,"user_tz":-480,"elapsed":2,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"9a5334e4-e060-4948-9042-d8609635121c"},"execution_count":31,"outputs":[{"output_type":"execute_result","data":{"text/plain":["(5, 10, -29, 0)"]},"metadata":{},"execution_count":31}]},{"cell_type":"code","source":["def decimal_to_binary(num):\n","\n","    \"\"\"\n","    Convert an Integer Decimal Number to a Binary Number as str.\n","    >>> decimal_to_binary(0)\n","    '0b0'\n","    >>> decimal_to_binary(2)\n","    '0b10'\n","    >>> decimal_to_binary(7)\n","    '0b111'\n","    >>> decimal_to_binary(35)\n","    '0b100011'\n","    >>> # negatives work too\n","    >>> decimal_to_binary(-2)\n","    '-0b10'\n","    \"\"\"\n","    if num == 0:\n","        return \"0b0\"\n","    negative = False\n","\n","    if num < 0:\n","        negative = True\n","        num = -num\n","\n","    binary = []\n","    while num > 0:\n","        binary.insert(0, num % 2)\n","        num >>= 1\n","\n","    if negative:\n","        return \"-0b\" + \"\".join(str(e) for e in binary)\n","\n","    return \"0b\" + \"\".join(str(e) for e in binary)"],"metadata":{"id":"spFR9INM7PEd","executionInfo":{"status":"ok","timestamp":1665659269921,"user_tz":-480,"elapsed":4,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}}},"execution_count":34,"outputs":[]},{"cell_type":"code","source":["decimal_to_binary(0), decimal_to_binary(2), decimal_to_binary(7), decimal_to_binary(35), decimal_to_binary(-2)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"6PJ8v08I7fnm","executionInfo":{"status":"ok","timestamp":1665659269922,"user_tz":-480,"elapsed":4,"user":{"displayName":"phonchi chung","userId":"13517391734500420886"}},"outputId":"bd437c39-8f7f-416a-c18e-7ffdb6bd161c"},"execution_count":35,"outputs":[{"output_type":"execute_result","data":{"text/plain":["('0b0', '0b10', '0b111', '0b100011', '-0b10')"]},"metadata":{},"execution_count":35}]},{"cell_type":"markdown","source":["## The little computer"],"metadata":{"id":"o-JZLs3LCZWd"}},{"cell_type":"markdown","source":["Check out https://computerscience.chemeketa.edu/cs160Reader/ProgrammingLanguages/LittleComputer1.html, https://eseo-tech.github.io/emulsiV/ or https://www.101computing.net/lmc-simulator/"],"metadata":{"id":"BzwRdjywCeek"}},{"cell_type":"markdown","source":["### Exercise 1: \n","Try to extend the decimal to binary operator, so that it can accept real number that contains fractional part."],"metadata":{"id":"FkfaeJLX7tmU"}},{"cell_type":"markdown","source":["### Exercise 2:"],"metadata":{"id":"ki50pTaOBpa-"}},{"cell_type":"markdown","source":["Try to understand the internal of `bin_to_decimal`, `decimal_to_binary()` and `bin_int()`"],"metadata":{"id":"cv1KonH2Bum1"}},{"cell_type":"code","source":[],"metadata":{"id":"RiepK6aAVa1O"},"execution_count":null,"outputs":[]}]}